You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1749 lines
60 KiB
1749 lines
60 KiB
(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
|