{"version":3,"file":"js/1072-3ddc29298c4fdfd0a20c.js","mappings":"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","sources":["webpack://app/./node_modules/call-bind-apply-helpers/actualApply.js","webpack://app/./node_modules/call-bind-apply-helpers/applyBind.js","webpack://app/./node_modules/call-bind-apply-helpers/functionApply.js","webpack://app/./node_modules/call-bind-apply-helpers/functionCall.js","webpack://app/./node_modules/call-bind-apply-helpers/index.js","webpack://app/./node_modules/call-bind-apply-helpers/reflectApply.js","webpack://app/./node_modules/call-bind/callBound.js","webpack://app/./node_modules/call-bind/index.js","webpack://app/./node_modules/call-bound/index.js","webpack://app/./node_modules/deep-equal/index.js","webpack://app/./node_modules/define-data-property/index.js","webpack://app/./node_modules/define-properties/index.js","webpack://app/./node_modules/dunder-proto/get.js","webpack://app/./node_modules/es-define-property/index.js","webpack://app/./node_modules/es-errors/eval.js","webpack://app/./node_modules/es-errors/index.js","webpack://app/./node_modules/es-errors/range.js","webpack://app/./node_modules/es-errors/ref.js","webpack://app/./node_modules/es-errors/syntax.js","webpack://app/./node_modules/es-errors/type.js","webpack://app/./node_modules/es-errors/uri.js","webpack://app/./node_modules/es-object-atoms/index.js","webpack://app/./node_modules/extend/index.js","webpack://app/./node_modules/fast-diff/diff.js","webpack://app/./node_modules/function-bind/implementation.js","webpack://app/./node_modules/function-bind/index.js","webpack://app/./node_modules/functions-have-names/index.js","webpack://app/./node_modules/get-intrinsic/index.js","webpack://app/./node_modules/get-proto/Object.getPrototypeOf.js","webpack://app/./node_modules/get-proto/Reflect.getPrototypeOf.js","webpack://app/./node_modules/get-proto/index.js","webpack://app/./node_modules/gopd/gOPD.js","webpack://app/./node_modules/gopd/index.js","webpack://app/./node_modules/has-property-descriptors/index.js","webpack://app/./node_modules/has-symbols/index.js","webpack://app/./node_modules/has-symbols/shams.js","webpack://app/./node_modules/has-tostringtag/shams.js","webpack://app/./node_modules/hasown/index.js","webpack://app/./node_modules/is-arguments/index.js","webpack://app/./node_modules/is-date-object/index.js","webpack://app/./node_modules/is-regex/index.js","webpack://app/./node_modules/math-intrinsics/abs.js","webpack://app/./node_modules/math-intrinsics/floor.js","webpack://app/./node_modules/math-intrinsics/isNaN.js","webpack://app/./node_modules/math-intrinsics/max.js","webpack://app/./node_modules/math-intrinsics/min.js","webpack://app/./node_modules/math-intrinsics/pow.js","webpack://app/./node_modules/math-intrinsics/round.js","webpack://app/./node_modules/math-intrinsics/sign.js","webpack://app/./node_modules/object-is/implementation.js","webpack://app/./node_modules/object-is/index.js","webpack://app/./node_modules/object-is/polyfill.js","webpack://app/./node_modules/object-is/shim.js","webpack://app/./node_modules/object-keys/implementation.js","webpack://app/./node_modules/object-keys/index.js","webpack://app/./node_modules/object-keys/isArguments.js","webpack://app/./node_modules/parchment/dist/parchment.js","webpack://app/./node_modules/quill-delta/lib/delta.js","webpack://app/./node_modules/quill-delta/lib/op.js","webpack://app/./node_modules/quill/blots/break.js","webpack://app/./node_modules/quill/blots/block.js","webpack://app/./node_modules/quill/blots/inline.js","webpack://app/./node_modules/quill/blots/text.js","webpack://app/./node_modules/quill/formats/code.js","webpack://app/./node_modules/regexp.prototype.flags/implementation.js","webpack://app/./node_modules/regexp.prototype.flags/index.js","webpack://app/./node_modules/regexp.prototype.flags/polyfill.js","webpack://app/./node_modules/regexp.prototype.flags/shim.js","webpack://app/./node_modules/set-function-length/index.js","webpack://app/./node_modules/set-function-name/index.js"],"sourcesContent":["'use strict';\n\nvar bind = require('function-bind');\n\nvar $apply = require('./functionApply');\nvar $call = require('./functionCall');\nvar $reflectApply = require('./reflectApply');\n\n/** @type {import('./actualApply')} */\nmodule.exports = $reflectApply || bind.call($call, $apply);\n","'use strict';\n\nvar bind = require('function-bind');\nvar $apply = require('./functionApply');\nvar actualApply = require('./actualApply');\n\n/** @type {import('./applyBind')} */\nmodule.exports = function applyBind() {\n\treturn actualApply(bind, $apply, arguments);\n};\n","'use strict';\n\n/** @type {import('./functionApply')} */\nmodule.exports = Function.prototype.apply;\n","'use strict';\n\n/** @type {import('./functionCall')} */\nmodule.exports = Function.prototype.call;\n","'use strict';\n\nvar bind = require('function-bind');\nvar $TypeError = require('es-errors/type');\n\nvar $call = require('./functionCall');\nvar $actualApply = require('./actualApply');\n\n/** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */\nmodule.exports = function callBindBasic(args) {\n\tif (args.length < 1 || typeof args[0] !== 'function') {\n\t\tthrow new $TypeError('a function is required');\n\t}\n\treturn $actualApply(bind, $call, args);\n};\n","'use strict';\n\n/** @type {import('./reflectApply')} */\nmodule.exports = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar callBind = require('./');\n\nvar $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));\n\nmodule.exports = function callBoundIntrinsic(name, allowMissing) {\n\tvar intrinsic = GetIntrinsic(name, !!allowMissing);\n\tif (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {\n\t\treturn callBind(intrinsic);\n\t}\n\treturn intrinsic;\n};\n","'use strict';\n\nvar setFunctionLength = require('set-function-length');\n\nvar $defineProperty = require('es-define-property');\n\nvar callBindBasic = require('call-bind-apply-helpers');\nvar applyBind = require('call-bind-apply-helpers/applyBind');\n\nmodule.exports = function callBind(originalFunction) {\n\tvar func = callBindBasic(arguments);\n\tvar adjustedLength = originalFunction.length - (arguments.length - 1);\n\treturn setFunctionLength(\n\t\tfunc,\n\t\t1 + (adjustedLength > 0 ? adjustedLength : 0),\n\t\ttrue\n\t);\n};\n\nif ($defineProperty) {\n\t$defineProperty(module.exports, 'apply', { value: applyBind });\n} else {\n\tmodule.exports.apply = applyBind;\n}\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar callBindBasic = require('call-bind-apply-helpers');\n\n/** @type {(thisArg: string, searchString: string, position?: number) => number} */\nvar $indexOf = callBindBasic([GetIntrinsic('%String.prototype.indexOf%')]);\n\n/** @type {import('.')} */\nmodule.exports = function callBoundIntrinsic(name, allowMissing) {\n\t// eslint-disable-next-line no-extra-parens\n\tvar intrinsic = /** @type {Parameters<typeof callBindBasic>[0][0]} */ (GetIntrinsic(name, !!allowMissing));\n\tif (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {\n\t\treturn callBindBasic([intrinsic]);\n\t}\n\treturn intrinsic;\n};\n","var objectKeys = require('object-keys');\nvar isArguments = require('is-arguments');\nvar is = require('object-is');\nvar isRegex = require('is-regex');\nvar flags = require('regexp.prototype.flags');\nvar isDate = require('is-date-object');\n\nvar getTime = Date.prototype.getTime;\n\nfunction deepEqual(actual, expected, options) {\n  var opts = options || {};\n\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (opts.strict ? is(actual, expected) : actual === expected) {\n    return true;\n  }\n\n  // 7.3. Other pairs that do not both pass typeof value == 'object', equivalence is determined by ==.\n  if (!actual || !expected || (typeof actual !== 'object' && typeof expected !== 'object')) {\n    return opts.strict ? is(actual, expected) : actual == expected;\n  }\n\n  /*\n   * 7.4. For all other Object pairs, including Array objects, equivalence is\n   * determined by having the same number of owned properties (as verified\n   * with Object.prototype.hasOwnProperty.call), the same set of keys\n   * (although not necessarily the same order), equivalent values for every\n   * corresponding key, and an identical 'prototype' property. Note: this\n   * accounts for both named and indexed properties on Arrays.\n   */\n  // eslint-disable-next-line no-use-before-define\n  return objEquiv(actual, expected, opts);\n}\n\nfunction isUndefinedOrNull(value) {\n  return value === null || value === undefined;\n}\n\nfunction isBuffer(x) {\n  if (!x || typeof x !== 'object' || typeof x.length !== 'number') {\n    return false;\n  }\n  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {\n    return false;\n  }\n  if (x.length > 0 && typeof x[0] !== 'number') {\n    return false;\n  }\n  return true;\n}\n\nfunction objEquiv(a, b, opts) {\n  /* eslint max-statements: [2, 50] */\n  var i, key;\n  if (typeof a !== typeof b) { return false; }\n  if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) { return false; }\n\n  // an identical 'prototype' property.\n  if (a.prototype !== b.prototype) { return false; }\n\n  if (isArguments(a) !== isArguments(b)) { return false; }\n\n  var aIsRegex = isRegex(a);\n  var bIsRegex = isRegex(b);\n  if (aIsRegex !== bIsRegex) { return false; }\n  if (aIsRegex || bIsRegex) {\n    return a.source === b.source && flags(a) === flags(b);\n  }\n\n  if (isDate(a) && isDate(b)) {\n    return getTime.call(a) === getTime.call(b);\n  }\n\n  var aIsBuffer = isBuffer(a);\n  var bIsBuffer = isBuffer(b);\n  if (aIsBuffer !== bIsBuffer) { return false; }\n  if (aIsBuffer || bIsBuffer) { // && would work too, because both are true or both false here\n    if (a.length !== b.length) { return false; }\n    for (i = 0; i < a.length; i++) {\n      if (a[i] !== b[i]) { return false; }\n    }\n    return true;\n  }\n\n  if (typeof a !== typeof b) { return false; }\n\n  try {\n    var ka = objectKeys(a);\n    var kb = objectKeys(b);\n  } catch (e) { // happens when one is a string literal and the other isn't\n    return false;\n  }\n  // having the same number of owned properties (keys incorporates hasOwnProperty)\n  if (ka.length !== kb.length) { return false; }\n\n  // the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  // ~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] != kb[i]) { return false; }\n  }\n  // equivalent values for every corresponding key, and ~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!deepEqual(a[key], b[key], opts)) { return false; }\n  }\n\n  return true;\n}\n\nmodule.exports = deepEqual;\n","'use strict';\n\nvar $defineProperty = require('es-define-property');\n\nvar $SyntaxError = require('es-errors/syntax');\nvar $TypeError = require('es-errors/type');\n\nvar gopd = require('gopd');\n\n/** @type {import('.')} */\nmodule.exports = function defineDataProperty(\n\tobj,\n\tproperty,\n\tvalue\n) {\n\tif (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {\n\t\tthrow new $TypeError('`obj` must be an object or a function`');\n\t}\n\tif (typeof property !== 'string' && typeof property !== 'symbol') {\n\t\tthrow new $TypeError('`property` must be a string or a symbol`');\n\t}\n\tif (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) {\n\t\tthrow new $TypeError('`nonEnumerable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) {\n\t\tthrow new $TypeError('`nonWritable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) {\n\t\tthrow new $TypeError('`nonConfigurable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 6 && typeof arguments[6] !== 'boolean') {\n\t\tthrow new $TypeError('`loose`, if provided, must be a boolean');\n\t}\n\n\tvar nonEnumerable = arguments.length > 3 ? arguments[3] : null;\n\tvar nonWritable = arguments.length > 4 ? arguments[4] : null;\n\tvar nonConfigurable = arguments.length > 5 ? arguments[5] : null;\n\tvar loose = arguments.length > 6 ? arguments[6] : false;\n\n\t/* @type {false | TypedPropertyDescriptor<unknown>} */\n\tvar desc = !!gopd && gopd(obj, property);\n\n\tif ($defineProperty) {\n\t\t$defineProperty(obj, property, {\n\t\t\tconfigurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,\n\t\t\tenumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,\n\t\t\tvalue: value,\n\t\t\twritable: nonWritable === null && desc ? desc.writable : !nonWritable\n\t\t});\n\t} else if (loose || (!nonEnumerable && !nonWritable && !nonConfigurable)) {\n\t\t// must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable\n\t\tobj[property] = value; // eslint-disable-line no-param-reassign\n\t} else {\n\t\tthrow new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.');\n\t}\n};\n","'use strict';\n\nvar keys = require('object-keys');\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';\n\nvar toStr = Object.prototype.toString;\nvar concat = Array.prototype.concat;\nvar defineDataProperty = require('define-data-property');\n\nvar isFunction = function (fn) {\n\treturn typeof fn === 'function' && toStr.call(fn) === '[object Function]';\n};\n\nvar supportsDescriptors = require('has-property-descriptors')();\n\nvar defineProperty = function (object, name, value, predicate) {\n\tif (name in object) {\n\t\tif (predicate === true) {\n\t\t\tif (object[name] === value) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t} else if (!isFunction(predicate) || !predicate()) {\n\t\t\treturn;\n\t\t}\n\t}\n\n\tif (supportsDescriptors) {\n\t\tdefineDataProperty(object, name, value, true);\n\t} else {\n\t\tdefineDataProperty(object, name, value);\n\t}\n};\n\nvar defineProperties = function (object, map) {\n\tvar predicates = arguments.length > 2 ? arguments[2] : {};\n\tvar props = keys(map);\n\tif (hasSymbols) {\n\t\tprops = concat.call(props, Object.getOwnPropertySymbols(map));\n\t}\n\tfor (var i = 0; i < props.length; i += 1) {\n\t\tdefineProperty(object, props[i], map[props[i]], predicates[props[i]]);\n\t}\n};\n\ndefineProperties.supportsDescriptors = !!supportsDescriptors;\n\nmodule.exports = defineProperties;\n","'use strict';\n\nvar callBind = require('call-bind-apply-helpers');\nvar gOPD = require('gopd');\n\nvar hasProtoAccessor;\ntry {\n\t// eslint-disable-next-line no-extra-parens, no-proto\n\thasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */ ([]).__proto__ === Array.prototype;\n} catch (e) {\n\tif (!e || typeof e !== 'object' || !('code' in e) || e.code !== 'ERR_PROTO_ACCESS') {\n\t\tthrow e;\n\t}\n}\n\n// eslint-disable-next-line no-extra-parens\nvar desc = !!hasProtoAccessor && gOPD && gOPD(Object.prototype, /** @type {keyof typeof Object.prototype} */ ('__proto__'));\n\nvar $Object = Object;\nvar $getPrototypeOf = $Object.getPrototypeOf;\n\n/** @type {import('./get')} */\nmodule.exports = desc && typeof desc.get === 'function'\n\t? callBind([desc.get])\n\t: typeof $getPrototypeOf === 'function'\n\t\t? /** @type {import('./get')} */ function getDunder(value) {\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\treturn $getPrototypeOf(value == null ? value : $Object(value));\n\t\t}\n\t\t: false;\n","'use strict';\n\n/** @type {import('.')} */\nvar $defineProperty = Object.defineProperty || false;\nif ($defineProperty) {\n\ttry {\n\t\t$defineProperty({}, 'a', { value: 1 });\n\t} catch (e) {\n\t\t// IE 8 has a broken defineProperty\n\t\t$defineProperty = false;\n\t}\n}\n\nmodule.exports = $defineProperty;\n","'use strict';\n\n/** @type {import('./eval')} */\nmodule.exports = EvalError;\n","'use strict';\n\n/** @type {import('.')} */\nmodule.exports = Error;\n","'use strict';\n\n/** @type {import('./range')} */\nmodule.exports = RangeError;\n","'use strict';\n\n/** @type {import('./ref')} */\nmodule.exports = ReferenceError;\n","'use strict';\n\n/** @type {import('./syntax')} */\nmodule.exports = SyntaxError;\n","'use strict';\n\n/** @type {import('./type')} */\nmodule.exports = TypeError;\n","'use strict';\n\n/** @type {import('./uri')} */\nmodule.exports = URIError;\n","'use strict';\n\n/** @type {import('.')} */\nmodule.exports = Object;\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","/**\n * This library modifies the diff-patch-match library by Neil Fraser\n * by removing the patch and match functionality and certain advanced\n * options in the diff function. The original license is as follows:\n *\n * ===\n *\n * Diff Match and Patch\n *\n * Copyright 2006 Google Inc.\n * http://code.google.com/p/google-diff-match-patch/\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/**\n * The data structure representing a diff is an array of tuples:\n * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]\n * which means: delete 'Hello', add 'Goodbye' and keep ' world.'\n */\nvar DIFF_DELETE = -1;\nvar DIFF_INSERT = 1;\nvar DIFF_EQUAL = 0;\n\n\n/**\n * Find the differences between two texts.  Simplifies the problem by stripping\n * any common prefix or suffix off the texts before diffing.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {Int} cursor_pos Expected edit position in text1 (optional)\n * @return {Array} Array of diff tuples.\n */\nfunction diff_main(text1, text2, cursor_pos) {\n  // Check for equality (speedup).\n  if (text1 == text2) {\n    if (text1) {\n      return [[DIFF_EQUAL, text1]];\n    }\n    return [];\n  }\n\n  // Check cursor_pos within bounds\n  if (cursor_pos < 0 || text1.length < cursor_pos) {\n    cursor_pos = null;\n  }\n\n  // Trim off common prefix (speedup).\n  var commonlength = diff_commonPrefix(text1, text2);\n  var commonprefix = text1.substring(0, commonlength);\n  text1 = text1.substring(commonlength);\n  text2 = text2.substring(commonlength);\n\n  // Trim off common suffix (speedup).\n  commonlength = diff_commonSuffix(text1, text2);\n  var commonsuffix = text1.substring(text1.length - commonlength);\n  text1 = text1.substring(0, text1.length - commonlength);\n  text2 = text2.substring(0, text2.length - commonlength);\n\n  // Compute the diff on the middle block.\n  var diffs = diff_compute_(text1, text2);\n\n  // Restore the prefix and suffix.\n  if (commonprefix) {\n    diffs.unshift([DIFF_EQUAL, commonprefix]);\n  }\n  if (commonsuffix) {\n    diffs.push([DIFF_EQUAL, commonsuffix]);\n  }\n  diff_cleanupMerge(diffs);\n  if (cursor_pos != null) {\n    diffs = fix_cursor(diffs, cursor_pos);\n  }\n  diffs = fix_emoji(diffs);\n  return diffs;\n};\n\n\n/**\n * Find the differences between two texts.  Assumes that the texts do not\n * have any common prefix or suffix.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @return {Array} Array of diff tuples.\n */\nfunction diff_compute_(text1, text2) {\n  var diffs;\n\n  if (!text1) {\n    // Just add some text (speedup).\n    return [[DIFF_INSERT, text2]];\n  }\n\n  if (!text2) {\n    // Just delete some text (speedup).\n    return [[DIFF_DELETE, text1]];\n  }\n\n  var longtext = text1.length > text2.length ? text1 : text2;\n  var shorttext = text1.length > text2.length ? text2 : text1;\n  var i = longtext.indexOf(shorttext);\n  if (i != -1) {\n    // Shorter text is inside the longer text (speedup).\n    diffs = [[DIFF_INSERT, longtext.substring(0, i)],\n             [DIFF_EQUAL, shorttext],\n             [DIFF_INSERT, longtext.substring(i + shorttext.length)]];\n    // Swap insertions for deletions if diff is reversed.\n    if (text1.length > text2.length) {\n      diffs[0][0] = diffs[2][0] = DIFF_DELETE;\n    }\n    return diffs;\n  }\n\n  if (shorttext.length == 1) {\n    // Single character string.\n    // After the previous speedup, the character can't be an equality.\n    return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];\n  }\n\n  // Check to see if the problem can be split in two.\n  var hm = diff_halfMatch_(text1, text2);\n  if (hm) {\n    // A half-match was found, sort out the return data.\n    var text1_a = hm[0];\n    var text1_b = hm[1];\n    var text2_a = hm[2];\n    var text2_b = hm[3];\n    var mid_common = hm[4];\n    // Send both pairs off for separate processing.\n    var diffs_a = diff_main(text1_a, text2_a);\n    var diffs_b = diff_main(text1_b, text2_b);\n    // Merge the results.\n    return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b);\n  }\n\n  return diff_bisect_(text1, text2);\n};\n\n\n/**\n * Find the 'middle snake' of a diff, split the problem in two\n * and return the recursively constructed diff.\n * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @return {Array} Array of diff tuples.\n * @private\n */\nfunction diff_bisect_(text1, text2) {\n  // Cache the text lengths to prevent multiple calls.\n  var text1_length = text1.length;\n  var text2_length = text2.length;\n  var max_d = Math.ceil((text1_length + text2_length) / 2);\n  var v_offset = max_d;\n  var v_length = 2 * max_d;\n  var v1 = new Array(v_length);\n  var v2 = new Array(v_length);\n  // Setting all elements to -1 is faster in Chrome & Firefox than mixing\n  // integers and undefined.\n  for (var x = 0; x < v_length; x++) {\n    v1[x] = -1;\n    v2[x] = -1;\n  }\n  v1[v_offset + 1] = 0;\n  v2[v_offset + 1] = 0;\n  var delta = text1_length - text2_length;\n  // If the total number of characters is odd, then the front path will collide\n  // with the reverse path.\n  var front = (delta % 2 != 0);\n  // Offsets for start and end of k loop.\n  // Prevents mapping of space beyond the grid.\n  var k1start = 0;\n  var k1end = 0;\n  var k2start = 0;\n  var k2end = 0;\n  for (var d = 0; d < max_d; d++) {\n    // Walk the front path one step.\n    for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {\n      var k1_offset = v_offset + k1;\n      var x1;\n      if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {\n        x1 = v1[k1_offset + 1];\n      } else {\n        x1 = v1[k1_offset - 1] + 1;\n      }\n      var y1 = x1 - k1;\n      while (x1 < text1_length && y1 < text2_length &&\n             text1.charAt(x1) == text2.charAt(y1)) {\n        x1++;\n        y1++;\n      }\n      v1[k1_offset] = x1;\n      if (x1 > text1_length) {\n        // Ran off the right of the graph.\n        k1end += 2;\n      } else if (y1 > text2_length) {\n        // Ran off the bottom of the graph.\n        k1start += 2;\n      } else if (front) {\n        var k2_offset = v_offset + delta - k1;\n        if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {\n          // Mirror x2 onto top-left coordinate system.\n          var x2 = text1_length - v2[k2_offset];\n          if (x1 >= x2) {\n            // Overlap detected.\n            return diff_bisectSplit_(text1, text2, x1, y1);\n          }\n        }\n      }\n    }\n\n    // Walk the reverse path one step.\n    for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {\n      var k2_offset = v_offset + k2;\n      var x2;\n      if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) {\n        x2 = v2[k2_offset + 1];\n      } else {\n        x2 = v2[k2_offset - 1] + 1;\n      }\n      var y2 = x2 - k2;\n      while (x2 < text1_length && y2 < text2_length &&\n             text1.charAt(text1_length - x2 - 1) ==\n             text2.charAt(text2_length - y2 - 1)) {\n        x2++;\n        y2++;\n      }\n      v2[k2_offset] = x2;\n      if (x2 > text1_length) {\n        // Ran off the left of the graph.\n        k2end += 2;\n      } else if (y2 > text2_length) {\n        // Ran off the top of the graph.\n        k2start += 2;\n      } else if (!front) {\n        var k1_offset = v_offset + delta - k2;\n        if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {\n          var x1 = v1[k1_offset];\n          var y1 = v_offset + x1 - k1_offset;\n          // Mirror x2 onto top-left coordinate system.\n          x2 = text1_length - x2;\n          if (x1 >= x2) {\n            // Overlap detected.\n            return diff_bisectSplit_(text1, text2, x1, y1);\n          }\n        }\n      }\n    }\n  }\n  // Diff took too long and hit the deadline or\n  // number of diffs equals number of characters, no commonality at all.\n  return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];\n};\n\n\n/**\n * Given the location of the 'middle snake', split the diff in two parts\n * and recurse.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} x Index of split point in text1.\n * @param {number} y Index of split point in text2.\n * @return {Array} Array of diff tuples.\n */\nfunction diff_bisectSplit_(text1, text2, x, y) {\n  var text1a = text1.substring(0, x);\n  var text2a = text2.substring(0, y);\n  var text1b = text1.substring(x);\n  var text2b = text2.substring(y);\n\n  // Compute both diffs serially.\n  var diffs = diff_main(text1a, text2a);\n  var diffsb = diff_main(text1b, text2b);\n\n  return diffs.concat(diffsb);\n};\n\n\n/**\n * Determine the common prefix of two strings.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the start of each\n *     string.\n */\nfunction diff_commonPrefix(text1, text2) {\n  // Quick check for common null cases.\n  if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {\n    return 0;\n  }\n  // Binary search.\n  // Performance analysis: http://neil.fraser.name/news/2007/10/09/\n  var pointermin = 0;\n  var pointermax = Math.min(text1.length, text2.length);\n  var pointermid = pointermax;\n  var pointerstart = 0;\n  while (pointermin < pointermid) {\n    if (text1.substring(pointerstart, pointermid) ==\n        text2.substring(pointerstart, pointermid)) {\n      pointermin = pointermid;\n      pointerstart = pointermin;\n    } else {\n      pointermax = pointermid;\n    }\n    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n  }\n  return pointermid;\n};\n\n\n/**\n * Determine the common suffix of two strings.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the end of each string.\n */\nfunction diff_commonSuffix(text1, text2) {\n  // Quick check for common null cases.\n  if (!text1 || !text2 ||\n      text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) {\n    return 0;\n  }\n  // Binary search.\n  // Performance analysis: http://neil.fraser.name/news/2007/10/09/\n  var pointermin = 0;\n  var pointermax = Math.min(text1.length, text2.length);\n  var pointermid = pointermax;\n  var pointerend = 0;\n  while (pointermin < pointermid) {\n    if (text1.substring(text1.length - pointermid, text1.length - pointerend) ==\n        text2.substring(text2.length - pointermid, text2.length - pointerend)) {\n      pointermin = pointermid;\n      pointerend = pointermin;\n    } else {\n      pointermax = pointermid;\n    }\n    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n  }\n  return pointermid;\n};\n\n\n/**\n * Do the two texts share a substring which is at least half the length of the\n * longer text?\n * This speedup can produce non-minimal diffs.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {Array.<string>} Five element Array, containing the prefix of\n *     text1, the suffix of text1, the prefix of text2, the suffix of\n *     text2 and the common middle.  Or null if there was no match.\n */\nfunction diff_halfMatch_(text1, text2) {\n  var longtext = text1.length > text2.length ? text1 : text2;\n  var shorttext = text1.length > text2.length ? text2 : text1;\n  if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {\n    return null;  // Pointless.\n  }\n\n  /**\n   * Does a substring of shorttext exist within longtext such that the substring\n   * is at least half the length of longtext?\n   * Closure, but does not reference any external variables.\n   * @param {string} longtext Longer string.\n   * @param {string} shorttext Shorter string.\n   * @param {number} i Start index of quarter length substring within longtext.\n   * @return {Array.<string>} Five element Array, containing the prefix of\n   *     longtext, the suffix of longtext, the prefix of shorttext, the suffix\n   *     of shorttext and the common middle.  Or null if there was no match.\n   * @private\n   */\n  function diff_halfMatchI_(longtext, shorttext, i) {\n    // Start with a 1/4 length substring at position i as a seed.\n    var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));\n    var j = -1;\n    var best_common = '';\n    var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;\n    while ((j = shorttext.indexOf(seed, j + 1)) != -1) {\n      var prefixLength = diff_commonPrefix(longtext.substring(i),\n                                           shorttext.substring(j));\n      var suffixLength = diff_commonSuffix(longtext.substring(0, i),\n                                           shorttext.substring(0, j));\n      if (best_common.length < suffixLength + prefixLength) {\n        best_common = shorttext.substring(j - suffixLength, j) +\n            shorttext.substring(j, j + prefixLength);\n        best_longtext_a = longtext.substring(0, i - suffixLength);\n        best_longtext_b = longtext.substring(i + prefixLength);\n        best_shorttext_a = shorttext.substring(0, j - suffixLength);\n        best_shorttext_b = shorttext.substring(j + prefixLength);\n      }\n    }\n    if (best_common.length * 2 >= longtext.length) {\n      return [best_longtext_a, best_longtext_b,\n              best_shorttext_a, best_shorttext_b, best_common];\n    } else {\n      return null;\n    }\n  }\n\n  // First check if the second quarter is the seed for a half-match.\n  var hm1 = diff_halfMatchI_(longtext, shorttext,\n                             Math.ceil(longtext.length / 4));\n  // Check again based on the third quarter.\n  var hm2 = diff_halfMatchI_(longtext, shorttext,\n                             Math.ceil(longtext.length / 2));\n  var hm;\n  if (!hm1 && !hm2) {\n    return null;\n  } else if (!hm2) {\n    hm = hm1;\n  } else if (!hm1) {\n    hm = hm2;\n  } else {\n    // Both matched.  Select the longest.\n    hm = hm1[4].length > hm2[4].length ? hm1 : hm2;\n  }\n\n  // A half-match was found, sort out the return data.\n  var text1_a, text1_b, text2_a, text2_b;\n  if (text1.length > text2.length) {\n    text1_a = hm[0];\n    text1_b = hm[1];\n    text2_a = hm[2];\n    text2_b = hm[3];\n  } else {\n    text2_a = hm[0];\n    text2_b = hm[1];\n    text1_a = hm[2];\n    text1_b = hm[3];\n  }\n  var mid_common = hm[4];\n  return [text1_a, text1_b, text2_a, text2_b, mid_common];\n};\n\n\n/**\n * Reorder and merge like edit sections.  Merge equalities.\n * Any edit section can move as long as it doesn't cross an equality.\n * @param {Array} diffs Array of diff tuples.\n */\nfunction diff_cleanupMerge(diffs) {\n  diffs.push([DIFF_EQUAL, '']);  // Add a dummy entry at the end.\n  var pointer = 0;\n  var count_delete = 0;\n  var count_insert = 0;\n  var text_delete = '';\n  var text_insert = '';\n  var commonlength;\n  while (pointer < diffs.length) {\n    switch (diffs[pointer][0]) {\n      case DIFF_INSERT:\n        count_insert++;\n        text_insert += diffs[pointer][1];\n        pointer++;\n        break;\n      case DIFF_DELETE:\n        count_delete++;\n        text_delete += diffs[pointer][1];\n        pointer++;\n        break;\n      case DIFF_EQUAL:\n        // Upon reaching an equality, check for prior redundancies.\n        if (count_delete + count_insert > 1) {\n          if (count_delete !== 0 && count_insert !== 0) {\n            // Factor out any common prefixies.\n            commonlength = diff_commonPrefix(text_insert, text_delete);\n            if (commonlength !== 0) {\n              if ((pointer - count_delete - count_insert) > 0 &&\n                  diffs[pointer - count_delete - count_insert - 1][0] ==\n                  DIFF_EQUAL) {\n                diffs[pointer - count_delete - count_insert - 1][1] +=\n                    text_insert.substring(0, commonlength);\n              } else {\n                diffs.splice(0, 0, [DIFF_EQUAL,\n                                    text_insert.substring(0, commonlength)]);\n                pointer++;\n              }\n              text_insert = text_insert.substring(commonlength);\n              text_delete = text_delete.substring(commonlength);\n            }\n            // Factor out any common suffixies.\n            commonlength = diff_commonSuffix(text_insert, text_delete);\n            if (commonlength !== 0) {\n              diffs[pointer][1] = text_insert.substring(text_insert.length -\n                  commonlength) + diffs[pointer][1];\n              text_insert = text_insert.substring(0, text_insert.length -\n                  commonlength);\n              text_delete = text_delete.substring(0, text_delete.length -\n                  commonlength);\n            }\n          }\n          // Delete the offending records and add the merged ones.\n          if (count_delete === 0) {\n            diffs.splice(pointer - count_insert,\n                count_delete + count_insert, [DIFF_INSERT, text_insert]);\n          } else if (count_insert === 0) {\n            diffs.splice(pointer - count_delete,\n                count_delete + count_insert, [DIFF_DELETE, text_delete]);\n          } else {\n            diffs.splice(pointer - count_delete - count_insert,\n                count_delete + count_insert, [DIFF_DELETE, text_delete],\n                [DIFF_INSERT, text_insert]);\n          }\n          pointer = pointer - count_delete - count_insert +\n                    (count_delete ? 1 : 0) + (count_insert ? 1 : 0) + 1;\n        } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) {\n          // Merge this equality with the previous one.\n          diffs[pointer - 1][1] += diffs[pointer][1];\n          diffs.splice(pointer, 1);\n        } else {\n          pointer++;\n        }\n        count_insert = 0;\n        count_delete = 0;\n        text_delete = '';\n        text_insert = '';\n        break;\n    }\n  }\n  if (diffs[diffs.length - 1][1] === '') {\n    diffs.pop();  // Remove the dummy entry at the end.\n  }\n\n  // Second pass: look for single edits surrounded on both sides by equalities\n  // which can be shifted sideways to eliminate an equality.\n  // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC\n  var changes = false;\n  pointer = 1;\n  // Intentionally ignore the first and last element (don't need checking).\n  while (pointer < diffs.length - 1) {\n    if (diffs[pointer - 1][0] == DIFF_EQUAL &&\n        diffs[pointer + 1][0] == DIFF_EQUAL) {\n      // This is a single edit surrounded by equalities.\n      if (diffs[pointer][1].substring(diffs[pointer][1].length -\n          diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) {\n        // Shift the edit over the previous equality.\n        diffs[pointer][1] = diffs[pointer - 1][1] +\n            diffs[pointer][1].substring(0, diffs[pointer][1].length -\n                                        diffs[pointer - 1][1].length);\n        diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];\n        diffs.splice(pointer - 1, 1);\n        changes = true;\n      } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==\n          diffs[pointer + 1][1]) {\n        // Shift the edit over the next equality.\n        diffs[pointer - 1][1] += diffs[pointer + 1][1];\n        diffs[pointer][1] =\n            diffs[pointer][1].substring(diffs[pointer + 1][1].length) +\n            diffs[pointer + 1][1];\n        diffs.splice(pointer + 1, 1);\n        changes = true;\n      }\n    }\n    pointer++;\n  }\n  // If shifts were made, the diff needs reordering and another shift sweep.\n  if (changes) {\n    diff_cleanupMerge(diffs);\n  }\n};\n\n\nvar diff = diff_main;\ndiff.INSERT = DIFF_INSERT;\ndiff.DELETE = DIFF_DELETE;\ndiff.EQUAL = DIFF_EQUAL;\n\nmodule.exports = diff;\n\n/*\n * Modify a diff such that the cursor position points to the start of a change:\n * E.g.\n *   cursor_normalize_diff([[DIFF_EQUAL, 'abc']], 1)\n *     => [1, [[DIFF_EQUAL, 'a'], [DIFF_EQUAL, 'bc']]]\n *   cursor_normalize_diff([[DIFF_INSERT, 'new'], [DIFF_DELETE, 'xyz']], 2)\n *     => [2, [[DIFF_INSERT, 'new'], [DIFF_DELETE, 'xy'], [DIFF_DELETE, 'z']]]\n *\n * @param {Array} diffs Array of diff tuples\n * @param {Int} cursor_pos Suggested edit position. Must not be out of bounds!\n * @return {Array} A tuple [cursor location in the modified diff, modified diff]\n */\nfunction cursor_normalize_diff (diffs, cursor_pos) {\n  if (cursor_pos === 0) {\n    return [DIFF_EQUAL, diffs];\n  }\n  for (var current_pos = 0, i = 0; i < diffs.length; i++) {\n    var d = diffs[i];\n    if (d[0] === DIFF_DELETE || d[0] === DIFF_EQUAL) {\n      var next_pos = current_pos + d[1].length;\n      if (cursor_pos === next_pos) {\n        return [i + 1, diffs];\n      } else if (cursor_pos < next_pos) {\n        // copy to prevent side effects\n        diffs = diffs.slice();\n        // split d into two diff changes\n        var split_pos = cursor_pos - current_pos;\n        var d_left = [d[0], d[1].slice(0, split_pos)];\n        var d_right = [d[0], d[1].slice(split_pos)];\n        diffs.splice(i, 1, d_left, d_right);\n        return [i + 1, diffs];\n      } else {\n        current_pos = next_pos;\n      }\n    }\n  }\n  throw new Error('cursor_pos is out of bounds!')\n}\n\n/*\n * Modify a diff such that the edit position is \"shifted\" to the proposed edit location (cursor_position).\n *\n * Case 1)\n *   Check if a naive shift is possible:\n *     [0, X], [ 1, Y] -> [ 1, Y], [0, X]    (if X + Y === Y + X)\n *     [0, X], [-1, Y] -> [-1, Y], [0, X]    (if X + Y === Y + X) - holds same result\n * Case 2)\n *   Check if the following shifts are possible:\n *     [0, 'pre'], [ 1, 'prefix'] -> [ 1, 'pre'], [0, 'pre'], [ 1, 'fix']\n *     [0, 'pre'], [-1, 'prefix'] -> [-1, 'pre'], [0, 'pre'], [-1, 'fix']\n *         ^            ^\n *         d          d_next\n *\n * @param {Array} diffs Array of diff tuples\n * @param {Int} cursor_pos Suggested edit position. Must not be out of bounds!\n * @return {Array} Array of diff tuples\n */\nfunction fix_cursor (diffs, cursor_pos) {\n  var norm = cursor_normalize_diff(diffs, cursor_pos);\n  var ndiffs = norm[1];\n  var cursor_pointer = norm[0];\n  var d = ndiffs[cursor_pointer];\n  var d_next = ndiffs[cursor_pointer + 1];\n\n  if (d == null) {\n    // Text was deleted from end of original string,\n    // cursor is now out of bounds in new string\n    return diffs;\n  } else if (d[0] !== DIFF_EQUAL) {\n    // A modification happened at the cursor location.\n    // This is the expected outcome, so we can return the original diff.\n    return diffs;\n  } else {\n    if (d_next != null && d[1] + d_next[1] === d_next[1] + d[1]) {\n      // Case 1)\n      // It is possible to perform a naive shift\n      ndiffs.splice(cursor_pointer, 2, d_next, d)\n      return merge_tuples(ndiffs, cursor_pointer, 2)\n    } else if (d_next != null && d_next[1].indexOf(d[1]) === 0) {\n      // Case 2)\n      // d[1] is a prefix of d_next[1]\n      // We can assume that d_next[0] !== 0, since d[0] === 0\n      // Shift edit locations..\n      ndiffs.splice(cursor_pointer, 2, [d_next[0], d[1]], [0, d[1]]);\n      var suffix = d_next[1].slice(d[1].length);\n      if (suffix.length > 0) {\n        ndiffs.splice(cursor_pointer + 2, 0, [d_next[0], suffix]);\n      }\n      return merge_tuples(ndiffs, cursor_pointer, 3)\n    } else {\n      // Not possible to perform any modification\n      return diffs;\n    }\n  }\n}\n\n/*\n * Check diff did not split surrogate pairs.\n * Ex. [0, '\\uD83D'], [-1, '\\uDC36'], [1, '\\uDC2F'] -> [-1, '\\uD83D\\uDC36'], [1, '\\uD83D\\uDC2F']\n *     '\\uD83D\\uDC36' === '🐶', '\\uD83D\\uDC2F' === '🐯'\n *\n * @param {Array} diffs Array of diff tuples\n * @return {Array} Array of diff tuples\n */\nfunction fix_emoji (diffs) {\n  var compact = false;\n  var starts_with_pair_end = function(str) {\n    return str.charCodeAt(0) >= 0xDC00 && str.charCodeAt(0) <= 0xDFFF;\n  }\n  var ends_with_pair_start = function(str) {\n    return str.charCodeAt(str.length-1) >= 0xD800 && str.charCodeAt(str.length-1) <= 0xDBFF;\n  }\n  for (var i = 2; i < diffs.length; i += 1) {\n    if (diffs[i-2][0] === DIFF_EQUAL && ends_with_pair_start(diffs[i-2][1]) &&\n        diffs[i-1][0] === DIFF_DELETE && starts_with_pair_end(diffs[i-1][1]) &&\n        diffs[i][0] === DIFF_INSERT && starts_with_pair_end(diffs[i][1])) {\n      compact = true;\n\n      diffs[i-1][1] = diffs[i-2][1].slice(-1) + diffs[i-1][1];\n      diffs[i][1] = diffs[i-2][1].slice(-1) + diffs[i][1];\n\n      diffs[i-2][1] = diffs[i-2][1].slice(0, -1);\n    }\n  }\n  if (!compact) {\n    return diffs;\n  }\n  var fixed_diffs = [];\n  for (var i = 0; i < diffs.length; i += 1) {\n    if (diffs[i][1].length > 0) {\n      fixed_diffs.push(diffs[i]);\n    }\n  }\n  return fixed_diffs;\n}\n\n/*\n * Try to merge tuples with their neigbors in a given range.\n * E.g. [0, 'a'], [0, 'b'] -> [0, 'ab']\n *\n * @param {Array} diffs Array of diff tuples.\n * @param {Int} start Position of the first element to merge (diffs[start] is also merged with diffs[start - 1]).\n * @param {Int} length Number of consecutive elements to check.\n * @return {Array} Array of merged diff tuples.\n */\nfunction merge_tuples (diffs, start, length) {\n  // Check from (start-1) to (start+length).\n  for (var i = start + length - 1; i >= 0 && i >= start - 1; i--) {\n    if (i + 1 < diffs.length) {\n      var left_d = diffs[i];\n      var right_d = diffs[i+1];\n      if (left_d[0] === right_d[1]) {\n        diffs.splice(i, 2, [left_d[0], left_d[1] + right_d[1]]);\n      }\n    }\n  }\n  return diffs;\n}\n","'use strict';\n\n/* eslint no-invalid-this: 1 */\n\nvar ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar toStr = Object.prototype.toString;\nvar max = Math.max;\nvar funcType = '[object Function]';\n\nvar concatty = function concatty(a, b) {\n    var arr = [];\n\n    for (var i = 0; i < a.length; i += 1) {\n        arr[i] = a[i];\n    }\n    for (var j = 0; j < b.length; j += 1) {\n        arr[j + a.length] = b[j];\n    }\n\n    return arr;\n};\n\nvar slicy = function slicy(arrLike, offset) {\n    var arr = [];\n    for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {\n        arr[j] = arrLike[i];\n    }\n    return arr;\n};\n\nvar joiny = function (arr, joiner) {\n    var str = '';\n    for (var i = 0; i < arr.length; i += 1) {\n        str += arr[i];\n        if (i + 1 < arr.length) {\n            str += joiner;\n        }\n    }\n    return str;\n};\n\nmodule.exports = function bind(that) {\n    var target = this;\n    if (typeof target !== 'function' || toStr.apply(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n    }\n    var args = slicy(arguments, 1);\n\n    var bound;\n    var binder = function () {\n        if (this instanceof bound) {\n            var result = target.apply(\n                this,\n                concatty(args, arguments)\n            );\n            if (Object(result) === result) {\n                return result;\n            }\n            return this;\n        }\n        return target.apply(\n            that,\n            concatty(args, arguments)\n        );\n\n    };\n\n    var boundLength = max(0, target.length - args.length);\n    var boundArgs = [];\n    for (var i = 0; i < boundLength; i++) {\n        boundArgs[i] = '$' + i;\n    }\n\n    bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder);\n\n    if (target.prototype) {\n        var Empty = function Empty() {};\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n    }\n\n    return bound;\n};\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = Function.prototype.bind || implementation;\n","'use strict';\n\nvar functionsHaveNames = function functionsHaveNames() {\n\treturn typeof function f() {}.name === 'string';\n};\n\nvar gOPD = Object.getOwnPropertyDescriptor;\nif (gOPD) {\n\ttry {\n\t\tgOPD([], 'length');\n\t} catch (e) {\n\t\t// IE 8 has a broken gOPD\n\t\tgOPD = null;\n\t}\n}\n\nfunctionsHaveNames.functionsHaveConfigurableNames = function functionsHaveConfigurableNames() {\n\tif (!functionsHaveNames() || !gOPD) {\n\t\treturn false;\n\t}\n\tvar desc = gOPD(function () {}, 'name');\n\treturn !!desc && !!desc.configurable;\n};\n\nvar $bind = Function.prototype.bind;\n\nfunctionsHaveNames.boundFunctionsHaveNames = function boundFunctionsHaveNames() {\n\treturn functionsHaveNames() && typeof $bind === 'function' && function f() {}.bind().name !== '';\n};\n\nmodule.exports = functionsHaveNames;\n","'use strict';\n\nvar undefined;\n\nvar $Object = require('es-object-atoms');\n\nvar $Error = require('es-errors');\nvar $EvalError = require('es-errors/eval');\nvar $RangeError = require('es-errors/range');\nvar $ReferenceError = require('es-errors/ref');\nvar $SyntaxError = require('es-errors/syntax');\nvar $TypeError = require('es-errors/type');\nvar $URIError = require('es-errors/uri');\n\nvar abs = require('math-intrinsics/abs');\nvar floor = require('math-intrinsics/floor');\nvar max = require('math-intrinsics/max');\nvar min = require('math-intrinsics/min');\nvar pow = require('math-intrinsics/pow');\nvar round = require('math-intrinsics/round');\nvar sign = require('math-intrinsics/sign');\n\nvar $Function = Function;\n\n// eslint-disable-next-line consistent-return\nvar getEvalledConstructor = function (expressionSyntax) {\n\ttry {\n\t\treturn $Function('\"use strict\"; return (' + expressionSyntax + ').constructor;')();\n\t} catch (e) {}\n};\n\nvar $gOPD = require('gopd');\nvar $defineProperty = require('es-define-property');\n\nvar throwTypeError = function () {\n\tthrow new $TypeError();\n};\nvar ThrowTypeError = $gOPD\n\t? (function () {\n\t\ttry {\n\t\t\t// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties\n\t\t\targuments.callee; // IE 8 does not throw here\n\t\t\treturn throwTypeError;\n\t\t} catch (calleeThrows) {\n\t\t\ttry {\n\t\t\t\t// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')\n\t\t\t\treturn $gOPD(arguments, 'callee').get;\n\t\t\t} catch (gOPDthrows) {\n\t\t\t\treturn throwTypeError;\n\t\t\t}\n\t\t}\n\t}())\n\t: throwTypeError;\n\nvar hasSymbols = require('has-symbols')();\n\nvar getProto = require('get-proto');\nvar $ObjectGPO = require('get-proto/Object.getPrototypeOf');\nvar $ReflectGPO = require('get-proto/Reflect.getPrototypeOf');\n\nvar $apply = require('call-bind-apply-helpers/functionApply');\nvar $call = require('call-bind-apply-helpers/functionCall');\n\nvar needsEval = {};\n\nvar TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array);\n\nvar INTRINSICS = {\n\t__proto__: null,\n\t'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,\n\t'%Array%': Array,\n\t'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,\n\t'%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined,\n\t'%AsyncFromSyncIteratorPrototype%': undefined,\n\t'%AsyncFunction%': needsEval,\n\t'%AsyncGenerator%': needsEval,\n\t'%AsyncGeneratorFunction%': needsEval,\n\t'%AsyncIteratorPrototype%': needsEval,\n\t'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,\n\t'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,\n\t'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array,\n\t'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array,\n\t'%Boolean%': Boolean,\n\t'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,\n\t'%Date%': Date,\n\t'%decodeURI%': decodeURI,\n\t'%decodeURIComponent%': decodeURIComponent,\n\t'%encodeURI%': encodeURI,\n\t'%encodeURIComponent%': encodeURIComponent,\n\t'%Error%': $Error,\n\t'%eval%': eval, // eslint-disable-line no-eval\n\t'%EvalError%': $EvalError,\n\t'%Float16Array%': typeof Float16Array === 'undefined' ? undefined : Float16Array,\n\t'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,\n\t'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,\n\t'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,\n\t'%Function%': $Function,\n\t'%GeneratorFunction%': needsEval,\n\t'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,\n\t'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,\n\t'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,\n\t'%isFinite%': isFinite,\n\t'%isNaN%': isNaN,\n\t'%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined,\n\t'%JSON%': typeof JSON === 'object' ? JSON : undefined,\n\t'%Map%': typeof Map === 'undefined' ? undefined : Map,\n\t'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()),\n\t'%Math%': Math,\n\t'%Number%': Number,\n\t'%Object%': $Object,\n\t'%Object.getOwnPropertyDescriptor%': $gOPD,\n\t'%parseFloat%': parseFloat,\n\t'%parseInt%': parseInt,\n\t'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,\n\t'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,\n\t'%RangeError%': $RangeError,\n\t'%ReferenceError%': $ReferenceError,\n\t'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,\n\t'%RegExp%': RegExp,\n\t'%Set%': typeof Set === 'undefined' ? undefined : Set,\n\t'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()),\n\t'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,\n\t'%String%': String,\n\t'%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined,\n\t'%Symbol%': hasSymbols ? Symbol : undefined,\n\t'%SyntaxError%': $SyntaxError,\n\t'%ThrowTypeError%': ThrowTypeError,\n\t'%TypedArray%': TypedArray,\n\t'%TypeError%': $TypeError,\n\t'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,\n\t'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,\n\t'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,\n\t'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,\n\t'%URIError%': $URIError,\n\t'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,\n\t'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,\n\t'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet,\n\n\t'%Function.prototype.call%': $call,\n\t'%Function.prototype.apply%': $apply,\n\t'%Object.defineProperty%': $defineProperty,\n\t'%Object.getPrototypeOf%': $ObjectGPO,\n\t'%Math.abs%': abs,\n\t'%Math.floor%': floor,\n\t'%Math.max%': max,\n\t'%Math.min%': min,\n\t'%Math.pow%': pow,\n\t'%Math.round%': round,\n\t'%Math.sign%': sign,\n\t'%Reflect.getPrototypeOf%': $ReflectGPO\n};\n\nif (getProto) {\n\ttry {\n\t\tnull.error; // eslint-disable-line no-unused-expressions\n\t} catch (e) {\n\t\t// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229\n\t\tvar errorProto = getProto(getProto(e));\n\t\tINTRINSICS['%Error.prototype%'] = errorProto;\n\t}\n}\n\nvar doEval = function doEval(name) {\n\tvar value;\n\tif (name === '%AsyncFunction%') {\n\t\tvalue = getEvalledConstructor('async function () {}');\n\t} else if (name === '%GeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('function* () {}');\n\t} else if (name === '%AsyncGeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('async function* () {}');\n\t} else if (name === '%AsyncGenerator%') {\n\t\tvar fn = doEval('%AsyncGeneratorFunction%');\n\t\tif (fn) {\n\t\t\tvalue = fn.prototype;\n\t\t}\n\t} else if (name === '%AsyncIteratorPrototype%') {\n\t\tvar gen = doEval('%AsyncGenerator%');\n\t\tif (gen && getProto) {\n\t\t\tvalue = getProto(gen.prototype);\n\t\t}\n\t}\n\n\tINTRINSICS[name] = value;\n\n\treturn value;\n};\n\nvar LEGACY_ALIASES = {\n\t__proto__: null,\n\t'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],\n\t'%ArrayPrototype%': ['Array', 'prototype'],\n\t'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],\n\t'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],\n\t'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],\n\t'%ArrayProto_values%': ['Array', 'prototype', 'values'],\n\t'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],\n\t'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],\n\t'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],\n\t'%BooleanPrototype%': ['Boolean', 'prototype'],\n\t'%DataViewPrototype%': ['DataView', 'prototype'],\n\t'%DatePrototype%': ['Date', 'prototype'],\n\t'%ErrorPrototype%': ['Error', 'prototype'],\n\t'%EvalErrorPrototype%': ['EvalError', 'prototype'],\n\t'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],\n\t'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],\n\t'%FunctionPrototype%': ['Function', 'prototype'],\n\t'%Generator%': ['GeneratorFunction', 'prototype'],\n\t'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],\n\t'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],\n\t'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],\n\t'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],\n\t'%JSONParse%': ['JSON', 'parse'],\n\t'%JSONStringify%': ['JSON', 'stringify'],\n\t'%MapPrototype%': ['Map', 'prototype'],\n\t'%NumberPrototype%': ['Number', 'prototype'],\n\t'%ObjectPrototype%': ['Object', 'prototype'],\n\t'%ObjProto_toString%': ['Object', 'prototype', 'toString'],\n\t'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],\n\t'%PromisePrototype%': ['Promise', 'prototype'],\n\t'%PromiseProto_then%': ['Promise', 'prototype', 'then'],\n\t'%Promise_all%': ['Promise', 'all'],\n\t'%Promise_reject%': ['Promise', 'reject'],\n\t'%Promise_resolve%': ['Promise', 'resolve'],\n\t'%RangeErrorPrototype%': ['RangeError', 'prototype'],\n\t'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],\n\t'%RegExpPrototype%': ['RegExp', 'prototype'],\n\t'%SetPrototype%': ['Set', 'prototype'],\n\t'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],\n\t'%StringPrototype%': ['String', 'prototype'],\n\t'%SymbolPrototype%': ['Symbol', 'prototype'],\n\t'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],\n\t'%TypedArrayPrototype%': ['TypedArray', 'prototype'],\n\t'%TypeErrorPrototype%': ['TypeError', 'prototype'],\n\t'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],\n\t'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],\n\t'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],\n\t'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],\n\t'%URIErrorPrototype%': ['URIError', 'prototype'],\n\t'%WeakMapPrototype%': ['WeakMap', 'prototype'],\n\t'%WeakSetPrototype%': ['WeakSet', 'prototype']\n};\n\nvar bind = require('function-bind');\nvar hasOwn = require('hasown');\nvar $concat = bind.call($call, Array.prototype.concat);\nvar $spliceApply = bind.call($apply, Array.prototype.splice);\nvar $replace = bind.call($call, String.prototype.replace);\nvar $strSlice = bind.call($call, String.prototype.slice);\nvar $exec = bind.call($call, RegExp.prototype.exec);\n\n/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */\nvar rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\nvar reEscapeChar = /\\\\(\\\\)?/g; /** Used to match backslashes in property paths. */\nvar stringToPath = function stringToPath(string) {\n\tvar first = $strSlice(string, 0, 1);\n\tvar last = $strSlice(string, -1);\n\tif (first === '%' && last !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected closing `%`');\n\t} else if (last === '%' && first !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected opening `%`');\n\t}\n\tvar result = [];\n\t$replace(string, rePropName, function (match, number, quote, subString) {\n\t\tresult[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;\n\t});\n\treturn result;\n};\n/* end adaptation */\n\nvar getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {\n\tvar intrinsicName = name;\n\tvar alias;\n\tif (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n\t\talias = LEGACY_ALIASES[intrinsicName];\n\t\tintrinsicName = '%' + alias[0] + '%';\n\t}\n\n\tif (hasOwn(INTRINSICS, intrinsicName)) {\n\t\tvar value = INTRINSICS[intrinsicName];\n\t\tif (value === needsEval) {\n\t\t\tvalue = doEval(intrinsicName);\n\t\t}\n\t\tif (typeof value === 'undefined' && !allowMissing) {\n\t\t\tthrow new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');\n\t\t}\n\n\t\treturn {\n\t\t\talias: alias,\n\t\t\tname: intrinsicName,\n\t\t\tvalue: value\n\t\t};\n\t}\n\n\tthrow new $SyntaxError('intrinsic ' + name + ' does not exist!');\n};\n\nmodule.exports = function GetIntrinsic(name, allowMissing) {\n\tif (typeof name !== 'string' || name.length === 0) {\n\t\tthrow new $TypeError('intrinsic name must be a non-empty string');\n\t}\n\tif (arguments.length > 1 && typeof allowMissing !== 'boolean') {\n\t\tthrow new $TypeError('\"allowMissing\" argument must be a boolean');\n\t}\n\n\tif ($exec(/^%?[^%]*%?$/, name) === null) {\n\t\tthrow new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');\n\t}\n\tvar parts = stringToPath(name);\n\tvar intrinsicBaseName = parts.length > 0 ? parts[0] : '';\n\n\tvar intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);\n\tvar intrinsicRealName = intrinsic.name;\n\tvar value = intrinsic.value;\n\tvar skipFurtherCaching = false;\n\n\tvar alias = intrinsic.alias;\n\tif (alias) {\n\t\tintrinsicBaseName = alias[0];\n\t\t$spliceApply(parts, $concat([0, 1], alias));\n\t}\n\n\tfor (var i = 1, isOwn = true; i < parts.length; i += 1) {\n\t\tvar part = parts[i];\n\t\tvar first = $strSlice(part, 0, 1);\n\t\tvar last = $strSlice(part, -1);\n\t\tif (\n\t\t\t(\n\t\t\t\t(first === '\"' || first === \"'\" || first === '`')\n\t\t\t\t|| (last === '\"' || last === \"'\" || last === '`')\n\t\t\t)\n\t\t\t&& first !== last\n\t\t) {\n\t\t\tthrow new $SyntaxError('property names with quotes must have matching quotes');\n\t\t}\n\t\tif (part === 'constructor' || !isOwn) {\n\t\t\tskipFurtherCaching = true;\n\t\t}\n\n\t\tintrinsicBaseName += '.' + part;\n\t\tintrinsicRealName = '%' + intrinsicBaseName + '%';\n\n\t\tif (hasOwn(INTRINSICS, intrinsicRealName)) {\n\t\t\tvalue = INTRINSICS[intrinsicRealName];\n\t\t} else if (value != null) {\n\t\t\tif (!(part in value)) {\n\t\t\t\tif (!allowMissing) {\n\t\t\t\t\tthrow new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');\n\t\t\t\t}\n\t\t\t\treturn void undefined;\n\t\t\t}\n\t\t\tif ($gOPD && (i + 1) >= parts.length) {\n\t\t\t\tvar desc = $gOPD(value, part);\n\t\t\t\tisOwn = !!desc;\n\n\t\t\t\t// By convention, when a data property is converted to an accessor\n\t\t\t\t// property to emulate a data property that does not suffer from\n\t\t\t\t// the override mistake, that accessor's getter is marked with\n\t\t\t\t// an `originalValue` property. Here, when we detect this, we\n\t\t\t\t// uphold the illusion by pretending to see that original data\n\t\t\t\t// property, i.e., returning the value rather than the getter\n\t\t\t\t// itself.\n\t\t\t\tif (isOwn && 'get' in desc && !('originalValue' in desc.get)) {\n\t\t\t\t\tvalue = desc.get;\n\t\t\t\t} else {\n\t\t\t\t\tvalue = value[part];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tisOwn = hasOwn(value, part);\n\t\t\t\tvalue = value[part];\n\t\t\t}\n\n\t\t\tif (isOwn && !skipFurtherCaching) {\n\t\t\t\tINTRINSICS[intrinsicRealName] = value;\n\t\t\t}\n\t\t}\n\t}\n\treturn value;\n};\n","'use strict';\n\nvar $Object = require('es-object-atoms');\n\n/** @type {import('./Object.getPrototypeOf')} */\nmodule.exports = $Object.getPrototypeOf || null;\n","'use strict';\n\n/** @type {import('./Reflect.getPrototypeOf')} */\nmodule.exports = (typeof Reflect !== 'undefined' && Reflect.getPrototypeOf) || null;\n","'use strict';\n\nvar reflectGetProto = require('./Reflect.getPrototypeOf');\nvar originalGetProto = require('./Object.getPrototypeOf');\n\nvar getDunderProto = require('dunder-proto/get');\n\n/** @type {import('.')} */\nmodule.exports = reflectGetProto\n\t? function getProto(O) {\n\t\t// @ts-expect-error TS can't narrow inside a closure, for some reason\n\t\treturn reflectGetProto(O);\n\t}\n\t: originalGetProto\n\t\t? function getProto(O) {\n\t\t\tif (!O || (typeof O !== 'object' && typeof O !== 'function')) {\n\t\t\t\tthrow new TypeError('getProto: not an object');\n\t\t\t}\n\t\t\t// @ts-expect-error TS can't narrow inside a closure, for some reason\n\t\t\treturn originalGetProto(O);\n\t\t}\n\t\t: getDunderProto\n\t\t\t? function getProto(O) {\n\t\t\t\t// @ts-expect-error TS can't narrow inside a closure, for some reason\n\t\t\t\treturn getDunderProto(O);\n\t\t\t}\n\t\t\t: null;\n","'use strict';\n\n/** @type {import('./gOPD')} */\nmodule.exports = Object.getOwnPropertyDescriptor;\n","'use strict';\n\n/** @type {import('.')} */\nvar $gOPD = require('./gOPD');\n\nif ($gOPD) {\n\ttry {\n\t\t$gOPD([], 'length');\n\t} catch (e) {\n\t\t// IE 8 has a broken gOPD\n\t\t$gOPD = null;\n\t}\n}\n\nmodule.exports = $gOPD;\n","'use strict';\n\nvar $defineProperty = require('es-define-property');\n\nvar hasPropertyDescriptors = function hasPropertyDescriptors() {\n\treturn !!$defineProperty;\n};\n\nhasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {\n\t// node v0.6 has a bug where array lengths can be Set but not Defined\n\tif (!$defineProperty) {\n\t\treturn null;\n\t}\n\ttry {\n\t\treturn $defineProperty([], 'length', { value: 1 }).length !== 1;\n\t} catch (e) {\n\t\t// In Firefox 4-22, defining length on an array throws an exception.\n\t\treturn true;\n\t}\n};\n\nmodule.exports = hasPropertyDescriptors;\n","'use strict';\n\nvar origSymbol = typeof Symbol !== 'undefined' && Symbol;\nvar hasSymbolSham = require('./shams');\n\n/** @type {import('.')} */\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","'use strict';\n\n/** @type {import('./shams')} */\n/* eslint complexity: [2, 18], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\t/** @type {{ [k in symbol]?: unknown }} */\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (var _ in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\t// eslint-disable-next-line no-extra-parens\n\t\tvar descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(obj, sym));\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","'use strict';\n\nvar hasSymbols = require('has-symbols/shams');\n\n/** @type {import('.')} */\nmodule.exports = function hasToStringTagShams() {\n\treturn hasSymbols() && !!Symbol.toStringTag;\n};\n","'use strict';\n\nvar call = Function.prototype.call;\nvar $hasOwn = Object.prototype.hasOwnProperty;\nvar bind = require('function-bind');\n\n/** @type {import('.')} */\nmodule.exports = bind.call(call, $hasOwn);\n","'use strict';\n\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar callBound = require('call-bind/callBound');\n\nvar $toString = callBound('Object.prototype.toString');\n\nvar isStandardArguments = function isArguments(value) {\n\tif (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {\n\t\treturn false;\n\t}\n\treturn $toString(value) === '[object Arguments]';\n};\n\nvar isLegacyArguments = function isArguments(value) {\n\tif (isStandardArguments(value)) {\n\t\treturn true;\n\t}\n\treturn value !== null &&\n\t\ttypeof value === 'object' &&\n\t\ttypeof value.length === 'number' &&\n\t\tvalue.length >= 0 &&\n\t\t$toString(value) !== '[object Array]' &&\n\t\t$toString(value.callee) === '[object Function]';\n};\n\nvar supportsStandardArguments = (function () {\n\treturn isStandardArguments(arguments);\n}());\n\nisStandardArguments.isLegacyArguments = isLegacyArguments; // for tests\n\nmodule.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;\n","'use strict';\n\nvar callBound = require('call-bound');\n\nvar getDay = callBound('Date.prototype.getDay');\n/** @type {import('.')} */\nvar tryDateObject = function tryDateGetDayCall(value) {\n\ttry {\n\t\tgetDay(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\n/** @type {(value: unknown) => string} */\nvar toStr = callBound('Object.prototype.toString');\nvar dateClass = '[object Date]';\nvar hasToStringTag = require('has-tostringtag/shams')();\n\n/** @type {import('.')} */\nmodule.exports = function isDateObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\treturn hasToStringTag ? tryDateObject(value) : toStr(value) === dateClass;\n};\n","'use strict';\n\nvar callBound = require('call-bound');\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar hasOwn = require('hasown');\nvar gOPD = require('gopd');\n\n/** @type {import('.')} */\nvar fn;\n\nif (hasToStringTag) {\n\t/** @type {(receiver: ThisParameterType<typeof RegExp.prototype.exec>, ...args: Parameters<typeof RegExp.prototype.exec>) => ReturnType<typeof RegExp.prototype.exec>} */\n\tvar $exec = callBound('RegExp.prototype.exec');\n\t/** @type {object} */\n\tvar isRegexMarker = {};\n\n\tvar throwRegexMarker = function () {\n\t\tthrow isRegexMarker;\n\t};\n\t/** @type {{ toString(): never, valueOf(): never, [Symbol.toPrimitive]?(): never }} */\n\tvar badStringifier = {\n\t\ttoString: throwRegexMarker,\n\t\tvalueOf: throwRegexMarker\n\t};\n\n\tif (typeof Symbol.toPrimitive === 'symbol') {\n\t\tbadStringifier[Symbol.toPrimitive] = throwRegexMarker;\n\t}\n\n\t/** @type {import('.')} */\n\t// @ts-expect-error TS can't figure out that the $exec call always throws\n\t// eslint-disable-next-line consistent-return\n\tfn = function isRegex(value) {\n\t\tif (!value || typeof value !== 'object') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// eslint-disable-next-line no-extra-parens\n\t\tvar descriptor = /** @type {NonNullable<typeof gOPD>} */ (gOPD)(/** @type {{ lastIndex?: unknown }} */ (value), 'lastIndex');\n\t\tvar hasLastIndexDataProperty = descriptor && hasOwn(descriptor, 'value');\n\t\tif (!hasLastIndexDataProperty) {\n\t\t\treturn false;\n\t\t}\n\n\t\ttry {\n\t\t\t// eslint-disable-next-line no-extra-parens\n\t\t\t$exec(value, /** @type {string} */ (/** @type {unknown} */ (badStringifier)));\n\t\t} catch (e) {\n\t\t\treturn e === isRegexMarker;\n\t\t}\n\t};\n} else {\n\t/** @type {(receiver: ThisParameterType<typeof Object.prototype.toString>, ...args: Parameters<typeof Object.prototype.toString>) => ReturnType<typeof Object.prototype.toString>} */\n\tvar $toString = callBound('Object.prototype.toString');\n\t/** @const @type {'[object RegExp]'} */\n\tvar regexClass = '[object RegExp]';\n\n\t/** @type {import('.')} */\n\tfn = function isRegex(value) {\n\t\t// In older browsers, typeof regex incorrectly returns 'function'\n\t\tif (!value || (typeof value !== 'object' && typeof value !== 'function')) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn $toString(value) === regexClass;\n\t};\n}\n\nmodule.exports = fn;\n","'use strict';\n\n/** @type {import('./abs')} */\nmodule.exports = Math.abs;\n","'use strict';\n\n/** @type {import('./floor')} */\nmodule.exports = Math.floor;\n","'use strict';\n\n/** @type {import('./isNaN')} */\nmodule.exports = Number.isNaN || function isNaN(a) {\n\treturn a !== a;\n};\n","'use strict';\n\n/** @type {import('./max')} */\nmodule.exports = Math.max;\n","'use strict';\n\n/** @type {import('./min')} */\nmodule.exports = Math.min;\n","'use strict';\n\n/** @type {import('./pow')} */\nmodule.exports = Math.pow;\n","'use strict';\n\n/** @type {import('./round')} */\nmodule.exports = Math.round;\n","'use strict';\n\nvar $isNaN = require('./isNaN');\n\n/** @type {import('./sign')} */\nmodule.exports = function sign(number) {\n\tif ($isNaN(number) || number === 0) {\n\t\treturn number;\n\t}\n\treturn number < 0 ? -1 : +1;\n};\n","'use strict';\n\nvar numberIsNaN = function (value) {\n\treturn value !== value;\n};\n\nmodule.exports = function is(a, b) {\n\tif (a === 0 && b === 0) {\n\t\treturn 1 / a === 1 / b;\n\t}\n\tif (a === b) {\n\t\treturn true;\n\t}\n\tif (numberIsNaN(a) && numberIsNaN(b)) {\n\t\treturn true;\n\t}\n\treturn false;\n};\n\n","'use strict';\n\nvar define = require('define-properties');\nvar callBind = require('call-bind');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar polyfill = callBind(getPolyfill(), Object);\n\ndefine(polyfill, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = polyfill;\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = function getPolyfill() {\n\treturn typeof Object.is === 'function' ? Object.is : implementation;\n};\n","'use strict';\n\nvar getPolyfill = require('./polyfill');\nvar define = require('define-properties');\n\nmodule.exports = function shimObjectIs() {\n\tvar polyfill = getPolyfill();\n\tdefine(Object, { is: polyfill }, {\n\t\tis: function testObjectIs() {\n\t\t\treturn Object.is !== polyfill;\n\t\t}\n\t});\n\treturn polyfill;\n};\n","'use strict';\n\nvar keysShim;\nif (!Object.keys) {\n\t// modified from https://github.com/es-shims/es5-shim\n\tvar has = Object.prototype.hasOwnProperty;\n\tvar toStr = Object.prototype.toString;\n\tvar isArgs = require('./isArguments'); // eslint-disable-line global-require\n\tvar isEnumerable = Object.prototype.propertyIsEnumerable;\n\tvar hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');\n\tvar hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');\n\tvar dontEnums = [\n\t\t'toString',\n\t\t'toLocaleString',\n\t\t'valueOf',\n\t\t'hasOwnProperty',\n\t\t'isPrototypeOf',\n\t\t'propertyIsEnumerable',\n\t\t'constructor'\n\t];\n\tvar equalsConstructorPrototype = function (o) {\n\t\tvar ctor = o.constructor;\n\t\treturn ctor && ctor.prototype === o;\n\t};\n\tvar excludedKeys = {\n\t\t$applicationCache: true,\n\t\t$console: true,\n\t\t$external: true,\n\t\t$frame: true,\n\t\t$frameElement: true,\n\t\t$frames: true,\n\t\t$innerHeight: true,\n\t\t$innerWidth: true,\n\t\t$onmozfullscreenchange: true,\n\t\t$onmozfullscreenerror: true,\n\t\t$outerHeight: true,\n\t\t$outerWidth: true,\n\t\t$pageXOffset: true,\n\t\t$pageYOffset: true,\n\t\t$parent: true,\n\t\t$scrollLeft: true,\n\t\t$scrollTop: true,\n\t\t$scrollX: true,\n\t\t$scrollY: true,\n\t\t$self: true,\n\t\t$webkitIndexedDB: true,\n\t\t$webkitStorageInfo: true,\n\t\t$window: true\n\t};\n\tvar hasAutomationEqualityBug = (function () {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined') { return false; }\n\t\tfor (var k in window) {\n\t\t\ttry {\n\t\t\t\tif (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tequalsConstructorPrototype(window[k]);\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}());\n\tvar equalsConstructorPrototypeIfNotBuggy = function (o) {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined' || !hasAutomationEqualityBug) {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t}\n\t\ttry {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n\n\tkeysShim = function keys(object) {\n\t\tvar isObject = object !== null && typeof object === 'object';\n\t\tvar isFunction = toStr.call(object) === '[object Function]';\n\t\tvar isArguments = isArgs(object);\n\t\tvar isString = isObject && toStr.call(object) === '[object String]';\n\t\tvar theKeys = [];\n\n\t\tif (!isObject && !isFunction && !isArguments) {\n\t\t\tthrow new TypeError('Object.keys called on a non-object');\n\t\t}\n\n\t\tvar skipProto = hasProtoEnumBug && isFunction;\n\t\tif (isString && object.length > 0 && !has.call(object, 0)) {\n\t\t\tfor (var i = 0; i < object.length; ++i) {\n\t\t\t\ttheKeys.push(String(i));\n\t\t\t}\n\t\t}\n\n\t\tif (isArguments && object.length > 0) {\n\t\t\tfor (var j = 0; j < object.length; ++j) {\n\t\t\t\ttheKeys.push(String(j));\n\t\t\t}\n\t\t} else {\n\t\t\tfor (var name in object) {\n\t\t\t\tif (!(skipProto && name === 'prototype') && has.call(object, name)) {\n\t\t\t\t\ttheKeys.push(String(name));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (hasDontEnumBug) {\n\t\t\tvar skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);\n\n\t\t\tfor (var k = 0; k < dontEnums.length; ++k) {\n\t\t\t\tif (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {\n\t\t\t\t\ttheKeys.push(dontEnums[k]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn theKeys;\n\t};\n}\nmodule.exports = keysShim;\n","'use strict';\n\nvar slice = Array.prototype.slice;\nvar isArgs = require('./isArguments');\n\nvar origKeys = Object.keys;\nvar keysShim = origKeys ? function keys(o) { return origKeys(o); } : require('./implementation');\n\nvar originalKeys = Object.keys;\n\nkeysShim.shim = function shimObjectKeys() {\n\tif (Object.keys) {\n\t\tvar keysWorksWithArguments = (function () {\n\t\t\t// Safari 5.0 bug\n\t\t\tvar args = Object.keys(arguments);\n\t\t\treturn args && args.length === arguments.length;\n\t\t}(1, 2));\n\t\tif (!keysWorksWithArguments) {\n\t\t\tObject.keys = function keys(object) { // eslint-disable-line func-name-matching\n\t\t\t\tif (isArgs(object)) {\n\t\t\t\t\treturn originalKeys(slice.call(object));\n\t\t\t\t}\n\t\t\t\treturn originalKeys(object);\n\t\t\t};\n\t\t}\n\t} else {\n\t\tObject.keys = keysShim;\n\t}\n\treturn Object.keys || keysShim;\n};\n\nmodule.exports = keysShim;\n","'use strict';\n\nvar toStr = Object.prototype.toString;\n\nmodule.exports = function isArguments(value) {\n\tvar str = toStr.call(value);\n\tvar isArgs = str === '[object Arguments]';\n\tif (!isArgs) {\n\t\tisArgs = str !== '[object Array]' &&\n\t\t\tvalue !== null &&\n\t\t\ttypeof value === 'object' &&\n\t\t\ttypeof value.length === 'number' &&\n\t\t\tvalue.length >= 0 &&\n\t\t\ttoStr.call(value.callee) === '[object Function]';\n\t}\n\treturn isArgs;\n};\n","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Parchment\"] = factory();\n\telse\n\t\troot[\"Parchment\"] = factory();\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 9);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ParchmentError = /** @class */ (function (_super) {\n    __extends(ParchmentError, _super);\n    function ParchmentError(message) {\n        var _this = this;\n        message = '[Parchment] ' + message;\n        _this = _super.call(this, message) || this;\n        _this.message = message;\n        _this.name = _this.constructor.name;\n        return _this;\n    }\n    return ParchmentError;\n}(Error));\nexports.ParchmentError = ParchmentError;\nvar attributes = {};\nvar classes = {};\nvar tags = {};\nvar types = {};\nexports.DATA_KEY = '__blot';\nvar Scope;\n(function (Scope) {\n    Scope[Scope[\"TYPE\"] = 3] = \"TYPE\";\n    Scope[Scope[\"LEVEL\"] = 12] = \"LEVEL\";\n    Scope[Scope[\"ATTRIBUTE\"] = 13] = \"ATTRIBUTE\";\n    Scope[Scope[\"BLOT\"] = 14] = \"BLOT\";\n    Scope[Scope[\"INLINE\"] = 7] = \"INLINE\";\n    Scope[Scope[\"BLOCK\"] = 11] = \"BLOCK\";\n    Scope[Scope[\"BLOCK_BLOT\"] = 10] = \"BLOCK_BLOT\";\n    Scope[Scope[\"INLINE_BLOT\"] = 6] = \"INLINE_BLOT\";\n    Scope[Scope[\"BLOCK_ATTRIBUTE\"] = 9] = \"BLOCK_ATTRIBUTE\";\n    Scope[Scope[\"INLINE_ATTRIBUTE\"] = 5] = \"INLINE_ATTRIBUTE\";\n    Scope[Scope[\"ANY\"] = 15] = \"ANY\";\n})(Scope = exports.Scope || (exports.Scope = {}));\nfunction create(input, value) {\n    var match = query(input);\n    if (match == null) {\n        throw new ParchmentError(\"Unable to create \" + input + \" blot\");\n    }\n    var BlotClass = match;\n    var node = \n    // @ts-ignore\n    input instanceof Node || input['nodeType'] === Node.TEXT_NODE ? input : BlotClass.create(value);\n    return new BlotClass(node, value);\n}\nexports.create = create;\nfunction find(node, bubble) {\n    if (bubble === void 0) { bubble = false; }\n    if (node == null)\n        return null;\n    // @ts-ignore\n    if (node[exports.DATA_KEY] != null)\n        return node[exports.DATA_KEY].blot;\n    if (bubble)\n        return find(node.parentNode, bubble);\n    return null;\n}\nexports.find = find;\nfunction query(query, scope) {\n    if (scope === void 0) { scope = Scope.ANY; }\n    var match;\n    if (typeof query === 'string') {\n        match = types[query] || attributes[query];\n        // @ts-ignore\n    }\n    else if (query instanceof Text || query['nodeType'] === Node.TEXT_NODE) {\n        match = types['text'];\n    }\n    else if (typeof query === 'number') {\n        if (query & Scope.LEVEL & Scope.BLOCK) {\n            match = types['block'];\n        }\n        else if (query & Scope.LEVEL & Scope.INLINE) {\n            match = types['inline'];\n        }\n    }\n    else if (query instanceof HTMLElement) {\n        var names = (query.getAttribute('class') || '').split(/\\s+/);\n        for (var i in names) {\n            match = classes[names[i]];\n            if (match)\n                break;\n        }\n        match = match || tags[query.tagName];\n    }\n    if (match == null)\n        return null;\n    // @ts-ignore\n    if (scope & Scope.LEVEL & match.scope && scope & Scope.TYPE & match.scope)\n        return match;\n    return null;\n}\nexports.query = query;\nfunction register() {\n    var Definitions = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        Definitions[_i] = arguments[_i];\n    }\n    if (Definitions.length > 1) {\n        return Definitions.map(function (d) {\n            return register(d);\n        });\n    }\n    var Definition = Definitions[0];\n    if (typeof Definition.blotName !== 'string' && typeof Definition.attrName !== 'string') {\n        throw new ParchmentError('Invalid definition');\n    }\n    else if (Definition.blotName === 'abstract') {\n        throw new ParchmentError('Cannot register abstract class');\n    }\n    types[Definition.blotName || Definition.attrName] = Definition;\n    if (typeof Definition.keyName === 'string') {\n        attributes[Definition.keyName] = Definition;\n    }\n    else {\n        if (Definition.className != null) {\n            classes[Definition.className] = Definition;\n        }\n        if (Definition.tagName != null) {\n            if (Array.isArray(Definition.tagName)) {\n                Definition.tagName = Definition.tagName.map(function (tagName) {\n                    return tagName.toUpperCase();\n                });\n            }\n            else {\n                Definition.tagName = Definition.tagName.toUpperCase();\n            }\n            var tagNames = Array.isArray(Definition.tagName) ? Definition.tagName : [Definition.tagName];\n            tagNames.forEach(function (tag) {\n                if (tags[tag] == null || Definition.className == null) {\n                    tags[tag] = Definition;\n                }\n            });\n        }\n    }\n    return Definition;\n}\nexports.register = register;\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Registry = __webpack_require__(0);\nvar Attributor = /** @class */ (function () {\n    function Attributor(attrName, keyName, options) {\n        if (options === void 0) { options = {}; }\n        this.attrName = attrName;\n        this.keyName = keyName;\n        var attributeBit = Registry.Scope.TYPE & Registry.Scope.ATTRIBUTE;\n        if (options.scope != null) {\n            // Ignore type bits, force attribute bit\n            this.scope = (options.scope & Registry.Scope.LEVEL) | attributeBit;\n        }\n        else {\n            this.scope = Registry.Scope.ATTRIBUTE;\n        }\n        if (options.whitelist != null)\n            this.whitelist = options.whitelist;\n    }\n    Attributor.keys = function (node) {\n        return [].map.call(node.attributes, function (item) {\n            return item.name;\n        });\n    };\n    Attributor.prototype.add = function (node, value) {\n        if (!this.canAdd(node, value))\n            return false;\n        node.setAttribute(this.keyName, value);\n        return true;\n    };\n    Attributor.prototype.canAdd = function (node, value) {\n        var match = Registry.query(node, Registry.Scope.BLOT & (this.scope | Registry.Scope.TYPE));\n        if (match == null)\n            return false;\n        if (this.whitelist == null)\n            return true;\n        if (typeof value === 'string') {\n            return this.whitelist.indexOf(value.replace(/[\"']/g, '')) > -1;\n        }\n        else {\n            return this.whitelist.indexOf(value) > -1;\n        }\n    };\n    Attributor.prototype.remove = function (node) {\n        node.removeAttribute(this.keyName);\n    };\n    Attributor.prototype.value = function (node) {\n        var value = node.getAttribute(this.keyName);\n        if (this.canAdd(node, value) && value) {\n            return value;\n        }\n        return '';\n    };\n    return Attributor;\n}());\nexports.default = Attributor;\n\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar linked_list_1 = __webpack_require__(11);\nvar shadow_1 = __webpack_require__(5);\nvar Registry = __webpack_require__(0);\nvar ContainerBlot = /** @class */ (function (_super) {\n    __extends(ContainerBlot, _super);\n    function ContainerBlot(domNode) {\n        var _this = _super.call(this, domNode) || this;\n        _this.build();\n        return _this;\n    }\n    ContainerBlot.prototype.appendChild = function (other) {\n        this.insertBefore(other);\n    };\n    ContainerBlot.prototype.attach = function () {\n        _super.prototype.attach.call(this);\n        this.children.forEach(function (child) {\n            child.attach();\n        });\n    };\n    ContainerBlot.prototype.build = function () {\n        var _this = this;\n        this.children = new linked_list_1.default();\n        // Need to be reversed for if DOM nodes already in order\n        [].slice\n            .call(this.domNode.childNodes)\n            .reverse()\n            .forEach(function (node) {\n            try {\n                var child = makeBlot(node);\n                _this.insertBefore(child, _this.children.head || undefined);\n            }\n            catch (err) {\n                if (err instanceof Registry.ParchmentError)\n                    return;\n                else\n                    throw err;\n            }\n        });\n    };\n    ContainerBlot.prototype.deleteAt = function (index, length) {\n        if (index === 0 && length === this.length()) {\n            return this.remove();\n        }\n        this.children.forEachAt(index, length, function (child, offset, length) {\n            child.deleteAt(offset, length);\n        });\n    };\n    ContainerBlot.prototype.descendant = function (criteria, index) {\n        var _a = this.children.find(index), child = _a[0], offset = _a[1];\n        if ((criteria.blotName == null && criteria(child)) ||\n            (criteria.blotName != null && child instanceof criteria)) {\n            return [child, offset];\n        }\n        else if (child instanceof ContainerBlot) {\n            return child.descendant(criteria, offset);\n        }\n        else {\n            return [null, -1];\n        }\n    };\n    ContainerBlot.prototype.descendants = function (criteria, index, length) {\n        if (index === void 0) { index = 0; }\n        if (length === void 0) { length = Number.MAX_VALUE; }\n        var descendants = [];\n        var lengthLeft = length;\n        this.children.forEachAt(index, length, function (child, index, length) {\n            if ((criteria.blotName == null && criteria(child)) ||\n                (criteria.blotName != null && child instanceof criteria)) {\n                descendants.push(child);\n            }\n            if (child instanceof ContainerBlot) {\n                descendants = descendants.concat(child.descendants(criteria, index, lengthLeft));\n            }\n            lengthLeft -= length;\n        });\n        return descendants;\n    };\n    ContainerBlot.prototype.detach = function () {\n        this.children.forEach(function (child) {\n            child.detach();\n        });\n        _super.prototype.detach.call(this);\n    };\n    ContainerBlot.prototype.formatAt = function (index, length, name, value) {\n        this.children.forEachAt(index, length, function (child, offset, length) {\n            child.formatAt(offset, length, name, value);\n        });\n    };\n    ContainerBlot.prototype.insertAt = function (index, value, def) {\n        var _a = this.children.find(index), child = _a[0], offset = _a[1];\n        if (child) {\n            child.insertAt(offset, value, def);\n        }\n        else {\n            var blot = def == null ? Registry.create('text', value) : Registry.create(value, def);\n            this.appendChild(blot);\n        }\n    };\n    ContainerBlot.prototype.insertBefore = function (childBlot, refBlot) {\n        if (this.statics.allowedChildren != null &&\n            !this.statics.allowedChildren.some(function (child) {\n                return childBlot instanceof child;\n            })) {\n            throw new Registry.ParchmentError(\"Cannot insert \" + childBlot.statics.blotName + \" into \" + this.statics.blotName);\n        }\n        childBlot.insertInto(this, refBlot);\n    };\n    ContainerBlot.prototype.length = function () {\n        return this.children.reduce(function (memo, child) {\n            return memo + child.length();\n        }, 0);\n    };\n    ContainerBlot.prototype.moveChildren = function (targetParent, refNode) {\n        this.children.forEach(function (child) {\n            targetParent.insertBefore(child, refNode);\n        });\n    };\n    ContainerBlot.prototype.optimize = function (context) {\n        _super.prototype.optimize.call(this, context);\n        if (this.children.length === 0) {\n            if (this.statics.defaultChild != null) {\n                var child = Registry.create(this.statics.defaultChild);\n                this.appendChild(child);\n                child.optimize(context);\n            }\n            else {\n                this.remove();\n            }\n        }\n    };\n    ContainerBlot.prototype.path = function (index, inclusive) {\n        if (inclusive === void 0) { inclusive = false; }\n        var _a = this.children.find(index, inclusive), child = _a[0], offset = _a[1];\n        var position = [[this, index]];\n        if (child instanceof ContainerBlot) {\n            return position.concat(child.path(offset, inclusive));\n        }\n        else if (child != null) {\n            position.push([child, offset]);\n        }\n        return position;\n    };\n    ContainerBlot.prototype.removeChild = function (child) {\n        this.children.remove(child);\n    };\n    ContainerBlot.prototype.replace = function (target) {\n        if (target instanceof ContainerBlot) {\n            target.moveChildren(this);\n        }\n        _super.prototype.replace.call(this, target);\n    };\n    ContainerBlot.prototype.split = function (index, force) {\n        if (force === void 0) { force = false; }\n        if (!force) {\n            if (index === 0)\n                return this;\n            if (index === this.length())\n                return this.next;\n        }\n        var after = this.clone();\n        this.parent.insertBefore(after, this.next);\n        this.children.forEachAt(index, this.length(), function (child, offset, length) {\n            child = child.split(offset, force);\n            after.appendChild(child);\n        });\n        return after;\n    };\n    ContainerBlot.prototype.unwrap = function () {\n        this.moveChildren(this.parent, this.next);\n        this.remove();\n    };\n    ContainerBlot.prototype.update = function (mutations, context) {\n        var _this = this;\n        var addedNodes = [];\n        var removedNodes = [];\n        mutations.forEach(function (mutation) {\n            if (mutation.target === _this.domNode && mutation.type === 'childList') {\n                addedNodes.push.apply(addedNodes, mutation.addedNodes);\n                removedNodes.push.apply(removedNodes, mutation.removedNodes);\n            }\n        });\n        removedNodes.forEach(function (node) {\n            // Check node has actually been removed\n            // One exception is Chrome does not immediately remove IFRAMEs\n            // from DOM but MutationRecord is correct in its reported removal\n            if (node.parentNode != null &&\n                // @ts-ignore\n                node.tagName !== 'IFRAME' &&\n                document.body.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n                return;\n            }\n            var blot = Registry.find(node);\n            if (blot == null)\n                return;\n            if (blot.domNode.parentNode == null || blot.domNode.parentNode === _this.domNode) {\n                blot.detach();\n            }\n        });\n        addedNodes\n            .filter(function (node) {\n            return node.parentNode == _this.domNode;\n        })\n            .sort(function (a, b) {\n            if (a === b)\n                return 0;\n            if (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING) {\n                return 1;\n            }\n            return -1;\n        })\n            .forEach(function (node) {\n            var refBlot = null;\n            if (node.nextSibling != null) {\n                refBlot = Registry.find(node.nextSibling);\n            }\n            var blot = makeBlot(node);\n            if (blot.next != refBlot || blot.next == null) {\n                if (blot.parent != null) {\n                    blot.parent.removeChild(_this);\n                }\n                _this.insertBefore(blot, refBlot || undefined);\n            }\n        });\n    };\n    return ContainerBlot;\n}(shadow_1.default));\nfunction makeBlot(node) {\n    var blot = Registry.find(node);\n    if (blot == null) {\n        try {\n            blot = Registry.create(node);\n        }\n        catch (e) {\n            blot = Registry.create(Registry.Scope.INLINE);\n            [].slice.call(node.childNodes).forEach(function (child) {\n                // @ts-ignore\n                blot.domNode.appendChild(child);\n            });\n            if (node.parentNode) {\n                node.parentNode.replaceChild(blot.domNode, node);\n            }\n            blot.attach();\n        }\n    }\n    return blot;\n}\nexports.default = ContainerBlot;\n\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar attributor_1 = __webpack_require__(1);\nvar store_1 = __webpack_require__(6);\nvar container_1 = __webpack_require__(2);\nvar Registry = __webpack_require__(0);\nvar FormatBlot = /** @class */ (function (_super) {\n    __extends(FormatBlot, _super);\n    function FormatBlot(domNode) {\n        var _this = _super.call(this, domNode) || this;\n        _this.attributes = new store_1.default(_this.domNode);\n        return _this;\n    }\n    FormatBlot.formats = function (domNode) {\n        if (typeof this.tagName === 'string') {\n            return true;\n        }\n        else if (Array.isArray(this.tagName)) {\n            return domNode.tagName.toLowerCase();\n        }\n        return undefined;\n    };\n    FormatBlot.prototype.format = function (name, value) {\n        var format = Registry.query(name);\n        if (format instanceof attributor_1.default) {\n            this.attributes.attribute(format, value);\n        }\n        else if (value) {\n            if (format != null && (name !== this.statics.blotName || this.formats()[name] !== value)) {\n                this.replaceWith(name, value);\n            }\n        }\n    };\n    FormatBlot.prototype.formats = function () {\n        var formats = this.attributes.values();\n        var format = this.statics.formats(this.domNode);\n        if (format != null) {\n            formats[this.statics.blotName] = format;\n        }\n        return formats;\n    };\n    FormatBlot.prototype.replaceWith = function (name, value) {\n        var replacement = _super.prototype.replaceWith.call(this, name, value);\n        this.attributes.copy(replacement);\n        return replacement;\n    };\n    FormatBlot.prototype.update = function (mutations, context) {\n        var _this = this;\n        _super.prototype.update.call(this, mutations, context);\n        if (mutations.some(function (mutation) {\n            return mutation.target === _this.domNode && mutation.type === 'attributes';\n        })) {\n            this.attributes.build();\n        }\n    };\n    FormatBlot.prototype.wrap = function (name, value) {\n        var wrapper = _super.prototype.wrap.call(this, name, value);\n        if (wrapper instanceof FormatBlot && wrapper.statics.scope === this.statics.scope) {\n            this.attributes.move(wrapper);\n        }\n        return wrapper;\n    };\n    return FormatBlot;\n}(container_1.default));\nexports.default = FormatBlot;\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar shadow_1 = __webpack_require__(5);\nvar Registry = __webpack_require__(0);\nvar LeafBlot = /** @class */ (function (_super) {\n    __extends(LeafBlot, _super);\n    function LeafBlot() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    LeafBlot.value = function (domNode) {\n        return true;\n    };\n    LeafBlot.prototype.index = function (node, offset) {\n        if (this.domNode === node ||\n            this.domNode.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n            return Math.min(offset, 1);\n        }\n        return -1;\n    };\n    LeafBlot.prototype.position = function (index, inclusive) {\n        var offset = [].indexOf.call(this.parent.domNode.childNodes, this.domNode);\n        if (index > 0)\n            offset += 1;\n        return [this.parent.domNode, offset];\n    };\n    LeafBlot.prototype.value = function () {\n        return _a = {}, _a[this.statics.blotName] = this.statics.value(this.domNode) || true, _a;\n        var _a;\n    };\n    LeafBlot.scope = Registry.Scope.INLINE_BLOT;\n    return LeafBlot;\n}(shadow_1.default));\nexports.default = LeafBlot;\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Registry = __webpack_require__(0);\nvar ShadowBlot = /** @class */ (function () {\n    function ShadowBlot(domNode) {\n        this.domNode = domNode;\n        // @ts-ignore\n        this.domNode[Registry.DATA_KEY] = { blot: this };\n    }\n    Object.defineProperty(ShadowBlot.prototype, \"statics\", {\n        // Hack for accessing inherited static methods\n        get: function () {\n            return this.constructor;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ShadowBlot.create = function (value) {\n        if (this.tagName == null) {\n            throw new Registry.ParchmentError('Blot definition missing tagName');\n        }\n        var node;\n        if (Array.isArray(this.tagName)) {\n            if (typeof value === 'string') {\n                value = value.toUpperCase();\n                if (parseInt(value).toString() === value) {\n                    value = parseInt(value);\n                }\n            }\n            if (typeof value === 'number') {\n                node = document.createElement(this.tagName[value - 1]);\n            }\n            else if (this.tagName.indexOf(value) > -1) {\n                node = document.createElement(value);\n            }\n            else {\n                node = document.createElement(this.tagName[0]);\n            }\n        }\n        else {\n            node = document.createElement(this.tagName);\n        }\n        if (this.className) {\n            node.classList.add(this.className);\n        }\n        return node;\n    };\n    ShadowBlot.prototype.attach = function () {\n        if (this.parent != null) {\n            this.scroll = this.parent.scroll;\n        }\n    };\n    ShadowBlot.prototype.clone = function () {\n        var domNode = this.domNode.cloneNode(false);\n        return Registry.create(domNode);\n    };\n    ShadowBlot.prototype.detach = function () {\n        if (this.parent != null)\n            this.parent.removeChild(this);\n        // @ts-ignore\n        delete this.domNode[Registry.DATA_KEY];\n    };\n    ShadowBlot.prototype.deleteAt = function (index, length) {\n        var blot = this.isolate(index, length);\n        blot.remove();\n    };\n    ShadowBlot.prototype.formatAt = function (index, length, name, value) {\n        var blot = this.isolate(index, length);\n        if (Registry.query(name, Registry.Scope.BLOT) != null && value) {\n            blot.wrap(name, value);\n        }\n        else if (Registry.query(name, Registry.Scope.ATTRIBUTE) != null) {\n            var parent_1 = Registry.create(this.statics.scope);\n            blot.wrap(parent_1);\n            parent_1.format(name, value);\n        }\n    };\n    ShadowBlot.prototype.insertAt = function (index, value, def) {\n        var blot = def == null ? Registry.create('text', value) : Registry.create(value, def);\n        var ref = this.split(index);\n        this.parent.insertBefore(blot, ref);\n    };\n    ShadowBlot.prototype.insertInto = function (parentBlot, refBlot) {\n        if (refBlot === void 0) { refBlot = null; }\n        if (this.parent != null) {\n            this.parent.children.remove(this);\n        }\n        var refDomNode = null;\n        parentBlot.children.insertBefore(this, refBlot);\n        if (refBlot != null) {\n            refDomNode = refBlot.domNode;\n        }\n        if (this.domNode.parentNode != parentBlot.domNode ||\n            this.domNode.nextSibling != refDomNode) {\n            parentBlot.domNode.insertBefore(this.domNode, refDomNode);\n        }\n        this.parent = parentBlot;\n        this.attach();\n    };\n    ShadowBlot.prototype.isolate = function (index, length) {\n        var target = this.split(index);\n        target.split(length);\n        return target;\n    };\n    ShadowBlot.prototype.length = function () {\n        return 1;\n    };\n    ShadowBlot.prototype.offset = function (root) {\n        if (root === void 0) { root = this.parent; }\n        if (this.parent == null || this == root)\n            return 0;\n        return this.parent.children.offset(this) + this.parent.offset(root);\n    };\n    ShadowBlot.prototype.optimize = function (context) {\n        // TODO clean up once we use WeakMap\n        // @ts-ignore\n        if (this.domNode[Registry.DATA_KEY] != null) {\n            // @ts-ignore\n            delete this.domNode[Registry.DATA_KEY].mutations;\n        }\n    };\n    ShadowBlot.prototype.remove = function () {\n        if (this.domNode.parentNode != null) {\n            this.domNode.parentNode.removeChild(this.domNode);\n        }\n        this.detach();\n    };\n    ShadowBlot.prototype.replace = function (target) {\n        if (target.parent == null)\n            return;\n        target.parent.insertBefore(this, target.next);\n        target.remove();\n    };\n    ShadowBlot.prototype.replaceWith = function (name, value) {\n        var replacement = typeof name === 'string' ? Registry.create(name, value) : name;\n        replacement.replace(this);\n        return replacement;\n    };\n    ShadowBlot.prototype.split = function (index, force) {\n        return index === 0 ? this : this.next;\n    };\n    ShadowBlot.prototype.update = function (mutations, context) {\n        // Nothing to do by default\n    };\n    ShadowBlot.prototype.wrap = function (name, value) {\n        var wrapper = typeof name === 'string' ? Registry.create(name, value) : name;\n        if (this.parent != null) {\n            this.parent.insertBefore(wrapper, this.next);\n        }\n        wrapper.appendChild(this);\n        return wrapper;\n    };\n    ShadowBlot.blotName = 'abstract';\n    return ShadowBlot;\n}());\nexports.default = ShadowBlot;\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar attributor_1 = __webpack_require__(1);\nvar class_1 = __webpack_require__(7);\nvar style_1 = __webpack_require__(8);\nvar Registry = __webpack_require__(0);\nvar AttributorStore = /** @class */ (function () {\n    function AttributorStore(domNode) {\n        this.attributes = {};\n        this.domNode = domNode;\n        this.build();\n    }\n    AttributorStore.prototype.attribute = function (attribute, value) {\n        // verb\n        if (value) {\n            if (attribute.add(this.domNode, value)) {\n                if (attribute.value(this.domNode) != null) {\n                    this.attributes[attribute.attrName] = attribute;\n                }\n                else {\n                    delete this.attributes[attribute.attrName];\n                }\n            }\n        }\n        else {\n            attribute.remove(this.domNode);\n            delete this.attributes[attribute.attrName];\n        }\n    };\n    AttributorStore.prototype.build = function () {\n        var _this = this;\n        this.attributes = {};\n        var attributes = attributor_1.default.keys(this.domNode);\n        var classes = class_1.default.keys(this.domNode);\n        var styles = style_1.default.keys(this.domNode);\n        attributes\n            .concat(classes)\n            .concat(styles)\n            .forEach(function (name) {\n            var attr = Registry.query(name, Registry.Scope.ATTRIBUTE);\n            if (attr instanceof attributor_1.default) {\n                _this.attributes[attr.attrName] = attr;\n            }\n        });\n    };\n    AttributorStore.prototype.copy = function (target) {\n        var _this = this;\n        Object.keys(this.attributes).forEach(function (key) {\n            var value = _this.attributes[key].value(_this.domNode);\n            target.format(key, value);\n        });\n    };\n    AttributorStore.prototype.move = function (target) {\n        var _this = this;\n        this.copy(target);\n        Object.keys(this.attributes).forEach(function (key) {\n            _this.attributes[key].remove(_this.domNode);\n        });\n        this.attributes = {};\n    };\n    AttributorStore.prototype.values = function () {\n        var _this = this;\n        return Object.keys(this.attributes).reduce(function (attributes, name) {\n            attributes[name] = _this.attributes[name].value(_this.domNode);\n            return attributes;\n        }, {});\n    };\n    return AttributorStore;\n}());\nexports.default = AttributorStore;\n\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar attributor_1 = __webpack_require__(1);\nfunction match(node, prefix) {\n    var className = node.getAttribute('class') || '';\n    return className.split(/\\s+/).filter(function (name) {\n        return name.indexOf(prefix + \"-\") === 0;\n    });\n}\nvar ClassAttributor = /** @class */ (function (_super) {\n    __extends(ClassAttributor, _super);\n    function ClassAttributor() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    ClassAttributor.keys = function (node) {\n        return (node.getAttribute('class') || '').split(/\\s+/).map(function (name) {\n            return name\n                .split('-')\n                .slice(0, -1)\n                .join('-');\n        });\n    };\n    ClassAttributor.prototype.add = function (node, value) {\n        if (!this.canAdd(node, value))\n            return false;\n        this.remove(node);\n        node.classList.add(this.keyName + \"-\" + value);\n        return true;\n    };\n    ClassAttributor.prototype.remove = function (node) {\n        var matches = match(node, this.keyName);\n        matches.forEach(function (name) {\n            node.classList.remove(name);\n        });\n        if (node.classList.length === 0) {\n            node.removeAttribute('class');\n        }\n    };\n    ClassAttributor.prototype.value = function (node) {\n        var result = match(node, this.keyName)[0] || '';\n        var value = result.slice(this.keyName.length + 1); // +1 for hyphen\n        return this.canAdd(node, value) ? value : '';\n    };\n    return ClassAttributor;\n}(attributor_1.default));\nexports.default = ClassAttributor;\n\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar attributor_1 = __webpack_require__(1);\nfunction camelize(name) {\n    var parts = name.split('-');\n    var rest = parts\n        .slice(1)\n        .map(function (part) {\n        return part[0].toUpperCase() + part.slice(1);\n    })\n        .join('');\n    return parts[0] + rest;\n}\nvar StyleAttributor = /** @class */ (function (_super) {\n    __extends(StyleAttributor, _super);\n    function StyleAttributor() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    StyleAttributor.keys = function (node) {\n        return (node.getAttribute('style') || '').split(';').map(function (value) {\n            var arr = value.split(':');\n            return arr[0].trim();\n        });\n    };\n    StyleAttributor.prototype.add = function (node, value) {\n        if (!this.canAdd(node, value))\n            return false;\n        // @ts-ignore\n        node.style[camelize(this.keyName)] = value;\n        return true;\n    };\n    StyleAttributor.prototype.remove = function (node) {\n        // @ts-ignore\n        node.style[camelize(this.keyName)] = '';\n        if (!node.getAttribute('style')) {\n            node.removeAttribute('style');\n        }\n    };\n    StyleAttributor.prototype.value = function (node) {\n        // @ts-ignore\n        var value = node.style[camelize(this.keyName)];\n        return this.canAdd(node, value) ? value : '';\n    };\n    return StyleAttributor;\n}(attributor_1.default));\nexports.default = StyleAttributor;\n\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\nmodule.exports = __webpack_require__(10);\n\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar container_1 = __webpack_require__(2);\nvar format_1 = __webpack_require__(3);\nvar leaf_1 = __webpack_require__(4);\nvar scroll_1 = __webpack_require__(12);\nvar inline_1 = __webpack_require__(13);\nvar block_1 = __webpack_require__(14);\nvar embed_1 = __webpack_require__(15);\nvar text_1 = __webpack_require__(16);\nvar attributor_1 = __webpack_require__(1);\nvar class_1 = __webpack_require__(7);\nvar style_1 = __webpack_require__(8);\nvar store_1 = __webpack_require__(6);\nvar Registry = __webpack_require__(0);\nvar Parchment = {\n    Scope: Registry.Scope,\n    create: Registry.create,\n    find: Registry.find,\n    query: Registry.query,\n    register: Registry.register,\n    Container: container_1.default,\n    Format: format_1.default,\n    Leaf: leaf_1.default,\n    Embed: embed_1.default,\n    Scroll: scroll_1.default,\n    Block: block_1.default,\n    Inline: inline_1.default,\n    Text: text_1.default,\n    Attributor: {\n        Attribute: attributor_1.default,\n        Class: class_1.default,\n        Style: style_1.default,\n        Store: store_1.default,\n    },\n};\nexports.default = Parchment;\n\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar LinkedList = /** @class */ (function () {\n    function LinkedList() {\n        this.head = this.tail = null;\n        this.length = 0;\n    }\n    LinkedList.prototype.append = function () {\n        var nodes = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            nodes[_i] = arguments[_i];\n        }\n        this.insertBefore(nodes[0], null);\n        if (nodes.length > 1) {\n            this.append.apply(this, nodes.slice(1));\n        }\n    };\n    LinkedList.prototype.contains = function (node) {\n        var cur, next = this.iterator();\n        while ((cur = next())) {\n            if (cur === node)\n                return true;\n        }\n        return false;\n    };\n    LinkedList.prototype.insertBefore = function (node, refNode) {\n        if (!node)\n            return;\n        node.next = refNode;\n        if (refNode != null) {\n            node.prev = refNode.prev;\n            if (refNode.prev != null) {\n                refNode.prev.next = node;\n            }\n            refNode.prev = node;\n            if (refNode === this.head) {\n                this.head = node;\n            }\n        }\n        else if (this.tail != null) {\n            this.tail.next = node;\n            node.prev = this.tail;\n            this.tail = node;\n        }\n        else {\n            node.prev = null;\n            this.head = this.tail = node;\n        }\n        this.length += 1;\n    };\n    LinkedList.prototype.offset = function (target) {\n        var index = 0, cur = this.head;\n        while (cur != null) {\n            if (cur === target)\n                return index;\n            index += cur.length();\n            cur = cur.next;\n        }\n        return -1;\n    };\n    LinkedList.prototype.remove = function (node) {\n        if (!this.contains(node))\n            return;\n        if (node.prev != null)\n            node.prev.next = node.next;\n        if (node.next != null)\n            node.next.prev = node.prev;\n        if (node === this.head)\n            this.head = node.next;\n        if (node === this.tail)\n            this.tail = node.prev;\n        this.length -= 1;\n    };\n    LinkedList.prototype.iterator = function (curNode) {\n        if (curNode === void 0) { curNode = this.head; }\n        // TODO use yield when we can\n        return function () {\n            var ret = curNode;\n            if (curNode != null)\n                curNode = curNode.next;\n            return ret;\n        };\n    };\n    LinkedList.prototype.find = function (index, inclusive) {\n        if (inclusive === void 0) { inclusive = false; }\n        var cur, next = this.iterator();\n        while ((cur = next())) {\n            var length_1 = cur.length();\n            if (index < length_1 ||\n                (inclusive && index === length_1 && (cur.next == null || cur.next.length() !== 0))) {\n                return [cur, index];\n            }\n            index -= length_1;\n        }\n        return [null, 0];\n    };\n    LinkedList.prototype.forEach = function (callback) {\n        var cur, next = this.iterator();\n        while ((cur = next())) {\n            callback(cur);\n        }\n    };\n    LinkedList.prototype.forEachAt = function (index, length, callback) {\n        if (length <= 0)\n            return;\n        var _a = this.find(index), startNode = _a[0], offset = _a[1];\n        var cur, curIndex = index - offset, next = this.iterator(startNode);\n        while ((cur = next()) && curIndex < index + length) {\n            var curLength = cur.length();\n            if (index > curIndex) {\n                callback(cur, index - curIndex, Math.min(length, curIndex + curLength - index));\n            }\n            else {\n                callback(cur, 0, Math.min(curLength, index + length - curIndex));\n            }\n            curIndex += curLength;\n        }\n    };\n    LinkedList.prototype.map = function (callback) {\n        return this.reduce(function (memo, cur) {\n            memo.push(callback(cur));\n            return memo;\n        }, []);\n    };\n    LinkedList.prototype.reduce = function (callback, memo) {\n        var cur, next = this.iterator();\n        while ((cur = next())) {\n            memo = callback(memo, cur);\n        }\n        return memo;\n    };\n    return LinkedList;\n}());\nexports.default = LinkedList;\n\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar container_1 = __webpack_require__(2);\nvar Registry = __webpack_require__(0);\nvar OBSERVER_CONFIG = {\n    attributes: true,\n    characterData: true,\n    characterDataOldValue: true,\n    childList: true,\n    subtree: true,\n};\nvar MAX_OPTIMIZE_ITERATIONS = 100;\nvar ScrollBlot = /** @class */ (function (_super) {\n    __extends(ScrollBlot, _super);\n    function ScrollBlot(node) {\n        var _this = _super.call(this, node) || this;\n        _this.scroll = _this;\n        _this.observer = new MutationObserver(function (mutations) {\n            _this.update(mutations);\n        });\n        _this.observer.observe(_this.domNode, OBSERVER_CONFIG);\n        _this.attach();\n        return _this;\n    }\n    ScrollBlot.prototype.detach = function () {\n        _super.prototype.detach.call(this);\n        this.observer.disconnect();\n    };\n    ScrollBlot.prototype.deleteAt = function (index, length) {\n        this.update();\n        if (index === 0 && length === this.length()) {\n            this.children.forEach(function (child) {\n                child.remove();\n            });\n        }\n        else {\n            _super.prototype.deleteAt.call(this, index, length);\n        }\n    };\n    ScrollBlot.prototype.formatAt = function (index, length, name, value) {\n        this.update();\n        _super.prototype.formatAt.call(this, index, length, name, value);\n    };\n    ScrollBlot.prototype.insertAt = function (index, value, def) {\n        this.update();\n        _super.prototype.insertAt.call(this, index, value, def);\n    };\n    ScrollBlot.prototype.optimize = function (mutations, context) {\n        var _this = this;\n        if (mutations === void 0) { mutations = []; }\n        if (context === void 0) { context = {}; }\n        _super.prototype.optimize.call(this, context);\n        // We must modify mutations directly, cannot make copy and then modify\n        var records = [].slice.call(this.observer.takeRecords());\n        // Array.push currently seems to be implemented by a non-tail recursive function\n        // so we cannot just mutations.push.apply(mutations, this.observer.takeRecords());\n        while (records.length > 0)\n            mutations.push(records.pop());\n        // TODO use WeakMap\n        var mark = function (blot, markParent) {\n            if (markParent === void 0) { markParent = true; }\n            if (blot == null || blot === _this)\n                return;\n            if (blot.domNode.parentNode == null)\n                return;\n            // @ts-ignore\n            if (blot.domNode[Registry.DATA_KEY].mutations == null) {\n                // @ts-ignore\n                blot.domNode[Registry.DATA_KEY].mutations = [];\n            }\n            if (markParent)\n                mark(blot.parent);\n        };\n        var optimize = function (blot) {\n            // Post-order traversal\n            if (\n            // @ts-ignore\n            blot.domNode[Registry.DATA_KEY] == null ||\n                // @ts-ignore\n                blot.domNode[Registry.DATA_KEY].mutations == null) {\n                return;\n            }\n            if (blot instanceof container_1.default) {\n                blot.children.forEach(optimize);\n            }\n            blot.optimize(context);\n        };\n        var remaining = mutations;\n        for (var i = 0; remaining.length > 0; i += 1) {\n            if (i >= MAX_OPTIMIZE_ITERATIONS) {\n                throw new Error('[Parchment] Maximum optimize iterations reached');\n            }\n            remaining.forEach(function (mutation) {\n                var blot = Registry.find(mutation.target, true);\n                if (blot == null)\n                    return;\n                if (blot.domNode === mutation.target) {\n                    if (mutation.type === 'childList') {\n                        mark(Registry.find(mutation.previousSibling, false));\n                        [].forEach.call(mutation.addedNodes, function (node) {\n                            var child = Registry.find(node, false);\n                            mark(child, false);\n                            if (child instanceof container_1.default) {\n                                child.children.forEach(function (grandChild) {\n                                    mark(grandChild, false);\n                                });\n                            }\n                        });\n                    }\n                    else if (mutation.type === 'attributes') {\n                        mark(blot.prev);\n                    }\n                }\n                mark(blot);\n            });\n            this.children.forEach(optimize);\n            remaining = [].slice.call(this.observer.takeRecords());\n            records = remaining.slice();\n            while (records.length > 0)\n                mutations.push(records.pop());\n        }\n    };\n    ScrollBlot.prototype.update = function (mutations, context) {\n        var _this = this;\n        if (context === void 0) { context = {}; }\n        mutations = mutations || this.observer.takeRecords();\n        // TODO use WeakMap\n        mutations\n            .map(function (mutation) {\n            var blot = Registry.find(mutation.target, true);\n            if (blot == null)\n                return null;\n            // @ts-ignore\n            if (blot.domNode[Registry.DATA_KEY].mutations == null) {\n                // @ts-ignore\n                blot.domNode[Registry.DATA_KEY].mutations = [mutation];\n                return blot;\n            }\n            else {\n                // @ts-ignore\n                blot.domNode[Registry.DATA_KEY].mutations.push(mutation);\n                return null;\n            }\n        })\n            .forEach(function (blot) {\n            if (blot == null ||\n                blot === _this ||\n                //@ts-ignore\n                blot.domNode[Registry.DATA_KEY] == null)\n                return;\n            // @ts-ignore\n            blot.update(blot.domNode[Registry.DATA_KEY].mutations || [], context);\n        });\n        // @ts-ignore\n        if (this.domNode[Registry.DATA_KEY].mutations != null) {\n            // @ts-ignore\n            _super.prototype.update.call(this, this.domNode[Registry.DATA_KEY].mutations, context);\n        }\n        this.optimize(mutations, context);\n    };\n    ScrollBlot.blotName = 'scroll';\n    ScrollBlot.defaultChild = 'block';\n    ScrollBlot.scope = Registry.Scope.BLOCK_BLOT;\n    ScrollBlot.tagName = 'DIV';\n    return ScrollBlot;\n}(container_1.default));\nexports.default = ScrollBlot;\n\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar format_1 = __webpack_require__(3);\nvar Registry = __webpack_require__(0);\n// Shallow object comparison\nfunction isEqual(obj1, obj2) {\n    if (Object.keys(obj1).length !== Object.keys(obj2).length)\n        return false;\n    // @ts-ignore\n    for (var prop in obj1) {\n        // @ts-ignore\n        if (obj1[prop] !== obj2[prop])\n            return false;\n    }\n    return true;\n}\nvar InlineBlot = /** @class */ (function (_super) {\n    __extends(InlineBlot, _super);\n    function InlineBlot() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    InlineBlot.formats = function (domNode) {\n        if (domNode.tagName === InlineBlot.tagName)\n            return undefined;\n        return _super.formats.call(this, domNode);\n    };\n    InlineBlot.prototype.format = function (name, value) {\n        var _this = this;\n        if (name === this.statics.blotName && !value) {\n            this.children.forEach(function (child) {\n                if (!(child instanceof format_1.default)) {\n                    child = child.wrap(InlineBlot.blotName, true);\n                }\n                _this.attributes.copy(child);\n            });\n            this.unwrap();\n        }\n        else {\n            _super.prototype.format.call(this, name, value);\n        }\n    };\n    InlineBlot.prototype.formatAt = function (index, length, name, value) {\n        if (this.formats()[name] != null || Registry.query(name, Registry.Scope.ATTRIBUTE)) {\n            var blot = this.isolate(index, length);\n            blot.format(name, value);\n        }\n        else {\n            _super.prototype.formatAt.call(this, index, length, name, value);\n        }\n    };\n    InlineBlot.prototype.optimize = function (context) {\n        _super.prototype.optimize.call(this, context);\n        var formats = this.formats();\n        if (Object.keys(formats).length === 0) {\n            return this.unwrap(); // unformatted span\n        }\n        var next = this.next;\n        if (next instanceof InlineBlot && next.prev === this && isEqual(formats, next.formats())) {\n            next.moveChildren(this);\n            next.remove();\n        }\n    };\n    InlineBlot.blotName = 'inline';\n    InlineBlot.scope = Registry.Scope.INLINE_BLOT;\n    InlineBlot.tagName = 'SPAN';\n    return InlineBlot;\n}(format_1.default));\nexports.default = InlineBlot;\n\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar format_1 = __webpack_require__(3);\nvar Registry = __webpack_require__(0);\nvar BlockBlot = /** @class */ (function (_super) {\n    __extends(BlockBlot, _super);\n    function BlockBlot() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    BlockBlot.formats = function (domNode) {\n        var tagName = Registry.query(BlockBlot.blotName).tagName;\n        if (domNode.tagName === tagName)\n            return undefined;\n        return _super.formats.call(this, domNode);\n    };\n    BlockBlot.prototype.format = function (name, value) {\n        if (Registry.query(name, Registry.Scope.BLOCK) == null) {\n            return;\n        }\n        else if (name === this.statics.blotName && !value) {\n            this.replaceWith(BlockBlot.blotName);\n        }\n        else {\n            _super.prototype.format.call(this, name, value);\n        }\n    };\n    BlockBlot.prototype.formatAt = function (index, length, name, value) {\n        if (Registry.query(name, Registry.Scope.BLOCK) != null) {\n            this.format(name, value);\n        }\n        else {\n            _super.prototype.formatAt.call(this, index, length, name, value);\n        }\n    };\n    BlockBlot.prototype.insertAt = function (index, value, def) {\n        if (def == null || Registry.query(value, Registry.Scope.INLINE) != null) {\n            // Insert text or inline\n            _super.prototype.insertAt.call(this, index, value, def);\n        }\n        else {\n            var after = this.split(index);\n            var blot = Registry.create(value, def);\n            after.parent.insertBefore(blot, after);\n        }\n    };\n    BlockBlot.prototype.update = function (mutations, context) {\n        if (navigator.userAgent.match(/Trident/)) {\n            this.build();\n        }\n        else {\n            _super.prototype.update.call(this, mutations, context);\n        }\n    };\n    BlockBlot.blotName = 'block';\n    BlockBlot.scope = Registry.Scope.BLOCK_BLOT;\n    BlockBlot.tagName = 'P';\n    return BlockBlot;\n}(format_1.default));\nexports.default = BlockBlot;\n\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar leaf_1 = __webpack_require__(4);\nvar EmbedBlot = /** @class */ (function (_super) {\n    __extends(EmbedBlot, _super);\n    function EmbedBlot() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    EmbedBlot.formats = function (domNode) {\n        return undefined;\n    };\n    EmbedBlot.prototype.format = function (name, value) {\n        // super.formatAt wraps, which is what we want in general,\n        // but this allows subclasses to overwrite for formats\n        // that just apply to particular embeds\n        _super.prototype.formatAt.call(this, 0, this.length(), name, value);\n    };\n    EmbedBlot.prototype.formatAt = function (index, length, name, value) {\n        if (index === 0 && length === this.length()) {\n            this.format(name, value);\n        }\n        else {\n            _super.prototype.formatAt.call(this, index, length, name, value);\n        }\n    };\n    EmbedBlot.prototype.formats = function () {\n        return this.statics.formats(this.domNode);\n    };\n    return EmbedBlot;\n}(leaf_1.default));\nexports.default = EmbedBlot;\n\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar leaf_1 = __webpack_require__(4);\nvar Registry = __webpack_require__(0);\nvar TextBlot = /** @class */ (function (_super) {\n    __extends(TextBlot, _super);\n    function TextBlot(node) {\n        var _this = _super.call(this, node) || this;\n        _this.text = _this.statics.value(_this.domNode);\n        return _this;\n    }\n    TextBlot.create = function (value) {\n        return document.createTextNode(value);\n    };\n    TextBlot.value = function (domNode) {\n        var text = domNode.data;\n        // @ts-ignore\n        if (text['normalize'])\n            text = text['normalize']();\n        return text;\n    };\n    TextBlot.prototype.deleteAt = function (index, length) {\n        this.domNode.data = this.text = this.text.slice(0, index) + this.text.slice(index + length);\n    };\n    TextBlot.prototype.index = function (node, offset) {\n        if (this.domNode === node) {\n            return offset;\n        }\n        return -1;\n    };\n    TextBlot.prototype.insertAt = function (index, value, def) {\n        if (def == null) {\n            this.text = this.text.slice(0, index) + value + this.text.slice(index);\n            this.domNode.data = this.text;\n        }\n        else {\n            _super.prototype.insertAt.call(this, index, value, def);\n        }\n    };\n    TextBlot.prototype.length = function () {\n        return this.text.length;\n    };\n    TextBlot.prototype.optimize = function (context) {\n        _super.prototype.optimize.call(this, context);\n        this.text = this.statics.value(this.domNode);\n        if (this.text.length === 0) {\n            this.remove();\n        }\n        else if (this.next instanceof TextBlot && this.next.prev === this) {\n            this.insertAt(this.length(), this.next.value());\n            this.next.remove();\n        }\n    };\n    TextBlot.prototype.position = function (index, inclusive) {\n        if (inclusive === void 0) { inclusive = false; }\n        return [this.domNode, index];\n    };\n    TextBlot.prototype.split = function (index, force) {\n        if (force === void 0) { force = false; }\n        if (!force) {\n            if (index === 0)\n                return this;\n            if (index === this.length())\n                return this.next;\n        }\n        var after = Registry.create(this.domNode.splitText(index));\n        this.parent.insertBefore(after, this.next);\n        this.text = this.statics.value(this.domNode);\n        return after;\n    };\n    TextBlot.prototype.update = function (mutations, context) {\n        var _this = this;\n        if (mutations.some(function (mutation) {\n            return mutation.type === 'characterData' && mutation.target === _this.domNode;\n        })) {\n            this.text = this.statics.value(this.domNode);\n        }\n    };\n    TextBlot.prototype.value = function () {\n        return this.text;\n    };\n    TextBlot.blotName = 'text';\n    TextBlot.scope = Registry.Scope.INLINE_BLOT;\n    return TextBlot;\n}(leaf_1.default));\nexports.default = TextBlot;\n\n\n/***/ })\n/******/ ]);\n});\n//# sourceMappingURL=parchment.js.map","var diff = require('fast-diff');\nvar equal = require('deep-equal');\nvar extend = require('extend');\nvar op = require('./op');\n\n\nvar NULL_CHARACTER = String.fromCharCode(0);  // Placeholder char for embed in diff()\n\n\nvar Delta = function (ops) {\n  // Assume we are given a well formed ops\n  if (Array.isArray(ops)) {\n    this.ops = ops;\n  } else if (ops != null && Array.isArray(ops.ops)) {\n    this.ops = ops.ops;\n  } else {\n    this.ops = [];\n  }\n};\n\n\nDelta.prototype.insert = function (text, attributes) {\n  var newOp = {};\n  if (text.length === 0) return this;\n  newOp.insert = text;\n  if (attributes != null && typeof attributes === 'object' && Object.keys(attributes).length > 0) {\n    newOp.attributes = attributes;\n  }\n  return this.push(newOp);\n};\n\nDelta.prototype['delete'] = function (length) {\n  if (length <= 0) return this;\n  return this.push({ 'delete': length });\n};\n\nDelta.prototype.retain = function (length, attributes) {\n  if (length <= 0) return this;\n  var newOp = { retain: length };\n  if (attributes != null && typeof attributes === 'object' && Object.keys(attributes).length > 0) {\n    newOp.attributes = attributes;\n  }\n  return this.push(newOp);\n};\n\nDelta.prototype.push = function (newOp) {\n  var index = this.ops.length;\n  var lastOp = this.ops[index - 1];\n  newOp = extend(true, {}, newOp);\n  if (typeof lastOp === 'object') {\n    if (typeof newOp['delete'] === 'number' && typeof lastOp['delete'] === 'number') {\n      this.ops[index - 1] = { 'delete': lastOp['delete'] + newOp['delete'] };\n      return this;\n    }\n    // Since it does not matter if we insert before or after deleting at the same index,\n    // always prefer to insert first\n    if (typeof lastOp['delete'] === 'number' && newOp.insert != null) {\n      index -= 1;\n      lastOp = this.ops[index - 1];\n      if (typeof lastOp !== 'object') {\n        this.ops.unshift(newOp);\n        return this;\n      }\n    }\n    if (equal(newOp.attributes, lastOp.attributes)) {\n      if (typeof newOp.insert === 'string' && typeof lastOp.insert === 'string') {\n        this.ops[index - 1] = { insert: lastOp.insert + newOp.insert };\n        if (typeof newOp.attributes === 'object') this.ops[index - 1].attributes = newOp.attributes\n        return this;\n      } else if (typeof newOp.retain === 'number' && typeof lastOp.retain === 'number') {\n        this.ops[index - 1] = { retain: lastOp.retain + newOp.retain };\n        if (typeof newOp.attributes === 'object') this.ops[index - 1].attributes = newOp.attributes\n        return this;\n      }\n    }\n  }\n  if (index === this.ops.length) {\n    this.ops.push(newOp);\n  } else {\n    this.ops.splice(index, 0, newOp);\n  }\n  return this;\n};\n\nDelta.prototype.chop = function () {\n  var lastOp = this.ops[this.ops.length - 1];\n  if (lastOp && lastOp.retain && !lastOp.attributes) {\n    this.ops.pop();\n  }\n  return this;\n};\n\nDelta.prototype.filter = function (predicate) {\n  return this.ops.filter(predicate);\n};\n\nDelta.prototype.forEach = function (predicate) {\n  this.ops.forEach(predicate);\n};\n\nDelta.prototype.map = function (predicate) {\n  return this.ops.map(predicate);\n};\n\nDelta.prototype.partition = function (predicate) {\n  var passed = [], failed = [];\n  this.forEach(function(op) {\n    var target = predicate(op) ? passed : failed;\n    target.push(op);\n  });\n  return [passed, failed];\n};\n\nDelta.prototype.reduce = function (predicate, initial) {\n  return this.ops.reduce(predicate, initial);\n};\n\nDelta.prototype.changeLength = function () {\n  return this.reduce(function (length, elem) {\n    if (elem.insert) {\n      return length + op.length(elem);\n    } else if (elem.delete) {\n      return length - elem.delete;\n    }\n    return length;\n  }, 0);\n};\n\nDelta.prototype.length = function () {\n  return this.reduce(function (length, elem) {\n    return length + op.length(elem);\n  }, 0);\n};\n\nDelta.prototype.slice = function (start, end) {\n  start = start || 0;\n  if (typeof end !== 'number') end = Infinity;\n  var ops = [];\n  var iter = op.iterator(this.ops);\n  var index = 0;\n  while (index < end && iter.hasNext()) {\n    var nextOp;\n    if (index < start) {\n      nextOp = iter.next(start - index);\n    } else {\n      nextOp = iter.next(end - index);\n      ops.push(nextOp);\n    }\n    index += op.length(nextOp);\n  }\n  return new Delta(ops);\n};\n\n\nDelta.prototype.compose = function (other) {\n  var thisIter = op.iterator(this.ops);\n  var otherIter = op.iterator(other.ops);\n  var ops = [];\n  var firstOther = otherIter.peek();\n  if (firstOther != null && typeof firstOther.retain === 'number' && firstOther.attributes == null) {\n    var firstLeft = firstOther.retain;\n    while (thisIter.peekType() === 'insert' && thisIter.peekLength() <= firstLeft) {\n      firstLeft -= thisIter.peekLength();\n      ops.push(thisIter.next());\n    }\n    if (firstOther.retain - firstLeft > 0) {\n      otherIter.next(firstOther.retain - firstLeft);\n    }\n  }\n  var delta = new Delta(ops);\n  while (thisIter.hasNext() || otherIter.hasNext()) {\n    if (otherIter.peekType() === 'insert') {\n      delta.push(otherIter.next());\n    } else if (thisIter.peekType() === 'delete') {\n      delta.push(thisIter.next());\n    } else {\n      var length = Math.min(thisIter.peekLength(), otherIter.peekLength());\n      var thisOp = thisIter.next(length);\n      var otherOp = otherIter.next(length);\n      if (typeof otherOp.retain === 'number') {\n        var newOp = {};\n        if (typeof thisOp.retain === 'number') {\n          newOp.retain = length;\n        } else {\n          newOp.insert = thisOp.insert;\n        }\n        // Preserve null when composing with a retain, otherwise remove it for inserts\n        var attributes = op.attributes.compose(thisOp.attributes, otherOp.attributes, typeof thisOp.retain === 'number');\n        if (attributes) newOp.attributes = attributes;\n        delta.push(newOp);\n\n        // Optimization if rest of other is just retain\n        if (!otherIter.hasNext() && equal(delta.ops[delta.ops.length - 1], newOp)) {\n          var rest = new Delta(thisIter.rest());\n          return delta.concat(rest).chop();\n        }\n\n      // Other op should be delete, we could be an insert or retain\n      // Insert + delete cancels out\n      } else if (typeof otherOp['delete'] === 'number' && typeof thisOp.retain === 'number') {\n        delta.push(otherOp);\n      }\n    }\n  }\n  return delta.chop();\n};\n\nDelta.prototype.concat = function (other) {\n  var delta = new Delta(this.ops.slice());\n  if (other.ops.length > 0) {\n    delta.push(other.ops[0]);\n    delta.ops = delta.ops.concat(other.ops.slice(1));\n  }\n  return delta;\n};\n\nDelta.prototype.diff = function (other, index) {\n  if (this.ops === other.ops) {\n    return new Delta();\n  }\n  var strings = [this, other].map(function (delta) {\n    return delta.map(function (op) {\n      if (op.insert != null) {\n        return typeof op.insert === 'string' ? op.insert : NULL_CHARACTER;\n      }\n      var prep = (delta === other) ? 'on' : 'with';\n      throw new Error('diff() called ' + prep + ' non-document');\n    }).join('');\n  });\n  var delta = new Delta();\n  var diffResult = diff(strings[0], strings[1], index);\n  var thisIter = op.iterator(this.ops);\n  var otherIter = op.iterator(other.ops);\n  diffResult.forEach(function (component) {\n    var length = component[1].length;\n    while (length > 0) {\n      var opLength = 0;\n      switch (component[0]) {\n        case diff.INSERT:\n          opLength = Math.min(otherIter.peekLength(), length);\n          delta.push(otherIter.next(opLength));\n          break;\n        case diff.DELETE:\n          opLength = Math.min(length, thisIter.peekLength());\n          thisIter.next(opLength);\n          delta['delete'](opLength);\n          break;\n        case diff.EQUAL:\n          opLength = Math.min(thisIter.peekLength(), otherIter.peekLength(), length);\n          var thisOp = thisIter.next(opLength);\n          var otherOp = otherIter.next(opLength);\n          if (equal(thisOp.insert, otherOp.insert)) {\n            delta.retain(opLength, op.attributes.diff(thisOp.attributes, otherOp.attributes));\n          } else {\n            delta.push(otherOp)['delete'](opLength);\n          }\n          break;\n      }\n      length -= opLength;\n    }\n  });\n  return delta.chop();\n};\n\nDelta.prototype.eachLine = function (predicate, newline) {\n  newline = newline || '\\n';\n  var iter = op.iterator(this.ops);\n  var line = new Delta();\n  var i = 0;\n  while (iter.hasNext()) {\n    if (iter.peekType() !== 'insert') return;\n    var thisOp = iter.peek();\n    var start = op.length(thisOp) - iter.peekLength();\n    var index = typeof thisOp.insert === 'string' ?\n      thisOp.insert.indexOf(newline, start) - start : -1;\n    if (index < 0) {\n      line.push(iter.next());\n    } else if (index > 0) {\n      line.push(iter.next(index));\n    } else {\n      if (predicate(line, iter.next(1).attributes || {}, i) === false) {\n        return;\n      }\n      i += 1;\n      line = new Delta();\n    }\n  }\n  if (line.length() > 0) {\n    predicate(line, {}, i);\n  }\n};\n\nDelta.prototype.transform = function (other, priority) {\n  priority = !!priority;\n  if (typeof other === 'number') {\n    return this.transformPosition(other, priority);\n  }\n  var thisIter = op.iterator(this.ops);\n  var otherIter = op.iterator(other.ops);\n  var delta = new Delta();\n  while (thisIter.hasNext() || otherIter.hasNext()) {\n    if (thisIter.peekType() === 'insert' && (priority || otherIter.peekType() !== 'insert')) {\n      delta.retain(op.length(thisIter.next()));\n    } else if (otherIter.peekType() === 'insert') {\n      delta.push(otherIter.next());\n    } else {\n      var length = Math.min(thisIter.peekLength(), otherIter.peekLength());\n      var thisOp = thisIter.next(length);\n      var otherOp = otherIter.next(length);\n      if (thisOp['delete']) {\n        // Our delete either makes their delete redundant or removes their retain\n        continue;\n      } else if (otherOp['delete']) {\n        delta.push(otherOp);\n      } else {\n        // We retain either their retain or insert\n        delta.retain(length, op.attributes.transform(thisOp.attributes, otherOp.attributes, priority));\n      }\n    }\n  }\n  return delta.chop();\n};\n\nDelta.prototype.transformPosition = function (index, priority) {\n  priority = !!priority;\n  var thisIter = op.iterator(this.ops);\n  var offset = 0;\n  while (thisIter.hasNext() && offset <= index) {\n    var length = thisIter.peekLength();\n    var nextType = thisIter.peekType();\n    thisIter.next();\n    if (nextType === 'delete') {\n      index -= Math.min(length, index - offset);\n      continue;\n    } else if (nextType === 'insert' && (offset < index || !priority)) {\n      index += length;\n    }\n    offset += length;\n  }\n  return index;\n};\n\n\nmodule.exports = Delta;\n","var equal = require('deep-equal');\nvar extend = require('extend');\n\n\nvar lib = {\n  attributes: {\n    compose: function (a, b, keepNull) {\n      if (typeof a !== 'object') a = {};\n      if (typeof b !== 'object') b = {};\n      var attributes = extend(true, {}, b);\n      if (!keepNull) {\n        attributes = Object.keys(attributes).reduce(function (copy, key) {\n          if (attributes[key] != null) {\n            copy[key] = attributes[key];\n          }\n          return copy;\n        }, {});\n      }\n      for (var key in a) {\n        if (a[key] !== undefined && b[key] === undefined) {\n          attributes[key] = a[key];\n        }\n      }\n      return Object.keys(attributes).length > 0 ? attributes : undefined;\n    },\n\n    diff: function(a, b) {\n      if (typeof a !== 'object') a = {};\n      if (typeof b !== 'object') b = {};\n      var attributes = Object.keys(a).concat(Object.keys(b)).reduce(function (attributes, key) {\n        if (!equal(a[key], b[key])) {\n          attributes[key] = b[key] === undefined ? null : b[key];\n        }\n        return attributes;\n      }, {});\n      return Object.keys(attributes).length > 0 ? attributes : undefined;\n    },\n\n    transform: function (a, b, priority) {\n      if (typeof a !== 'object') return b;\n      if (typeof b !== 'object') return undefined;\n      if (!priority) return b;  // b simply overwrites us without priority\n      var attributes = Object.keys(b).reduce(function (attributes, key) {\n        if (a[key] === undefined) attributes[key] = b[key];  // null is a valid value\n        return attributes;\n      }, {});\n      return Object.keys(attributes).length > 0 ? attributes : undefined;\n    }\n  },\n\n  iterator: function (ops) {\n    return new Iterator(ops);\n  },\n\n  length: function (op) {\n    if (typeof op['delete'] === 'number') {\n      return op['delete'];\n    } else if (typeof op.retain === 'number') {\n      return op.retain;\n    } else {\n      return typeof op.insert === 'string' ? op.insert.length : 1;\n    }\n  }\n};\n\n\nfunction Iterator(ops) {\n  this.ops = ops;\n  this.index = 0;\n  this.offset = 0;\n};\n\nIterator.prototype.hasNext = function () {\n  return this.peekLength() < Infinity;\n};\n\nIterator.prototype.next = function (length) {\n  if (!length) length = Infinity;\n  var nextOp = this.ops[this.index];\n  if (nextOp) {\n    var offset = this.offset;\n    var opLength = lib.length(nextOp)\n    if (length >= opLength - offset) {\n      length = opLength - offset;\n      this.index += 1;\n      this.offset = 0;\n    } else {\n      this.offset += length;\n    }\n    if (typeof nextOp['delete'] === 'number') {\n      return { 'delete': length };\n    } else {\n      var retOp = {};\n      if (nextOp.attributes) {\n        retOp.attributes = nextOp.attributes;\n      }\n      if (typeof nextOp.retain === 'number') {\n        retOp.retain = length;\n      } else if (typeof nextOp.insert === 'string') {\n        retOp.insert = nextOp.insert.substr(offset, length);\n      } else {\n        // offset should === 0, length should === 1\n        retOp.insert = nextOp.insert;\n      }\n      return retOp;\n    }\n  } else {\n    return { retain: Infinity };\n  }\n};\n\nIterator.prototype.peek = function () {\n  return this.ops[this.index];\n};\n\nIterator.prototype.peekLength = function () {\n  if (this.ops[this.index]) {\n    // Should never return 0 if our index is being managed correctly\n    return lib.length(this.ops[this.index]) - this.offset;\n  } else {\n    return Infinity;\n  }\n};\n\nIterator.prototype.peekType = function () {\n  if (this.ops[this.index]) {\n    if (typeof this.ops[this.index]['delete'] === 'number') {\n      return 'delete';\n    } else if (typeof this.ops[this.index].retain === 'number') {\n      return 'retain';\n    } else {\n      return 'insert';\n    }\n  }\n  return 'retain';\n};\n\nIterator.prototype.rest = function () {\n  if (!this.hasNext()) {\n    return [];\n  } else if (this.offset === 0) {\n    return this.ops.slice(this.index);\n  } else {\n    var offset = this.offset;\n    var index = this.index;\n    var next = this.next();\n    var rest = this.ops.slice(this.index);\n    this.offset = offset;\n    this.index = index;\n    return [next].concat(rest);\n  }\n};\n\n\nmodule.exports = lib;\n","import Parchment from 'parchment';\n\n\nclass Break extends Parchment.Embed {\n  static value() {\n    return undefined;\n  }\n\n  insertInto(parent, ref) {\n    if (parent.children.length === 0) {\n      super.insertInto(parent, ref);\n    } else {\n      this.remove();\n    }\n  }\n\n  length() {\n    return 0;\n  }\n\n  value() {\n    return '';\n  }\n}\nBreak.blotName = 'break';\nBreak.tagName = 'BR';\n\n\nexport default Break;\n","import extend from 'extend';\nimport Delta from 'quill-delta';\nimport Parchment from 'parchment';\nimport Break from './break';\nimport Inline from './inline';\nimport TextBlot from './text';\n\n\nconst NEWLINE_LENGTH = 1;\n\n\nclass BlockEmbed extends Parchment.Embed {\n  attach() {\n    super.attach();\n    this.attributes = new Parchment.Attributor.Store(this.domNode);\n  }\n\n  delta() {\n    return new Delta().insert(this.value(), extend(this.formats(), this.attributes.values()));\n  }\n\n  format(name, value) {\n    let attribute = Parchment.query(name, Parchment.Scope.BLOCK_ATTRIBUTE);\n    if (attribute != null) {\n      this.attributes.attribute(attribute, value);\n    }\n  }\n\n  formatAt(index, length, name, value) {\n    this.format(name, value);\n  }\n\n  insertAt(index, value, def) {\n    if (typeof value === 'string' && value.endsWith('\\n')) {\n      let block = Parchment.create(Block.blotName);\n      this.parent.insertBefore(block, index === 0 ? this : this.next);\n      block.insertAt(0, value.slice(0, -1));\n    } else {\n      super.insertAt(index, value, def);\n    }\n  }\n}\nBlockEmbed.scope = Parchment.Scope.BLOCK_BLOT;\n// It is important for cursor behavior BlockEmbeds use tags that are block level elements\n\n\nclass Block extends Parchment.Block {\n  constructor(domNode) {\n    super(domNode);\n    this.cache = {};\n  }\n\n  delta() {\n    if (this.cache.delta == null) {\n      this.cache.delta = this.descendants(Parchment.Leaf).reduce((delta, leaf) => {\n        if (leaf.length() === 0) {\n          return delta;\n        } else {\n          return delta.insert(leaf.value(), bubbleFormats(leaf));\n        }\n      }, new Delta()).insert('\\n', bubbleFormats(this));\n    }\n    return this.cache.delta;\n  }\n\n  deleteAt(index, length) {\n    super.deleteAt(index, length);\n    this.cache = {};\n  }\n\n  formatAt(index, length, name, value) {\n    if (length <= 0) return;\n    if (Parchment.query(name, Parchment.Scope.BLOCK)) {\n      if (index + length === this.length()) {\n        this.format(name, value);\n      }\n    } else {\n      super.formatAt(index, Math.min(length, this.length() - index - 1), name, value);\n    }\n    this.cache = {};\n  }\n\n  insertAt(index, value, def) {\n    if (def != null) return super.insertAt(index, value, def);\n    if (value.length === 0) return;\n    let lines = value.split('\\n');\n    let text = lines.shift();\n    if (text.length > 0) {\n      if (index < this.length() - 1 || this.children.tail == null) {\n        super.insertAt(Math.min(index, this.length() - 1), text);\n      } else {\n        this.children.tail.insertAt(this.children.tail.length(), text);\n      }\n      this.cache = {};\n    }\n    let block = this;\n    lines.reduce(function(index, line) {\n      block = block.split(index, true);\n      block.insertAt(0, line);\n      return line.length;\n    }, index + text.length);\n  }\n\n  insertBefore(blot, ref) {\n    let head = this.children.head;\n    super.insertBefore(blot, ref);\n    if (head instanceof Break) {\n      head.remove();\n    }\n    this.cache = {};\n  }\n\n  length() {\n    if (this.cache.length == null) {\n      this.cache.length = super.length() + NEWLINE_LENGTH;\n    }\n    return this.cache.length;\n  }\n\n  moveChildren(target, ref) {\n    super.moveChildren(target, ref);\n    this.cache = {};\n  }\n\n  optimize(context) {\n    super.optimize(context);\n    this.cache = {};\n  }\n\n  path(index) {\n    return super.path(index, true);\n  }\n\n  removeChild(child) {\n    super.removeChild(child);\n    this.cache = {};\n  }\n\n  split(index, force = false) {\n    if (force && (index === 0 || index >= this.length() - NEWLINE_LENGTH)) {\n      let clone = this.clone();\n      if (index === 0) {\n        this.parent.insertBefore(clone, this);\n        return this;\n      } else {\n        this.parent.insertBefore(clone, this.next);\n        return clone;\n      }\n    } else {\n      let next = super.split(index, force);\n      this.cache = {};\n      return next;\n    }\n  }\n}\nBlock.blotName = 'block';\nBlock.tagName = 'P';\nBlock.defaultChild = 'break';\nBlock.allowedChildren = [Inline, Parchment.Embed, TextBlot];\n\n\nfunction bubbleFormats(blot, formats = {}) {\n  if (blot == null) return formats;\n  if (typeof blot.formats === 'function') {\n    formats = extend(formats, blot.formats());\n  }\n  if (blot.parent == null || blot.parent.blotName == 'scroll' || blot.parent.statics.scope !== blot.statics.scope) {\n    return formats;\n  }\n  return bubbleFormats(blot.parent, formats);\n}\n\n\nexport { bubbleFormats, BlockEmbed, Block as default };\n","import Text from './text';\nimport Parchment from 'parchment';\n\n\nclass Inline extends Parchment.Inline {\n  static compare(self, other) {\n    let selfIndex = Inline.order.indexOf(self);\n    let otherIndex = Inline.order.indexOf(other);\n    if (selfIndex >= 0 || otherIndex >= 0) {\n      return selfIndex - otherIndex;\n    } else if (self === other) {\n      return 0;\n    } else if (self < other) {\n      return -1;\n    } else {\n      return 1;\n    }\n  }\n\n  formatAt(index, length, name, value) {\n    if (Inline.compare(this.statics.blotName, name) < 0 && Parchment.query(name, Parchment.Scope.BLOT)) {\n      let blot = this.isolate(index, length);\n      if (value) {\n        blot.wrap(name, value);\n      }\n    } else {\n      super.formatAt(index, length, name, value);\n    }\n  }\n\n  optimize(context) {\n    super.optimize(context);\n    if (this.parent instanceof Inline &&\n        Inline.compare(this.statics.blotName, this.parent.statics.blotName) > 0) {\n      let parent = this.parent.isolate(this.offset(), this.length());\n      this.moveChildren(parent);\n      parent.wrap(this);\n    }\n  }\n}\nInline.allowedChildren = [Inline, Parchment.Embed, Text];\n// Lower index means deeper in the DOM tree, since not found (-1) is for embeds\nInline.order = [\n  'cursor', 'inline',   // Must be lower\n  'underline', 'strike', 'italic', 'bold', 'script',\n  'link', 'code'        // Must be higher\n];\n\n\nexport default Inline;\n","import Parchment from 'parchment';\n\nclass TextBlot extends Parchment.Text { }\n\nexport default TextBlot;\n","import Delta from 'quill-delta';\nimport Parchment from 'parchment';\nimport Block from '../blots/block';\nimport Inline from '../blots/inline';\nimport TextBlot from '../blots/text';\n\n\nclass Code extends Inline {}\nCode.blotName = 'code';\nCode.tagName = 'CODE';\n\n\nclass CodeBlock extends Block {\n  static create(value) {\n    let domNode = super.create(value);\n    domNode.setAttribute('spellcheck', false);\n    return domNode;\n  }\n\n  static formats() {\n    return true;\n  }\n\n  delta() {\n    let text = this.domNode.textContent;\n    if (text.endsWith('\\n')) {      // Should always be true\n      text = text.slice(0, -1);\n    }\n    return text.split('\\n').reduce((delta, frag) => {\n      return delta.insert(frag).insert('\\n', this.formats());\n    }, new Delta());\n  }\n\n  format(name, value) {\n    if (name === this.statics.blotName && value) return;\n    let [text, ] = this.descendant(TextBlot, this.length() - 1);\n    if (text != null) {\n      text.deleteAt(text.length() - 1, 1);\n    }\n    super.format(name, value);\n  }\n\n  formatAt(index, length, name, value) {\n    if (length === 0) return;\n    if (Parchment.query(name, Parchment.Scope.BLOCK) == null ||\n        (name === this.statics.blotName && value === this.statics.formats(this.domNode))) {\n      return;\n    }\n    let nextNewline = this.newlineIndex(index);\n    if (nextNewline < 0 || nextNewline >= index + length) return;\n    let prevNewline = this.newlineIndex(index, true) + 1;\n    let isolateLength = nextNewline - prevNewline + 1;\n    let blot = this.isolate(prevNewline, isolateLength);\n    let next = blot.next;\n    blot.format(name, value);\n    if (next instanceof CodeBlock) {\n      next.formatAt(0, index - prevNewline + length - isolateLength, name, value);\n    }\n  }\n\n  insertAt(index, value, def) {\n    if (def != null) return;\n    let [text, offset] = this.descendant(TextBlot, index);\n    text.insertAt(offset, value);\n  }\n\n  length() {\n    let length = this.domNode.textContent.length;\n    if (!this.domNode.textContent.endsWith('\\n')) {\n      return length + 1;\n    }\n    return length;\n  }\n\n  newlineIndex(searchIndex, reverse = false) {\n    if (!reverse) {\n      let offset = this.domNode.textContent.slice(searchIndex).indexOf('\\n');\n      return offset > -1 ? searchIndex + offset : -1;\n    } else {\n      return this.domNode.textContent.slice(0, searchIndex).lastIndexOf('\\n');\n    }\n  }\n\n  optimize(context) {\n    if (!this.domNode.textContent.endsWith('\\n')) {\n      this.appendChild(Parchment.create('text', '\\n'));\n    }\n    super.optimize(context);\n    let next = this.next;\n    if (next != null && next.prev === this &&\n        next.statics.blotName === this.statics.blotName &&\n        this.statics.formats(this.domNode) === next.statics.formats(next.domNode)) {\n      next.optimize(context);\n      next.moveChildren(this);\n      next.remove();\n    }\n  }\n\n  replace(target) {\n    super.replace(target);\n    [].slice.call(this.domNode.querySelectorAll('*')).forEach(function(node) {\n      let blot = Parchment.find(node);\n      if (blot == null) {\n        node.parentNode.removeChild(node);\n      } else if (blot instanceof Parchment.Embed) {\n        blot.remove();\n      } else {\n        blot.unwrap();\n      }\n    });\n  }\n}\nCodeBlock.blotName = 'code-block';\nCodeBlock.tagName = 'PRE';\nCodeBlock.TAB = '  ';\n\n\nexport { Code, CodeBlock as default };\n","'use strict';\n\nvar setFunctionName = require('set-function-name');\nvar $TypeError = require('es-errors/type');\n\nvar $Object = Object;\n\nmodule.exports = setFunctionName(function flags() {\n\tif (this == null || this !== $Object(this)) {\n\t\tthrow new $TypeError('RegExp.prototype.flags getter called on non-object');\n\t}\n\tvar result = '';\n\tif (this.hasIndices) {\n\t\tresult += 'd';\n\t}\n\tif (this.global) {\n\t\tresult += 'g';\n\t}\n\tif (this.ignoreCase) {\n\t\tresult += 'i';\n\t}\n\tif (this.multiline) {\n\t\tresult += 'm';\n\t}\n\tif (this.dotAll) {\n\t\tresult += 's';\n\t}\n\tif (this.unicode) {\n\t\tresult += 'u';\n\t}\n\tif (this.unicodeSets) {\n\t\tresult += 'v';\n\t}\n\tif (this.sticky) {\n\t\tresult += 'y';\n\t}\n\treturn result;\n}, 'get flags', true);\n\n","'use strict';\n\nvar define = require('define-properties');\nvar callBind = require('call-bind');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar flagsBound = callBind(getPolyfill());\n\ndefine(flagsBound, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = flagsBound;\n","'use strict';\n\nvar implementation = require('./implementation');\n\nvar supportsDescriptors = require('define-properties').supportsDescriptors;\nvar $gOPD = Object.getOwnPropertyDescriptor;\n\nmodule.exports = function getPolyfill() {\n\tif (supportsDescriptors && (/a/mig).flags === 'gim') {\n\t\tvar descriptor = $gOPD(RegExp.prototype, 'flags');\n\t\tif (\n\t\t\tdescriptor\n\t\t\t&& typeof descriptor.get === 'function'\n\t\t\t&& 'dotAll' in RegExp.prototype\n\t\t\t&& 'hasIndices' in RegExp.prototype\n\t\t) {\n\t\t\t/* eslint getter-return: 0 */\n\t\t\tvar calls = '';\n\t\t\tvar o = {};\n\t\t\tObject.defineProperty(o, 'hasIndices', {\n\t\t\t\tget: function () {\n\t\t\t\t\tcalls += 'd';\n\t\t\t\t}\n\t\t\t});\n\t\t\tObject.defineProperty(o, 'sticky', {\n\t\t\t\tget: function () {\n\t\t\t\t\tcalls += 'y';\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tdescriptor.get.call(o);\n\n\t\t\tif (calls === 'dy') {\n\t\t\t\treturn descriptor.get;\n\t\t\t}\n\t\t}\n\t}\n\treturn implementation;\n};\n","'use strict';\n\nvar supportsDescriptors = require('define-properties').supportsDescriptors;\nvar getPolyfill = require('./polyfill');\nvar gOPD = require('gopd');\nvar defineProperty = Object.defineProperty;\nvar $TypeError = require('es-errors');\nvar getProto = require('get-proto');\nvar regex = /a/;\n\nmodule.exports = function shimFlags() {\n\tif (!supportsDescriptors || !getProto) {\n\t\tthrow new $TypeError('RegExp.prototype.flags requires a true ES5 environment that supports property descriptors');\n\t}\n\tvar polyfill = getPolyfill();\n\tvar proto = getProto(regex);\n\tvar descriptor = gOPD(proto, 'flags');\n\tif (!descriptor || descriptor.get !== polyfill) {\n\t\tdefineProperty(proto, 'flags', {\n\t\t\tconfigurable: true,\n\t\t\tenumerable: false,\n\t\t\tget: polyfill\n\t\t});\n\t}\n\treturn polyfill;\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\nvar define = require('define-data-property');\nvar hasDescriptors = require('has-property-descriptors')();\nvar gOPD = require('gopd');\n\nvar $TypeError = require('es-errors/type');\nvar $floor = GetIntrinsic('%Math.floor%');\n\n/** @type {import('.')} */\nmodule.exports = function setFunctionLength(fn, length) {\n\tif (typeof fn !== 'function') {\n\t\tthrow new $TypeError('`fn` is not a function');\n\t}\n\tif (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) {\n\t\tthrow new $TypeError('`length` must be a positive 32-bit integer');\n\t}\n\n\tvar loose = arguments.length > 2 && !!arguments[2];\n\n\tvar functionLengthIsConfigurable = true;\n\tvar functionLengthIsWritable = true;\n\tif ('length' in fn && gOPD) {\n\t\tvar desc = gOPD(fn, 'length');\n\t\tif (desc && !desc.configurable) {\n\t\t\tfunctionLengthIsConfigurable = false;\n\t\t}\n\t\tif (desc && !desc.writable) {\n\t\t\tfunctionLengthIsWritable = false;\n\t\t}\n\t}\n\n\tif (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {\n\t\tif (hasDescriptors) {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true);\n\t\t} else {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length);\n\t\t}\n\t}\n\treturn fn;\n};\n","'use strict';\n\nvar define = require('define-data-property');\nvar hasDescriptors = require('has-property-descriptors')();\nvar functionsHaveConfigurableNames = require('functions-have-names').functionsHaveConfigurableNames();\n\nvar $TypeError = require('es-errors/type');\n\n/** @type {import('.')} */\nmodule.exports = function setFunctionName(fn, name) {\n\tif (typeof fn !== 'function') {\n\t\tthrow new $TypeError('`fn` is not a function');\n\t}\n\tvar loose = arguments.length > 2 && !!arguments[2];\n\tif (!loose || functionsHaveConfigurableNames) {\n\t\tif (hasDescriptors) {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'name', name, true, true);\n\t\t} else {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'name', name);\n\t\t}\n\t}\n\treturn fn;\n};\n"],"names":["bind","$apply","$call","$reflectApply","module","exports","call","actualApply","arguments","Function","prototype","apply","$TypeError","$actualApply","args","length","Reflect","GetIntrinsic","callBind","$indexOf","name","allowMissing","intrinsic","setFunctionLength","$defineProperty","callBindBasic","applyBind","originalFunction","func","adjustedLength","value","objectKeys","isArguments","is","isRegex","flags","isDate","getTime","Date","deepEqual","actual","expected","options","opts","strict","a","b","i","key","isUndefinedOrNull","aIsRegex","bIsRegex","source","aIsBuffer","isBuffer","bIsBuffer","ka","kb","e","sort","objEquiv","undefined","x","copy","slice","$SyntaxError","gopd","obj","property","nonEnumerable","nonWritable","nonConfigurable","loose","desc","configurable","enumerable","writable","keys","hasSymbols","Symbol","toStr","Object","toString","concat","Array","defineDataProperty","supportsDescriptors","defineProperty","object","predicate","fn","defineProperties","map","predicates","props","getOwnPropertySymbols","hasProtoAccessor","gOPD","__proto__","code","$Object","$getPrototypeOf","getPrototypeOf","get","EvalError","Error","RangeError","ReferenceError","SyntaxError","TypeError","URIError","hasOwn","hasOwnProperty","getOwnPropertyDescriptor","isArray","arr","isPlainObject","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","newValue","getProperty","extend","src","copyIsArray","clone","deep","DIFF_DELETE","DIFF_INSERT","DIFF_EQUAL","diff_main","text1","text2","cursor_pos","commonlength","diff_commonPrefix","commonprefix","substring","diff_commonSuffix","commonsuffix","diffs","longtext","shorttext","indexOf","hm","diff_halfMatchI_","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","seed","Math","floor","j","best_common","prefixLength","suffixLength","text1_a","text1_b","text2_a","text2_b","hm1","ceil","hm2","mid_common","diff_halfMatch_","diffs_a","diffs_b","text1_length","text2_length","max_d","v_offset","v_length","v1","v2","delta","front","k1start","k1end","k2start","k2end","d","k1","k1_offset","y1","x1","charAt","k2_offset","x2","diff_bisectSplit_","k2","y2","diff_bisect_","diff_compute_","unshift","push","diff_cleanupMerge","norm","current_pos","next_pos","split_pos","d_left","d_right","splice","cursor_normalize_diff","ndiffs","cursor_pointer","d_next","merge_tuples","suffix","fix_cursor","compact","starts_with_pair_end","str","charCodeAt","ends_with_pair_start","fixed_diffs","fix_emoji","y","text1a","text2a","text1b","text2b","diffsb","pointermin","pointermax","min","pointermid","pointerstart","pointerend","pointer","count_delete","count_insert","text_delete","text_insert","pop","changes","diff","start","left_d","right_d","INSERT","DELETE","EQUAL","max","concatty","that","this","bound","arrLike","offset","slicy","boundLength","boundArgs","joiner","joiny","result","Empty","implementation","functionsHaveNames","functionsHaveConfigurableNames","$bind","boundFunctionsHaveNames","$Error","$EvalError","$RangeError","$ReferenceError","$URIError","abs","pow","round","sign","$Function","getEvalledConstructor","expressionSyntax","$gOPD","throwTypeError","ThrowTypeError","calleeThrows","gOPDthrows","getProto","$ObjectGPO","$ReflectGPO","needsEval","TypedArray","Uint8Array","INTRINSICS","AggregateError","ArrayBuffer","iterator","Atomics","BigInt","BigInt64Array","BigUint64Array","Boolean","DataView","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","eval","Float16Array","Float32Array","Float64Array","FinalizationRegistry","Int8Array","Int16Array","Int32Array","isFinite","isNaN","JSON","Map","Number","parseFloat","parseInt","Promise","Proxy","RegExp","Set","SharedArrayBuffer","String","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","WeakRef","WeakSet","error","errorProto","doEval","gen","LEGACY_ALIASES","$concat","$spliceApply","$replace","replace","$strSlice","$exec","exec","rePropName","reEscapeChar","getBaseIntrinsic","alias","intrinsicName","parts","string","first","last","match","number","quote","subString","stringToPath","intrinsicBaseName","intrinsicRealName","skipFurtherCaching","isOwn","part","reflectGetProto","originalGetProto","getDunderProto","O","hasPropertyDescriptors","hasArrayLengthDefineBug","origSymbol","hasSymbolSham","sym","symObj","_","getOwnPropertyNames","syms","propertyIsEnumerable","descriptor","toStringTag","$hasOwn","hasToStringTag","$toString","callBound","isStandardArguments","isLegacyArguments","callee","supportsStandardArguments","getDay","tryDateObject","isRegexMarker","throwRegexMarker","badStringifier","valueOf","toPrimitive","$isNaN","numberIsNaN","define","getPolyfill","shim","polyfill","keysShim","has","isArgs","isEnumerable","hasDontEnumBug","hasProtoEnumBug","dontEnums","equalsConstructorPrototype","o","ctor","excludedKeys","$applicationCache","$console","$external","$frame","$frameElement","$frames","$innerHeight","$innerWidth","$onmozfullscreenchange","$onmozfullscreenerror","$outerHeight","$outerWidth","$pageXOffset","$pageYOffset","$parent","$scrollLeft","$scrollTop","$scrollX","$scrollY","$self","$webkitIndexedDB","$webkitStorageInfo","$window","hasAutomationEqualityBug","window","k","isObject","isFunction","isString","theKeys","skipProto","skipConstructor","equalsConstructorPrototypeIfNotBuggy","origKeys","originalKeys","keysWorksWithArguments","factory","self","modules","installedModules","moduleId","l","m","c","getter","n","__esModule","p","s","__webpack_require__","extendStatics","__extends","setPrototypeOf","__","create","ParchmentError","_super","message","_this","Scope","attributes","classes","tags","types","query","scope","ANY","Text","Node","TEXT_NODE","LEVEL","BLOCK","INLINE","HTMLElement","names","getAttribute","split","tagName","TYPE","DATA_KEY","input","BlotClass","node","find","bubble","blot","parentNode","register","Definitions","_i","Definition","blotName","attrName","keyName","className","toUpperCase","forEach","tag","Registry","Attributor","attributeBit","ATTRIBUTE","whitelist","item","add","canAdd","setAttribute","BLOT","remove","removeAttribute","default","linked_list_1","shadow_1","ContainerBlot","domNode","build","appendChild","other","insertBefore","attach","children","child","childNodes","reverse","makeBlot","head","err","deleteAt","index","forEachAt","descendant","criteria","_a","descendants","MAX_VALUE","lengthLeft","detach","formatAt","insertAt","def","childBlot","refBlot","statics","allowedChildren","some","insertInto","reduce","memo","moveChildren","targetParent","refNode","optimize","context","defaultChild","path","inclusive","position","removeChild","force","next","after","parent","unwrap","update","mutations","addedNodes","removedNodes","mutation","type","document","body","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","filter","DOCUMENT_POSITION_FOLLOWING","nextSibling","replaceChild","attributor_1","store_1","container_1","FormatBlot","formats","toLowerCase","format","attribute","replaceWith","values","replacement","wrap","wrapper","move","LeafBlot","INLINE_BLOT","ShadowBlot","createElement","classList","scroll","cloneNode","isolate","parent_1","ref","parentBlot","refDomNode","root","class_1","style_1","AttributorStore","styles","attr","prefix","ClassAttributor","join","camelize","rest","StyleAttributor","trim","style","format_1","leaf_1","scroll_1","inline_1","block_1","embed_1","text_1","Parchment","Container","Format","Leaf","Embed","Scroll","Block","Inline","Attribute","Class","Style","Store","LinkedList","tail","append","nodes","contains","cur","prev","curNode","ret","length_1","callback","startNode","curIndex","curLength","OBSERVER_CONFIG","characterData","characterDataOldValue","childList","subtree","ScrollBlot","observer","MutationObserver","observe","disconnect","records","takeRecords","mark","markParent","remaining","previousSibling","grandChild","BLOCK_BLOT","InlineBlot","obj1","obj2","prop","isEqual","BlockBlot","navigator","userAgent","EmbedBlot","TextBlot","text","createTextNode","data","splitText","equal","op","NULL_CHARACTER","fromCharCode","Delta","ops","insert","newOp","retain","lastOp","chop","partition","passed","failed","initial","changeLength","elem","delete","end","Infinity","iter","hasNext","nextOp","compose","thisIter","otherIter","firstOther","peek","firstLeft","peekType","peekLength","thisOp","otherOp","strings","diffResult","component","opLength","eachLine","newline","line","transform","priority","transformPosition","nextType","lib","keepNull","Iterator","retOp","substr","Break","super","BlockEmbed","BLOCK_ATTRIBUTE","endsWith","block","cache","leaf","bubbleFormats","lines","shift","compare","selfIndex","order","otherIndex","Code","CodeBlock","textContent","frag","nextNewline","newlineIndex","prevNewline","isolateLength","searchIndex","lastIndexOf","querySelectorAll","TAB","setFunctionName","hasIndices","global","ignoreCase","multiline","dotAll","unicode","unicodeSets","sticky","flagsBound","calls","regex","proto","hasDescriptors","$floor","functionLengthIsConfigurable","functionLengthIsWritable"],"sourceRoot":""}