forked from FINAKON/HelpProject
Bhargava
6063bd1724
1. Initial Commit - a boiler plate code and POC to realize the concept of context
sensitive help
2. Frontend code written in ReactJS
3. Backend code written in Java, Spring Boot Framework
4. Frontend Start:
pre-requisites : node, npm
npm run dev ==> to start the frontend vite server
5. Backend Start:
pre-requisites : java, mvn
mvn spring-boot:run ==> to start the backend server
6. Visit http://localhost:5173/ for basic demo of help, press F1 in textboxes
7. Visit http://localhost:5173/editor and enter "admin123" to add/modify texts.
Happy Coding !!!
Thank you,
Bhargava.
1749 lines
60 KiB
JavaScript
1749 lines
60 KiB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
module.exports = factory();
|
|
else if(typeof define === 'function' && define.amd)
|
|
define([], factory);
|
|
else if(typeof exports === 'object')
|
|
exports["Parchment"] = factory();
|
|
else
|
|
root["Parchment"] = factory();
|
|
})(typeof self !== 'undefined' ? self : this, function() {
|
|
return /******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId]) {
|
|
/******/ return installedModules[moduleId].exports;
|
|
/******/ }
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ i: moduleId,
|
|
/******/ l: false,
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.l = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
/******/
|
|
/******/ // define getter function for harmony exports
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
|
/******/ Object.defineProperty(exports, name, {
|
|
/******/ configurable: false,
|
|
/******/ enumerable: true,
|
|
/******/ get: getter
|
|
/******/ });
|
|
/******/ }
|
|
/******/ };
|
|
/******/
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = function(module) {
|
|
/******/ var getter = module && module.__esModule ?
|
|
/******/ function getDefault() { return module['default']; } :
|
|
/******/ function getModuleExports() { return module; };
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
|
/******/ return getter;
|
|
/******/ };
|
|
/******/
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "";
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(__webpack_require__.s = 9);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var ParchmentError = /** @class */ (function (_super) {
|
|
__extends(ParchmentError, _super);
|
|
function ParchmentError(message) {
|
|
var _this = this;
|
|
message = '[Parchment] ' + message;
|
|
_this = _super.call(this, message) || this;
|
|
_this.message = message;
|
|
_this.name = _this.constructor.name;
|
|
return _this;
|
|
}
|
|
return ParchmentError;
|
|
}(Error));
|
|
exports.ParchmentError = ParchmentError;
|
|
var attributes = {};
|
|
var classes = {};
|
|
var tags = {};
|
|
var types = {};
|
|
exports.DATA_KEY = '__blot';
|
|
var Scope;
|
|
(function (Scope) {
|
|
Scope[Scope["TYPE"] = 3] = "TYPE";
|
|
Scope[Scope["LEVEL"] = 12] = "LEVEL";
|
|
Scope[Scope["ATTRIBUTE"] = 13] = "ATTRIBUTE";
|
|
Scope[Scope["BLOT"] = 14] = "BLOT";
|
|
Scope[Scope["INLINE"] = 7] = "INLINE";
|
|
Scope[Scope["BLOCK"] = 11] = "BLOCK";
|
|
Scope[Scope["BLOCK_BLOT"] = 10] = "BLOCK_BLOT";
|
|
Scope[Scope["INLINE_BLOT"] = 6] = "INLINE_BLOT";
|
|
Scope[Scope["BLOCK_ATTRIBUTE"] = 9] = "BLOCK_ATTRIBUTE";
|
|
Scope[Scope["INLINE_ATTRIBUTE"] = 5] = "INLINE_ATTRIBUTE";
|
|
Scope[Scope["ANY"] = 15] = "ANY";
|
|
})(Scope = exports.Scope || (exports.Scope = {}));
|
|
function create(input, value) {
|
|
var match = query(input);
|
|
if (match == null) {
|
|
throw new ParchmentError("Unable to create " + input + " blot");
|
|
}
|
|
var BlotClass = match;
|
|
var node =
|
|
// @ts-ignore
|
|
input instanceof Node || input['nodeType'] === Node.TEXT_NODE ? input : BlotClass.create(value);
|
|
return new BlotClass(node, value);
|
|
}
|
|
exports.create = create;
|
|
function find(node, bubble) {
|
|
if (bubble === void 0) { bubble = false; }
|
|
if (node == null)
|
|
return null;
|
|
// @ts-ignore
|
|
if (node[exports.DATA_KEY] != null)
|
|
return node[exports.DATA_KEY].blot;
|
|
if (bubble)
|
|
return find(node.parentNode, bubble);
|
|
return null;
|
|
}
|
|
exports.find = find;
|
|
function query(query, scope) {
|
|
if (scope === void 0) { scope = Scope.ANY; }
|
|
var match;
|
|
if (typeof query === 'string') {
|
|
match = types[query] || attributes[query];
|
|
// @ts-ignore
|
|
}
|
|
else if (query instanceof Text || query['nodeType'] === Node.TEXT_NODE) {
|
|
match = types['text'];
|
|
}
|
|
else if (typeof query === 'number') {
|
|
if (query & Scope.LEVEL & Scope.BLOCK) {
|
|
match = types['block'];
|
|
}
|
|
else if (query & Scope.LEVEL & Scope.INLINE) {
|
|
match = types['inline'];
|
|
}
|
|
}
|
|
else if (query instanceof HTMLElement) {
|
|
var names = (query.getAttribute('class') || '').split(/\s+/);
|
|
for (var i in names) {
|
|
match = classes[names[i]];
|
|
if (match)
|
|
break;
|
|
}
|
|
match = match || tags[query.tagName];
|
|
}
|
|
if (match == null)
|
|
return null;
|
|
// @ts-ignore
|
|
if (scope & Scope.LEVEL & match.scope && scope & Scope.TYPE & match.scope)
|
|
return match;
|
|
return null;
|
|
}
|
|
exports.query = query;
|
|
function register() {
|
|
var Definitions = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
Definitions[_i] = arguments[_i];
|
|
}
|
|
if (Definitions.length > 1) {
|
|
return Definitions.map(function (d) {
|
|
return register(d);
|
|
});
|
|
}
|
|
var Definition = Definitions[0];
|
|
if (typeof Definition.blotName !== 'string' && typeof Definition.attrName !== 'string') {
|
|
throw new ParchmentError('Invalid definition');
|
|
}
|
|
else if (Definition.blotName === 'abstract') {
|
|
throw new ParchmentError('Cannot register abstract class');
|
|
}
|
|
types[Definition.blotName || Definition.attrName] = Definition;
|
|
if (typeof Definition.keyName === 'string') {
|
|
attributes[Definition.keyName] = Definition;
|
|
}
|
|
else {
|
|
if (Definition.className != null) {
|
|
classes[Definition.className] = Definition;
|
|
}
|
|
if (Definition.tagName != null) {
|
|
if (Array.isArray(Definition.tagName)) {
|
|
Definition.tagName = Definition.tagName.map(function (tagName) {
|
|
return tagName.toUpperCase();
|
|
});
|
|
}
|
|
else {
|
|
Definition.tagName = Definition.tagName.toUpperCase();
|
|
}
|
|
var tagNames = Array.isArray(Definition.tagName) ? Definition.tagName : [Definition.tagName];
|
|
tagNames.forEach(function (tag) {
|
|
if (tags[tag] == null || Definition.className == null) {
|
|
tags[tag] = Definition;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
return Definition;
|
|
}
|
|
exports.register = register;
|
|
|
|
|
|
/***/ }),
|
|
/* 1 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var Registry = __webpack_require__(0);
|
|
var Attributor = /** @class */ (function () {
|
|
function Attributor(attrName, keyName, options) {
|
|
if (options === void 0) { options = {}; }
|
|
this.attrName = attrName;
|
|
this.keyName = keyName;
|
|
var attributeBit = Registry.Scope.TYPE & Registry.Scope.ATTRIBUTE;
|
|
if (options.scope != null) {
|
|
// Ignore type bits, force attribute bit
|
|
this.scope = (options.scope & Registry.Scope.LEVEL) | attributeBit;
|
|
}
|
|
else {
|
|
this.scope = Registry.Scope.ATTRIBUTE;
|
|
}
|
|
if (options.whitelist != null)
|
|
this.whitelist = options.whitelist;
|
|
}
|
|
Attributor.keys = function (node) {
|
|
return [].map.call(node.attributes, function (item) {
|
|
return item.name;
|
|
});
|
|
};
|
|
Attributor.prototype.add = function (node, value) {
|
|
if (!this.canAdd(node, value))
|
|
return false;
|
|
node.setAttribute(this.keyName, value);
|
|
return true;
|
|
};
|
|
Attributor.prototype.canAdd = function (node, value) {
|
|
var match = Registry.query(node, Registry.Scope.BLOT & (this.scope | Registry.Scope.TYPE));
|
|
if (match == null)
|
|
return false;
|
|
if (this.whitelist == null)
|
|
return true;
|
|
if (typeof value === 'string') {
|
|
return this.whitelist.indexOf(value.replace(/["']/g, '')) > -1;
|
|
}
|
|
else {
|
|
return this.whitelist.indexOf(value) > -1;
|
|
}
|
|
};
|
|
Attributor.prototype.remove = function (node) {
|
|
node.removeAttribute(this.keyName);
|
|
};
|
|
Attributor.prototype.value = function (node) {
|
|
var value = node.getAttribute(this.keyName);
|
|
if (this.canAdd(node, value) && value) {
|
|
return value;
|
|
}
|
|
return '';
|
|
};
|
|
return Attributor;
|
|
}());
|
|
exports.default = Attributor;
|
|
|
|
|
|
/***/ }),
|
|
/* 2 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var linked_list_1 = __webpack_require__(11);
|
|
var shadow_1 = __webpack_require__(5);
|
|
var Registry = __webpack_require__(0);
|
|
var ContainerBlot = /** @class */ (function (_super) {
|
|
__extends(ContainerBlot, _super);
|
|
function ContainerBlot(domNode) {
|
|
var _this = _super.call(this, domNode) || this;
|
|
_this.build();
|
|
return _this;
|
|
}
|
|
ContainerBlot.prototype.appendChild = function (other) {
|
|
this.insertBefore(other);
|
|
};
|
|
ContainerBlot.prototype.attach = function () {
|
|
_super.prototype.attach.call(this);
|
|
this.children.forEach(function (child) {
|
|
child.attach();
|
|
});
|
|
};
|
|
ContainerBlot.prototype.build = function () {
|
|
var _this = this;
|
|
this.children = new linked_list_1.default();
|
|
// Need to be reversed for if DOM nodes already in order
|
|
[].slice
|
|
.call(this.domNode.childNodes)
|
|
.reverse()
|
|
.forEach(function (node) {
|
|
try {
|
|
var child = makeBlot(node);
|
|
_this.insertBefore(child, _this.children.head || undefined);
|
|
}
|
|
catch (err) {
|
|
if (err instanceof Registry.ParchmentError)
|
|
return;
|
|
else
|
|
throw err;
|
|
}
|
|
});
|
|
};
|
|
ContainerBlot.prototype.deleteAt = function (index, length) {
|
|
if (index === 0 && length === this.length()) {
|
|
return this.remove();
|
|
}
|
|
this.children.forEachAt(index, length, function (child, offset, length) {
|
|
child.deleteAt(offset, length);
|
|
});
|
|
};
|
|
ContainerBlot.prototype.descendant = function (criteria, index) {
|
|
var _a = this.children.find(index), child = _a[0], offset = _a[1];
|
|
if ((criteria.blotName == null && criteria(child)) ||
|
|
(criteria.blotName != null && child instanceof criteria)) {
|
|
return [child, offset];
|
|
}
|
|
else if (child instanceof ContainerBlot) {
|
|
return child.descendant(criteria, offset);
|
|
}
|
|
else {
|
|
return [null, -1];
|
|
}
|
|
};
|
|
ContainerBlot.prototype.descendants = function (criteria, index, length) {
|
|
if (index === void 0) { index = 0; }
|
|
if (length === void 0) { length = Number.MAX_VALUE; }
|
|
var descendants = [];
|
|
var lengthLeft = length;
|
|
this.children.forEachAt(index, length, function (child, index, length) {
|
|
if ((criteria.blotName == null && criteria(child)) ||
|
|
(criteria.blotName != null && child instanceof criteria)) {
|
|
descendants.push(child);
|
|
}
|
|
if (child instanceof ContainerBlot) {
|
|
descendants = descendants.concat(child.descendants(criteria, index, lengthLeft));
|
|
}
|
|
lengthLeft -= length;
|
|
});
|
|
return descendants;
|
|
};
|
|
ContainerBlot.prototype.detach = function () {
|
|
this.children.forEach(function (child) {
|
|
child.detach();
|
|
});
|
|
_super.prototype.detach.call(this);
|
|
};
|
|
ContainerBlot.prototype.formatAt = function (index, length, name, value) {
|
|
this.children.forEachAt(index, length, function (child, offset, length) {
|
|
child.formatAt(offset, length, name, value);
|
|
});
|
|
};
|
|
ContainerBlot.prototype.insertAt = function (index, value, def) {
|
|
var _a = this.children.find(index), child = _a[0], offset = _a[1];
|
|
if (child) {
|
|
child.insertAt(offset, value, def);
|
|
}
|
|
else {
|
|
var blot = def == null ? Registry.create('text', value) : Registry.create(value, def);
|
|
this.appendChild(blot);
|
|
}
|
|
};
|
|
ContainerBlot.prototype.insertBefore = function (childBlot, refBlot) {
|
|
if (this.statics.allowedChildren != null &&
|
|
!this.statics.allowedChildren.some(function (child) {
|
|
return childBlot instanceof child;
|
|
})) {
|
|
throw new Registry.ParchmentError("Cannot insert " + childBlot.statics.blotName + " into " + this.statics.blotName);
|
|
}
|
|
childBlot.insertInto(this, refBlot);
|
|
};
|
|
ContainerBlot.prototype.length = function () {
|
|
return this.children.reduce(function (memo, child) {
|
|
return memo + child.length();
|
|
}, 0);
|
|
};
|
|
ContainerBlot.prototype.moveChildren = function (targetParent, refNode) {
|
|
this.children.forEach(function (child) {
|
|
targetParent.insertBefore(child, refNode);
|
|
});
|
|
};
|
|
ContainerBlot.prototype.optimize = function (context) {
|
|
_super.prototype.optimize.call(this, context);
|
|
if (this.children.length === 0) {
|
|
if (this.statics.defaultChild != null) {
|
|
var child = Registry.create(this.statics.defaultChild);
|
|
this.appendChild(child);
|
|
child.optimize(context);
|
|
}
|
|
else {
|
|
this.remove();
|
|
}
|
|
}
|
|
};
|
|
ContainerBlot.prototype.path = function (index, inclusive) {
|
|
if (inclusive === void 0) { inclusive = false; }
|
|
var _a = this.children.find(index, inclusive), child = _a[0], offset = _a[1];
|
|
var position = [[this, index]];
|
|
if (child instanceof ContainerBlot) {
|
|
return position.concat(child.path(offset, inclusive));
|
|
}
|
|
else if (child != null) {
|
|
position.push([child, offset]);
|
|
}
|
|
return position;
|
|
};
|
|
ContainerBlot.prototype.removeChild = function (child) {
|
|
this.children.remove(child);
|
|
};
|
|
ContainerBlot.prototype.replace = function (target) {
|
|
if (target instanceof ContainerBlot) {
|
|
target.moveChildren(this);
|
|
}
|
|
_super.prototype.replace.call(this, target);
|
|
};
|
|
ContainerBlot.prototype.split = function (index, force) {
|
|
if (force === void 0) { force = false; }
|
|
if (!force) {
|
|
if (index === 0)
|
|
return this;
|
|
if (index === this.length())
|
|
return this.next;
|
|
}
|
|
var after = this.clone();
|
|
this.parent.insertBefore(after, this.next);
|
|
this.children.forEachAt(index, this.length(), function (child, offset, length) {
|
|
child = child.split(offset, force);
|
|
after.appendChild(child);
|
|
});
|
|
return after;
|
|
};
|
|
ContainerBlot.prototype.unwrap = function () {
|
|
this.moveChildren(this.parent, this.next);
|
|
this.remove();
|
|
};
|
|
ContainerBlot.prototype.update = function (mutations, context) {
|
|
var _this = this;
|
|
var addedNodes = [];
|
|
var removedNodes = [];
|
|
mutations.forEach(function (mutation) {
|
|
if (mutation.target === _this.domNode && mutation.type === 'childList') {
|
|
addedNodes.push.apply(addedNodes, mutation.addedNodes);
|
|
removedNodes.push.apply(removedNodes, mutation.removedNodes);
|
|
}
|
|
});
|
|
removedNodes.forEach(function (node) {
|
|
// Check node has actually been removed
|
|
// One exception is Chrome does not immediately remove IFRAMEs
|
|
// from DOM but MutationRecord is correct in its reported removal
|
|
if (node.parentNode != null &&
|
|
// @ts-ignore
|
|
node.tagName !== 'IFRAME' &&
|
|
document.body.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_CONTAINED_BY) {
|
|
return;
|
|
}
|
|
var blot = Registry.find(node);
|
|
if (blot == null)
|
|
return;
|
|
if (blot.domNode.parentNode == null || blot.domNode.parentNode === _this.domNode) {
|
|
blot.detach();
|
|
}
|
|
});
|
|
addedNodes
|
|
.filter(function (node) {
|
|
return node.parentNode == _this.domNode;
|
|
})
|
|
.sort(function (a, b) {
|
|
if (a === b)
|
|
return 0;
|
|
if (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING) {
|
|
return 1;
|
|
}
|
|
return -1;
|
|
})
|
|
.forEach(function (node) {
|
|
var refBlot = null;
|
|
if (node.nextSibling != null) {
|
|
refBlot = Registry.find(node.nextSibling);
|
|
}
|
|
var blot = makeBlot(node);
|
|
if (blot.next != refBlot || blot.next == null) {
|
|
if (blot.parent != null) {
|
|
blot.parent.removeChild(_this);
|
|
}
|
|
_this.insertBefore(blot, refBlot || undefined);
|
|
}
|
|
});
|
|
};
|
|
return ContainerBlot;
|
|
}(shadow_1.default));
|
|
function makeBlot(node) {
|
|
var blot = Registry.find(node);
|
|
if (blot == null) {
|
|
try {
|
|
blot = Registry.create(node);
|
|
}
|
|
catch (e) {
|
|
blot = Registry.create(Registry.Scope.INLINE);
|
|
[].slice.call(node.childNodes).forEach(function (child) {
|
|
// @ts-ignore
|
|
blot.domNode.appendChild(child);
|
|
});
|
|
if (node.parentNode) {
|
|
node.parentNode.replaceChild(blot.domNode, node);
|
|
}
|
|
blot.attach();
|
|
}
|
|
}
|
|
return blot;
|
|
}
|
|
exports.default = ContainerBlot;
|
|
|
|
|
|
/***/ }),
|
|
/* 3 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var attributor_1 = __webpack_require__(1);
|
|
var store_1 = __webpack_require__(6);
|
|
var container_1 = __webpack_require__(2);
|
|
var Registry = __webpack_require__(0);
|
|
var FormatBlot = /** @class */ (function (_super) {
|
|
__extends(FormatBlot, _super);
|
|
function FormatBlot(domNode) {
|
|
var _this = _super.call(this, domNode) || this;
|
|
_this.attributes = new store_1.default(_this.domNode);
|
|
return _this;
|
|
}
|
|
FormatBlot.formats = function (domNode) {
|
|
if (typeof this.tagName === 'string') {
|
|
return true;
|
|
}
|
|
else if (Array.isArray(this.tagName)) {
|
|
return domNode.tagName.toLowerCase();
|
|
}
|
|
return undefined;
|
|
};
|
|
FormatBlot.prototype.format = function (name, value) {
|
|
var format = Registry.query(name);
|
|
if (format instanceof attributor_1.default) {
|
|
this.attributes.attribute(format, value);
|
|
}
|
|
else if (value) {
|
|
if (format != null && (name !== this.statics.blotName || this.formats()[name] !== value)) {
|
|
this.replaceWith(name, value);
|
|
}
|
|
}
|
|
};
|
|
FormatBlot.prototype.formats = function () {
|
|
var formats = this.attributes.values();
|
|
var format = this.statics.formats(this.domNode);
|
|
if (format != null) {
|
|
formats[this.statics.blotName] = format;
|
|
}
|
|
return formats;
|
|
};
|
|
FormatBlot.prototype.replaceWith = function (name, value) {
|
|
var replacement = _super.prototype.replaceWith.call(this, name, value);
|
|
this.attributes.copy(replacement);
|
|
return replacement;
|
|
};
|
|
FormatBlot.prototype.update = function (mutations, context) {
|
|
var _this = this;
|
|
_super.prototype.update.call(this, mutations, context);
|
|
if (mutations.some(function (mutation) {
|
|
return mutation.target === _this.domNode && mutation.type === 'attributes';
|
|
})) {
|
|
this.attributes.build();
|
|
}
|
|
};
|
|
FormatBlot.prototype.wrap = function (name, value) {
|
|
var wrapper = _super.prototype.wrap.call(this, name, value);
|
|
if (wrapper instanceof FormatBlot && wrapper.statics.scope === this.statics.scope) {
|
|
this.attributes.move(wrapper);
|
|
}
|
|
return wrapper;
|
|
};
|
|
return FormatBlot;
|
|
}(container_1.default));
|
|
exports.default = FormatBlot;
|
|
|
|
|
|
/***/ }),
|
|
/* 4 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var shadow_1 = __webpack_require__(5);
|
|
var Registry = __webpack_require__(0);
|
|
var LeafBlot = /** @class */ (function (_super) {
|
|
__extends(LeafBlot, _super);
|
|
function LeafBlot() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
LeafBlot.value = function (domNode) {
|
|
return true;
|
|
};
|
|
LeafBlot.prototype.index = function (node, offset) {
|
|
if (this.domNode === node ||
|
|
this.domNode.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_CONTAINED_BY) {
|
|
return Math.min(offset, 1);
|
|
}
|
|
return -1;
|
|
};
|
|
LeafBlot.prototype.position = function (index, inclusive) {
|
|
var offset = [].indexOf.call(this.parent.domNode.childNodes, this.domNode);
|
|
if (index > 0)
|
|
offset += 1;
|
|
return [this.parent.domNode, offset];
|
|
};
|
|
LeafBlot.prototype.value = function () {
|
|
return _a = {}, _a[this.statics.blotName] = this.statics.value(this.domNode) || true, _a;
|
|
var _a;
|
|
};
|
|
LeafBlot.scope = Registry.Scope.INLINE_BLOT;
|
|
return LeafBlot;
|
|
}(shadow_1.default));
|
|
exports.default = LeafBlot;
|
|
|
|
|
|
/***/ }),
|
|
/* 5 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var Registry = __webpack_require__(0);
|
|
var ShadowBlot = /** @class */ (function () {
|
|
function ShadowBlot(domNode) {
|
|
this.domNode = domNode;
|
|
// @ts-ignore
|
|
this.domNode[Registry.DATA_KEY] = { blot: this };
|
|
}
|
|
Object.defineProperty(ShadowBlot.prototype, "statics", {
|
|
// Hack for accessing inherited static methods
|
|
get: function () {
|
|
return this.constructor;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
ShadowBlot.create = function (value) {
|
|
if (this.tagName == null) {
|
|
throw new Registry.ParchmentError('Blot definition missing tagName');
|
|
}
|
|
var node;
|
|
if (Array.isArray(this.tagName)) {
|
|
if (typeof value === 'string') {
|
|
value = value.toUpperCase();
|
|
if (parseInt(value).toString() === value) {
|
|
value = parseInt(value);
|
|
}
|
|
}
|
|
if (typeof value === 'number') {
|
|
node = document.createElement(this.tagName[value - 1]);
|
|
}
|
|
else if (this.tagName.indexOf(value) > -1) {
|
|
node = document.createElement(value);
|
|
}
|
|
else {
|
|
node = document.createElement(this.tagName[0]);
|
|
}
|
|
}
|
|
else {
|
|
node = document.createElement(this.tagName);
|
|
}
|
|
if (this.className) {
|
|
node.classList.add(this.className);
|
|
}
|
|
return node;
|
|
};
|
|
ShadowBlot.prototype.attach = function () {
|
|
if (this.parent != null) {
|
|
this.scroll = this.parent.scroll;
|
|
}
|
|
};
|
|
ShadowBlot.prototype.clone = function () {
|
|
var domNode = this.domNode.cloneNode(false);
|
|
return Registry.create(domNode);
|
|
};
|
|
ShadowBlot.prototype.detach = function () {
|
|
if (this.parent != null)
|
|
this.parent.removeChild(this);
|
|
// @ts-ignore
|
|
delete this.domNode[Registry.DATA_KEY];
|
|
};
|
|
ShadowBlot.prototype.deleteAt = function (index, length) {
|
|
var blot = this.isolate(index, length);
|
|
blot.remove();
|
|
};
|
|
ShadowBlot.prototype.formatAt = function (index, length, name, value) {
|
|
var blot = this.isolate(index, length);
|
|
if (Registry.query(name, Registry.Scope.BLOT) != null && value) {
|
|
blot.wrap(name, value);
|
|
}
|
|
else if (Registry.query(name, Registry.Scope.ATTRIBUTE) != null) {
|
|
var parent_1 = Registry.create(this.statics.scope);
|
|
blot.wrap(parent_1);
|
|
parent_1.format(name, value);
|
|
}
|
|
};
|
|
ShadowBlot.prototype.insertAt = function (index, value, def) {
|
|
var blot = def == null ? Registry.create('text', value) : Registry.create(value, def);
|
|
var ref = this.split(index);
|
|
this.parent.insertBefore(blot, ref);
|
|
};
|
|
ShadowBlot.prototype.insertInto = function (parentBlot, refBlot) {
|
|
if (refBlot === void 0) { refBlot = null; }
|
|
if (this.parent != null) {
|
|
this.parent.children.remove(this);
|
|
}
|
|
var refDomNode = null;
|
|
parentBlot.children.insertBefore(this, refBlot);
|
|
if (refBlot != null) {
|
|
refDomNode = refBlot.domNode;
|
|
}
|
|
if (this.domNode.parentNode != parentBlot.domNode ||
|
|
this.domNode.nextSibling != refDomNode) {
|
|
parentBlot.domNode.insertBefore(this.domNode, refDomNode);
|
|
}
|
|
this.parent = parentBlot;
|
|
this.attach();
|
|
};
|
|
ShadowBlot.prototype.isolate = function (index, length) {
|
|
var target = this.split(index);
|
|
target.split(length);
|
|
return target;
|
|
};
|
|
ShadowBlot.prototype.length = function () {
|
|
return 1;
|
|
};
|
|
ShadowBlot.prototype.offset = function (root) {
|
|
if (root === void 0) { root = this.parent; }
|
|
if (this.parent == null || this == root)
|
|
return 0;
|
|
return this.parent.children.offset(this) + this.parent.offset(root);
|
|
};
|
|
ShadowBlot.prototype.optimize = function (context) {
|
|
// TODO clean up once we use WeakMap
|
|
// @ts-ignore
|
|
if (this.domNode[Registry.DATA_KEY] != null) {
|
|
// @ts-ignore
|
|
delete this.domNode[Registry.DATA_KEY].mutations;
|
|
}
|
|
};
|
|
ShadowBlot.prototype.remove = function () {
|
|
if (this.domNode.parentNode != null) {
|
|
this.domNode.parentNode.removeChild(this.domNode);
|
|
}
|
|
this.detach();
|
|
};
|
|
ShadowBlot.prototype.replace = function (target) {
|
|
if (target.parent == null)
|
|
return;
|
|
target.parent.insertBefore(this, target.next);
|
|
target.remove();
|
|
};
|
|
ShadowBlot.prototype.replaceWith = function (name, value) {
|
|
var replacement = typeof name === 'string' ? Registry.create(name, value) : name;
|
|
replacement.replace(this);
|
|
return replacement;
|
|
};
|
|
ShadowBlot.prototype.split = function (index, force) {
|
|
return index === 0 ? this : this.next;
|
|
};
|
|
ShadowBlot.prototype.update = function (mutations, context) {
|
|
// Nothing to do by default
|
|
};
|
|
ShadowBlot.prototype.wrap = function (name, value) {
|
|
var wrapper = typeof name === 'string' ? Registry.create(name, value) : name;
|
|
if (this.parent != null) {
|
|
this.parent.insertBefore(wrapper, this.next);
|
|
}
|
|
wrapper.appendChild(this);
|
|
return wrapper;
|
|
};
|
|
ShadowBlot.blotName = 'abstract';
|
|
return ShadowBlot;
|
|
}());
|
|
exports.default = ShadowBlot;
|
|
|
|
|
|
/***/ }),
|
|
/* 6 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var attributor_1 = __webpack_require__(1);
|
|
var class_1 = __webpack_require__(7);
|
|
var style_1 = __webpack_require__(8);
|
|
var Registry = __webpack_require__(0);
|
|
var AttributorStore = /** @class */ (function () {
|
|
function AttributorStore(domNode) {
|
|
this.attributes = {};
|
|
this.domNode = domNode;
|
|
this.build();
|
|
}
|
|
AttributorStore.prototype.attribute = function (attribute, value) {
|
|
// verb
|
|
if (value) {
|
|
if (attribute.add(this.domNode, value)) {
|
|
if (attribute.value(this.domNode) != null) {
|
|
this.attributes[attribute.attrName] = attribute;
|
|
}
|
|
else {
|
|
delete this.attributes[attribute.attrName];
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
attribute.remove(this.domNode);
|
|
delete this.attributes[attribute.attrName];
|
|
}
|
|
};
|
|
AttributorStore.prototype.build = function () {
|
|
var _this = this;
|
|
this.attributes = {};
|
|
var attributes = attributor_1.default.keys(this.domNode);
|
|
var classes = class_1.default.keys(this.domNode);
|
|
var styles = style_1.default.keys(this.domNode);
|
|
attributes
|
|
.concat(classes)
|
|
.concat(styles)
|
|
.forEach(function (name) {
|
|
var attr = Registry.query(name, Registry.Scope.ATTRIBUTE);
|
|
if (attr instanceof attributor_1.default) {
|
|
_this.attributes[attr.attrName] = attr;
|
|
}
|
|
});
|
|
};
|
|
AttributorStore.prototype.copy = function (target) {
|
|
var _this = this;
|
|
Object.keys(this.attributes).forEach(function (key) {
|
|
var value = _this.attributes[key].value(_this.domNode);
|
|
target.format(key, value);
|
|
});
|
|
};
|
|
AttributorStore.prototype.move = function (target) {
|
|
var _this = this;
|
|
this.copy(target);
|
|
Object.keys(this.attributes).forEach(function (key) {
|
|
_this.attributes[key].remove(_this.domNode);
|
|
});
|
|
this.attributes = {};
|
|
};
|
|
AttributorStore.prototype.values = function () {
|
|
var _this = this;
|
|
return Object.keys(this.attributes).reduce(function (attributes, name) {
|
|
attributes[name] = _this.attributes[name].value(_this.domNode);
|
|
return attributes;
|
|
}, {});
|
|
};
|
|
return AttributorStore;
|
|
}());
|
|
exports.default = AttributorStore;
|
|
|
|
|
|
/***/ }),
|
|
/* 7 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var attributor_1 = __webpack_require__(1);
|
|
function match(node, prefix) {
|
|
var className = node.getAttribute('class') || '';
|
|
return className.split(/\s+/).filter(function (name) {
|
|
return name.indexOf(prefix + "-") === 0;
|
|
});
|
|
}
|
|
var ClassAttributor = /** @class */ (function (_super) {
|
|
__extends(ClassAttributor, _super);
|
|
function ClassAttributor() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
ClassAttributor.keys = function (node) {
|
|
return (node.getAttribute('class') || '').split(/\s+/).map(function (name) {
|
|
return name
|
|
.split('-')
|
|
.slice(0, -1)
|
|
.join('-');
|
|
});
|
|
};
|
|
ClassAttributor.prototype.add = function (node, value) {
|
|
if (!this.canAdd(node, value))
|
|
return false;
|
|
this.remove(node);
|
|
node.classList.add(this.keyName + "-" + value);
|
|
return true;
|
|
};
|
|
ClassAttributor.prototype.remove = function (node) {
|
|
var matches = match(node, this.keyName);
|
|
matches.forEach(function (name) {
|
|
node.classList.remove(name);
|
|
});
|
|
if (node.classList.length === 0) {
|
|
node.removeAttribute('class');
|
|
}
|
|
};
|
|
ClassAttributor.prototype.value = function (node) {
|
|
var result = match(node, this.keyName)[0] || '';
|
|
var value = result.slice(this.keyName.length + 1); // +1 for hyphen
|
|
return this.canAdd(node, value) ? value : '';
|
|
};
|
|
return ClassAttributor;
|
|
}(attributor_1.default));
|
|
exports.default = ClassAttributor;
|
|
|
|
|
|
/***/ }),
|
|
/* 8 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var attributor_1 = __webpack_require__(1);
|
|
function camelize(name) {
|
|
var parts = name.split('-');
|
|
var rest = parts
|
|
.slice(1)
|
|
.map(function (part) {
|
|
return part[0].toUpperCase() + part.slice(1);
|
|
})
|
|
.join('');
|
|
return parts[0] + rest;
|
|
}
|
|
var StyleAttributor = /** @class */ (function (_super) {
|
|
__extends(StyleAttributor, _super);
|
|
function StyleAttributor() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
StyleAttributor.keys = function (node) {
|
|
return (node.getAttribute('style') || '').split(';').map(function (value) {
|
|
var arr = value.split(':');
|
|
return arr[0].trim();
|
|
});
|
|
};
|
|
StyleAttributor.prototype.add = function (node, value) {
|
|
if (!this.canAdd(node, value))
|
|
return false;
|
|
// @ts-ignore
|
|
node.style[camelize(this.keyName)] = value;
|
|
return true;
|
|
};
|
|
StyleAttributor.prototype.remove = function (node) {
|
|
// @ts-ignore
|
|
node.style[camelize(this.keyName)] = '';
|
|
if (!node.getAttribute('style')) {
|
|
node.removeAttribute('style');
|
|
}
|
|
};
|
|
StyleAttributor.prototype.value = function (node) {
|
|
// @ts-ignore
|
|
var value = node.style[camelize(this.keyName)];
|
|
return this.canAdd(node, value) ? value : '';
|
|
};
|
|
return StyleAttributor;
|
|
}(attributor_1.default));
|
|
exports.default = StyleAttributor;
|
|
|
|
|
|
/***/ }),
|
|
/* 9 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
module.exports = __webpack_require__(10);
|
|
|
|
|
|
/***/ }),
|
|
/* 10 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var container_1 = __webpack_require__(2);
|
|
var format_1 = __webpack_require__(3);
|
|
var leaf_1 = __webpack_require__(4);
|
|
var scroll_1 = __webpack_require__(12);
|
|
var inline_1 = __webpack_require__(13);
|
|
var block_1 = __webpack_require__(14);
|
|
var embed_1 = __webpack_require__(15);
|
|
var text_1 = __webpack_require__(16);
|
|
var attributor_1 = __webpack_require__(1);
|
|
var class_1 = __webpack_require__(7);
|
|
var style_1 = __webpack_require__(8);
|
|
var store_1 = __webpack_require__(6);
|
|
var Registry = __webpack_require__(0);
|
|
var Parchment = {
|
|
Scope: Registry.Scope,
|
|
create: Registry.create,
|
|
find: Registry.find,
|
|
query: Registry.query,
|
|
register: Registry.register,
|
|
Container: container_1.default,
|
|
Format: format_1.default,
|
|
Leaf: leaf_1.default,
|
|
Embed: embed_1.default,
|
|
Scroll: scroll_1.default,
|
|
Block: block_1.default,
|
|
Inline: inline_1.default,
|
|
Text: text_1.default,
|
|
Attributor: {
|
|
Attribute: attributor_1.default,
|
|
Class: class_1.default,
|
|
Style: style_1.default,
|
|
Store: store_1.default,
|
|
},
|
|
};
|
|
exports.default = Parchment;
|
|
|
|
|
|
/***/ }),
|
|
/* 11 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var LinkedList = /** @class */ (function () {
|
|
function LinkedList() {
|
|
this.head = this.tail = null;
|
|
this.length = 0;
|
|
}
|
|
LinkedList.prototype.append = function () {
|
|
var nodes = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
nodes[_i] = arguments[_i];
|
|
}
|
|
this.insertBefore(nodes[0], null);
|
|
if (nodes.length > 1) {
|
|
this.append.apply(this, nodes.slice(1));
|
|
}
|
|
};
|
|
LinkedList.prototype.contains = function (node) {
|
|
var cur, next = this.iterator();
|
|
while ((cur = next())) {
|
|
if (cur === node)
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
LinkedList.prototype.insertBefore = function (node, refNode) {
|
|
if (!node)
|
|
return;
|
|
node.next = refNode;
|
|
if (refNode != null) {
|
|
node.prev = refNode.prev;
|
|
if (refNode.prev != null) {
|
|
refNode.prev.next = node;
|
|
}
|
|
refNode.prev = node;
|
|
if (refNode === this.head) {
|
|
this.head = node;
|
|
}
|
|
}
|
|
else if (this.tail != null) {
|
|
this.tail.next = node;
|
|
node.prev = this.tail;
|
|
this.tail = node;
|
|
}
|
|
else {
|
|
node.prev = null;
|
|
this.head = this.tail = node;
|
|
}
|
|
this.length += 1;
|
|
};
|
|
LinkedList.prototype.offset = function (target) {
|
|
var index = 0, cur = this.head;
|
|
while (cur != null) {
|
|
if (cur === target)
|
|
return index;
|
|
index += cur.length();
|
|
cur = cur.next;
|
|
}
|
|
return -1;
|
|
};
|
|
LinkedList.prototype.remove = function (node) {
|
|
if (!this.contains(node))
|
|
return;
|
|
if (node.prev != null)
|
|
node.prev.next = node.next;
|
|
if (node.next != null)
|
|
node.next.prev = node.prev;
|
|
if (node === this.head)
|
|
this.head = node.next;
|
|
if (node === this.tail)
|
|
this.tail = node.prev;
|
|
this.length -= 1;
|
|
};
|
|
LinkedList.prototype.iterator = function (curNode) {
|
|
if (curNode === void 0) { curNode = this.head; }
|
|
// TODO use yield when we can
|
|
return function () {
|
|
var ret = curNode;
|
|
if (curNode != null)
|
|
curNode = curNode.next;
|
|
return ret;
|
|
};
|
|
};
|
|
LinkedList.prototype.find = function (index, inclusive) {
|
|
if (inclusive === void 0) { inclusive = false; }
|
|
var cur, next = this.iterator();
|
|
while ((cur = next())) {
|
|
var length_1 = cur.length();
|
|
if (index < length_1 ||
|
|
(inclusive && index === length_1 && (cur.next == null || cur.next.length() !== 0))) {
|
|
return [cur, index];
|
|
}
|
|
index -= length_1;
|
|
}
|
|
return [null, 0];
|
|
};
|
|
LinkedList.prototype.forEach = function (callback) {
|
|
var cur, next = this.iterator();
|
|
while ((cur = next())) {
|
|
callback(cur);
|
|
}
|
|
};
|
|
LinkedList.prototype.forEachAt = function (index, length, callback) {
|
|
if (length <= 0)
|
|
return;
|
|
var _a = this.find(index), startNode = _a[0], offset = _a[1];
|
|
var cur, curIndex = index - offset, next = this.iterator(startNode);
|
|
while ((cur = next()) && curIndex < index + length) {
|
|
var curLength = cur.length();
|
|
if (index > curIndex) {
|
|
callback(cur, index - curIndex, Math.min(length, curIndex + curLength - index));
|
|
}
|
|
else {
|
|
callback(cur, 0, Math.min(curLength, index + length - curIndex));
|
|
}
|
|
curIndex += curLength;
|
|
}
|
|
};
|
|
LinkedList.prototype.map = function (callback) {
|
|
return this.reduce(function (memo, cur) {
|
|
memo.push(callback(cur));
|
|
return memo;
|
|
}, []);
|
|
};
|
|
LinkedList.prototype.reduce = function (callback, memo) {
|
|
var cur, next = this.iterator();
|
|
while ((cur = next())) {
|
|
memo = callback(memo, cur);
|
|
}
|
|
return memo;
|
|
};
|
|
return LinkedList;
|
|
}());
|
|
exports.default = LinkedList;
|
|
|
|
|
|
/***/ }),
|
|
/* 12 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var container_1 = __webpack_require__(2);
|
|
var Registry = __webpack_require__(0);
|
|
var OBSERVER_CONFIG = {
|
|
attributes: true,
|
|
characterData: true,
|
|
characterDataOldValue: true,
|
|
childList: true,
|
|
subtree: true,
|
|
};
|
|
var MAX_OPTIMIZE_ITERATIONS = 100;
|
|
var ScrollBlot = /** @class */ (function (_super) {
|
|
__extends(ScrollBlot, _super);
|
|
function ScrollBlot(node) {
|
|
var _this = _super.call(this, node) || this;
|
|
_this.scroll = _this;
|
|
_this.observer = new MutationObserver(function (mutations) {
|
|
_this.update(mutations);
|
|
});
|
|
_this.observer.observe(_this.domNode, OBSERVER_CONFIG);
|
|
_this.attach();
|
|
return _this;
|
|
}
|
|
ScrollBlot.prototype.detach = function () {
|
|
_super.prototype.detach.call(this);
|
|
this.observer.disconnect();
|
|
};
|
|
ScrollBlot.prototype.deleteAt = function (index, length) {
|
|
this.update();
|
|
if (index === 0 && length === this.length()) {
|
|
this.children.forEach(function (child) {
|
|
child.remove();
|
|
});
|
|
}
|
|
else {
|
|
_super.prototype.deleteAt.call(this, index, length);
|
|
}
|
|
};
|
|
ScrollBlot.prototype.formatAt = function (index, length, name, value) {
|
|
this.update();
|
|
_super.prototype.formatAt.call(this, index, length, name, value);
|
|
};
|
|
ScrollBlot.prototype.insertAt = function (index, value, def) {
|
|
this.update();
|
|
_super.prototype.insertAt.call(this, index, value, def);
|
|
};
|
|
ScrollBlot.prototype.optimize = function (mutations, context) {
|
|
var _this = this;
|
|
if (mutations === void 0) { mutations = []; }
|
|
if (context === void 0) { context = {}; }
|
|
_super.prototype.optimize.call(this, context);
|
|
// We must modify mutations directly, cannot make copy and then modify
|
|
var records = [].slice.call(this.observer.takeRecords());
|
|
// Array.push currently seems to be implemented by a non-tail recursive function
|
|
// so we cannot just mutations.push.apply(mutations, this.observer.takeRecords());
|
|
while (records.length > 0)
|
|
mutations.push(records.pop());
|
|
// TODO use WeakMap
|
|
var mark = function (blot, markParent) {
|
|
if (markParent === void 0) { markParent = true; }
|
|
if (blot == null || blot === _this)
|
|
return;
|
|
if (blot.domNode.parentNode == null)
|
|
return;
|
|
// @ts-ignore
|
|
if (blot.domNode[Registry.DATA_KEY].mutations == null) {
|
|
// @ts-ignore
|
|
blot.domNode[Registry.DATA_KEY].mutations = [];
|
|
}
|
|
if (markParent)
|
|
mark(blot.parent);
|
|
};
|
|
var optimize = function (blot) {
|
|
// Post-order traversal
|
|
if (
|
|
// @ts-ignore
|
|
blot.domNode[Registry.DATA_KEY] == null ||
|
|
// @ts-ignore
|
|
blot.domNode[Registry.DATA_KEY].mutations == null) {
|
|
return;
|
|
}
|
|
if (blot instanceof container_1.default) {
|
|
blot.children.forEach(optimize);
|
|
}
|
|
blot.optimize(context);
|
|
};
|
|
var remaining = mutations;
|
|
for (var i = 0; remaining.length > 0; i += 1) {
|
|
if (i >= MAX_OPTIMIZE_ITERATIONS) {
|
|
throw new Error('[Parchment] Maximum optimize iterations reached');
|
|
}
|
|
remaining.forEach(function (mutation) {
|
|
var blot = Registry.find(mutation.target, true);
|
|
if (blot == null)
|
|
return;
|
|
if (blot.domNode === mutation.target) {
|
|
if (mutation.type === 'childList') {
|
|
mark(Registry.find(mutation.previousSibling, false));
|
|
[].forEach.call(mutation.addedNodes, function (node) {
|
|
var child = Registry.find(node, false);
|
|
mark(child, false);
|
|
if (child instanceof container_1.default) {
|
|
child.children.forEach(function (grandChild) {
|
|
mark(grandChild, false);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
else if (mutation.type === 'attributes') {
|
|
mark(blot.prev);
|
|
}
|
|
}
|
|
mark(blot);
|
|
});
|
|
this.children.forEach(optimize);
|
|
remaining = [].slice.call(this.observer.takeRecords());
|
|
records = remaining.slice();
|
|
while (records.length > 0)
|
|
mutations.push(records.pop());
|
|
}
|
|
};
|
|
ScrollBlot.prototype.update = function (mutations, context) {
|
|
var _this = this;
|
|
if (context === void 0) { context = {}; }
|
|
mutations = mutations || this.observer.takeRecords();
|
|
// TODO use WeakMap
|
|
mutations
|
|
.map(function (mutation) {
|
|
var blot = Registry.find(mutation.target, true);
|
|
if (blot == null)
|
|
return null;
|
|
// @ts-ignore
|
|
if (blot.domNode[Registry.DATA_KEY].mutations == null) {
|
|
// @ts-ignore
|
|
blot.domNode[Registry.DATA_KEY].mutations = [mutation];
|
|
return blot;
|
|
}
|
|
else {
|
|
// @ts-ignore
|
|
blot.domNode[Registry.DATA_KEY].mutations.push(mutation);
|
|
return null;
|
|
}
|
|
})
|
|
.forEach(function (blot) {
|
|
if (blot == null ||
|
|
blot === _this ||
|
|
//@ts-ignore
|
|
blot.domNode[Registry.DATA_KEY] == null)
|
|
return;
|
|
// @ts-ignore
|
|
blot.update(blot.domNode[Registry.DATA_KEY].mutations || [], context);
|
|
});
|
|
// @ts-ignore
|
|
if (this.domNode[Registry.DATA_KEY].mutations != null) {
|
|
// @ts-ignore
|
|
_super.prototype.update.call(this, this.domNode[Registry.DATA_KEY].mutations, context);
|
|
}
|
|
this.optimize(mutations, context);
|
|
};
|
|
ScrollBlot.blotName = 'scroll';
|
|
ScrollBlot.defaultChild = 'block';
|
|
ScrollBlot.scope = Registry.Scope.BLOCK_BLOT;
|
|
ScrollBlot.tagName = 'DIV';
|
|
return ScrollBlot;
|
|
}(container_1.default));
|
|
exports.default = ScrollBlot;
|
|
|
|
|
|
/***/ }),
|
|
/* 13 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var format_1 = __webpack_require__(3);
|
|
var Registry = __webpack_require__(0);
|
|
// Shallow object comparison
|
|
function isEqual(obj1, obj2) {
|
|
if (Object.keys(obj1).length !== Object.keys(obj2).length)
|
|
return false;
|
|
// @ts-ignore
|
|
for (var prop in obj1) {
|
|
// @ts-ignore
|
|
if (obj1[prop] !== obj2[prop])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
var InlineBlot = /** @class */ (function (_super) {
|
|
__extends(InlineBlot, _super);
|
|
function InlineBlot() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
InlineBlot.formats = function (domNode) {
|
|
if (domNode.tagName === InlineBlot.tagName)
|
|
return undefined;
|
|
return _super.formats.call(this, domNode);
|
|
};
|
|
InlineBlot.prototype.format = function (name, value) {
|
|
var _this = this;
|
|
if (name === this.statics.blotName && !value) {
|
|
this.children.forEach(function (child) {
|
|
if (!(child instanceof format_1.default)) {
|
|
child = child.wrap(InlineBlot.blotName, true);
|
|
}
|
|
_this.attributes.copy(child);
|
|
});
|
|
this.unwrap();
|
|
}
|
|
else {
|
|
_super.prototype.format.call(this, name, value);
|
|
}
|
|
};
|
|
InlineBlot.prototype.formatAt = function (index, length, name, value) {
|
|
if (this.formats()[name] != null || Registry.query(name, Registry.Scope.ATTRIBUTE)) {
|
|
var blot = this.isolate(index, length);
|
|
blot.format(name, value);
|
|
}
|
|
else {
|
|
_super.prototype.formatAt.call(this, index, length, name, value);
|
|
}
|
|
};
|
|
InlineBlot.prototype.optimize = function (context) {
|
|
_super.prototype.optimize.call(this, context);
|
|
var formats = this.formats();
|
|
if (Object.keys(formats).length === 0) {
|
|
return this.unwrap(); // unformatted span
|
|
}
|
|
var next = this.next;
|
|
if (next instanceof InlineBlot && next.prev === this && isEqual(formats, next.formats())) {
|
|
next.moveChildren(this);
|
|
next.remove();
|
|
}
|
|
};
|
|
InlineBlot.blotName = 'inline';
|
|
InlineBlot.scope = Registry.Scope.INLINE_BLOT;
|
|
InlineBlot.tagName = 'SPAN';
|
|
return InlineBlot;
|
|
}(format_1.default));
|
|
exports.default = InlineBlot;
|
|
|
|
|
|
/***/ }),
|
|
/* 14 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var format_1 = __webpack_require__(3);
|
|
var Registry = __webpack_require__(0);
|
|
var BlockBlot = /** @class */ (function (_super) {
|
|
__extends(BlockBlot, _super);
|
|
function BlockBlot() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
BlockBlot.formats = function (domNode) {
|
|
var tagName = Registry.query(BlockBlot.blotName).tagName;
|
|
if (domNode.tagName === tagName)
|
|
return undefined;
|
|
return _super.formats.call(this, domNode);
|
|
};
|
|
BlockBlot.prototype.format = function (name, value) {
|
|
if (Registry.query(name, Registry.Scope.BLOCK) == null) {
|
|
return;
|
|
}
|
|
else if (name === this.statics.blotName && !value) {
|
|
this.replaceWith(BlockBlot.blotName);
|
|
}
|
|
else {
|
|
_super.prototype.format.call(this, name, value);
|
|
}
|
|
};
|
|
BlockBlot.prototype.formatAt = function (index, length, name, value) {
|
|
if (Registry.query(name, Registry.Scope.BLOCK) != null) {
|
|
this.format(name, value);
|
|
}
|
|
else {
|
|
_super.prototype.formatAt.call(this, index, length, name, value);
|
|
}
|
|
};
|
|
BlockBlot.prototype.insertAt = function (index, value, def) {
|
|
if (def == null || Registry.query(value, Registry.Scope.INLINE) != null) {
|
|
// Insert text or inline
|
|
_super.prototype.insertAt.call(this, index, value, def);
|
|
}
|
|
else {
|
|
var after = this.split(index);
|
|
var blot = Registry.create(value, def);
|
|
after.parent.insertBefore(blot, after);
|
|
}
|
|
};
|
|
BlockBlot.prototype.update = function (mutations, context) {
|
|
if (navigator.userAgent.match(/Trident/)) {
|
|
this.build();
|
|
}
|
|
else {
|
|
_super.prototype.update.call(this, mutations, context);
|
|
}
|
|
};
|
|
BlockBlot.blotName = 'block';
|
|
BlockBlot.scope = Registry.Scope.BLOCK_BLOT;
|
|
BlockBlot.tagName = 'P';
|
|
return BlockBlot;
|
|
}(format_1.default));
|
|
exports.default = BlockBlot;
|
|
|
|
|
|
/***/ }),
|
|
/* 15 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var leaf_1 = __webpack_require__(4);
|
|
var EmbedBlot = /** @class */ (function (_super) {
|
|
__extends(EmbedBlot, _super);
|
|
function EmbedBlot() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
EmbedBlot.formats = function (domNode) {
|
|
return undefined;
|
|
};
|
|
EmbedBlot.prototype.format = function (name, value) {
|
|
// super.formatAt wraps, which is what we want in general,
|
|
// but this allows subclasses to overwrite for formats
|
|
// that just apply to particular embeds
|
|
_super.prototype.formatAt.call(this, 0, this.length(), name, value);
|
|
};
|
|
EmbedBlot.prototype.formatAt = function (index, length, name, value) {
|
|
if (index === 0 && length === this.length()) {
|
|
this.format(name, value);
|
|
}
|
|
else {
|
|
_super.prototype.formatAt.call(this, index, length, name, value);
|
|
}
|
|
};
|
|
EmbedBlot.prototype.formats = function () {
|
|
return this.statics.formats(this.domNode);
|
|
};
|
|
return EmbedBlot;
|
|
}(leaf_1.default));
|
|
exports.default = EmbedBlot;
|
|
|
|
|
|
/***/ }),
|
|
/* 16 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var leaf_1 = __webpack_require__(4);
|
|
var Registry = __webpack_require__(0);
|
|
var TextBlot = /** @class */ (function (_super) {
|
|
__extends(TextBlot, _super);
|
|
function TextBlot(node) {
|
|
var _this = _super.call(this, node) || this;
|
|
_this.text = _this.statics.value(_this.domNode);
|
|
return _this;
|
|
}
|
|
TextBlot.create = function (value) {
|
|
return document.createTextNode(value);
|
|
};
|
|
TextBlot.value = function (domNode) {
|
|
var text = domNode.data;
|
|
// @ts-ignore
|
|
if (text['normalize'])
|
|
text = text['normalize']();
|
|
return text;
|
|
};
|
|
TextBlot.prototype.deleteAt = function (index, length) {
|
|
this.domNode.data = this.text = this.text.slice(0, index) + this.text.slice(index + length);
|
|
};
|
|
TextBlot.prototype.index = function (node, offset) {
|
|
if (this.domNode === node) {
|
|
return offset;
|
|
}
|
|
return -1;
|
|
};
|
|
TextBlot.prototype.insertAt = function (index, value, def) {
|
|
if (def == null) {
|
|
this.text = this.text.slice(0, index) + value + this.text.slice(index);
|
|
this.domNode.data = this.text;
|
|
}
|
|
else {
|
|
_super.prototype.insertAt.call(this, index, value, def);
|
|
}
|
|
};
|
|
TextBlot.prototype.length = function () {
|
|
return this.text.length;
|
|
};
|
|
TextBlot.prototype.optimize = function (context) {
|
|
_super.prototype.optimize.call(this, context);
|
|
this.text = this.statics.value(this.domNode);
|
|
if (this.text.length === 0) {
|
|
this.remove();
|
|
}
|
|
else if (this.next instanceof TextBlot && this.next.prev === this) {
|
|
this.insertAt(this.length(), this.next.value());
|
|
this.next.remove();
|
|
}
|
|
};
|
|
TextBlot.prototype.position = function (index, inclusive) {
|
|
if (inclusive === void 0) { inclusive = false; }
|
|
return [this.domNode, index];
|
|
};
|
|
TextBlot.prototype.split = function (index, force) {
|
|
if (force === void 0) { force = false; }
|
|
if (!force) {
|
|
if (index === 0)
|
|
return this;
|
|
if (index === this.length())
|
|
return this.next;
|
|
}
|
|
var after = Registry.create(this.domNode.splitText(index));
|
|
this.parent.insertBefore(after, this.next);
|
|
this.text = this.statics.value(this.domNode);
|
|
return after;
|
|
};
|
|
TextBlot.prototype.update = function (mutations, context) {
|
|
var _this = this;
|
|
if (mutations.some(function (mutation) {
|
|
return mutation.type === 'characterData' && mutation.target === _this.domNode;
|
|
})) {
|
|
this.text = this.statics.value(this.domNode);
|
|
}
|
|
};
|
|
TextBlot.prototype.value = function () {
|
|
return this.text;
|
|
};
|
|
TextBlot.blotName = 'text';
|
|
TextBlot.scope = Registry.Scope.INLINE_BLOT;
|
|
return TextBlot;
|
|
}(leaf_1.default));
|
|
exports.default = TextBlot;
|
|
|
|
|
|
/***/ })
|
|
/******/ ]);
|
|
});
|
|
//# sourceMappingURL=parchment.js.map
|