var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));

// node_modules/@babel/runtime/helpers/interopRequireDefault.js
var require_interopRequireDefault = __commonJS({
  "node_modules/@babel/runtime/helpers/interopRequireDefault.js"(exports2, module2) {
    function _interopRequireDefault(e) {
      return e && e.__esModule ? e : {
        "default": e
      };
    }
    module2.exports = _interopRequireDefault, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/classCallCheck.js
var require_classCallCheck = __commonJS({
  "node_modules/@babel/runtime/helpers/classCallCheck.js"(exports2, module2) {
    function _classCallCheck(a, n) {
      if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
    }
    module2.exports = _classCallCheck, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/typeof.js
var require_typeof = __commonJS({
  "node_modules/@babel/runtime/helpers/typeof.js"(exports2, module2) {
    function _typeof(o) {
      "@babel/helpers - typeof";
      return module2.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
        return typeof o2;
      } : function(o2) {
        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _typeof(o);
    }
    module2.exports = _typeof, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/toPrimitive.js
var require_toPrimitive = __commonJS({
  "node_modules/@babel/runtime/helpers/toPrimitive.js"(exports2, module2) {
    var _typeof = require_typeof()["default"];
    function toPrimitive(t, r) {
      if ("object" != _typeof(t) || !t) return t;
      var e = t[Symbol.toPrimitive];
      if (void 0 !== e) {
        var i = e.call(t, r || "default");
        if ("object" != _typeof(i)) return i;
        throw new TypeError("@@toPrimitive must return a primitive value.");
      }
      return ("string" === r ? String : Number)(t);
    }
    module2.exports = toPrimitive, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/toPropertyKey.js
var require_toPropertyKey = __commonJS({
  "node_modules/@babel/runtime/helpers/toPropertyKey.js"(exports2, module2) {
    var _typeof = require_typeof()["default"];
    var toPrimitive = require_toPrimitive();
    function toPropertyKey(t) {
      var i = toPrimitive(t, "string");
      return "symbol" == _typeof(i) ? i : i + "";
    }
    module2.exports = toPropertyKey, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/createClass.js
var require_createClass = __commonJS({
  "node_modules/@babel/runtime/helpers/createClass.js"(exports2, module2) {
    var toPropertyKey = require_toPropertyKey();
    function _defineProperties(e, r) {
      for (var t = 0; t < r.length; t++) {
        var o = r[t];
        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, toPropertyKey(o.key), o);
      }
    }
    function _createClass(e, r, t) {
      return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
        writable: false
      }), e;
    }
    module2.exports = _createClass, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/memoize-one/dist/memoize-one.cjs.js
var require_memoize_one_cjs = __commonJS({
  "node_modules/memoize-one/dist/memoize-one.cjs.js"(exports2, module2) {
    "use strict";
    var safeIsNaN = Number.isNaN || function ponyfill(value) {
      return typeof value === "number" && value !== value;
    };
    function isEqual(first, second) {
      if (first === second) {
        return true;
      }
      if (safeIsNaN(first) && safeIsNaN(second)) {
        return true;
      }
      return false;
    }
    function areInputsEqual(newInputs, lastInputs) {
      if (newInputs.length !== lastInputs.length) {
        return false;
      }
      for (var i = 0; i < newInputs.length; i++) {
        if (!isEqual(newInputs[i], lastInputs[i])) {
          return false;
        }
      }
      return true;
    }
    function memoizeOne(resultFn, isEqual2) {
      if (isEqual2 === void 0) {
        isEqual2 = areInputsEqual;
      }
      var cache = null;
      function memoized() {
        var newArgs = [];
        for (var _i = 0; _i < arguments.length; _i++) {
          newArgs[_i] = arguments[_i];
        }
        if (cache && cache.lastThis === this && isEqual2(newArgs, cache.lastArgs)) {
          return cache.lastResult;
        }
        var lastResult = resultFn.apply(this, newArgs);
        cache = {
          lastResult,
          lastArgs: newArgs,
          lastThis: this
        };
        return lastResult;
      }
      memoized.clear = function clear() {
        cache = null;
      };
      return memoized;
    }
    module2.exports = memoizeOne;
  }
});

// node_modules/@babel/runtime/helpers/defineProperty.js
var require_defineProperty = __commonJS({
  "node_modules/@babel/runtime/helpers/defineProperty.js"(exports2, module2) {
    var toPropertyKey = require_toPropertyKey();
    function _defineProperty(e, r, t) {
      return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
        value: t,
        enumerable: true,
        configurable: true,
        writable: true
      }) : e[r] = t, e;
    }
    module2.exports = _defineProperty, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/createPMSpecFactory.js
var require_createPMSpecFactory = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/createPMSpecFactory.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.createPMNodeSpecFactory = exports2.createPMMarkSpecFactory = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var createPMNodeSpecFactory = exports2.createPMNodeSpecFactory = function createPMNodeSpecFactory2(nodeSpec) {
      return function(_ref) {
        var parseDOM = _ref.parseDOM, toDOM = _ref.toDOM, toDebugString = _ref.toDebugString;
        return _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, nodeSpec), parseDOM && {
          parseDOM
        }), toDOM && {
          toDOM
        }), toDebugString && {
          toDebugString
        });
      };
    };
    var createPMMarkSpecFactory = exports2.createPMMarkSpecFactory = function createPMMarkSpecFactory2(markSpec) {
      return function(_ref2) {
        var parseDOM = _ref2.parseDOM, toDOM = _ref2.toDOM, toDebugString = _ref2.toDebugString;
        return _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, markSpec), parseDOM && {
          parseDOM
        }), toDOM && {
          toDOM
        }), toDebugString && {
          toDebugString
        });
      };
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/next-schema/generated/nodeTypes.js
var require_nodeTypes = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/next-schema/generated/nodeTypes.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.unsupportedInline = exports2.unsupportedBlock = exports2.textWithNoMarks = exports2.textFormatted = exports2.textCodeInline = exports2.text = exports2.taskList = exports2.taskItem = exports2.tableWithNestedTable = exports2.tableRowWithNestedTable = exports2.tableRow = exports2.tableHeaderWithNestedTable = exports2.tableHeader = exports2.tableCellWithNestedTable = exports2.tableCell = exports2.table = exports2.syncBlockStage0 = exports2.statusStage0 = exports2.status = exports2.rule = exports2.placeholder = exports2.paragraphWithNoMarks = exports2.paragraphWithIndentation = exports2.paragraphWithAlignment = exports2.paragraph = exports2.panel = exports2.orderedList = exports2.nestedExpandWithNoMarks = exports2.nestedExpand = exports2.multiBodiedExtensionStage0 = exports2.mentionStage0 = exports2.mention = exports2.mediaSingleWidthType = exports2.mediaSingleFull = exports2.mediaSingleCaption = exports2.mediaSingle = exports2.mediaInline = exports2.mediaGroup = exports2.media = exports2.listItemWithNestedDecisionStage0 = exports2.listItem = exports2.layoutSectionWithSingleColumnStage0 = exports2.layoutSectionFull = exports2.layoutSection = exports2.layoutColumn = exports2.inlineExtensionWithMarks = exports2.inlineExtension = exports2.inlineCardStage0 = exports2.inlineCard = exports2.image = exports2.headingWithNoMarks = exports2.headingWithIndentation = exports2.headingWithAlignment = exports2.heading = exports2.hardBreak = exports2.extensionWithMarks = exports2.extensionFrameStage0 = exports2.extension = exports2.expandRootOnly = exports2.expand = exports2.emojiStage0 = exports2.emoji = exports2.embedCard = exports2.doc = exports2.decisionList = exports2.decisionItem = exports2.dateStage0 = exports2.date = exports2.confluenceUnsupportedInline = exports2.confluenceUnsupportedBlock = exports2.confluenceJiraIssue = exports2.codeBlockRootOnly = exports2.codeBlock = exports2.caption = exports2.bulletList = exports2.bodiedExtensionWithMarks = exports2.bodiedExtension = exports2.blockquoteLegacy = exports2.blockquote = exports2.blockTaskItem = exports2.blockCard = void 0;
    var _createPMSpecFactory = require_createPMSpecFactory();
    var blockCard = exports2.blockCard = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      attrs: {
        localId: {
          default: null
        },
        url: {
          default: null
        },
        datasource: {
          default: null
        },
        width: {
          default: null
        },
        layout: {
          default: null
        },
        data: {
          default: null
        }
      },
      selectable: true,
      draggable: true
    });
    var blockquote = exports2.blockquote = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | orderedList | bulletList | unsupportedBlock | codeBlock | mediaSingle | mediaGroup | extension)+",
      marks: "unsupportedMark unsupportedNodeAttribute dataConsumer fragment",
      group: "block",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: true,
      defining: true
    });
    var blockquoteLegacy = exports2.blockquoteLegacy = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | unsupportedBlock)+",
      marks: "unsupportedMark unsupportedNodeAttribute",
      group: "block",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: true,
      defining: true
    });
    var blockTaskItem = exports2.blockTaskItem = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | extension) (paragraph | extension)*",
      marks: "dataConsumer fragment unsupportedMark unsupportedNodeAttribute",
      attrs: {
        localId: {
          default: ""
        },
        state: {
          default: "TODO"
        }
      },
      selectable: false,
      defining: true
    });
    var bodiedExtension = exports2.bodiedExtension = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaGroup | mediaSingle | decisionList | taskList | table | blockCard | embedCard | extension | unsupportedBlock)+",
      marks: "dataConsumer fragment unsupportedMark unsupportedNodeAttribute",
      group: "block",
      attrs: {
        extensionKey: {
          default: ""
        },
        extensionType: {
          default: ""
        },
        parameters: {
          default: null
        },
        text: {
          default: null
        },
        layout: {
          default: "default"
        },
        localId: {
          default: null
        }
      },
      selectable: true,
      defining: true,
      isolating: true
    });
    var bodiedExtensionWithMarks = exports2.bodiedExtensionWithMarks = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      marks: "dataConsumer fragment unsupportedMark unsupportedNodeAttribute",
      group: "block",
      attrs: {
        extensionKey: {
          default: ""
        },
        extensionType: {
          default: ""
        },
        parameters: {
          default: null
        },
        text: {
          default: null
        },
        layout: {
          default: "default"
        },
        localId: {
          default: null
        }
      },
      selectable: true,
      defining: true,
      isolating: true
    });
    var bulletList = exports2.bulletList = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "listItem+",
      marks: "unsupportedMark unsupportedNodeAttribute",
      group: "block",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: false
    });
    var caption = exports2.caption = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(hardBreak | mention | emoji | date | placeholder | inlineCard | status | text | unsupportedInline)*",
      marks: "_",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: false,
      isolating: true
    });
    var codeBlock = exports2.codeBlock = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(text | unsupportedInline)*",
      marks: "unsupportedMark unsupportedNodeAttribute",
      group: "block",
      attrs: {
        language: {
          default: null
        },
        uniqueId: {
          default: null
        },
        localId: {
          default: null
        }
      },
      code: true,
      defining: true
    });
    var codeBlockRootOnly = exports2.codeBlockRootOnly = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(text | unsupportedInline)*",
      marks: "unsupportedMark unsupportedNodeAttribute",
      attrs: {
        language: {
          default: null
        },
        uniqueId: {
          default: null
        },
        localId: {
          default: null
        }
      },
      code: true,
      defining: true
    });
    var confluenceJiraIssue = exports2.confluenceJiraIssue = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      atom: true,
      attrs: {
        issueKey: {
          default: ""
        },
        macroId: {
          default: null
        },
        schemaVersion: {
          default: null
        },
        server: {
          default: null
        },
        serverId: {
          default: null
        }
      }
    });
    var confluenceUnsupportedBlock = exports2.confluenceUnsupportedBlock = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      attrs: {
        cxhtml: {
          default: null
        }
      }
    });
    var confluenceUnsupportedInline = exports2.confluenceUnsupportedInline = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      atom: true,
      attrs: {
        cxhtml: {
          default: null
        }
      }
    });
    var date = exports2.date = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        timestamp: {
          default: ""
        },
        localId: {
          default: null
        }
      },
      selectable: true
    });
    var dateStage0 = exports2.dateStage0 = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        timestamp: {
          default: ""
        },
        localId: {
          default: null
        }
      },
      selectable: true
    });
    var decisionItem = exports2.decisionItem = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "inline*",
      marks: "_",
      attrs: {
        localId: {
          default: ""
        },
        state: {
          default: "DECIDED"
        }
      },
      defining: true
    });
    var decisionList = exports2.decisionList = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(decisionItem | unsupportedBlock)+",
      marks: "unsupportedMark unsupportedNodeAttribute",
      group: "block",
      attrs: {
        localId: {
          default: ""
        }
      },
      selectable: false,
      defining: true
    });
    var doc = exports2.doc = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(block | codeBlock | layoutSection | blockRootOnly | expand | syncBlock)+",
      marks: "unsupportedMark unsupportedNodeAttribute alignment indentation dataConsumer fragment breakout"
    });
    var embedCard = exports2.embedCard = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      attrs: {
        url: {
          default: ""
        },
        layout: {
          default: "center"
        },
        width: {
          default: 100
        },
        originalHeight: {
          default: null
        },
        originalWidth: {
          default: null
        },
        localId: {
          default: null
        }
      },
      selectable: true
    });
    var emoji = exports2.emoji = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        shortName: {
          default: ""
        },
        id: {
          default: ""
        },
        text: {
          default: ""
        },
        localId: {
          default: null
        }
      },
      selectable: true
    });
    var emojiStage0 = exports2.emojiStage0 = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        shortName: {
          default: ""
        },
        id: {
          default: ""
        },
        text: {
          default: ""
        },
        localId: {
          default: null
        }
      },
      selectable: true
    });
    var expand = exports2.expand = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaGroup | mediaSingle | decisionList | taskList | table | blockCard | embedCard | extension | unsupportedBlock | nestedExpand)+",
      marks: "unsupportedMark unsupportedNodeAttribute fragment dataConsumer",
      group: "block",
      attrs: {
        title: {
          default: ""
        },
        __expanded: {
          default: true
        },
        localId: {
          default: null
        }
      },
      selectable: true,
      isolating: true
    });
    var expandRootOnly = exports2.expandRootOnly = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaGroup | mediaSingle | decisionList | taskList | table | blockCard | embedCard | extension | unsupportedBlock | nestedExpand)+",
      marks: "unsupportedMark unsupportedNodeAttribute fragment dataConsumer",
      attrs: {
        title: {
          default: ""
        },
        __expanded: {
          default: true
        },
        localId: {
          default: null
        }
      },
      selectable: true,
      isolating: true
    });
    var extension = exports2.extension = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      atom: true,
      attrs: {
        extensionKey: {
          default: ""
        },
        extensionType: {
          default: ""
        },
        parameters: {
          default: null
        },
        text: {
          default: null
        },
        layout: {
          default: "default"
        },
        localId: {
          default: null
        }
      },
      selectable: true
    });
    var extensionWithMarks = exports2.extensionWithMarks = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      atom: true,
      attrs: {
        extensionKey: {
          default: ""
        },
        extensionType: {
          default: ""
        },
        parameters: {
          default: null
        },
        text: {
          default: null
        },
        layout: {
          default: "default"
        },
        localId: {
          default: null
        }
      },
      selectable: true
    });
    var extensionFrameStage0 = exports2.extensionFrameStage0 = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaGroup | mediaSingle | decisionList | taskList | table | extension | bodiedExtension | unsupportedBlock | blockCard | embedCard)+",
      marks: "dataConsumer fragment unsupportedMark unsupportedNodeAttribute",
      attrs: {},
      selectable: false,
      definingAsContext: false,
      definingForContent: true,
      isolating: true
    });
    var hardBreak = exports2.hardBreak = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        text: {
          default: "\n"
        },
        localId: {
          default: null
        }
      },
      selectable: false,
      linebreakReplacement: true
    });
    var heading = exports2.heading = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "inline*",
      marks: "link em strong strike subsup underline textColor annotation backgroundColor typeAheadQuery confluenceInlineComment unsupportedNodeAttribute unsupportedMark code dataConsumer fragment border",
      group: "block",
      attrs: {
        level: {
          default: 1
        },
        localId: {
          default: null
        }
      },
      selectable: false,
      defining: true
    });
    var headingWithAlignment = exports2.headingWithAlignment = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      attrs: {
        level: {
          default: 1
        },
        localId: {
          default: null
        }
      },
      selectable: false,
      defining: true
    });
    var headingWithIndentation = exports2.headingWithIndentation = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      attrs: {
        level: {
          default: 1
        },
        localId: {
          default: null
        }
      },
      selectable: false,
      defining: true
    });
    var headingWithNoMarks = exports2.headingWithNoMarks = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      attrs: {
        level: {
          default: 1
        },
        localId: {
          default: null
        }
      },
      selectable: false,
      defining: true
    });
    var image = exports2.image = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        src: {
          default: ""
        },
        alt: {
          default: ""
        },
        title: {
          default: null
        }
      },
      draggable: true
    });
    var inlineCard = exports2.inlineCard = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        url: {
          default: null
        },
        localId: {
          default: null
        },
        data: {
          default: null
        }
      },
      selectable: true,
      draggable: true
    });
    var inlineCardStage0 = exports2.inlineCardStage0 = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        url: {
          default: null
        },
        localId: {
          default: null
        },
        data: {
          default: null
        }
      },
      selectable: true,
      draggable: true
    });
    var inlineExtension = exports2.inlineExtension = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        extensionKey: {
          default: ""
        },
        extensionType: {
          default: ""
        },
        parameters: {
          default: null
        },
        text: {
          default: null
        },
        localId: {
          default: null
        }
      },
      selectable: true
    });
    var inlineExtensionWithMarks = exports2.inlineExtensionWithMarks = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        extensionKey: {
          default: ""
        },
        extensionType: {
          default: ""
        },
        parameters: {
          default: null
        },
        text: {
          default: null
        },
        localId: {
          default: null
        }
      },
      selectable: true
    });
    var layoutColumn = exports2.layoutColumn = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(block | unsupportedBlock)+",
      marks: "unsupportedMark unsupportedNodeAttribute alignment indentation dataConsumer fragment",
      attrs: {
        width: {
          default: void 0
        },
        localId: {
          default: null
        }
      },
      selectable: false,
      isolating: true
    });
    var layoutSection = exports2.layoutSection = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(layoutColumn | unsupportedBlock){1,3} unsupportedBlock*",
      marks: "unsupportedMark unsupportedNodeAttribute",
      attrs: {
        localId: {
          default: null
        }
      },
      isolating: true
    });
    var layoutSectionFull = exports2.layoutSectionFull = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(layoutColumn | unsupportedBlock){2,3}",
      marks: "unsupportedMark unsupportedNodeAttribute",
      attrs: {
        localId: {
          default: null
        }
      },
      isolating: true
    });
    var layoutSectionWithSingleColumnStage0 = exports2.layoutSectionWithSingleColumnStage0 = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(layoutColumn | unsupportedBlock){1,5} unsupportedBlock*",
      marks: "unsupportedMark unsupportedNodeAttribute",
      attrs: {
        columnRuleStyle: {
          default: null
        },
        localId: {
          default: null
        }
      },
      isolating: true
    });
    var listItem = exports2.listItem = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | mediaSingle | codeBlock | unsupportedBlock | extension) (paragraph | bulletList | orderedList | taskList | mediaSingle | codeBlock | unsupportedBlock | extension)*",
      marks: "dataConsumer fragment unsupportedMark unsupportedNodeAttribute",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: false,
      defining: true
    });
    var listItemWithNestedDecisionStage0 = exports2.listItemWithNestedDecisionStage0 = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | mediaSingle | codeBlock | unsupportedBlock | decisionList | extension) (paragraph | bulletList | orderedList | taskList | mediaSingle | codeBlock | unsupportedBlock | decisionList | extension)*",
      marks: "unsupportedMark unsupportedNodeAttribute dataConsumer fragment",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: false,
      defining: true
    });
    var media = exports2.media = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      attrs: {
        type: {
          default: "file"
        },
        localId: {
          default: null
        },
        id: {
          default: ""
        },
        alt: {
          default: ""
        },
        collection: {
          default: ""
        },
        height: {
          default: null
        },
        occurrenceKey: {
          default: null
        },
        width: {
          default: null
        },
        __contextId: {
          default: null
        },
        __displayType: {
          default: null
        },
        __external: {
          default: false
        },
        __fileMimeType: {
          default: null
        },
        __fileName: {
          default: null
        },
        __fileSize: {
          default: null
        },
        __mediaTraceId: {
          default: null
        },
        url: {
          default: null
        }
      },
      selectable: true
    });
    var mediaGroup = exports2.mediaGroup = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(media | unsupportedBlock)+",
      marks: "link annotation border unsupportedMark unsupportedNodeAttribute",
      group: "block",
      attrs: {},
      selectable: false
    });
    var mediaInline = exports2.mediaInline = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        type: {
          default: "file"
        },
        localId: {
          default: null
        },
        url: {
          default: null
        },
        id: {
          default: ""
        },
        alt: {
          default: ""
        },
        collection: {
          default: ""
        },
        occurrenceKey: {
          default: null
        },
        width: {
          default: null
        },
        height: {
          default: null
        },
        __fileName: {
          default: null
        },
        __fileSize: {
          default: null
        },
        __fileMimeType: {
          default: null
        },
        __displayType: {
          default: null
        },
        __contextId: {
          default: null
        },
        __mediaTraceId: {
          default: null
        },
        __external: {
          default: false
        }
      },
      selectable: true
    });
    var mediaSingle = exports2.mediaSingle = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      atom: true,
      attrs: {
        layout: {
          default: "center"
        },
        width: {
          default: null
        }
      },
      selectable: true,
      content: "media|unsupportedBlock+|media unsupportedBlock+",
      marks: "annotation border link unsupportedMark unsupportedNodeAttribute"
    });
    var mediaSingleCaption = exports2.mediaSingleCaption = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "media|unsupportedBlock+|media (caption|unsupportedBlock) unsupportedBlock*",
      marks: "link annotation border unsupportedMark unsupportedNodeAttribute",
      group: "block",
      atom: false,
      attrs: {
        layout: {
          default: "center"
        },
        width: {
          default: null
        }
      },
      selectable: true
    });
    var mediaSingleFull = exports2.mediaSingleFull = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "media|unsupportedBlock+|media (caption|unsupportedBlock) unsupportedBlock*",
      marks: "link annotation border unsupportedMark unsupportedNodeAttribute",
      group: "block",
      atom: false,
      attrs: {
        localId: {
          default: null
        },
        width: {
          default: null
        },
        layout: {
          default: "center"
        },
        widthType: {
          default: null
        }
      },
      selectable: true
    });
    var mediaSingleWidthType = exports2.mediaSingleWidthType = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "media|unsupportedBlock+|media unsupportedBlock+",
      marks: "link annotation border unsupportedMark unsupportedNodeAttribute",
      group: "block",
      atom: true,
      attrs: {
        localId: {
          default: null
        },
        width: {
          default: null
        },
        layout: {
          default: "center"
        },
        widthType: {
          default: null
        }
      },
      selectable: true
    });
    var mention = exports2.mention = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        id: {
          default: ""
        },
        localId: {
          default: null
        },
        text: {
          default: ""
        },
        accessLevel: {
          default: ""
        },
        userType: {
          default: null
        }
      },
      selectable: true
    });
    var mentionStage0 = exports2.mentionStage0 = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        id: {
          default: ""
        },
        localId: {
          default: null
        },
        text: {
          default: ""
        },
        accessLevel: {
          default: ""
        },
        userType: {
          default: null
        }
      },
      selectable: true
    });
    var multiBodiedExtensionStage0 = exports2.multiBodiedExtensionStage0 = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "extensionFrame+",
      marks: "unsupportedNodeAttribute unsupportedMark",
      group: "blockRootOnly",
      attrs: {
        extensionKey: {
          default: ""
        },
        extensionType: {
          default: ""
        },
        parameters: {
          default: null
        },
        text: {
          default: null
        },
        layout: {
          default: "default"
        },
        localId: {
          default: null
        }
      },
      selectable: true,
      definingAsContext: true
    });
    var nestedExpand = exports2.nestedExpand = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | heading | mediaSingle | mediaGroup | codeBlock | bulletList | orderedList | taskList | decisionList | rule | panel | blockquote | unsupportedBlock | extension)+",
      marks: "unsupportedMark unsupportedNodeAttribute dataConsumer fragment",
      attrs: {
        title: {
          default: ""
        },
        __expanded: {
          default: true
        },
        localId: {
          default: null
        }
      },
      selectable: true,
      isolating: true
    });
    var nestedExpandWithNoMarks = exports2.nestedExpandWithNoMarks = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      attrs: {
        title: {
          default: ""
        },
        __expanded: {
          default: true
        },
        localId: {
          default: null
        }
      },
      selectable: true,
      isolating: true
    });
    var orderedList = exports2.orderedList = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "listItem+",
      marks: "unsupportedMark unsupportedNodeAttribute",
      group: "block",
      attrs: {
        order: {
          default: 1
        },
        localId: {
          default: null
        }
      },
      selectable: false
    });
    var panel = exports2.panel = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | heading | bulletList | orderedList | blockCard | mediaGroup | mediaSingle | codeBlock | taskList | rule | decisionList | unsupportedBlock | extension)+",
      marks: "unsupportedMark unsupportedNodeAttribute dataConsumer fragment",
      group: "block",
      attrs: {
        panelType: {
          default: "info"
        },
        panelIcon: {
          default: null
        },
        panelIconId: {
          default: null
        },
        panelIconText: {
          default: null
        },
        panelColor: {
          default: null
        },
        localId: {
          default: null
        }
      },
      selectable: true
    });
    var paragraph = exports2.paragraph = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "inline*",
      marks: "link em strong strike subsup underline textColor annotation backgroundColor typeAheadQuery confluenceInlineComment unsupportedNodeAttribute unsupportedMark code dataConsumer fragment border",
      group: "block",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: false
    });
    var paragraphWithAlignment = exports2.paragraphWithAlignment = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: false
    });
    var paragraphWithIndentation = exports2.paragraphWithIndentation = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: false
    });
    var paragraphWithNoMarks = exports2.paragraphWithNoMarks = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: false
    });
    var placeholder = exports2.placeholder = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      marks: "",
      group: "inline",
      inline: true,
      attrs: {
        text: {
          default: ""
        },
        localId: {
          default: null
        }
      },
      selectable: false
    });
    var rule = exports2.rule = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      attrs: {
        localId: {
          default: null
        }
      }
    });
    var status = exports2.status = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        text: {
          default: ""
        },
        color: {
          default: ""
        },
        localId: {
          default: ""
        },
        style: {
          default: ""
        }
      },
      selectable: true
    });
    var statusStage0 = exports2.statusStage0 = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        text: {
          default: ""
        },
        color: {
          default: ""
        },
        localId: {
          default: ""
        },
        style: {
          default: ""
        }
      },
      selectable: true
    });
    var syncBlockStage0 = exports2.syncBlockStage0 = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      attrs: {
        resourceId: {
          default: ""
        },
        localId: {
          default: ""
        }
      },
      selectable: true
    });
    var table = exports2.table = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "tableRow+",
      marks: "unsupportedMark unsupportedNodeAttribute",
      group: "block",
      attrs: {
        displayMode: {
          default: null
        },
        isNumberColumnEnabled: {
          default: false
        },
        layout: {
          default: "default"
        },
        localId: {
          default: ""
        },
        width: {
          default: null
        },
        __autoSize: {
          default: false
        }
      },
      selectable: true,
      isolating: true,
      tableRole: "table"
    });
    var tableWithNestedTable = exports2.tableWithNestedTable = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "tableRow+",
      marks: "unsupportedMark unsupportedNodeAttribute",
      group: "block",
      attrs: {
        displayMode: {
          default: null
        },
        isNumberColumnEnabled: {
          default: false
        },
        layout: {
          default: "default"
        },
        localId: {
          default: ""
        },
        width: {
          default: null
        },
        __autoSize: {
          default: false
        }
      },
      selectable: true,
      isolating: true,
      tableRole: "table"
    });
    var tableCell = exports2.tableCell = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaSingle | mediaGroup | decisionList | taskList | blockCard | embedCard | extension | nestedExpand | unsupportedBlock)+",
      marks: "alignment unsupportedMark unsupportedNodeAttribute dataConsumer fragment",
      attrs: {
        colspan: {
          default: 1
        },
        rowspan: {
          default: 1
        },
        colwidth: {
          default: null
        },
        background: {
          default: null
        },
        localId: {
          default: null
        }
      },
      selectable: false,
      isolating: true,
      tableRole: "cell"
    });
    var tableCellWithNestedTable = exports2.tableCellWithNestedTable = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaSingle | mediaGroup | decisionList | taskList | blockCard | embedCard | extension | nestedExpand | unsupportedBlock | table)+",
      marks: "alignment unsupportedMark unsupportedNodeAttribute dataConsumer fragment",
      attrs: {
        colspan: {
          default: 1
        },
        rowspan: {
          default: 1
        },
        colwidth: {
          default: null
        },
        background: {
          default: null
        },
        localId: {
          default: null
        }
      },
      selectable: false,
      isolating: true,
      tableRole: "cell"
    });
    var tableHeader = exports2.tableHeader = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaSingle | mediaGroup | decisionList | taskList | blockCard | embedCard | extension | nestedExpand)+",
      marks: "alignment unsupportedMark unsupportedNodeAttribute dataConsumer fragment",
      attrs: {
        colspan: {
          default: 1
        },
        rowspan: {
          default: 1
        },
        colwidth: {
          default: null
        },
        background: {
          default: null
        },
        localId: {
          default: null
        }
      },
      selectable: false,
      isolating: true,
      tableRole: "header_cell"
    });
    var tableHeaderWithNestedTable = exports2.tableHeaderWithNestedTable = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaSingle | mediaGroup | decisionList | taskList | blockCard | embedCard | extension | nestedExpand | table)+",
      marks: "alignment unsupportedMark unsupportedNodeAttribute dataConsumer fragment",
      attrs: {
        colspan: {
          default: 1
        },
        rowspan: {
          default: 1
        },
        colwidth: {
          default: null
        },
        background: {
          default: null
        },
        localId: {
          default: null
        }
      },
      selectable: false,
      isolating: true,
      tableRole: "header_cell"
    });
    var tableRow = exports2.tableRow = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(tableCell | tableHeader)+",
      marks: "unsupportedMark unsupportedNodeAttribute",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: false,
      tableRole: "row"
    });
    var tableRowWithNestedTable = exports2.tableRowWithNestedTable = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(tableCell | tableHeader)+",
      marks: "unsupportedMark unsupportedNodeAttribute",
      attrs: {
        localId: {
          default: null
        }
      },
      selectable: false,
      tableRole: "row"
    });
    var taskItem = exports2.taskItem = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "inline*",
      marks: "_",
      attrs: {
        localId: {
          default: ""
        },
        state: {
          default: "TODO"
        }
      },
      selectable: false,
      defining: true
    });
    var taskList = exports2.taskList = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      content: "(taskItem | unsupportedBlock | blockTaskItem)+ (taskItem | taskList | unsupportedBlock | blockTaskItem)*",
      marks: "unsupportedMark unsupportedNodeAttribute",
      group: "block",
      attrs: {
        localId: {
          default: ""
        }
      },
      selectable: false,
      defining: true
    });
    var text = exports2.text = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline"
    });
    var textCodeInline = exports2.textCodeInline = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline"
    });
    var textFormatted = exports2.textFormatted = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline"
    });
    var textWithNoMarks = exports2.textWithNoMarks = (0, _createPMSpecFactory.createPMNodeSpecFactory)({});
    var unsupportedBlock = exports2.unsupportedBlock = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "block",
      atom: true,
      attrs: {
        originalValue: {
          default: {}
        }
      },
      selectable: true
    });
    var unsupportedInline = exports2.unsupportedInline = (0, _createPMSpecFactory.createPMNodeSpecFactory)({
      group: "inline",
      inline: true,
      attrs: {
        originalValue: {
          default: {}
        }
      },
      selectable: true
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/utils/uuid.js
var require_uuid = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/utils/uuid.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.uuid = exports2.generateUuid = void 0;
    var generateUuid = exports2.generateUuid = function generateUuid2() {
      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
        var r = Math.random() * 16 | 0;
        return (c === "x" ? r : r & 3 | 8).toString(16);
      });
    };
    var staticValue = false;
    var uuid = exports2.uuid = {
      setStatic: function setStatic(value) {
        staticValue = value;
      },
      generate: function generate() {
        return staticValue || generateUuid();
      }
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/expand.js
var require_expand = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/expand.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.toJSON = exports2.expandWithNestedExpandLocalId = exports2.expandWithNestedExpand = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    function getExpandAttrs(domNode) {
      var dom = domNode;
      return {
        title: dom.getAttribute("data-title"),
        __expanded: true
      };
    }
    var nodeSpecOptions = {
      parseDOM: [{
        context: "table//",
        tag: 'div[data-node-type="expand"]',
        getAttrs: getExpandAttrs
      }, {
        context: "expand//",
        tag: '[data-node-type="expand"]',
        getAttrs: getExpandAttrs
      }, {
        context: "nestedExpand//",
        tag: '[data-node-type="expand"]',
        getAttrs: getExpandAttrs
      }, {
        tag: '[data-node-type="nestedExpand"] button',
        ignore: true
      }, {
        tag: '[data-node-type="expand"] button',
        ignore: true
      }, {
        tag: 'div[data-node-type="expand"]',
        getAttrs: getExpandAttrs
      }],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-node-type": "expand",
          "data-title": node.attrs.title,
          "data-expanded": node.attrs.__expanded
        };
        return ["div", attrs, 0];
      }
    };
    var expandWithNestedExpand = exports2.expandWithNestedExpand = (0, _nodeTypes.expand)(nodeSpecOptions);
    var expandWithNestedExpandLocalId = exports2.expandWithNestedExpandLocalId = (0, _nodeTypes.expand)({
      parseDOM: [{
        context: "table//",
        tag: 'div[data-node-type="expand"]',
        getAttrs: function getAttrs(dom) {
          var attrs = getExpandAttrs(dom);
          return _objectSpread(_objectSpread({}, attrs), {}, {
            localId: _uuid.uuid.generate()
          });
        }
      }, {
        context: "expand//",
        tag: '[data-node-type="expand"]',
        getAttrs: function getAttrs(dom) {
          var attrs = getExpandAttrs(dom);
          return _objectSpread(_objectSpread({}, attrs), {}, {
            localId: _uuid.uuid.generate()
          });
        }
      }, {
        context: "nestedExpand//",
        tag: '[data-node-type="expand"]',
        getAttrs: function getAttrs(dom) {
          var attrs = getExpandAttrs(dom);
          return _objectSpread(_objectSpread({}, attrs), {}, {
            localId: _uuid.uuid.generate()
          });
        }
      }, {
        tag: '[data-node-type="nestedExpand"] button',
        ignore: true
      }, {
        tag: '[data-node-type="expand"] button',
        ignore: true
      }, {
        tag: 'div[data-node-type="expand"]',
        getAttrs: function getAttrs(dom) {
          var attrs = getExpandAttrs(dom);
          return _objectSpread(_objectSpread({}, attrs), {}, {
            localId: _uuid.uuid.generate()
          });
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var attrs = {
          "data-node-type": "expand",
          "data-title": node.attrs.title,
          "data-expanded": node.attrs.__expanded,
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        };
        return ["div", attrs, 0];
      }
    });
    var toJSON = exports2.toJSON = function toJSON2(node) {
      return {
        attrs: Object.keys(node.attrs).filter(function(key) {
          return !key.startsWith("__");
        }).reduce(function(obj, key) {
          return _objectSpread(_objectSpread({}, obj), {}, (0, _defineProperty2.default)({}, key, node.attrs[key]));
        }, {})
      };
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/confluence-jira-issue.js
var require_confluence_jira_issue = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/confluence-jira-issue.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.confluenceJiraIssue = void 0;
    var _nodeTypes = require_nodeTypes();
    var name = "confluenceJiraIssue";
    var confluenceJiraIssue = exports2.confluenceJiraIssue = (0, _nodeTypes.confluenceJiraIssue)({
      parseDOM: [{
        tag: 'span[data-node-type="'.concat(name, '"]'),
        getAttrs: function getAttrs(domNode) {
          var dom = domNode;
          return {
            issueKey: dom.textContent,
            macroId: dom.dataset && dom.dataset.macroId,
            schemaVersion: dom.dataset && dom.dataset.schemaVersion,
            server: dom.dataset && dom.dataset.server,
            serverId: dom.dataset && dom.dataset.serverId
          };
        }
      }],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-node-type": name,
          "data-macro-id": node.attrs.macroId,
          "data-schema-version": node.attrs.schemaVersion,
          "data-server": node.attrs.server,
          "data-server-id": node.attrs.serverId,
          "data-jira-issue": node.attrs.issueKey
        };
        return ["span", attrs, node.attrs.issueKey];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/confluence-unsupported-block.js
var require_confluence_unsupported_block = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/confluence-unsupported-block.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.confluenceUnsupportedBlock = void 0;
    var _nodeTypes = require_nodeTypes();
    var name = "confluenceUnsupportedBlock";
    var confluenceUnsupportedBlock = exports2.confluenceUnsupportedBlock = (0, _nodeTypes.confluenceUnsupportedBlock)({
      toDOM: function toDOM(node) {
        var attrs = {
          "data-node-type": name,
          "data-confluence-unsupported": "block",
          "data-confluence-unsupported-block-cxhtml": node.attrs["cxhtml"]
        };
        return ["div", attrs, "Unsupported content"];
      },
      parseDOM: [{
        tag: 'div[data-node-type="'.concat(name, '"]'),
        getAttrs: function getAttrs(dom) {
          return {
            cxhtml: dom.getAttribute("data-confluence-unsupported-block-cxhtml")
          };
        }
      }]
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/confluence-unsupported-inline.js
var require_confluence_unsupported_inline = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/confluence-unsupported-inline.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.confluenceUnsupportedInline = void 0;
    var _nodeTypes = require_nodeTypes();
    var name = "confluenceUnsupportedInline";
    var confluenceUnsupportedInline = exports2.confluenceUnsupportedInline = (0, _nodeTypes.confluenceUnsupportedInline)({
      toDOM: function toDOM(node) {
        var attrs = {
          "data-node-type": name,
          "data-confluence-unsupported": "inline",
          "data-confluence-unsupported-inline-cxhtml": node.attrs["cxhtml"]
        };
        return ["div", attrs, "Unsupported content"];
      },
      parseDOM: [{
        tag: 'div[data-node-type="'.concat(name, '"]'),
        getAttrs: function getAttrs(dom) {
          return {
            cxhtml: dom.getAttribute("data-confluence-unsupported-inline-cxhtml")
          };
        }
      }]
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/doc.js
var require_doc = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/doc.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.doc = void 0;
    var _nodeTypes = require_nodeTypes();
    var doc = exports2.doc = (0, _nodeTypes.doc)({});
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/utils/confluence/emoji.js
var require_emoji = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/utils/confluence/emoji.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.acNameToEmoji = acNameToEmoji;
    exports2.acShortcutToEmoji = acShortcutToEmoji;
    exports2.emojiIdToAcName = emojiIdToAcName;
    exports2.getEmojiAcName = getEmojiAcName;
    var DEFAULT_EMOJI_ID = "2b50";
    var DEFAULT_EMOJI_ACNAME = "blue-star";
    var HC_EMOTICON_PREFIX = "atlassian-";
    var acNameToEmojiMap = {
      smile: ["1f642", ":slight_smile:", "\u{1F642}"],
      sad: ["1f641", ":slight_frown:", "\u{1F641}"],
      cheeky: ["1f61b", ":stuck_out_tongue:", "\u{1F61B}"],
      laugh: ["1f600", ":grinning:", "\u{1F600}"],
      wink: ["1f609", ":wink:", "\u{1F609}"],
      information: ["2139", ":information_source:", "\u2139"],
      tick: ["2705", ":white_check_mark:", "\u2705"],
      cross: ["274c", ":x:", "\u274C"],
      warning: ["26a0", ":warning:", "\u26A0"],
      plus: ["2795", ":heavy_plus_sign:", "\u2795"],
      minus: ["2796", ":heavy_minus_sign:", "\u2796"],
      question: ["2753", ":question:", "?"],
      "thumbs-up": ["1f44d", ":thumbsup:", "\u{1F44D}"],
      "thumbs-down": ["1f44e", ":thumbsdown:", "\u{1F44E}"],
      "light-on": ["1f4a1", ":bulb:", "\u{1F4A1}"],
      "yellow-star": ["2b50", ":star:", "\u{1F49B}"],
      "light-off": ["1f6ab", ":no_entry_sign:", "\u{1F6AB}"],
      "red-star": ["2764", ":heart:", "\u2764\uFE0F"],
      "green-star": ["1f49a", ":green_heart:", "\u{1F49A}"],
      "blue-star": ["1f499", ":blue_heart:", "\u{1F499}"],
      heart: ["2764", ":heart:", "\u2764\uFE0F"],
      "broken-heart": ["1f494", ":broken_heart:", "\u{1F494}"]
    };
    function acNameToEmoji(acName) {
      var emojiData = acNameToEmojiMap[acName];
      return emojiData ? {
        id: emojiData[0],
        shortName: emojiData[1],
        text: emojiData[2]
      } : {
        id: DEFAULT_EMOJI_ID,
        shortName: ":".concat(acName, ":"),
        text: ""
      };
    }
    function emojiIdToAcName(emojiId) {
      var filterEmojis = function filterEmojis2(acName) {
        return acNameToEmojiMap[acName] ? acNameToEmojiMap[acName][0] === emojiId : false;
      };
      return Object.keys(acNameToEmojiMap).filter(filterEmojis)[0];
    }
    function acShortcutToEmoji(hipchatEmoticonShortName) {
      return {
        id: "".concat(HC_EMOTICON_PREFIX).concat(hipchatEmoticonShortName),
        shortName: ":".concat(hipchatEmoticonShortName, ":"),
        text: ""
      };
    }
    function getAcNameFromShortName(shortName) {
      return shortName.slice(shortName[0] === ":" ? 1 : 0, shortName[shortName.length - 1] === ":" ? -1 : shortName.length);
    }
    function getEmojiAcName(_ref) {
      var id = _ref.id, shortName = _ref.shortName;
      if (DEFAULT_EMOJI_ID === id) {
        var possibleName = getAcNameFromShortName(shortName);
        if (possibleName in acNameToEmojiMap) {
          return possibleName;
        }
      }
      return emojiIdToAcName(id) || DEFAULT_EMOJI_ACNAME;
    }
  }
});

// node_modules/@babel/runtime/helpers/arrayWithHoles.js
var require_arrayWithHoles = __commonJS({
  "node_modules/@babel/runtime/helpers/arrayWithHoles.js"(exports2, module2) {
    function _arrayWithHoles(r) {
      if (Array.isArray(r)) return r;
    }
    module2.exports = _arrayWithHoles, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/iterableToArrayLimit.js
var require_iterableToArrayLimit = __commonJS({
  "node_modules/@babel/runtime/helpers/iterableToArrayLimit.js"(exports2, module2) {
    function _iterableToArrayLimit(r, l) {
      var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
      if (null != t) {
        var e, n, i, u, a = [], f = true, o = false;
        try {
          if (i = (t = t.call(r)).next, 0 === l) {
            if (Object(t) !== t) return;
            f = false;
          } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
        } catch (r2) {
          o = true, n = r2;
        } finally {
          try {
            if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
          } finally {
            if (o) throw n;
          }
        }
        return a;
      }
    }
    module2.exports = _iterableToArrayLimit, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/arrayLikeToArray.js
var require_arrayLikeToArray = __commonJS({
  "node_modules/@babel/runtime/helpers/arrayLikeToArray.js"(exports2, module2) {
    function _arrayLikeToArray(r, a) {
      (null == a || a > r.length) && (a = r.length);
      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
      return n;
    }
    module2.exports = _arrayLikeToArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js
var require_unsupportedIterableToArray = __commonJS({
  "node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js"(exports2, module2) {
    var arrayLikeToArray = require_arrayLikeToArray();
    function _unsupportedIterableToArray(r, a) {
      if (r) {
        if ("string" == typeof r) return arrayLikeToArray(r, a);
        var t = {}.toString.call(r).slice(8, -1);
        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;
      }
    }
    module2.exports = _unsupportedIterableToArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/nonIterableRest.js
var require_nonIterableRest = __commonJS({
  "node_modules/@babel/runtime/helpers/nonIterableRest.js"(exports2, module2) {
    function _nonIterableRest() {
      throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
    }
    module2.exports = _nonIterableRest, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/slicedToArray.js
var require_slicedToArray = __commonJS({
  "node_modules/@babel/runtime/helpers/slicedToArray.js"(exports2, module2) {
    var arrayWithHoles = require_arrayWithHoles();
    var iterableToArrayLimit = require_iterableToArrayLimit();
    var unsupportedIterableToArray = require_unsupportedIterableToArray();
    var nonIterableRest = require_nonIterableRest();
    function _slicedToArray(r, e) {
      return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest();
    }
    module2.exports = _slicedToArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/css-color-names/css-color-names.json
var require_css_color_names = __commonJS({
  "node_modules/css-color-names/css-color-names.json"(exports2, module2) {
    module2.exports = {
      aliceblue: "#f0f8ff",
      antiquewhite: "#faebd7",
      aqua: "#00ffff",
      aquamarine: "#7fffd4",
      azure: "#f0ffff",
      beige: "#f5f5dc",
      bisque: "#ffe4c4",
      black: "#000000",
      blanchedalmond: "#ffebcd",
      blue: "#0000ff",
      blueviolet: "#8a2be2",
      brown: "#a52a2a",
      burlywood: "#deb887",
      cadetblue: "#5f9ea0",
      chartreuse: "#7fff00",
      chocolate: "#d2691e",
      coral: "#ff7f50",
      cornflowerblue: "#6495ed",
      cornsilk: "#fff8dc",
      crimson: "#dc143c",
      cyan: "#00ffff",
      darkblue: "#00008b",
      darkcyan: "#008b8b",
      darkgoldenrod: "#b8860b",
      darkgray: "#a9a9a9",
      darkgreen: "#006400",
      darkgrey: "#a9a9a9",
      darkkhaki: "#bdb76b",
      darkmagenta: "#8b008b",
      darkolivegreen: "#556b2f",
      darkorange: "#ff8c00",
      darkorchid: "#9932cc",
      darkred: "#8b0000",
      darksalmon: "#e9967a",
      darkseagreen: "#8fbc8f",
      darkslateblue: "#483d8b",
      darkslategray: "#2f4f4f",
      darkslategrey: "#2f4f4f",
      darkturquoise: "#00ced1",
      darkviolet: "#9400d3",
      deeppink: "#ff1493",
      deepskyblue: "#00bfff",
      dimgray: "#696969",
      dimgrey: "#696969",
      dodgerblue: "#1e90ff",
      firebrick: "#b22222",
      floralwhite: "#fffaf0",
      forestgreen: "#228b22",
      fuchsia: "#ff00ff",
      gainsboro: "#dcdcdc",
      ghostwhite: "#f8f8ff",
      gold: "#ffd700",
      goldenrod: "#daa520",
      gray: "#808080",
      green: "#008000",
      greenyellow: "#adff2f",
      grey: "#808080",
      honeydew: "#f0fff0",
      hotpink: "#ff69b4",
      indianred: "#cd5c5c",
      indigo: "#4b0082",
      ivory: "#fffff0",
      khaki: "#f0e68c",
      lavender: "#e6e6fa",
      lavenderblush: "#fff0f5",
      lawngreen: "#7cfc00",
      lemonchiffon: "#fffacd",
      lightblue: "#add8e6",
      lightcoral: "#f08080",
      lightcyan: "#e0ffff",
      lightgoldenrodyellow: "#fafad2",
      lightgray: "#d3d3d3",
      lightgreen: "#90ee90",
      lightgrey: "#d3d3d3",
      lightpink: "#ffb6c1",
      lightsalmon: "#ffa07a",
      lightseagreen: "#20b2aa",
      lightskyblue: "#87cefa",
      lightslategray: "#778899",
      lightslategrey: "#778899",
      lightsteelblue: "#b0c4de",
      lightyellow: "#ffffe0",
      lime: "#00ff00",
      limegreen: "#32cd32",
      linen: "#faf0e6",
      magenta: "#ff00ff",
      maroon: "#800000",
      mediumaquamarine: "#66cdaa",
      mediumblue: "#0000cd",
      mediumorchid: "#ba55d3",
      mediumpurple: "#9370db",
      mediumseagreen: "#3cb371",
      mediumslateblue: "#7b68ee",
      mediumspringgreen: "#00fa9a",
      mediumturquoise: "#48d1cc",
      mediumvioletred: "#c71585",
      midnightblue: "#191970",
      mintcream: "#f5fffa",
      mistyrose: "#ffe4e1",
      moccasin: "#ffe4b5",
      navajowhite: "#ffdead",
      navy: "#000080",
      oldlace: "#fdf5e6",
      olive: "#808000",
      olivedrab: "#6b8e23",
      orange: "#ffa500",
      orangered: "#ff4500",
      orchid: "#da70d6",
      palegoldenrod: "#eee8aa",
      palegreen: "#98fb98",
      paleturquoise: "#afeeee",
      palevioletred: "#db7093",
      papayawhip: "#ffefd5",
      peachpuff: "#ffdab9",
      peru: "#cd853f",
      pink: "#ffc0cb",
      plum: "#dda0dd",
      powderblue: "#b0e0e6",
      purple: "#800080",
      rebeccapurple: "#663399",
      red: "#ff0000",
      rosybrown: "#bc8f8f",
      royalblue: "#4169e1",
      saddlebrown: "#8b4513",
      salmon: "#fa8072",
      sandybrown: "#f4a460",
      seagreen: "#2e8b57",
      seashell: "#fff5ee",
      sienna: "#a0522d",
      silver: "#c0c0c0",
      skyblue: "#87ceeb",
      slateblue: "#6a5acd",
      slategray: "#708090",
      slategrey: "#708090",
      snow: "#fffafa",
      springgreen: "#00ff7f",
      steelblue: "#4682b4",
      tan: "#d2b48c",
      teal: "#008080",
      thistle: "#d8bfd8",
      tomato: "#ff6347",
      turquoise: "#40e0d0",
      violet: "#ee82ee",
      wheat: "#f5deb3",
      white: "#ffffff",
      whitesmoke: "#f5f5f5",
      yellow: "#ffff00",
      yellowgreen: "#9acd32"
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/utils/colors.js
var require_colors = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/utils/colors.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    var _typeof = require_typeof();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.Yellow200 = exports2.Y75 = exports2.Y500 = exports2.Y50 = exports2.Y400 = exports2.Y200 = exports2.T75 = exports2.T500 = exports2.T50 = exports2.T300 = exports2.T200 = exports2.T100 = exports2.R75 = exports2.R500 = exports2.R50 = exports2.R400 = exports2.R300 = exports2.R100 = exports2.P75 = exports2.P500 = exports2.P50 = exports2.P400 = exports2.P300 = exports2.P200 = exports2.P100 = exports2.O200 = exports2.Neutral300 = exports2.N90 = exports2.N800 = exports2.N80 = exports2.N600 = exports2.N60 = exports2.N500 = exports2.N50 = exports2.N40 = exports2.N300A = exports2.N300 = exports2.N30 = exports2.N200 = exports2.N20 = exports2.N1000 = exports2.N0 = exports2.M200 = exports2.L200 = exports2.G75 = exports2.G500 = exports2.G50 = exports2.G400 = exports2.G300 = exports2.G200 = exports2.B75 = exports2.B500 = exports2.B50 = exports2.B400 = exports2.B100 = void 0;
    exports2.hexToRgb = hexToRgb;
    exports2.hexToRgba = hexToRgba;
    exports2.isHex = isHex;
    exports2.isRgb = isRgb;
    exports2.normalizeHexColor = normalizeHexColor;
    exports2.rgbToHex = rgbToHex;
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var namedColors = _interopRequireWildcard(require_css_color_names());
    function _interopRequireWildcard(e, t) {
      if ("function" == typeof WeakMap) var r = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
      return (_interopRequireWildcard = function _interopRequireWildcard2(e2, t2) {
        if (!t2 && e2 && e2.__esModule) return e2;
        var o, i, f = { __proto__: null, default: e2 };
        if (null === e2 || "object" != _typeof(e2) && "function" != typeof e2) return f;
        if (o = t2 ? n : r) {
          if (o.has(e2)) return o.get(e2);
          o.set(e2, f);
        }
        for (var _t in e2) "default" !== _t && {}.hasOwnProperty.call(e2, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e2, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e2[_t]);
        return f;
      })(e, t);
    }
    var R50 = exports2.R50 = "#FFEBE6";
    var R75 = exports2.R75 = "#FFBDAD";
    var R100 = exports2.R100 = "#FF8F73";
    var R300 = exports2.R300 = "#FF5630";
    var R400 = exports2.R400 = "#DE350B";
    var R500 = exports2.R500 = "#BF2600";
    var Y50 = exports2.Y50 = "#FFFAE6";
    var Y75 = exports2.Y75 = "#FFF0B3";
    var Y200 = exports2.Y200 = "#FFC400";
    var Yellow200 = exports2.Yellow200 = "#F8E6A0";
    var Y400 = exports2.Y400 = "#FF991F";
    var Y500 = exports2.Y500 = "#FF8B00";
    var G50 = exports2.G50 = "#E3FCEF";
    var G75 = exports2.G75 = "#ABF5D1";
    var G200 = exports2.G200 = "#57D9A3";
    var G300 = exports2.G300 = "#36B37E";
    var G400 = exports2.G400 = "#00875A";
    var G500 = exports2.G500 = "#006644";
    var B50 = exports2.B50 = "#DEEBFF";
    var B75 = exports2.B75 = "#B3D4FF";
    var B100 = exports2.B100 = "#4C9AFF";
    var B400 = exports2.B400 = "#0052CC";
    var B500 = exports2.B500 = "#0747A6";
    var L200 = exports2.L200 = "#D3F1A7";
    var N0 = exports2.N0 = "#FFFFFF";
    var N20 = exports2.N20 = "#F4F5F7";
    var N30 = exports2.N30 = "#EBECF0";
    var N40 = exports2.N40 = "#DFE1E6";
    var N50 = exports2.N50 = "#C1C7D0";
    var N60 = exports2.N60 = "#B3BAC5";
    var N80 = exports2.N80 = "#97A0AF";
    var N90 = exports2.N90 = "#8993A4";
    var N200 = exports2.N200 = "#6B778C";
    var N300 = exports2.N300 = "#5E6C84";
    var Neutral300 = exports2.Neutral300 = "#DCDFE4";
    var N300A = exports2.N300A = "#091E4224";
    var N500 = exports2.N500 = "#42526E";
    var N600 = exports2.N600 = "#758195";
    var N800 = exports2.N800 = "#172B4D";
    var N1000 = exports2.N1000 = "#172B4D";
    var M200 = exports2.M200 = "#FDD0EC";
    var O200 = exports2.O200 = "#FEDEC8";
    var P50 = exports2.P50 = "#EAE6FF";
    var P75 = exports2.P75 = "#C0B6F2";
    var P100 = exports2.P100 = "#998DD9";
    var P200 = exports2.P200 = "#DFD8FD";
    var P300 = exports2.P300 = "#6554C0";
    var P400 = exports2.P400 = "#5243AA";
    var P500 = exports2.P500 = "#403294";
    var T50 = exports2.T50 = "#E6FCFF";
    var T75 = exports2.T75 = "#B3F5FF";
    var T100 = exports2.T100 = "#79E2F2";
    var T200 = exports2.T200 = "#C6EDFB";
    var T300 = exports2.T300 = "#00B8D9";
    var T500 = exports2.T500 = "#008DA6";
    function normalizeHexColor(color, defaultColor) {
      if (!color) {
        return null;
      }
      color = color.trim().toLowerCase();
      if (isHex(color)) {
        if (color.length === 4) {
          color = color.split("").map(function(c) {
            return c === "#" ? "#" : "".concat(c).concat(c);
          }).join("");
        }
      } else if (isRgb(color)) {
        return rgbToHex(color);
      } else {
        if (color === "default") {
          return null;
        } else if (namedColors.default && namedColors.default[color]) {
          color = namedColors.default[color];
        } else if (namedColors && namedColors[color]) {
          color = namedColors[color];
        } else {
          return null;
        }
      }
      if (color === defaultColor) {
        return null;
      }
      return color;
    }
    function hexToRgb(color) {
      if (!isHex(color)) {
        return null;
      }
      var colorBits = color.substring(1).split("");
      if (colorBits.length === 3) {
        colorBits = [colorBits[0], colorBits[0], colorBits[1], colorBits[1], colorBits[2], colorBits[2]];
      }
      var rgb = Number("0x".concat(colorBits.join("")));
      return "rgb(".concat(rgb >> 16 & 255, ",").concat(rgb >> 8 & 255, ",").concat(rgb & 255, ")");
    }
    function hexToRgba(rawColor, alpha) {
      var color = normalizeHexColor(rawColor);
      if (!color) {
        return null;
      }
      var hex2rgb = function hex2rgb2(color2) {
        return color2.match(/[a-z0-9]{2}/gi).map(function(hex) {
          return parseInt(hex, 16);
        });
      };
      return "rgba(".concat(hex2rgb(color).concat(alpha).join(","), ")");
    }
    function rgbToHex(value) {
      var matches = value.match(/(0?\.?\d{1,3})%?\b/g);
      if (matches && matches.length >= 3) {
        var _matches$map = matches.map(Number), _matches$map2 = (0, _slicedToArray2.default)(_matches$map, 3), red = _matches$map2[0], green = _matches$map2[1], blue = _matches$map2[2];
        return "#" + (blue | green << 8 | red << 16 | 1 << 24).toString(16).slice(1);
      }
      return null;
    }
    function isRgb(color) {
      return /rgba?\(/.test(color);
    }
    function isHex(color) {
      return /^#([A-Fa-f0-9]{3}){1,2}$/.test(color);
    }
  }
});

// node_modules/uc.micro/properties/Any/regex.js
var require_regex = __commonJS({
  "node_modules/uc.micro/properties/Any/regex.js"(exports2, module2) {
    module2.exports = /[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
  }
});

// node_modules/uc.micro/categories/Cc/regex.js
var require_regex2 = __commonJS({
  "node_modules/uc.micro/categories/Cc/regex.js"(exports2, module2) {
    module2.exports = /[\0-\x1F\x7F-\x9F]/;
  }
});

// node_modules/uc.micro/categories/Z/regex.js
var require_regex3 = __commonJS({
  "node_modules/uc.micro/categories/Z/regex.js"(exports2, module2) {
    module2.exports = /[ \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/;
  }
});

// node_modules/uc.micro/categories/P/regex.js
var require_regex4 = __commonJS({
  "node_modules/uc.micro/categories/P/regex.js"(exports2, module2) {
    module2.exports = /[!-#%-\*,-\/:;\?@\[-\]_\{\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4E\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDF55-\uDF59]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDF3C-\uDF3E]|\uD806[\uDC3B\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]/;
  }
});

// node_modules/linkify-it/lib/re.js
var require_re = __commonJS({
  "node_modules/linkify-it/lib/re.js"(exports2, module2) {
    "use strict";
    module2.exports = function(opts) {
      var re = {};
      re.src_Any = require_regex().source;
      re.src_Cc = require_regex2().source;
      re.src_Z = require_regex3().source;
      re.src_P = require_regex4().source;
      re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join("|");
      re.src_ZCc = [re.src_Z, re.src_Cc].join("|");
      var text_separators = "[><\uFF5C]";
      re.src_pseudo_letter = "(?:(?!" + text_separators + "|" + re.src_ZPCc + ")" + re.src_Any + ")";
      re.src_ip4 = "(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)";
      re.src_auth = "(?:(?:(?!" + re.src_ZCc + "|[@/\\[\\]()]).)+@)?";
      re.src_port = "(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?";
      re.src_host_terminator = "(?=$|" + text_separators + "|" + re.src_ZPCc + ")(?!-|_|:\\d|\\.-|\\.(?!$|" + re.src_ZPCc + "))";
      re.src_path = "(?:[/?#](?:(?!" + re.src_ZCc + "|" + text_separators + `|[()[\\]{}.,"'?!\\-]).|\\[(?:(?!` + re.src_ZCc + "|\\]).)*\\]|\\((?:(?!" + re.src_ZCc + "|[)]).)*\\)|\\{(?:(?!" + re.src_ZCc + '|[}]).)*\\}|\\"(?:(?!' + re.src_ZCc + `|["]).)+\\"|\\'(?:(?!` + re.src_ZCc + "|[']).)+\\'|\\'(?=" + re.src_pseudo_letter + "|[-]).|\\.{2,4}[a-zA-Z0-9%/]|\\.(?!" + re.src_ZCc + "|[.]).|" + (opts && opts["---"] ? "\\-(?!--(?:[^-]|$))(?:-*)|" : "\\-+|") + "\\,(?!" + re.src_ZCc + ").|\\!(?!" + re.src_ZCc + "|[!]).|\\?(?!" + re.src_ZCc + "|[?]).)+|\\/)?";
      re.src_email_name = '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
      re.src_xn = "xn--[a-z0-9\\-]{1,59}";
      re.src_domain_root = // Allow letters & digits (http://test1)
      "(?:" + re.src_xn + "|" + re.src_pseudo_letter + "{1,63})";
      re.src_domain = "(?:" + re.src_xn + "|(?:" + re.src_pseudo_letter + ")|(?:" + re.src_pseudo_letter + "(?:-|" + re.src_pseudo_letter + "){0,61}" + re.src_pseudo_letter + "))";
      re.src_host = "(?:(?:(?:(?:" + re.src_domain + ")\\.)*" + re.src_domain + "))";
      re.tpl_host_fuzzy = "(?:" + re.src_ip4 + "|(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%)))";
      re.tpl_host_no_ip_fuzzy = "(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%))";
      re.src_host_strict = re.src_host + re.src_host_terminator;
      re.tpl_host_fuzzy_strict = re.tpl_host_fuzzy + re.src_host_terminator;
      re.src_host_port_strict = re.src_host + re.src_port + re.src_host_terminator;
      re.tpl_host_port_fuzzy_strict = re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
      re.tpl_host_port_no_ip_fuzzy_strict = re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;
      re.tpl_host_fuzzy_test = "localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:" + re.src_ZPCc + "|>|$))";
      re.tpl_email_fuzzy = "(^|" + text_separators + '|"|\\(|' + re.src_ZCc + ")(" + re.src_email_name + "@" + re.tpl_host_fuzzy_strict + ")";
      re.tpl_link_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
      // but can start with > (markdown blockquote)
      "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_fuzzy_strict + re.src_path + ")";
      re.tpl_link_no_ip_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
      // but can start with > (markdown blockquote)
      "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ")";
      return re;
    };
  }
});

// node_modules/linkify-it/index.js
var require_linkify_it = __commonJS({
  "node_modules/linkify-it/index.js"(exports2, module2) {
    "use strict";
    function assign(obj) {
      var sources = Array.prototype.slice.call(arguments, 1);
      sources.forEach(function(source) {
        if (!source) {
          return;
        }
        Object.keys(source).forEach(function(key) {
          obj[key] = source[key];
        });
      });
      return obj;
    }
    function _class(obj) {
      return Object.prototype.toString.call(obj);
    }
    function isString(obj) {
      return _class(obj) === "[object String]";
    }
    function isObject(obj) {
      return _class(obj) === "[object Object]";
    }
    function isRegExp(obj) {
      return _class(obj) === "[object RegExp]";
    }
    function isFunction(obj) {
      return _class(obj) === "[object Function]";
    }
    function escapeRE(str) {
      return str.replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&");
    }
    var defaultOptions = {
      fuzzyLink: true,
      fuzzyEmail: true,
      fuzzyIP: false
    };
    function isOptionsObj(obj) {
      return Object.keys(obj || {}).reduce(function(acc, k) {
        return acc || defaultOptions.hasOwnProperty(k);
      }, false);
    }
    var defaultSchemas = {
      "http:": {
        validate: function(text, pos, self2) {
          var tail = text.slice(pos);
          if (!self2.re.http) {
            self2.re.http = new RegExp(
              "^\\/\\/" + self2.re.src_auth + self2.re.src_host_port_strict + self2.re.src_path,
              "i"
            );
          }
          if (self2.re.http.test(tail)) {
            return tail.match(self2.re.http)[0].length;
          }
          return 0;
        }
      },
      "https:": "http:",
      "ftp:": "http:",
      "//": {
        validate: function(text, pos, self2) {
          var tail = text.slice(pos);
          if (!self2.re.no_http) {
            self2.re.no_http = new RegExp(
              "^" + self2.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'
              // with code comments
              "(?:localhost|(?:(?:" + self2.re.src_domain + ")\\.)+" + self2.re.src_domain_root + ")" + self2.re.src_port + self2.re.src_host_terminator + self2.re.src_path,
              "i"
            );
          }
          if (self2.re.no_http.test(tail)) {
            if (pos >= 3 && text[pos - 3] === ":") {
              return 0;
            }
            if (pos >= 3 && text[pos - 3] === "/") {
              return 0;
            }
            return tail.match(self2.re.no_http)[0].length;
          }
          return 0;
        }
      },
      "mailto:": {
        validate: function(text, pos, self2) {
          var tail = text.slice(pos);
          if (!self2.re.mailto) {
            self2.re.mailto = new RegExp(
              "^" + self2.re.src_email_name + "@" + self2.re.src_host_strict,
              "i"
            );
          }
          if (self2.re.mailto.test(tail)) {
            return tail.match(self2.re.mailto)[0].length;
          }
          return 0;
        }
      }
    };
    var tlds_2ch_src_re = "a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]";
    var tlds_default = "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|\u0440\u0444".split("|");
    function resetScanCache(self2) {
      self2.__index__ = -1;
      self2.__text_cache__ = "";
    }
    function createValidator(re) {
      return function(text, pos) {
        var tail = text.slice(pos);
        if (re.test(tail)) {
          return tail.match(re)[0].length;
        }
        return 0;
      };
    }
    function createNormalizer() {
      return function(match, self2) {
        self2.normalize(match);
      };
    }
    function compile(self2) {
      var re = self2.re = require_re()(self2.__opts__);
      var tlds = self2.__tlds__.slice();
      self2.onCompile();
      if (!self2.__tlds_replaced__) {
        tlds.push(tlds_2ch_src_re);
      }
      tlds.push(re.src_xn);
      re.src_tlds = tlds.join("|");
      function untpl(tpl) {
        return tpl.replace("%TLDS%", re.src_tlds);
      }
      re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), "i");
      re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), "i");
      re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "i");
      re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), "i");
      var aliases = [];
      self2.__compiled__ = {};
      function schemaError(name, val) {
        throw new Error('(LinkifyIt) Invalid schema "' + name + '": ' + val);
      }
      Object.keys(self2.__schemas__).forEach(function(name) {
        var val = self2.__schemas__[name];
        if (val === null) {
          return;
        }
        var compiled = { validate: null, link: null };
        self2.__compiled__[name] = compiled;
        if (isObject(val)) {
          if (isRegExp(val.validate)) {
            compiled.validate = createValidator(val.validate);
          } else if (isFunction(val.validate)) {
            compiled.validate = val.validate;
          } else {
            schemaError(name, val);
          }
          if (isFunction(val.normalize)) {
            compiled.normalize = val.normalize;
          } else if (!val.normalize) {
            compiled.normalize = createNormalizer();
          } else {
            schemaError(name, val);
          }
          return;
        }
        if (isString(val)) {
          aliases.push(name);
          return;
        }
        schemaError(name, val);
      });
      aliases.forEach(function(alias) {
        if (!self2.__compiled__[self2.__schemas__[alias]]) {
          return;
        }
        self2.__compiled__[alias].validate = self2.__compiled__[self2.__schemas__[alias]].validate;
        self2.__compiled__[alias].normalize = self2.__compiled__[self2.__schemas__[alias]].normalize;
      });
      self2.__compiled__[""] = { validate: null, normalize: createNormalizer() };
      var slist = Object.keys(self2.__compiled__).filter(function(name) {
        return name.length > 0 && self2.__compiled__[name];
      }).map(escapeRE).join("|");
      self2.re.schema_test = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "i");
      self2.re.schema_search = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "ig");
      self2.re.pretest = RegExp(
        "(" + self2.re.schema_test.source + ")|(" + self2.re.host_fuzzy_test.source + ")|@",
        "i"
      );
      resetScanCache(self2);
    }
    function Match(self2, shift) {
      var start = self2.__index__, end = self2.__last_index__, text = self2.__text_cache__.slice(start, end);
      this.schema = self2.__schema__.toLowerCase();
      this.index = start + shift;
      this.lastIndex = end + shift;
      this.raw = text;
      this.text = text;
      this.url = text;
    }
    function createMatch(self2, shift) {
      var match = new Match(self2, shift);
      self2.__compiled__[match.schema].normalize(match, self2);
      return match;
    }
    function LinkifyIt(schemas, options) {
      if (!(this instanceof LinkifyIt)) {
        return new LinkifyIt(schemas, options);
      }
      if (!options) {
        if (isOptionsObj(schemas)) {
          options = schemas;
          schemas = {};
        }
      }
      this.__opts__ = assign({}, defaultOptions, options);
      this.__index__ = -1;
      this.__last_index__ = -1;
      this.__schema__ = "";
      this.__text_cache__ = "";
      this.__schemas__ = assign({}, defaultSchemas, schemas);
      this.__compiled__ = {};
      this.__tlds__ = tlds_default;
      this.__tlds_replaced__ = false;
      this.re = {};
      compile(this);
    }
    LinkifyIt.prototype.add = function add(schema, definition) {
      this.__schemas__[schema] = definition;
      compile(this);
      return this;
    };
    LinkifyIt.prototype.set = function set(options) {
      this.__opts__ = assign(this.__opts__, options);
      return this;
    };
    LinkifyIt.prototype.test = function test(text) {
      this.__text_cache__ = text;
      this.__index__ = -1;
      if (!text.length) {
        return false;
      }
      var m, ml, me, len, shift, next, re, tld_pos, at_pos;
      if (this.re.schema_test.test(text)) {
        re = this.re.schema_search;
        re.lastIndex = 0;
        while ((m = re.exec(text)) !== null) {
          len = this.testSchemaAt(text, m[2], re.lastIndex);
          if (len) {
            this.__schema__ = m[2];
            this.__index__ = m.index + m[1].length;
            this.__last_index__ = m.index + m[0].length + len;
            break;
          }
        }
      }
      if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
        tld_pos = text.search(this.re.host_fuzzy_test);
        if (tld_pos >= 0) {
          if (this.__index__ < 0 || tld_pos < this.__index__) {
            if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {
              shift = ml.index + ml[1].length;
              if (this.__index__ < 0 || shift < this.__index__) {
                this.__schema__ = "";
                this.__index__ = shift;
                this.__last_index__ = ml.index + ml[0].length;
              }
            }
          }
        }
      }
      if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
        at_pos = text.indexOf("@");
        if (at_pos >= 0) {
          if ((me = text.match(this.re.email_fuzzy)) !== null) {
            shift = me.index + me[1].length;
            next = me.index + me[0].length;
            if (this.__index__ < 0 || shift < this.__index__ || shift === this.__index__ && next > this.__last_index__) {
              this.__schema__ = "mailto:";
              this.__index__ = shift;
              this.__last_index__ = next;
            }
          }
        }
      }
      return this.__index__ >= 0;
    };
    LinkifyIt.prototype.pretest = function pretest(text) {
      return this.re.pretest.test(text);
    };
    LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {
      if (!this.__compiled__[schema.toLowerCase()]) {
        return 0;
      }
      return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);
    };
    LinkifyIt.prototype.match = function match(text) {
      var shift = 0, result = [];
      if (this.__index__ >= 0 && this.__text_cache__ === text) {
        result.push(createMatch(this, shift));
        shift = this.__last_index__;
      }
      var tail = shift ? text.slice(shift) : text;
      while (this.test(tail)) {
        result.push(createMatch(this, shift));
        tail = tail.slice(this.__last_index__);
        shift += this.__last_index__;
      }
      if (result.length) {
        return result;
      }
      return null;
    };
    LinkifyIt.prototype.tlds = function tlds(list, keepOld) {
      list = Array.isArray(list) ? list : [list];
      if (!keepOld) {
        this.__tlds__ = list.slice();
        this.__tlds_replaced__ = true;
        compile(this);
        return this;
      }
      this.__tlds__ = this.__tlds__.concat(list).sort().filter(function(el, idx, arr) {
        return el !== arr[idx - 1];
      }).reverse();
      compile(this);
      return this;
    };
    LinkifyIt.prototype.normalize = function normalize(match) {
      if (!match.schema) {
        match.url = "http://" + match.url;
      }
      if (match.schema === "mailto:" && !/^mailto:/i.test(match.url)) {
        match.url = "mailto:" + match.url;
      }
    };
    LinkifyIt.prototype.onCompile = function onCompile() {
    };
    module2.exports = LinkifyIt;
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/utils/url.js
var require_url = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/utils/url.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.LINK_REGEXP = void 0;
    exports2.getLinkMatch = getLinkMatch;
    exports2.isRootRelative = isRootRelative;
    exports2.linkifyMatch = exports2.linkify = exports2.isSafeUrl = void 0;
    exports2.normalizeUrl = normalizeUrl;
    var _linkifyIt = _interopRequireDefault(require_linkify_it());
    var whitelistedURLPatterns = [
      /^https?:\/\//im,
      /^ftps?:\/\//im,
      /^gopher:\/\//im,
      /^integrity:\/\//im,
      /^file:\/\//im,
      /^smb:\/\//im,
      /^dynamicsnav:\/\//im,
      /^jamfselfservice:\/\//im,
      /^\//im,
      /^mailto:/im,
      /^skype:/im,
      /^callto:/im,
      /^facetime:/im,
      /^git:/im,
      /^irc6?:/im,
      /^news:/im,
      /^nntp:/im,
      /^feed:/im,
      /^cvs:/im,
      /^svn:/im,
      /^mvn:/im,
      /^ssh:/im,
      /^scp:\/\//im,
      /^sftp:\/\//im,
      /^itms:/im,
      // This is not a valid notes link, but we support this pattern for backwards compatibility
      /^notes:/im,
      /^notes:\/\//im,
      /^hipchat:\/\//im,
      // This is not a valid sourcetree link, but we support this pattern for backwards compatibility
      /^sourcetree:/im,
      /^sourcetree:\/\//im,
      /^urn:/im,
      /^tel:/im,
      /^xmpp:/im,
      /^telnet:/im,
      /^vnc:/im,
      /^rdp:/im,
      /^whatsapp:/im,
      /^slack:/im,
      /^sips?:/im,
      /^magnet:/im,
      /^#/im
    ];
    var isSafeUrl = exports2.isSafeUrl = function isSafeUrl2(url) {
      var urlTrimmed = url.trim();
      if (urlTrimmed.length === 0) {
        return true;
      }
      return whitelistedURLPatterns.some(function(p) {
        return p.test(urlTrimmed);
      });
    };
    var linkify = exports2.linkify = (0, _linkifyIt.default)();
    linkify.add("sourcetree:", "http:");
    linkify.add("jamfselfservice:", "http:");
    var urlWithoutSpacesValidator = {
      validate: /[^\s]+/
    };
    linkify.add("tel:", urlWithoutSpacesValidator);
    linkify.add("file:", urlWithoutSpacesValidator);
    linkify.add("notes:", "http:");
    var tlds = "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|\u0440\u0444".split("|");
    var tlds2Char = "a[cdefgilmnoqrtuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrtuvwxyz]|n[acefgilopruz]|om|p[aefghkmnrtw]|qa|r[eosuw]|s[abcdegijklmnrtuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]";
    tlds.push(tlds2Char);
    linkify.tlds(tlds, false);
    var LINK_REGEXP = exports2.LINK_REGEXP = /(https?|ftp|jamfselfservice|gopher|dynamicsnav|integrity|file|smb):\/\/[^\s]+/;
    var linkifyMatch = exports2.linkifyMatch = function linkifyMatch2(text) {
      if (!LINK_REGEXP.test(text)) {
        return [];
      }
      var matches = [];
      var startpos = 0;
      var substr;
      while (substr = text.substr(startpos)) {
        var link = (substr.match(LINK_REGEXP) || [""])[0];
        if (link) {
          var index = substr.search(LINK_REGEXP);
          var start = index >= 0 ? index + startpos : index;
          var end = start + link.length;
          matches.push({
            index: start,
            lastIndex: end,
            raw: link,
            url: link,
            text: link,
            schema: ""
          });
          startpos += end;
        } else {
          break;
        }
      }
      return matches;
    };
    function getLinkMatch(str) {
      if (!str) {
        return null;
      }
      var match = linkifyMatch(str);
      if (!match.length) {
        match = linkify.match(str);
      }
      return match && match[0];
    }
    function normalizeUrl(url) {
      var match = getLinkMatch(url);
      return match && match.url || "";
    }
    function isRootRelative(url) {
      return url.startsWith("/") || url === "#top" || url === "#";
    }
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/utils/lch-color-inversion.js
var require_lch_color_inversion = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/utils/lch-color-inversion.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.getDarkModeLCHColor = exports2.clampLightness = void 0;
    var clamp = function clamp2(i, min, max) {
      return Math.round(Math.min(Math.max(i, min), max));
    };
    var expandShorthandHex = function expandShorthandHex2(input2) {
      return input2.replace(/^#?([a-f\d])([a-f\d])([a-f\d])$/i, function(m, r, g, b) {
        return r + r + g + g + b + b;
      });
    };
    var rgbFromHex = function rgbFromHex2(input2) {
      var fullHex = expandShorthandHex(input2);
      var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(fullHex);
      return result === null ? null : {
        r: parseInt(result[1], 16),
        g: parseInt(result[2], 16),
        b: parseInt(result[3], 16)
      };
    };
    var rgbToHex = function rgbToHex2(_ref) {
      var r = _ref.r, g = _ref.g, b = _ref.b;
      var convertComponent = function convertComponent2(c) {
        var cBase16 = c.toString(16);
        return cBase16.length === 1 ? "0".concat(cBase16) : cBase16;
      };
      return "#".concat(convertComponent(r)).concat(convertComponent(g)).concat(convertComponent(b));
    };
    var rgbToXyz = function rgbToXyz2(rgb) {
      var convertRgbComponent = function convertRgbComponent2(c) {
        return c > 0.04045 ? Math.pow((c + 0.055) / 1.055, 2.4) : c / 12.92;
      };
      var convertXyzComponent = function convertXyzComponent2(c) {
        return c > 8856452e-9 ? Math.pow(c, 1 / 3) : c / 0.12841855 + 0.137931034;
      };
      var r = convertRgbComponent(rgb.r / 255);
      var g = convertRgbComponent(rgb.g / 255);
      var b = convertRgbComponent(rgb.b / 255);
      return {
        x: convertXyzComponent((0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / 0.95047),
        y: convertXyzComponent(0.2126729 * r + 0.7151522 * g + 0.072175 * b),
        z: convertXyzComponent((0.0193339 * r + 0.119192 * g + 0.9503041 * b) / 1.08883)
      };
    };
    var xyzToLab = function xyzToLab2(_ref2) {
      var x = _ref2.x, y = _ref2.y, z = _ref2.z;
      return {
        l: Math.max(116 * y - 16, 0),
        a: 500 * (x - y),
        b: 200 * (y - z)
      };
    };
    var labToLch = function labToLch2(_ref3) {
      var l = _ref3.l, a = _ref3.a, b = _ref3.b;
      var h = (Math.atan2(b, a) * (180 / Math.PI) + 360) % 360;
      var c = Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2));
      if (Math.round(c * 1e4) === 0) h = Number.NaN;
      return {
        l,
        c,
        h
      };
    };
    var lchToLab = function lchToLab2(_ref4) {
      var l = _ref4.l, c = _ref4.c, h = _ref4.h;
      var convertH = Number.isNaN(h) ? 0 : h * (Math.PI / 180);
      return {
        l,
        a: Math.cos(convertH) * c,
        b: Math.sin(convertH) * c
      };
    };
    var labToXyz = function labToXyz2(_ref5) {
      var l = _ref5.l, a = _ref5.a, b = _ref5.b;
      var convertComponent = function convertComponent2(c) {
        return c > 0.206896552 ? Math.pow(c, 3) : 0.12841855 * (c - 0.137931034);
      };
      var y = (l + 16) / 116;
      var x = a / 500 + y;
      var z = y - b / 200;
      return {
        x: convertComponent(x) * 0.95047,
        y: convertComponent(y),
        z: convertComponent(z) * 1.08883
      };
    };
    var xyzToRgb = function xyzToRgb2(_ref6) {
      var x = _ref6.x, y = _ref6.y, z = _ref6.z;
      var convertComponent = function convertComponent2(c) {
        return 255 * (c <= 304e-5 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055);
      };
      return {
        r: clamp(convertComponent(3.2404542 * x - 1.5371385 * y - 0.4985314 * z), 0, 255),
        g: clamp(convertComponent(-0.969266 * x + 1.8760108 * y + 0.041556 * z), 0, 255),
        b: clamp(convertComponent(0.0556434 * x - 0.2040259 * y + 1.0572252 * z), 0, 255)
      };
    };
    var rgbToLch = function rgbToLch2(rgb) {
      return labToLch(xyzToLab(rgbToXyz(rgb)));
    };
    var lchToRgb = function lchToRgb2(lch) {
      return xyzToRgb(labToXyz(lchToLab(lch)));
    };
    var clampLightness = exports2.clampLightness = function clampLightness2(color, newPercent) {
      var rgb = rgbFromHex(color);
      if (rgb === null) {
        return color;
      }
      var lch = rgbToLch(rgb);
      lch.l = clamp(newPercent, 0, 100);
      return rgbToHex(lchToRgb(lch));
    };
    var getLightness = function getLightness2(color) {
      var rgb = rgbFromHex(color);
      if (rgb === null) {
        return 0;
      }
      var lch = rgbToLch(rgb);
      return lch.l;
    };
    var getDarkModeLCHColor = exports2.getDarkModeLCHColor = function getDarkModeLCHColor2(currentBackgroundColor) {
      var lightness = getLightness(currentBackgroundColor);
      var newLightness = Math.abs(100 - lightness);
      return clampLightness(currentBackgroundColor, newLightness).toUpperCase();
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/utils/index.js
var require_utils = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/utils/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "B100", {
      enumerable: true,
      get: function get() {
        return _colors.B100;
      }
    });
    Object.defineProperty(exports2, "B400", {
      enumerable: true,
      get: function get() {
        return _colors.B400;
      }
    });
    Object.defineProperty(exports2, "B50", {
      enumerable: true,
      get: function get() {
        return _colors.B50;
      }
    });
    Object.defineProperty(exports2, "B500", {
      enumerable: true,
      get: function get() {
        return _colors.B500;
      }
    });
    Object.defineProperty(exports2, "B75", {
      enumerable: true,
      get: function get() {
        return _colors.B75;
      }
    });
    Object.defineProperty(exports2, "G200", {
      enumerable: true,
      get: function get() {
        return _colors.G200;
      }
    });
    Object.defineProperty(exports2, "G300", {
      enumerable: true,
      get: function get() {
        return _colors.G300;
      }
    });
    Object.defineProperty(exports2, "G400", {
      enumerable: true,
      get: function get() {
        return _colors.G400;
      }
    });
    Object.defineProperty(exports2, "G50", {
      enumerable: true,
      get: function get() {
        return _colors.G50;
      }
    });
    Object.defineProperty(exports2, "G500", {
      enumerable: true,
      get: function get() {
        return _colors.G500;
      }
    });
    Object.defineProperty(exports2, "G75", {
      enumerable: true,
      get: function get() {
        return _colors.G75;
      }
    });
    Object.defineProperty(exports2, "N0", {
      enumerable: true,
      get: function get() {
        return _colors.N0;
      }
    });
    Object.defineProperty(exports2, "N20", {
      enumerable: true,
      get: function get() {
        return _colors.N20;
      }
    });
    Object.defineProperty(exports2, "N200", {
      enumerable: true,
      get: function get() {
        return _colors.N200;
      }
    });
    Object.defineProperty(exports2, "N30", {
      enumerable: true,
      get: function get() {
        return _colors.N30;
      }
    });
    Object.defineProperty(exports2, "N300", {
      enumerable: true,
      get: function get() {
        return _colors.N300;
      }
    });
    Object.defineProperty(exports2, "N40", {
      enumerable: true,
      get: function get() {
        return _colors.N40;
      }
    });
    Object.defineProperty(exports2, "N50", {
      enumerable: true,
      get: function get() {
        return _colors.N50;
      }
    });
    Object.defineProperty(exports2, "N500", {
      enumerable: true,
      get: function get() {
        return _colors.N500;
      }
    });
    Object.defineProperty(exports2, "N60", {
      enumerable: true,
      get: function get() {
        return _colors.N60;
      }
    });
    Object.defineProperty(exports2, "N80", {
      enumerable: true,
      get: function get() {
        return _colors.N80;
      }
    });
    Object.defineProperty(exports2, "N800", {
      enumerable: true,
      get: function get() {
        return _colors.N800;
      }
    });
    Object.defineProperty(exports2, "N90", {
      enumerable: true,
      get: function get() {
        return _colors.N90;
      }
    });
    Object.defineProperty(exports2, "P100", {
      enumerable: true,
      get: function get() {
        return _colors.P100;
      }
    });
    Object.defineProperty(exports2, "P300", {
      enumerable: true,
      get: function get() {
        return _colors.P300;
      }
    });
    Object.defineProperty(exports2, "P400", {
      enumerable: true,
      get: function get() {
        return _colors.P400;
      }
    });
    Object.defineProperty(exports2, "P50", {
      enumerable: true,
      get: function get() {
        return _colors.P50;
      }
    });
    Object.defineProperty(exports2, "P500", {
      enumerable: true,
      get: function get() {
        return _colors.P500;
      }
    });
    Object.defineProperty(exports2, "P75", {
      enumerable: true,
      get: function get() {
        return _colors.P75;
      }
    });
    Object.defineProperty(exports2, "R100", {
      enumerable: true,
      get: function get() {
        return _colors.R100;
      }
    });
    Object.defineProperty(exports2, "R300", {
      enumerable: true,
      get: function get() {
        return _colors.R300;
      }
    });
    Object.defineProperty(exports2, "R400", {
      enumerable: true,
      get: function get() {
        return _colors.R400;
      }
    });
    Object.defineProperty(exports2, "R50", {
      enumerable: true,
      get: function get() {
        return _colors.R50;
      }
    });
    Object.defineProperty(exports2, "R500", {
      enumerable: true,
      get: function get() {
        return _colors.R500;
      }
    });
    Object.defineProperty(exports2, "R75", {
      enumerable: true,
      get: function get() {
        return _colors.R75;
      }
    });
    Object.defineProperty(exports2, "T100", {
      enumerable: true,
      get: function get() {
        return _colors.T100;
      }
    });
    Object.defineProperty(exports2, "T300", {
      enumerable: true,
      get: function get() {
        return _colors.T300;
      }
    });
    Object.defineProperty(exports2, "T50", {
      enumerable: true,
      get: function get() {
        return _colors.T50;
      }
    });
    Object.defineProperty(exports2, "T500", {
      enumerable: true,
      get: function get() {
        return _colors.T500;
      }
    });
    Object.defineProperty(exports2, "T75", {
      enumerable: true,
      get: function get() {
        return _colors.T75;
      }
    });
    Object.defineProperty(exports2, "Y200", {
      enumerable: true,
      get: function get() {
        return _colors.Y200;
      }
    });
    Object.defineProperty(exports2, "Y400", {
      enumerable: true,
      get: function get() {
        return _colors.Y400;
      }
    });
    Object.defineProperty(exports2, "Y50", {
      enumerable: true,
      get: function get() {
        return _colors.Y50;
      }
    });
    Object.defineProperty(exports2, "Y500", {
      enumerable: true,
      get: function get() {
        return _colors.Y500;
      }
    });
    Object.defineProperty(exports2, "Y75", {
      enumerable: true,
      get: function get() {
        return _colors.Y75;
      }
    });
    Object.defineProperty(exports2, "acNameToEmoji", {
      enumerable: true,
      get: function get() {
        return _emoji.acNameToEmoji;
      }
    });
    Object.defineProperty(exports2, "acShortcutToEmoji", {
      enumerable: true,
      get: function get() {
        return _emoji.acShortcutToEmoji;
      }
    });
    Object.defineProperty(exports2, "emojiIdToAcName", {
      enumerable: true,
      get: function get() {
        return _emoji.emojiIdToAcName;
      }
    });
    Object.defineProperty(exports2, "generateUuid", {
      enumerable: true,
      get: function get() {
        return _uuid.generateUuid;
      }
    });
    Object.defineProperty(exports2, "getDarkModeLCHColor", {
      enumerable: true,
      get: function get() {
        return _lchColorInversion.getDarkModeLCHColor;
      }
    });
    Object.defineProperty(exports2, "getEmojiAcName", {
      enumerable: true,
      get: function get() {
        return _emoji.getEmojiAcName;
      }
    });
    Object.defineProperty(exports2, "getLinkMatch", {
      enumerable: true,
      get: function get() {
        return _url.getLinkMatch;
      }
    });
    Object.defineProperty(exports2, "hexToRgb", {
      enumerable: true,
      get: function get() {
        return _colors.hexToRgb;
      }
    });
    Object.defineProperty(exports2, "hexToRgba", {
      enumerable: true,
      get: function get() {
        return _colors.hexToRgba;
      }
    });
    Object.defineProperty(exports2, "isHex", {
      enumerable: true,
      get: function get() {
        return _colors.isHex;
      }
    });
    Object.defineProperty(exports2, "isRgb", {
      enumerable: true,
      get: function get() {
        return _colors.isRgb;
      }
    });
    Object.defineProperty(exports2, "isSafeUrl", {
      enumerable: true,
      get: function get() {
        return _url.isSafeUrl;
      }
    });
    Object.defineProperty(exports2, "linkify", {
      enumerable: true,
      get: function get() {
        return _url.linkify;
      }
    });
    Object.defineProperty(exports2, "linkifyMatch", {
      enumerable: true,
      get: function get() {
        return _url.linkifyMatch;
      }
    });
    Object.defineProperty(exports2, "normalizeHexColor", {
      enumerable: true,
      get: function get() {
        return _colors.normalizeHexColor;
      }
    });
    Object.defineProperty(exports2, "normalizeUrl", {
      enumerable: true,
      get: function get() {
        return _url.normalizeUrl;
      }
    });
    Object.defineProperty(exports2, "rgbToHex", {
      enumerable: true,
      get: function get() {
        return _colors.rgbToHex;
      }
    });
    Object.defineProperty(exports2, "uuid", {
      enumerable: true,
      get: function get() {
        return _uuid.uuid;
      }
    });
    var _emoji = require_emoji();
    var _uuid = require_uuid();
    var _colors = require_colors();
    var _url = require_url();
    var _lchColorInversion = require_lch_color_inversion();
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/blockquote.js
var require_blockquote = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/blockquote.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.extendedBlockquoteWithLocalId = exports2.extendedBlockquote = exports2.blockquote = void 0;
    var _nodeTypes = require_nodeTypes();
    var _utils = require_utils();
    var nodeSpecOptions = {
      parseDOM: [{
        tag: "blockquote"
      }],
      toDOM: function toDOM() {
        return ["blockquote", 0];
      }
    };
    var blockquote = exports2.blockquote = (0, _nodeTypes.blockquoteLegacy)(nodeSpecOptions);
    var extendedBlockquote = exports2.extendedBlockquote = (0, _nodeTypes.blockquote)(nodeSpecOptions);
    var nodeSpecOptionsWithLocalId = {
      parseDOM: [{
        tag: "blockquote",
        getAttrs: function getAttrs() {
          return {
            localId: _utils.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        return ["blockquote", {
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        }, 0];
      }
    };
    var extendedBlockquoteWithLocalId = exports2.extendedBlockquoteWithLocalId = (0, _nodeTypes.blockquote)(nodeSpecOptionsWithLocalId);
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/bullet-list.js
var require_bullet_list = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/bullet-list.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.bulletListWithLocalId = exports2.bulletListSelector = exports2.bulletList = void 0;
    var _utils = require_utils();
    var _nodeTypes = require_nodeTypes();
    var bulletListSelector = exports2.bulletListSelector = ".ak-ul";
    var bulletList = exports2.bulletList = (0, _nodeTypes.bulletList)({
      parseDOM: [{
        tag: "ul"
      }],
      toDOM: function toDOM() {
        var attrs = {
          class: bulletListSelector.substr(1)
        };
        return ["ul", attrs, 0];
      }
    });
    var bulletListWithLocalId = exports2.bulletListWithLocalId = (0, _nodeTypes.bulletList)({
      parseDOM: [{
        tag: "ul",
        getAttrs: function getAttrs() {
          return {
            localId: _utils.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var attrs = {
          class: bulletListSelector.substr(1),
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        };
        return ["ul", attrs, 0];
      }
    });
  }
});

// node_modules/orderedmap/dist/index.cjs
var require_dist = __commonJS({
  "node_modules/orderedmap/dist/index.cjs"(exports2, module2) {
    "use strict";
    function OrderedMap(content) {
      this.content = content;
    }
    OrderedMap.prototype = {
      constructor: OrderedMap,
      find: function(key) {
        for (var i = 0; i < this.content.length; i += 2)
          if (this.content[i] === key) return i;
        return -1;
      },
      // :: (string) → ?any
      // Retrieve the value stored under `key`, or return undefined when
      // no such key exists.
      get: function(key) {
        var found = this.find(key);
        return found == -1 ? void 0 : this.content[found + 1];
      },
      // :: (string, any, ?string) → OrderedMap
      // Create a new map by replacing the value of `key` with a new
      // value, or adding a binding to the end of the map. If `newKey` is
      // given, the key of the binding will be replaced with that key.
      update: function(key, value, newKey) {
        var self2 = newKey && newKey != key ? this.remove(newKey) : this;
        var found = self2.find(key), content = self2.content.slice();
        if (found == -1) {
          content.push(newKey || key, value);
        } else {
          content[found + 1] = value;
          if (newKey) content[found] = newKey;
        }
        return new OrderedMap(content);
      },
      // :: (string) → OrderedMap
      // Return a map with the given key removed, if it existed.
      remove: function(key) {
        var found = this.find(key);
        if (found == -1) return this;
        var content = this.content.slice();
        content.splice(found, 2);
        return new OrderedMap(content);
      },
      // :: (string, any) → OrderedMap
      // Add a new key to the start of the map.
      addToStart: function(key, value) {
        return new OrderedMap([key, value].concat(this.remove(key).content));
      },
      // :: (string, any) → OrderedMap
      // Add a new key to the end of the map.
      addToEnd: function(key, value) {
        var content = this.remove(key).content.slice();
        content.push(key, value);
        return new OrderedMap(content);
      },
      // :: (string, string, any) → OrderedMap
      // Add a key after the given key. If `place` is not found, the new
      // key is added to the end.
      addBefore: function(place, key, value) {
        var without = this.remove(key), content = without.content.slice();
        var found = without.find(place);
        content.splice(found == -1 ? content.length : found, 0, key, value);
        return new OrderedMap(content);
      },
      // :: ((key: string, value: any))
      // Call the given function for each key/value pair in the map, in
      // order.
      forEach: function(f) {
        for (var i = 0; i < this.content.length; i += 2)
          f(this.content[i], this.content[i + 1]);
      },
      // :: (union<Object, OrderedMap>) → OrderedMap
      // Create a new map by prepending the keys in this map that don't
      // appear in `map` before the keys in `map`.
      prepend: function(map) {
        map = OrderedMap.from(map);
        if (!map.size) return this;
        return new OrderedMap(map.content.concat(this.subtract(map).content));
      },
      // :: (union<Object, OrderedMap>) → OrderedMap
      // Create a new map by appending the keys in this map that don't
      // appear in `map` after the keys in `map`.
      append: function(map) {
        map = OrderedMap.from(map);
        if (!map.size) return this;
        return new OrderedMap(this.subtract(map).content.concat(map.content));
      },
      // :: (union<Object, OrderedMap>) → OrderedMap
      // Create a map containing all the keys in this map that don't
      // appear in `map`.
      subtract: function(map) {
        var result = this;
        map = OrderedMap.from(map);
        for (var i = 0; i < map.content.length; i += 2)
          result = result.remove(map.content[i]);
        return result;
      },
      // :: () → Object
      // Turn ordered map into a plain object.
      toObject: function() {
        var result = {};
        this.forEach(function(key, value) {
          result[key] = value;
        });
        return result;
      },
      // :: number
      // The amount of keys in this map.
      get size() {
        return this.content.length >> 1;
      }
    };
    OrderedMap.from = function(value) {
      if (value instanceof OrderedMap) return value;
      var content = [];
      if (value) for (var prop in value) content.push(prop, value[prop]);
      return new OrderedMap(content);
    };
    module2.exports = OrderedMap;
  }
});

// node_modules/prosemirror-model/dist/index.cjs
var require_dist2 = __commonJS({
  "node_modules/prosemirror-model/dist/index.cjs"(exports2) {
    "use strict";
    function _createForOfIteratorHelper(o, allowArrayLike) {
      var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
      if (!it) {
        if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
          if (it) o = it;
          var i = 0;
          var F = function F2() {
          };
          return { s: F, n: function n() {
            if (i >= o.length) return { done: true };
            return { done: false, value: o[i++] };
          }, e: function e(_e) {
            throw _e;
          }, f: F };
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }
      var normalCompletion = true, didErr = false, err;
      return { s: function s() {
        it = it.call(o);
      }, n: function n() {
        var step = it.next();
        normalCompletion = step.done;
        return step;
      }, e: function e(_e2) {
        didErr = true;
        err = _e2;
      }, f: function f() {
        try {
          if (!normalCompletion && it["return"] != null) it["return"]();
        } finally {
          if (didErr) throw err;
        }
      } };
    }
    function _unsupportedIterableToArray(o, minLen) {
      if (!o) return;
      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
      var n = Object.prototype.toString.call(o).slice(8, -1);
      if (n === "Object" && o.constructor) n = o.constructor.name;
      if (n === "Map" || n === "Set") return Array.from(o);
      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
    }
    function _arrayLikeToArray(arr, len) {
      if (len == null || len > arr.length) len = arr.length;
      for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
      return arr2;
    }
    function _get() {
      if (typeof Reflect !== "undefined" && Reflect.get) {
        _get = Reflect.get.bind();
      } else {
        _get = function _get2(target, property, receiver) {
          var base = _superPropBase(target, property);
          if (!base) return;
          var desc = Object.getOwnPropertyDescriptor(base, property);
          if (desc.get) {
            return desc.get.call(arguments.length < 3 ? target : receiver);
          }
          return desc.value;
        };
      }
      return _get.apply(this, arguments);
    }
    function _superPropBase(object, property) {
      while (!Object.prototype.hasOwnProperty.call(object, property)) {
        object = _getPrototypeOf(object);
        if (object === null) break;
      }
      return object;
    }
    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function");
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
      Object.defineProperty(subClass, "prototype", { writable: false });
      if (superClass) _setPrototypeOf(subClass, superClass);
    }
    function _createSuper(Derived) {
      var hasNativeReflectConstruct = _isNativeReflectConstruct();
      return function _createSuperInternal() {
        var Super = _getPrototypeOf(Derived), result;
        if (hasNativeReflectConstruct) {
          var NewTarget = _getPrototypeOf(this).constructor;
          result = Reflect.construct(Super, arguments, NewTarget);
        } else {
          result = Super.apply(this, arguments);
        }
        return _possibleConstructorReturn(this, result);
      };
    }
    function _possibleConstructorReturn(self2, call) {
      if (call && (_typeof(call) === "object" || typeof call === "function")) {
        return call;
      } else if (call !== void 0) {
        throw new TypeError("Derived constructors may only return object or undefined");
      }
      return _assertThisInitialized(self2);
    }
    function _assertThisInitialized(self2) {
      if (self2 === void 0) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return self2;
    }
    function _wrapNativeSuper(Class) {
      var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
      _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
        if (Class2 === null || !_isNativeFunction(Class2)) return Class2;
        if (typeof Class2 !== "function") {
          throw new TypeError("Super expression must either be null or a function");
        }
        if (typeof _cache !== "undefined") {
          if (_cache.has(Class2)) return _cache.get(Class2);
          _cache.set(Class2, Wrapper);
        }
        function Wrapper() {
          return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
        }
        Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });
        return _setPrototypeOf(Wrapper, Class2);
      };
      return _wrapNativeSuper(Class);
    }
    function _construct(Parent, args2, Class) {
      if (_isNativeReflectConstruct()) {
        _construct = Reflect.construct.bind();
      } else {
        _construct = function _construct2(Parent2, args3, Class2) {
          var a = [null];
          a.push.apply(a, args3);
          var Constructor = Function.bind.apply(Parent2, a);
          var instance = new Constructor();
          if (Class2) _setPrototypeOf(instance, Class2.prototype);
          return instance;
        };
      }
      return _construct.apply(null, arguments);
    }
    function _isNativeReflectConstruct() {
      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
      if (Reflect.construct.sham) return false;
      if (typeof Proxy === "function") return true;
      try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
        }));
        return true;
      } catch (e) {
        return false;
      }
    }
    function _isNativeFunction(fn) {
      try {
        return Function.toString.call(fn).indexOf("[native code]") !== -1;
      } catch (e) {
        return typeof fn === "function";
      }
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    function _getPrototypeOf(o) {
      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
        return o2.__proto__ || Object.getPrototypeOf(o2);
      };
      return _getPrototypeOf(o);
    }
    function _typeof(o) {
      "@babel/helpers - typeof";
      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
        return typeof o2;
      } : function(o2) {
        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
      }, _typeof(o);
    }
    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
      }
    }
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
      if (staticProps) _defineProperties(Constructor, staticProps);
      Object.defineProperty(Constructor, "prototype", { writable: false });
      return Constructor;
    }
    function _toPropertyKey(arg) {
      var key = _toPrimitive(arg, "string");
      return _typeof(key) === "symbol" ? key : String(key);
    }
    function _toPrimitive(input2, hint) {
      if (_typeof(input2) !== "object" || input2 === null) return input2;
      var prim = input2[Symbol.toPrimitive];
      if (prim !== void 0) {
        var res = prim.call(input2, hint || "default");
        if (_typeof(res) !== "object") return res;
        throw new TypeError("@@toPrimitive must return a primitive value.");
      }
      return (hint === "string" ? String : Number)(input2);
    }
    var OrderedMap = require_dist();
    function _findDiffStart(a, b, pos) {
      for (var i = 0; ; i++) {
        if (i == a.childCount || i == b.childCount) return a.childCount == b.childCount ? null : pos;
        var childA = a.child(i), childB = b.child(i);
        if (childA == childB) {
          pos += childA.nodeSize;
          continue;
        }
        if (!childA.sameMarkup(childB)) return pos;
        if (childA.isText && childA.text != childB.text) {
          for (var j = 0; childA.text[j] == childB.text[j]; j++) pos++;
          return pos;
        }
        if (childA.content.size || childB.content.size) {
          var inner = _findDiffStart(childA.content, childB.content, pos + 1);
          if (inner != null) return inner;
        }
        pos += childA.nodeSize;
      }
    }
    function _findDiffEnd(a, b, posA, posB) {
      for (var iA = a.childCount, iB = b.childCount; ; ) {
        if (iA == 0 || iB == 0) return iA == iB ? null : {
          a: posA,
          b: posB
        };
        var childA = a.child(--iA), childB = b.child(--iB), size = childA.nodeSize;
        if (childA == childB) {
          posA -= size;
          posB -= size;
          continue;
        }
        if (!childA.sameMarkup(childB)) return {
          a: posA,
          b: posB
        };
        if (childA.isText && childA.text != childB.text) {
          var same = 0, minSize = Math.min(childA.text.length, childB.text.length);
          while (same < minSize && childA.text[childA.text.length - same - 1] == childB.text[childB.text.length - same - 1]) {
            same++;
            posA--;
            posB--;
          }
          return {
            a: posA,
            b: posB
          };
        }
        if (childA.content.size || childB.content.size) {
          var inner = _findDiffEnd(childA.content, childB.content, posA - 1, posB - 1);
          if (inner) return inner;
        }
        posA -= size;
        posB -= size;
      }
    }
    var Fragment = (function() {
      function Fragment2(content, size) {
        _classCallCheck(this, Fragment2);
        this.content = content;
        this.size = size || 0;
        if (size == null) for (var i = 0; i < content.length; i++) this.size += content[i].nodeSize;
      }
      _createClass(Fragment2, [{
        key: "nodesBetween",
        value: function nodesBetween(from, to, f) {
          var nodeStart = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
          var parent = arguments.length > 4 ? arguments[4] : void 0;
          for (var i = 0, pos = 0; pos < to; i++) {
            var child = this.content[i], end = pos + child.nodeSize;
            if (end > from && f(child, nodeStart + pos, parent || null, i) !== false && child.content.size) {
              var start = pos + 1;
              child.nodesBetween(Math.max(0, from - start), Math.min(child.content.size, to - start), f, nodeStart + start);
            }
            pos = end;
          }
        }
      }, {
        key: "descendants",
        value: function descendants(f) {
          this.nodesBetween(0, this.size, f);
        }
      }, {
        key: "textBetween",
        value: function textBetween(from, to, blockSeparator, leafText) {
          var text = "", first = true;
          this.nodesBetween(from, to, function(node, pos) {
            var nodeText = node.isText ? node.text.slice(Math.max(from, pos) - pos, to - pos) : !node.isLeaf ? "" : leafText ? typeof leafText === "function" ? leafText(node) : leafText : node.type.spec.leafText ? node.type.spec.leafText(node) : "";
            if (node.isBlock && (node.isLeaf && nodeText || node.isTextblock) && blockSeparator) {
              if (first) first = false;
              else text += blockSeparator;
            }
            text += nodeText;
          }, 0);
          return text;
        }
      }, {
        key: "append",
        value: function append(other) {
          if (!other.size) return this;
          if (!this.size) return other;
          var last = this.lastChild, first = other.firstChild, content = this.content.slice(), i = 0;
          if (last.isText && last.sameMarkup(first)) {
            content[content.length - 1] = last.withText(last.text + first.text);
            i = 1;
          }
          for (; i < other.content.length; i++) content.push(other.content[i]);
          return new Fragment2(content, this.size + other.size);
        }
      }, {
        key: "cut",
        value: function cut(from) {
          var to = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.size;
          if (from == 0 && to == this.size) return this;
          var result = [], size = 0;
          if (to > from) for (var i = 0, pos = 0; pos < to; i++) {
            var child = this.content[i], end = pos + child.nodeSize;
            if (end > from) {
              if (pos < from || end > to) {
                if (child.isText) child = child.cut(Math.max(0, from - pos), Math.min(child.text.length, to - pos));
                else child = child.cut(Math.max(0, from - pos - 1), Math.min(child.content.size, to - pos - 1));
              }
              result.push(child);
              size += child.nodeSize;
            }
            pos = end;
          }
          return new Fragment2(result, size);
        }
      }, {
        key: "cutByIndex",
        value: function cutByIndex(from, to) {
          if (from == to) return Fragment2.empty;
          if (from == 0 && to == this.content.length) return this;
          return new Fragment2(this.content.slice(from, to));
        }
      }, {
        key: "replaceChild",
        value: function replaceChild(index, node) {
          var current = this.content[index];
          if (current == node) return this;
          var copy2 = this.content.slice();
          var size = this.size + node.nodeSize - current.nodeSize;
          copy2[index] = node;
          return new Fragment2(copy2, size);
        }
      }, {
        key: "addToStart",
        value: function addToStart(node) {
          return new Fragment2([node].concat(this.content), this.size + node.nodeSize);
        }
      }, {
        key: "addToEnd",
        value: function addToEnd(node) {
          return new Fragment2(this.content.concat(node), this.size + node.nodeSize);
        }
      }, {
        key: "eq",
        value: function eq(other) {
          if (this.content.length != other.content.length) return false;
          for (var i = 0; i < this.content.length; i++) if (!this.content[i].eq(other.content[i])) return false;
          return true;
        }
      }, {
        key: "firstChild",
        get: function get() {
          return this.content.length ? this.content[0] : null;
        }
      }, {
        key: "lastChild",
        get: function get() {
          return this.content.length ? this.content[this.content.length - 1] : null;
        }
      }, {
        key: "childCount",
        get: function get() {
          return this.content.length;
        }
      }, {
        key: "child",
        value: function child(index) {
          var found2 = this.content[index];
          if (!found2) throw new RangeError("Index " + index + " out of range for " + this);
          return found2;
        }
      }, {
        key: "maybeChild",
        value: function maybeChild(index) {
          return this.content[index] || null;
        }
      }, {
        key: "forEach",
        value: function forEach(f) {
          for (var i = 0, p = 0; i < this.content.length; i++) {
            var child = this.content[i];
            f(child, p, i);
            p += child.nodeSize;
          }
        }
      }, {
        key: "findDiffStart",
        value: function findDiffStart(other) {
          var pos = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
          return _findDiffStart(this, other, pos);
        }
      }, {
        key: "findDiffEnd",
        value: function findDiffEnd(other) {
          var pos = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.size;
          var otherPos = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : other.size;
          return _findDiffEnd(this, other, pos, otherPos);
        }
      }, {
        key: "findIndex",
        value: function findIndex(pos) {
          var round = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : -1;
          if (pos == 0) return retIndex(0, pos);
          if (pos == this.size) return retIndex(this.content.length, pos);
          if (pos > this.size || pos < 0) throw new RangeError("Position ".concat(pos, " outside of fragment (").concat(this, ")"));
          for (var i = 0, curPos = 0; ; i++) {
            var cur = this.child(i), end = curPos + cur.nodeSize;
            if (end >= pos) {
              if (end == pos || round > 0) return retIndex(i + 1, end);
              return retIndex(i, curPos);
            }
            curPos = end;
          }
        }
      }, {
        key: "toString",
        value: function toString() {
          return "<" + this.toStringInner() + ">";
        }
      }, {
        key: "toStringInner",
        value: function toStringInner() {
          return this.content.join(", ");
        }
      }, {
        key: "toJSON",
        value: function toJSON() {
          return this.content.length ? this.content.map(function(n) {
            return n.toJSON();
          }) : null;
        }
      }], [{
        key: "fromJSON",
        value: function fromJSON(schema, value) {
          if (!value) return Fragment2.empty;
          if (!Array.isArray(value)) throw new RangeError("Invalid input for Fragment.fromJSON");
          return new Fragment2(value.map(schema.nodeFromJSON));
        }
      }, {
        key: "fromArray",
        value: function fromArray(array) {
          if (!array.length) return Fragment2.empty;
          var joined, size = 0;
          for (var i = 0; i < array.length; i++) {
            var node = array[i];
            size += node.nodeSize;
            if (i && node.isText && array[i - 1].sameMarkup(node)) {
              if (!joined) joined = array.slice(0, i);
              joined[joined.length - 1] = node.withText(joined[joined.length - 1].text + node.text);
            } else if (joined) {
              joined.push(node);
            }
          }
          return new Fragment2(joined || array, size);
        }
      }, {
        key: "from",
        value: function from(nodes) {
          if (!nodes) return Fragment2.empty;
          if (nodes instanceof Fragment2) return nodes;
          if (Array.isArray(nodes)) return this.fromArray(nodes);
          if (nodes.attrs) return new Fragment2([nodes], nodes.nodeSize);
          throw new RangeError("Can not convert " + nodes + " to a Fragment" + (nodes.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
        }
      }]);
      return Fragment2;
    })();
    Fragment.empty = new Fragment([], 0);
    var found = {
      index: 0,
      offset: 0
    };
    function retIndex(index, offset) {
      found.index = index;
      found.offset = offset;
      return found;
    }
    function compareDeep(a, b) {
      if (a === b) return true;
      if (!(a && _typeof(a) == "object") || !(b && _typeof(b) == "object")) return false;
      var array = Array.isArray(a);
      if (Array.isArray(b) != array) return false;
      if (array) {
        if (a.length != b.length) return false;
        for (var i = 0; i < a.length; i++) if (!compareDeep(a[i], b[i])) return false;
      } else {
        for (var p in a) if (!(p in b) || !compareDeep(a[p], b[p])) return false;
        for (var _p in b) if (!(_p in a)) return false;
      }
      return true;
    }
    var Mark = (function() {
      function Mark2(type, attrs) {
        _classCallCheck(this, Mark2);
        this.type = type;
        this.attrs = attrs;
      }
      _createClass(Mark2, [{
        key: "addToSet",
        value: function addToSet(set) {
          var copy2, placed = false;
          for (var i = 0; i < set.length; i++) {
            var other = set[i];
            if (this.eq(other)) return set;
            if (this.type.excludes(other.type)) {
              if (!copy2) copy2 = set.slice(0, i);
            } else if (other.type.excludes(this.type)) {
              return set;
            } else {
              if (!placed && other.type.rank > this.type.rank) {
                if (!copy2) copy2 = set.slice(0, i);
                copy2.push(this);
                placed = true;
              }
              if (copy2) copy2.push(other);
            }
          }
          if (!copy2) copy2 = set.slice();
          if (!placed) copy2.push(this);
          return copy2;
        }
      }, {
        key: "removeFromSet",
        value: function removeFromSet(set) {
          for (var i = 0; i < set.length; i++) if (this.eq(set[i])) return set.slice(0, i).concat(set.slice(i + 1));
          return set;
        }
      }, {
        key: "isInSet",
        value: function isInSet(set) {
          for (var i = 0; i < set.length; i++) if (this.eq(set[i])) return true;
          return false;
        }
      }, {
        key: "eq",
        value: function eq(other) {
          return this == other || this.type == other.type && compareDeep(this.attrs, other.attrs);
        }
      }, {
        key: "toJSON",
        value: function toJSON() {
          var obj = {
            type: this.type.name
          };
          for (var _ in this.attrs) {
            obj.attrs = this.attrs;
            break;
          }
          return obj;
        }
      }], [{
        key: "fromJSON",
        value: function fromJSON(schema, json) {
          if (!json) throw new RangeError("Invalid input for Mark.fromJSON");
          var type = schema.marks[json.type];
          if (!type) throw new RangeError("There is no mark type ".concat(json.type, " in this schema"));
          var mark = type.create(json.attrs);
          type.checkAttrs(mark.attrs);
          return mark;
        }
      }, {
        key: "sameSet",
        value: function sameSet(a, b) {
          if (a == b) return true;
          if (a.length != b.length) return false;
          for (var i = 0; i < a.length; i++) if (!a[i].eq(b[i])) return false;
          return true;
        }
      }, {
        key: "setFrom",
        value: function setFrom(marks) {
          if (!marks || Array.isArray(marks) && marks.length == 0) return Mark2.none;
          if (marks instanceof Mark2) return [marks];
          var copy2 = marks.slice();
          copy2.sort(function(a, b) {
            return a.type.rank - b.type.rank;
          });
          return copy2;
        }
      }]);
      return Mark2;
    })();
    Mark.none = [];
    var ReplaceError = (function(_Error) {
      _inherits(ReplaceError2, _Error);
      var _super = _createSuper(ReplaceError2);
      function ReplaceError2() {
        _classCallCheck(this, ReplaceError2);
        return _super.apply(this, arguments);
      }
      return _createClass(ReplaceError2);
    })(_wrapNativeSuper(Error));
    var Slice = (function() {
      function Slice2(content, openStart, openEnd) {
        _classCallCheck(this, Slice2);
        this.content = content;
        this.openStart = openStart;
        this.openEnd = openEnd;
      }
      _createClass(Slice2, [{
        key: "size",
        get: function get() {
          return this.content.size - this.openStart - this.openEnd;
        }
      }, {
        key: "insertAt",
        value: function insertAt(pos, fragment) {
          var content = insertInto(this.content, pos + this.openStart, fragment);
          return content && new Slice2(content, this.openStart, this.openEnd);
        }
      }, {
        key: "removeBetween",
        value: function removeBetween(from, to) {
          return new Slice2(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
        }
      }, {
        key: "eq",
        value: function eq(other) {
          return this.content.eq(other.content) && this.openStart == other.openStart && this.openEnd == other.openEnd;
        }
      }, {
        key: "toString",
        value: function toString() {
          return this.content + "(" + this.openStart + "," + this.openEnd + ")";
        }
      }, {
        key: "toJSON",
        value: function toJSON() {
          if (!this.content.size) return null;
          var json = {
            content: this.content.toJSON()
          };
          if (this.openStart > 0) json.openStart = this.openStart;
          if (this.openEnd > 0) json.openEnd = this.openEnd;
          return json;
        }
      }], [{
        key: "fromJSON",
        value: function fromJSON(schema, json) {
          if (!json) return Slice2.empty;
          var openStart = json.openStart || 0, openEnd = json.openEnd || 0;
          if (typeof openStart != "number" || typeof openEnd != "number") throw new RangeError("Invalid input for Slice.fromJSON");
          return new Slice2(Fragment.fromJSON(schema, json.content), openStart, openEnd);
        }
      }, {
        key: "maxOpen",
        value: function maxOpen(fragment) {
          var openIsolating = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
          var openStart = 0, openEnd = 0;
          for (var n = fragment.firstChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.firstChild) openStart++;
          for (var _n = fragment.lastChild; _n && !_n.isLeaf && (openIsolating || !_n.type.spec.isolating); _n = _n.lastChild) openEnd++;
          return new Slice2(fragment, openStart, openEnd);
        }
      }]);
      return Slice2;
    })();
    Slice.empty = new Slice(Fragment.empty, 0, 0);
    function removeRange(content, from, to) {
      var _content$findIndex = content.findIndex(from), index = _content$findIndex.index, offset = _content$findIndex.offset, child = content.maybeChild(index);
      var _content$findIndex2 = content.findIndex(to), indexTo = _content$findIndex2.index, offsetTo = _content$findIndex2.offset;
      if (offset == from || child.isText) {
        if (offsetTo != to && !content.child(indexTo).isText) throw new RangeError("Removing non-flat range");
        return content.cut(0, from).append(content.cut(to));
      }
      if (index != indexTo) throw new RangeError("Removing non-flat range");
      return content.replaceChild(index, child.copy(removeRange(child.content, from - offset - 1, to - offset - 1)));
    }
    function insertInto(content, dist, insert, parent) {
      var _content$findIndex3 = content.findIndex(dist), index = _content$findIndex3.index, offset = _content$findIndex3.offset, child = content.maybeChild(index);
      if (offset == dist || child.isText) {
        if (parent && !parent.canReplace(index, index, insert)) return null;
        return content.cut(0, dist).append(insert).append(content.cut(dist));
      }
      var inner = insertInto(child.content, dist - offset - 1, insert);
      return inner && content.replaceChild(index, child.copy(inner));
    }
    function _replace($from, $to, slice) {
      if (slice.openStart > $from.depth) throw new ReplaceError("Inserted content deeper than insertion position");
      if ($from.depth - slice.openStart != $to.depth - slice.openEnd) throw new ReplaceError("Inconsistent open depths");
      return replaceOuter($from, $to, slice, 0);
    }
    function replaceOuter($from, $to, slice, depth) {
      var index = $from.index(depth), node = $from.node(depth);
      if (index == $to.index(depth) && depth < $from.depth - slice.openStart) {
        var inner = replaceOuter($from, $to, slice, depth + 1);
        return node.copy(node.content.replaceChild(index, inner));
      } else if (!slice.content.size) {
        return close(node, replaceTwoWay($from, $to, depth));
      } else if (!slice.openStart && !slice.openEnd && $from.depth == depth && $to.depth == depth) {
        var parent = $from.parent, content = parent.content;
        return close(parent, content.cut(0, $from.parentOffset).append(slice.content).append(content.cut($to.parentOffset)));
      } else {
        var _prepareSliceForRepla = prepareSliceForReplace(slice, $from), start = _prepareSliceForRepla.start, end = _prepareSliceForRepla.end;
        return close(node, replaceThreeWay($from, start, end, $to, depth));
      }
    }
    function checkJoin(main, sub) {
      if (!sub.type.compatibleContent(main.type)) throw new ReplaceError("Cannot join " + sub.type.name + " onto " + main.type.name);
    }
    function joinable($before, $after, depth) {
      var node = $before.node(depth);
      checkJoin(node, $after.node(depth));
      return node;
    }
    function addNode(child, target) {
      var last = target.length - 1;
      if (last >= 0 && child.isText && child.sameMarkup(target[last])) target[last] = child.withText(target[last].text + child.text);
      else target.push(child);
    }
    function addRange($start, $end, depth, target) {
      var node = ($end || $start).node(depth);
      var startIndex = 0, endIndex = $end ? $end.index(depth) : node.childCount;
      if ($start) {
        startIndex = $start.index(depth);
        if ($start.depth > depth) {
          startIndex++;
        } else if ($start.textOffset) {
          addNode($start.nodeAfter, target);
          startIndex++;
        }
      }
      for (var i = startIndex; i < endIndex; i++) addNode(node.child(i), target);
      if ($end && $end.depth == depth && $end.textOffset) addNode($end.nodeBefore, target);
    }
    function close(node, content) {
      node.type.checkContent(content);
      return node.copy(content);
    }
    function replaceThreeWay($from, $start, $end, $to, depth) {
      var openStart = $from.depth > depth && joinable($from, $start, depth + 1);
      var openEnd = $to.depth > depth && joinable($end, $to, depth + 1);
      var content = [];
      addRange(null, $from, depth, content);
      if (openStart && openEnd && $start.index(depth) == $end.index(depth)) {
        checkJoin(openStart, openEnd);
        addNode(close(openStart, replaceThreeWay($from, $start, $end, $to, depth + 1)), content);
      } else {
        if (openStart) addNode(close(openStart, replaceTwoWay($from, $start, depth + 1)), content);
        addRange($start, $end, depth, content);
        if (openEnd) addNode(close(openEnd, replaceTwoWay($end, $to, depth + 1)), content);
      }
      addRange($to, null, depth, content);
      return new Fragment(content);
    }
    function replaceTwoWay($from, $to, depth) {
      var content = [];
      addRange(null, $from, depth, content);
      if ($from.depth > depth) {
        var type = joinable($from, $to, depth + 1);
        addNode(close(type, replaceTwoWay($from, $to, depth + 1)), content);
      }
      addRange($to, null, depth, content);
      return new Fragment(content);
    }
    function prepareSliceForReplace(slice, $along) {
      var extra = $along.depth - slice.openStart, parent = $along.node(extra);
      var node = parent.copy(slice.content);
      for (var i = extra - 1; i >= 0; i--) node = $along.node(i).copy(Fragment.from(node));
      return {
        start: node.resolveNoCache(slice.openStart + extra),
        end: node.resolveNoCache(node.content.size - slice.openEnd - extra)
      };
    }
    var ResolvedPos = (function() {
      function ResolvedPos2(pos, path, parentOffset) {
        _classCallCheck(this, ResolvedPos2);
        this.pos = pos;
        this.path = path;
        this.parentOffset = parentOffset;
        this.depth = path.length / 3 - 1;
      }
      _createClass(ResolvedPos2, [{
        key: "resolveDepth",
        value: function resolveDepth(val) {
          if (val == null) return this.depth;
          if (val < 0) return this.depth + val;
          return val;
        }
      }, {
        key: "parent",
        get: function get() {
          return this.node(this.depth);
        }
      }, {
        key: "doc",
        get: function get() {
          return this.node(0);
        }
      }, {
        key: "node",
        value: function node(depth) {
          return this.path[this.resolveDepth(depth) * 3];
        }
      }, {
        key: "index",
        value: function index(depth) {
          return this.path[this.resolveDepth(depth) * 3 + 1];
        }
      }, {
        key: "indexAfter",
        value: function indexAfter(depth) {
          depth = this.resolveDepth(depth);
          return this.index(depth) + (depth == this.depth && !this.textOffset ? 0 : 1);
        }
      }, {
        key: "start",
        value: function start(depth) {
          depth = this.resolveDepth(depth);
          return depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
        }
      }, {
        key: "end",
        value: function end(depth) {
          depth = this.resolveDepth(depth);
          return this.start(depth) + this.node(depth).content.size;
        }
      }, {
        key: "before",
        value: function before(depth) {
          depth = this.resolveDepth(depth);
          if (!depth) throw new RangeError("There is no position before the top-level node");
          return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1];
        }
      }, {
        key: "after",
        value: function after(depth) {
          depth = this.resolveDepth(depth);
          if (!depth) throw new RangeError("There is no position after the top-level node");
          return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1] + this.path[depth * 3].nodeSize;
        }
      }, {
        key: "textOffset",
        get: function get() {
          return this.pos - this.path[this.path.length - 1];
        }
      }, {
        key: "nodeAfter",
        get: function get() {
          var parent = this.parent, index = this.index(this.depth);
          if (index == parent.childCount) return null;
          var dOff = this.pos - this.path[this.path.length - 1], child = parent.child(index);
          return dOff ? parent.child(index).cut(dOff) : child;
        }
      }, {
        key: "nodeBefore",
        get: function get() {
          var index = this.index(this.depth);
          var dOff = this.pos - this.path[this.path.length - 1];
          if (dOff) return this.parent.child(index).cut(0, dOff);
          return index == 0 ? null : this.parent.child(index - 1);
        }
      }, {
        key: "posAtIndex",
        value: function posAtIndex(index, depth) {
          depth = this.resolveDepth(depth);
          var node = this.path[depth * 3], pos = depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
          for (var i = 0; i < index; i++) pos += node.child(i).nodeSize;
          return pos;
        }
      }, {
        key: "marks",
        value: function marks() {
          var parent = this.parent, index = this.index();
          if (parent.content.size == 0) return Mark.none;
          if (this.textOffset) return parent.child(index).marks;
          var main = parent.maybeChild(index - 1), other = parent.maybeChild(index);
          if (!main) {
            var tmp = main;
            main = other;
            other = tmp;
          }
          var marks2 = main.marks;
          for (var i = 0; i < marks2.length; i++) if (marks2[i].type.spec.inclusive === false && (!other || !marks2[i].isInSet(other.marks))) marks2 = marks2[i--].removeFromSet(marks2);
          return marks2;
        }
      }, {
        key: "marksAcross",
        value: function marksAcross($end) {
          var after = this.parent.maybeChild(this.index());
          if (!after || !after.isInline) return null;
          var marks = after.marks, next = $end.parent.maybeChild($end.index());
          for (var i = 0; i < marks.length; i++) if (marks[i].type.spec.inclusive === false && (!next || !marks[i].isInSet(next.marks))) marks = marks[i--].removeFromSet(marks);
          return marks;
        }
      }, {
        key: "sharedDepth",
        value: function sharedDepth(pos) {
          for (var depth = this.depth; depth > 0; depth--) if (this.start(depth) <= pos && this.end(depth) >= pos) return depth;
          return 0;
        }
      }, {
        key: "blockRange",
        value: function blockRange() {
          var other = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this;
          var pred = arguments.length > 1 ? arguments[1] : void 0;
          if (other.pos < this.pos) return other.blockRange(this);
          for (var d = this.depth - (this.parent.inlineContent || this.pos == other.pos ? 1 : 0); d >= 0; d--) if (other.pos <= this.end(d) && (!pred || pred(this.node(d)))) return new NodeRange(this, other, d);
          return null;
        }
      }, {
        key: "sameParent",
        value: function sameParent(other) {
          return this.pos - this.parentOffset == other.pos - other.parentOffset;
        }
      }, {
        key: "max",
        value: function max(other) {
          return other.pos > this.pos ? other : this;
        }
      }, {
        key: "min",
        value: function min(other) {
          return other.pos < this.pos ? other : this;
        }
      }, {
        key: "toString",
        value: function toString() {
          var str = "";
          for (var i = 1; i <= this.depth; i++) str += (str ? "/" : "") + this.node(i).type.name + "_" + this.index(i - 1);
          return str + ":" + this.parentOffset;
        }
      }], [{
        key: "resolve",
        value: function resolve(doc2, pos) {
          if (!(pos >= 0 && pos <= doc2.content.size)) throw new RangeError("Position " + pos + " out of range");
          var path = [];
          var start = 0, parentOffset = pos;
          for (var node = doc2; ; ) {
            var _node$content$findInd = node.content.findIndex(parentOffset), index = _node$content$findInd.index, offset = _node$content$findInd.offset;
            var rem = parentOffset - offset;
            path.push(node, index, start + offset);
            if (!rem) break;
            node = node.child(index);
            if (node.isText) break;
            parentOffset = rem - 1;
            start += offset + 1;
          }
          return new ResolvedPos2(pos, path, parentOffset);
        }
      }, {
        key: "resolveCached",
        value: function resolveCached(doc2, pos) {
          var cache = resolveCache.get(doc2);
          if (cache) {
            for (var i = 0; i < cache.elts.length; i++) {
              var elt = cache.elts[i];
              if (elt.pos == pos) return elt;
            }
          } else {
            resolveCache.set(doc2, cache = new ResolveCache());
          }
          var result = cache.elts[cache.i] = ResolvedPos2.resolve(doc2, pos);
          cache.i = (cache.i + 1) % resolveCacheSize;
          return result;
        }
      }]);
      return ResolvedPos2;
    })();
    var ResolveCache = _createClass(function ResolveCache2() {
      _classCallCheck(this, ResolveCache2);
      this.elts = [];
      this.i = 0;
    });
    var resolveCacheSize = 12;
    var resolveCache = /* @__PURE__ */ new WeakMap();
    var NodeRange = (function() {
      function NodeRange2($from, $to, depth) {
        _classCallCheck(this, NodeRange2);
        this.$from = $from;
        this.$to = $to;
        this.depth = depth;
      }
      _createClass(NodeRange2, [{
        key: "start",
        get: function get() {
          return this.$from.before(this.depth + 1);
        }
      }, {
        key: "end",
        get: function get() {
          return this.$to.after(this.depth + 1);
        }
      }, {
        key: "parent",
        get: function get() {
          return this.$from.node(this.depth);
        }
      }, {
        key: "startIndex",
        get: function get() {
          return this.$from.index(this.depth);
        }
      }, {
        key: "endIndex",
        get: function get() {
          return this.$to.indexAfter(this.depth);
        }
      }]);
      return NodeRange2;
    })();
    var emptyAttrs = /* @__PURE__ */ Object.create(null);
    var Node2 = (function() {
      function Node3(type, attrs, content) {
        var marks = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : Mark.none;
        _classCallCheck(this, Node3);
        this.type = type;
        this.attrs = attrs;
        this.marks = marks;
        this.content = content || Fragment.empty;
      }
      _createClass(Node3, [{
        key: "children",
        get: function get() {
          return this.content.content;
        }
      }, {
        key: "nodeSize",
        get: function get() {
          return this.isLeaf ? 1 : 2 + this.content.size;
        }
      }, {
        key: "childCount",
        get: function get() {
          return this.content.childCount;
        }
      }, {
        key: "child",
        value: function child(index) {
          return this.content.child(index);
        }
      }, {
        key: "maybeChild",
        value: function maybeChild(index) {
          return this.content.maybeChild(index);
        }
      }, {
        key: "forEach",
        value: function forEach(f) {
          this.content.forEach(f);
        }
      }, {
        key: "nodesBetween",
        value: function nodesBetween(from, to, f) {
          var startPos = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
          this.content.nodesBetween(from, to, f, startPos, this);
        }
      }, {
        key: "descendants",
        value: function descendants(f) {
          this.nodesBetween(0, this.content.size, f);
        }
      }, {
        key: "textContent",
        get: function get() {
          return this.isLeaf && this.type.spec.leafText ? this.type.spec.leafText(this) : this.textBetween(0, this.content.size, "");
        }
      }, {
        key: "textBetween",
        value: function textBetween(from, to, blockSeparator, leafText) {
          return this.content.textBetween(from, to, blockSeparator, leafText);
        }
      }, {
        key: "firstChild",
        get: function get() {
          return this.content.firstChild;
        }
      }, {
        key: "lastChild",
        get: function get() {
          return this.content.lastChild;
        }
      }, {
        key: "eq",
        value: function eq(other) {
          return this == other || this.sameMarkup(other) && this.content.eq(other.content);
        }
      }, {
        key: "sameMarkup",
        value: function sameMarkup(other) {
          return this.hasMarkup(other.type, other.attrs, other.marks);
        }
      }, {
        key: "hasMarkup",
        value: function hasMarkup(type, attrs, marks) {
          return this.type == type && compareDeep(this.attrs, attrs || type.defaultAttrs || emptyAttrs) && Mark.sameSet(this.marks, marks || Mark.none);
        }
      }, {
        key: "copy",
        value: function copy2() {
          var content = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
          if (content == this.content) return this;
          return new Node3(this.type, this.attrs, content, this.marks);
        }
      }, {
        key: "mark",
        value: function mark(marks) {
          return marks == this.marks ? this : new Node3(this.type, this.attrs, this.content, marks);
        }
      }, {
        key: "cut",
        value: function cut(from) {
          var to = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.content.size;
          if (from == 0 && to == this.content.size) return this;
          return this.copy(this.content.cut(from, to));
        }
      }, {
        key: "slice",
        value: function slice(from) {
          var to = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.content.size;
          var includeParents = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
          if (from == to) return Slice.empty;
          var $from = this.resolve(from), $to = this.resolve(to);
          var depth = includeParents ? 0 : $from.sharedDepth(to);
          var start = $from.start(depth), node = $from.node(depth);
          var content = node.content.cut($from.pos - start, $to.pos - start);
          return new Slice(content, $from.depth - depth, $to.depth - depth);
        }
      }, {
        key: "replace",
        value: function replace(from, to, slice) {
          return _replace(this.resolve(from), this.resolve(to), slice);
        }
      }, {
        key: "nodeAt",
        value: function nodeAt(pos) {
          for (var node = this; ; ) {
            var _node$content$findInd2 = node.content.findIndex(pos), index = _node$content$findInd2.index, offset = _node$content$findInd2.offset;
            node = node.maybeChild(index);
            if (!node) return null;
            if (offset == pos || node.isText) return node;
            pos -= offset + 1;
          }
        }
      }, {
        key: "childAfter",
        value: function childAfter(pos) {
          var _this$content$findInd = this.content.findIndex(pos), index = _this$content$findInd.index, offset = _this$content$findInd.offset;
          return {
            node: this.content.maybeChild(index),
            index,
            offset
          };
        }
      }, {
        key: "childBefore",
        value: function childBefore(pos) {
          if (pos == 0) return {
            node: null,
            index: 0,
            offset: 0
          };
          var _this$content$findInd2 = this.content.findIndex(pos), index = _this$content$findInd2.index, offset = _this$content$findInd2.offset;
          if (offset < pos) return {
            node: this.content.child(index),
            index,
            offset
          };
          var node = this.content.child(index - 1);
          return {
            node,
            index: index - 1,
            offset: offset - node.nodeSize
          };
        }
      }, {
        key: "resolve",
        value: function resolve(pos) {
          return ResolvedPos.resolveCached(this, pos);
        }
      }, {
        key: "resolveNoCache",
        value: function resolveNoCache(pos) {
          return ResolvedPos.resolve(this, pos);
        }
      }, {
        key: "rangeHasMark",
        value: function rangeHasMark(from, to, type) {
          var found2 = false;
          if (to > from) this.nodesBetween(from, to, function(node) {
            if (type.isInSet(node.marks)) found2 = true;
            return !found2;
          });
          return found2;
        }
      }, {
        key: "isBlock",
        get: function get() {
          return this.type.isBlock;
        }
      }, {
        key: "isTextblock",
        get: function get() {
          return this.type.isTextblock;
        }
      }, {
        key: "inlineContent",
        get: function get() {
          return this.type.inlineContent;
        }
      }, {
        key: "isInline",
        get: function get() {
          return this.type.isInline;
        }
      }, {
        key: "isText",
        get: function get() {
          return this.type.isText;
        }
      }, {
        key: "isLeaf",
        get: function get() {
          return this.type.isLeaf;
        }
      }, {
        key: "isAtom",
        get: function get() {
          return this.type.isAtom;
        }
      }, {
        key: "toString",
        value: function toString() {
          if (this.type.spec.toDebugString) return this.type.spec.toDebugString(this);
          var name = this.type.name;
          if (this.content.size) name += "(" + this.content.toStringInner() + ")";
          return wrapMarks(this.marks, name);
        }
      }, {
        key: "contentMatchAt",
        value: function contentMatchAt(index) {
          var match = this.type.contentMatch.matchFragment(this.content, 0, index);
          if (!match) throw new Error("Called contentMatchAt on a node with invalid content");
          return match;
        }
      }, {
        key: "canReplace",
        value: function canReplace(from, to) {
          var replacement = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : Fragment.empty;
          var start = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
          var end = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : replacement.childCount;
          var one = this.contentMatchAt(from).matchFragment(replacement, start, end);
          var two = one && one.matchFragment(this.content, to);
          if (!two || !two.validEnd) return false;
          for (var i = start; i < end; i++) if (!this.type.allowsMarks(replacement.child(i).marks)) return false;
          return true;
        }
      }, {
        key: "canReplaceWith",
        value: function canReplaceWith(from, to, type, marks) {
          if (marks && !this.type.allowsMarks(marks)) return false;
          var start = this.contentMatchAt(from).matchType(type);
          var end = start && start.matchFragment(this.content, to);
          return end ? end.validEnd : false;
        }
      }, {
        key: "canAppend",
        value: function canAppend(other) {
          if (other.content.size) return this.canReplace(this.childCount, this.childCount, other.content);
          else return this.type.compatibleContent(other.type);
        }
      }, {
        key: "check",
        value: function check() {
          this.type.checkContent(this.content);
          this.type.checkAttrs(this.attrs);
          var copy2 = Mark.none;
          for (var i = 0; i < this.marks.length; i++) {
            var mark = this.marks[i];
            mark.type.checkAttrs(mark.attrs);
            copy2 = mark.addToSet(copy2);
          }
          if (!Mark.sameSet(copy2, this.marks)) throw new RangeError("Invalid collection of marks for node ".concat(this.type.name, ": ").concat(this.marks.map(function(m) {
            return m.type.name;
          })));
          this.content.forEach(function(node) {
            return node.check();
          });
        }
      }, {
        key: "toJSON",
        value: function toJSON() {
          var obj = {
            type: this.type.name
          };
          for (var _ in this.attrs) {
            obj.attrs = this.attrs;
            break;
          }
          if (this.content.size) obj.content = this.content.toJSON();
          if (this.marks.length) obj.marks = this.marks.map(function(n) {
            return n.toJSON();
          });
          return obj;
        }
      }], [{
        key: "fromJSON",
        value: function fromJSON(schema, json) {
          if (!json) throw new RangeError("Invalid input for Node.fromJSON");
          var marks = void 0;
          if (json.marks) {
            if (!Array.isArray(json.marks)) throw new RangeError("Invalid mark data for Node.fromJSON");
            marks = json.marks.map(schema.markFromJSON);
          }
          if (json.type == "text") {
            if (typeof json.text != "string") throw new RangeError("Invalid text node in JSON");
            return schema.text(json.text, marks);
          }
          var content = Fragment.fromJSON(schema, json.content);
          var node = schema.nodeType(json.type).create(json.attrs, content, marks);
          node.type.checkAttrs(node.attrs);
          return node;
        }
      }]);
      return Node3;
    })();
    Node2.prototype.text = void 0;
    var TextNode = (function(_Node) {
      _inherits(TextNode2, _Node);
      var _super2 = _createSuper(TextNode2);
      function TextNode2(type, attrs, content, marks) {
        var _this;
        _classCallCheck(this, TextNode2);
        _this = _super2.call(this, type, attrs, null, marks);
        if (!content) throw new RangeError("Empty text nodes are not allowed");
        _this.text = content;
        return _this;
      }
      _createClass(TextNode2, [{
        key: "toString",
        value: function toString() {
          if (this.type.spec.toDebugString) return this.type.spec.toDebugString(this);
          return wrapMarks(this.marks, JSON.stringify(this.text));
        }
      }, {
        key: "textContent",
        get: function get() {
          return this.text;
        }
      }, {
        key: "textBetween",
        value: function textBetween(from, to) {
          return this.text.slice(from, to);
        }
      }, {
        key: "nodeSize",
        get: function get() {
          return this.text.length;
        }
      }, {
        key: "mark",
        value: function mark(marks) {
          return marks == this.marks ? this : new TextNode2(this.type, this.attrs, this.text, marks);
        }
      }, {
        key: "withText",
        value: function withText(text) {
          if (text == this.text) return this;
          return new TextNode2(this.type, this.attrs, text, this.marks);
        }
      }, {
        key: "cut",
        value: function cut() {
          var from = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
          var to = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.text.length;
          if (from == 0 && to == this.text.length) return this;
          return this.withText(this.text.slice(from, to));
        }
      }, {
        key: "eq",
        value: function eq(other) {
          return this.sameMarkup(other) && this.text == other.text;
        }
      }, {
        key: "toJSON",
        value: function toJSON() {
          var base = _get(_getPrototypeOf(TextNode2.prototype), "toJSON", this).call(this);
          base.text = this.text;
          return base;
        }
      }]);
      return TextNode2;
    })(Node2);
    function wrapMarks(marks, str) {
      for (var i = marks.length - 1; i >= 0; i--) str = marks[i].type.name + "(" + str + ")";
      return str;
    }
    var ContentMatch = (function() {
      function ContentMatch2(validEnd) {
        _classCallCheck(this, ContentMatch2);
        this.validEnd = validEnd;
        this.next = [];
        this.wrapCache = [];
      }
      _createClass(ContentMatch2, [{
        key: "matchType",
        value: function matchType(type) {
          for (var i = 0; i < this.next.length; i++) if (this.next[i].type == type) return this.next[i].next;
          return null;
        }
      }, {
        key: "matchFragment",
        value: function matchFragment(frag) {
          var start = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
          var end = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : frag.childCount;
          var cur = this;
          for (var i = start; cur && i < end; i++) cur = cur.matchType(frag.child(i).type);
          return cur;
        }
      }, {
        key: "inlineContent",
        get: function get() {
          return this.next.length != 0 && this.next[0].type.isInline;
        }
      }, {
        key: "defaultType",
        get: function get() {
          for (var i = 0; i < this.next.length; i++) {
            var type = this.next[i].type;
            if (!(type.isText || type.hasRequiredAttrs())) return type;
          }
          return null;
        }
      }, {
        key: "compatible",
        value: function compatible(other) {
          for (var i = 0; i < this.next.length; i++) for (var j = 0; j < other.next.length; j++) if (this.next[i].type == other.next[j].type) return true;
          return false;
        }
      }, {
        key: "fillBefore",
        value: function fillBefore(after) {
          var toEnd = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
          var startIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
          var seen = [this];
          function search(match, types) {
            var finished = match.matchFragment(after, startIndex);
            if (finished && (!toEnd || finished.validEnd)) return Fragment.from(types.map(function(tp) {
              return tp.createAndFill();
            }));
            for (var i = 0; i < match.next.length; i++) {
              var _match$next$i = match.next[i], type = _match$next$i.type, next = _match$next$i.next;
              if (!(type.isText || type.hasRequiredAttrs()) && seen.indexOf(next) == -1) {
                seen.push(next);
                var _found = search(next, types.concat(type));
                if (_found) return _found;
              }
            }
            return null;
          }
          return search(this, []);
        }
      }, {
        key: "findWrapping",
        value: function findWrapping(target) {
          for (var i = 0; i < this.wrapCache.length; i += 2) if (this.wrapCache[i] == target) return this.wrapCache[i + 1];
          var computed = this.computeWrapping(target);
          this.wrapCache.push(target, computed);
          return computed;
        }
      }, {
        key: "computeWrapping",
        value: function computeWrapping(target) {
          var seen = /* @__PURE__ */ Object.create(null), active = [{
            match: this,
            type: null,
            via: null
          }];
          while (active.length) {
            var current = active.shift(), match = current.match;
            if (match.matchType(target)) {
              var result = [];
              for (var obj = current; obj.type; obj = obj.via) result.push(obj.type);
              return result.reverse();
            }
            for (var i = 0; i < match.next.length; i++) {
              var _match$next$i2 = match.next[i], type = _match$next$i2.type, next = _match$next$i2.next;
              if (!type.isLeaf && !type.hasRequiredAttrs() && !(type.name in seen) && (!current.type || next.validEnd)) {
                active.push({
                  match: type.contentMatch,
                  type,
                  via: current
                });
                seen[type.name] = true;
              }
            }
          }
          return null;
        }
      }, {
        key: "edgeCount",
        get: function get() {
          return this.next.length;
        }
      }, {
        key: "edge",
        value: function edge(n) {
          if (n >= this.next.length) throw new RangeError("There's no ".concat(n, "th edge in this content match"));
          return this.next[n];
        }
      }, {
        key: "toString",
        value: function toString() {
          var seen = [];
          function scan(m) {
            seen.push(m);
            for (var i = 0; i < m.next.length; i++) if (seen.indexOf(m.next[i].next) == -1) scan(m.next[i].next);
          }
          scan(this);
          return seen.map(function(m, i) {
            var out = i + (m.validEnd ? "*" : " ") + " ";
            for (var _i = 0; _i < m.next.length; _i++) out += (_i ? ", " : "") + m.next[_i].type.name + "->" + seen.indexOf(m.next[_i].next);
            return out;
          }).join("\n");
        }
      }], [{
        key: "parse",
        value: function parse(string, nodeTypes) {
          var stream = new TokenStream(string, nodeTypes);
          if (stream.next == null) return ContentMatch2.empty;
          var expr = parseExpr(stream);
          if (stream.next) stream.err("Unexpected trailing text");
          var match = dfa(nfa(expr));
          checkForDeadEnds(match, stream);
          return match;
        }
      }]);
      return ContentMatch2;
    })();
    ContentMatch.empty = new ContentMatch(true);
    var TokenStream = (function() {
      function TokenStream2(string, nodeTypes) {
        _classCallCheck(this, TokenStream2);
        this.string = string;
        this.nodeTypes = nodeTypes;
        this.inline = null;
        this.pos = 0;
        this.tokens = string.split(/\s*(?=\b|\W|$)/);
        if (this.tokens[this.tokens.length - 1] == "") this.tokens.pop();
        if (this.tokens[0] == "") this.tokens.shift();
      }
      _createClass(TokenStream2, [{
        key: "next",
        get: function get() {
          return this.tokens[this.pos];
        }
      }, {
        key: "eat",
        value: function eat(tok) {
          return this.next == tok && (this.pos++ || true);
        }
      }, {
        key: "err",
        value: function err(str) {
          throw new SyntaxError(str + " (in content expression '" + this.string + "')");
        }
      }]);
      return TokenStream2;
    })();
    function parseExpr(stream) {
      var exprs = [];
      do {
        exprs.push(parseExprSeq(stream));
      } while (stream.eat("|"));
      return exprs.length == 1 ? exprs[0] : {
        type: "choice",
        exprs
      };
    }
    function parseExprSeq(stream) {
      var exprs = [];
      do {
        exprs.push(parseExprSubscript(stream));
      } while (stream.next && stream.next != ")" && stream.next != "|");
      return exprs.length == 1 ? exprs[0] : {
        type: "seq",
        exprs
      };
    }
    function parseExprSubscript(stream) {
      var expr = parseExprAtom(stream);
      for (; ; ) {
        if (stream.eat("+")) expr = {
          type: "plus",
          expr
        };
        else if (stream.eat("*")) expr = {
          type: "star",
          expr
        };
        else if (stream.eat("?")) expr = {
          type: "opt",
          expr
        };
        else if (stream.eat("{")) expr = parseExprRange(stream, expr);
        else break;
      }
      return expr;
    }
    function parseNum(stream) {
      if (/\D/.test(stream.next)) stream.err("Expected number, got '" + stream.next + "'");
      var result = Number(stream.next);
      stream.pos++;
      return result;
    }
    function parseExprRange(stream, expr) {
      var min = parseNum(stream), max = min;
      if (stream.eat(",")) {
        if (stream.next != "}") max = parseNum(stream);
        else max = -1;
      }
      if (!stream.eat("}")) stream.err("Unclosed braced range");
      return {
        type: "range",
        min,
        max,
        expr
      };
    }
    function resolveName(stream, name) {
      var types = stream.nodeTypes, type = types[name];
      if (type) return [type];
      var result = [];
      for (var typeName in types) {
        var _type = types[typeName];
        if (_type.isInGroup(name)) result.push(_type);
      }
      if (result.length == 0) stream.err("No node type or group '" + name + "' found");
      return result;
    }
    function parseExprAtom(stream) {
      if (stream.eat("(")) {
        var expr = parseExpr(stream);
        if (!stream.eat(")")) stream.err("Missing closing paren");
        return expr;
      } else if (!/\W/.test(stream.next)) {
        var exprs = resolveName(stream, stream.next).map(function(type) {
          if (stream.inline == null) stream.inline = type.isInline;
          else if (stream.inline != type.isInline) stream.err("Mixing inline and block content");
          return {
            type: "name",
            value: type
          };
        });
        stream.pos++;
        return exprs.length == 1 ? exprs[0] : {
          type: "choice",
          exprs
        };
      } else {
        stream.err("Unexpected token '" + stream.next + "'");
      }
    }
    function nfa(expr) {
      var nfa2 = [[]];
      connect(compile(expr, 0), node());
      return nfa2;
      function node() {
        return nfa2.push([]) - 1;
      }
      function edge(from, to, term) {
        var edge2 = {
          term,
          to
        };
        nfa2[from].push(edge2);
        return edge2;
      }
      function connect(edges, to) {
        edges.forEach(function(edge2) {
          return edge2.to = to;
        });
      }
      function compile(expr2, from) {
        if (expr2.type == "choice") {
          return expr2.exprs.reduce(function(out, expr3) {
            return out.concat(compile(expr3, from));
          }, []);
        } else if (expr2.type == "seq") {
          for (var i = 0; ; i++) {
            var next = compile(expr2.exprs[i], from);
            if (i == expr2.exprs.length - 1) return next;
            connect(next, from = node());
          }
        } else if (expr2.type == "star") {
          var loop = node();
          edge(from, loop);
          connect(compile(expr2.expr, loop), loop);
          return [edge(loop)];
        } else if (expr2.type == "plus") {
          var _loop = node();
          connect(compile(expr2.expr, from), _loop);
          connect(compile(expr2.expr, _loop), _loop);
          return [edge(_loop)];
        } else if (expr2.type == "opt") {
          return [edge(from)].concat(compile(expr2.expr, from));
        } else if (expr2.type == "range") {
          var cur = from;
          for (var _i2 = 0; _i2 < expr2.min; _i2++) {
            var _next = node();
            connect(compile(expr2.expr, cur), _next);
            cur = _next;
          }
          if (expr2.max == -1) {
            connect(compile(expr2.expr, cur), cur);
          } else {
            for (var _i3 = expr2.min; _i3 < expr2.max; _i3++) {
              var _next2 = node();
              edge(cur, _next2);
              connect(compile(expr2.expr, cur), _next2);
              cur = _next2;
            }
          }
          return [edge(cur)];
        } else if (expr2.type == "name") {
          return [edge(from, void 0, expr2.value)];
        } else {
          throw new Error("Unknown expr type");
        }
      }
    }
    function cmp(a, b) {
      return b - a;
    }
    function nullFrom(nfa2, node) {
      var result = [];
      scan(node);
      return result.sort(cmp);
      function scan(node2) {
        var edges = nfa2[node2];
        if (edges.length == 1 && !edges[0].term) return scan(edges[0].to);
        result.push(node2);
        for (var i = 0; i < edges.length; i++) {
          var _edges$i = edges[i], term = _edges$i.term, to = _edges$i.to;
          if (!term && result.indexOf(to) == -1) scan(to);
        }
      }
    }
    function dfa(nfa2) {
      var labeled = /* @__PURE__ */ Object.create(null);
      return explore(nullFrom(nfa2, 0));
      function explore(states) {
        var out = [];
        states.forEach(function(node) {
          nfa2[node].forEach(function(_ref) {
            var term = _ref.term, to = _ref.to;
            if (!term) return;
            var set;
            for (var i2 = 0; i2 < out.length; i2++) if (out[i2][0] == term) set = out[i2][1];
            nullFrom(nfa2, to).forEach(function(node2) {
              if (!set) out.push([term, set = []]);
              if (set.indexOf(node2) == -1) set.push(node2);
            });
          });
        });
        var state = labeled[states.join(",")] = new ContentMatch(states.indexOf(nfa2.length - 1) > -1);
        for (var i = 0; i < out.length; i++) {
          var _states = out[i][1].sort(cmp);
          state.next.push({
            type: out[i][0],
            next: labeled[_states.join(",")] || explore(_states)
          });
        }
        return state;
      }
    }
    function checkForDeadEnds(match, stream) {
      for (var i = 0, work = [match]; i < work.length; i++) {
        var state = work[i], dead = !state.validEnd, nodes = [];
        for (var j = 0; j < state.next.length; j++) {
          var _state$next$j = state.next[j], type = _state$next$j.type, next = _state$next$j.next;
          nodes.push(type.name);
          if (dead && !(type.isText || type.hasRequiredAttrs())) dead = false;
          if (work.indexOf(next) == -1) work.push(next);
        }
        if (dead) stream.err("Only non-generatable nodes (" + nodes.join(", ") + ") in a required position (see https://prosemirror.net/docs/guide/#generatable)");
      }
    }
    function defaultAttrs(attrs) {
      var defaults = /* @__PURE__ */ Object.create(null);
      for (var attrName in attrs) {
        var attr = attrs[attrName];
        if (!attr.hasDefault) return null;
        defaults[attrName] = attr["default"];
      }
      return defaults;
    }
    function _computeAttrs(attrs, value) {
      var built = /* @__PURE__ */ Object.create(null);
      for (var name in attrs) {
        var given = value && value[name];
        if (given === void 0) {
          var attr = attrs[name];
          if (attr.hasDefault) given = attr["default"];
          else throw new RangeError("No value supplied for attribute " + name);
        }
        built[name] = given;
      }
      return built;
    }
    function _checkAttrs(attrs, values, type, name) {
      for (var _name in values) if (!(_name in attrs)) throw new RangeError("Unsupported attribute ".concat(_name, " for ").concat(type, " of type ").concat(_name));
      for (var _name2 in attrs) {
        var attr = attrs[_name2];
        if (attr.validate) attr.validate(values[_name2]);
      }
    }
    function initAttrs(typeName, attrs) {
      var result = /* @__PURE__ */ Object.create(null);
      if (attrs) for (var name in attrs) result[name] = new Attribute(typeName, name, attrs[name]);
      return result;
    }
    var NodeType = (function() {
      function NodeType2(name, schema, spec) {
        _classCallCheck(this, NodeType2);
        this.name = name;
        this.schema = schema;
        this.spec = spec;
        this.markSet = null;
        this.groups = spec.group ? spec.group.split(" ") : [];
        this.attrs = initAttrs(name, spec.attrs);
        this.defaultAttrs = defaultAttrs(this.attrs);
        this.contentMatch = null;
        this.inlineContent = null;
        this.isBlock = !(spec.inline || name == "text");
        this.isText = name == "text";
      }
      _createClass(NodeType2, [{
        key: "isInline",
        get: function get() {
          return !this.isBlock;
        }
      }, {
        key: "isTextblock",
        get: function get() {
          return this.isBlock && this.inlineContent;
        }
      }, {
        key: "isLeaf",
        get: function get() {
          return this.contentMatch == ContentMatch.empty;
        }
      }, {
        key: "isAtom",
        get: function get() {
          return this.isLeaf || !!this.spec.atom;
        }
      }, {
        key: "isInGroup",
        value: function isInGroup(group) {
          return this.groups.indexOf(group) > -1;
        }
      }, {
        key: "whitespace",
        get: function get() {
          return this.spec.whitespace || (this.spec.code ? "pre" : "normal");
        }
      }, {
        key: "hasRequiredAttrs",
        value: function hasRequiredAttrs() {
          for (var n in this.attrs) if (this.attrs[n].isRequired) return true;
          return false;
        }
      }, {
        key: "compatibleContent",
        value: function compatibleContent(other) {
          return this == other || this.contentMatch.compatible(other.contentMatch);
        }
      }, {
        key: "computeAttrs",
        value: function computeAttrs(attrs) {
          if (!attrs && this.defaultAttrs) return this.defaultAttrs;
          else return _computeAttrs(this.attrs, attrs);
        }
      }, {
        key: "create",
        value: function create() {
          var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
          var content = arguments.length > 1 ? arguments[1] : void 0;
          var marks = arguments.length > 2 ? arguments[2] : void 0;
          if (this.isText) throw new Error("NodeType.create can't construct text nodes");
          return new Node2(this, this.computeAttrs(attrs), Fragment.from(content), Mark.setFrom(marks));
        }
      }, {
        key: "createChecked",
        value: function createChecked() {
          var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
          var content = arguments.length > 1 ? arguments[1] : void 0;
          var marks = arguments.length > 2 ? arguments[2] : void 0;
          content = Fragment.from(content);
          this.checkContent(content);
          return new Node2(this, this.computeAttrs(attrs), content, Mark.setFrom(marks));
        }
      }, {
        key: "createAndFill",
        value: function createAndFill() {
          var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
          var content = arguments.length > 1 ? arguments[1] : void 0;
          var marks = arguments.length > 2 ? arguments[2] : void 0;
          attrs = this.computeAttrs(attrs);
          content = Fragment.from(content);
          if (content.size) {
            var before = this.contentMatch.fillBefore(content);
            if (!before) return null;
            content = before.append(content);
          }
          var matched = this.contentMatch.matchFragment(content);
          var after = matched && matched.fillBefore(Fragment.empty, true);
          if (!after) return null;
          return new Node2(this, attrs, content.append(after), Mark.setFrom(marks));
        }
      }, {
        key: "validContent",
        value: function validContent(content) {
          var result = this.contentMatch.matchFragment(content);
          if (!result || !result.validEnd) return false;
          for (var i = 0; i < content.childCount; i++) if (!this.allowsMarks(content.child(i).marks)) return false;
          return true;
        }
      }, {
        key: "checkContent",
        value: function checkContent(content) {
          if (!this.validContent(content)) throw new RangeError("Invalid content for node ".concat(this.name, ": ").concat(content.toString().slice(0, 50)));
        }
      }, {
        key: "checkAttrs",
        value: function checkAttrs(attrs) {
          _checkAttrs(this.attrs, attrs, "node", this.name);
        }
      }, {
        key: "allowsMarkType",
        value: function allowsMarkType(markType) {
          return this.markSet == null || this.markSet.indexOf(markType) > -1;
        }
      }, {
        key: "allowsMarks",
        value: function allowsMarks(marks) {
          if (this.markSet == null) return true;
          for (var i = 0; i < marks.length; i++) if (!this.allowsMarkType(marks[i].type)) return false;
          return true;
        }
      }, {
        key: "allowedMarks",
        value: function allowedMarks(marks) {
          if (this.markSet == null) return marks;
          var copy2;
          for (var i = 0; i < marks.length; i++) {
            if (!this.allowsMarkType(marks[i].type)) {
              if (!copy2) copy2 = marks.slice(0, i);
            } else if (copy2) {
              copy2.push(marks[i]);
            }
          }
          return !copy2 ? marks : copy2.length ? copy2 : Mark.none;
        }
      }], [{
        key: "compile",
        value: function compile(nodes, schema) {
          var result = /* @__PURE__ */ Object.create(null);
          nodes.forEach(function(name, spec) {
            return result[name] = new NodeType2(name, schema, spec);
          });
          var topType = schema.spec.topNode || "doc";
          if (!result[topType]) throw new RangeError("Schema is missing its top node type ('" + topType + "')");
          if (!result.text) throw new RangeError("Every schema needs a 'text' type");
          for (var _ in result.text.attrs) throw new RangeError("The text node type should not have attributes");
          return result;
        }
      }]);
      return NodeType2;
    })();
    function validateType(typeName, attrName, type) {
      var types = type.split("|");
      return function(value) {
        var name = value === null ? "null" : _typeof(value);
        if (types.indexOf(name) < 0) throw new RangeError("Expected value of type ".concat(types, " for attribute ").concat(attrName, " on type ").concat(typeName, ", got ").concat(name));
      };
    }
    var Attribute = (function() {
      function Attribute2(typeName, attrName, options) {
        _classCallCheck(this, Attribute2);
        this.hasDefault = Object.prototype.hasOwnProperty.call(options, "default");
        this["default"] = options["default"];
        this.validate = typeof options.validate == "string" ? validateType(typeName, attrName, options.validate) : options.validate;
      }
      _createClass(Attribute2, [{
        key: "isRequired",
        get: function get() {
          return !this.hasDefault;
        }
      }]);
      return Attribute2;
    })();
    var MarkType = (function() {
      function MarkType2(name, rank, schema, spec) {
        _classCallCheck(this, MarkType2);
        this.name = name;
        this.rank = rank;
        this.schema = schema;
        this.spec = spec;
        this.attrs = initAttrs(name, spec.attrs);
        this.excluded = null;
        var defaults = defaultAttrs(this.attrs);
        this.instance = defaults ? new Mark(this, defaults) : null;
      }
      _createClass(MarkType2, [{
        key: "create",
        value: function create() {
          var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
          if (!attrs && this.instance) return this.instance;
          return new Mark(this, _computeAttrs(this.attrs, attrs));
        }
      }, {
        key: "removeFromSet",
        value: function removeFromSet(set) {
          for (var i = 0; i < set.length; i++) if (set[i].type == this) {
            set = set.slice(0, i).concat(set.slice(i + 1));
            i--;
          }
          return set;
        }
      }, {
        key: "isInSet",
        value: function isInSet(set) {
          for (var i = 0; i < set.length; i++) if (set[i].type == this) return set[i];
        }
      }, {
        key: "checkAttrs",
        value: function checkAttrs(attrs) {
          _checkAttrs(this.attrs, attrs, "mark", this.name);
        }
      }, {
        key: "excludes",
        value: function excludes(other) {
          return this.excluded.indexOf(other) > -1;
        }
      }], [{
        key: "compile",
        value: function compile(marks, schema) {
          var result = /* @__PURE__ */ Object.create(null), rank = 0;
          marks.forEach(function(name, spec) {
            return result[name] = new MarkType2(name, rank++, schema, spec);
          });
          return result;
        }
      }]);
      return MarkType2;
    })();
    var Schema = (function() {
      function Schema2(spec) {
        _classCallCheck(this, Schema2);
        this.linebreakReplacement = null;
        this.cached = /* @__PURE__ */ Object.create(null);
        var instanceSpec = this.spec = {};
        for (var prop in spec) instanceSpec[prop] = spec[prop];
        instanceSpec.nodes = OrderedMap.from(spec.nodes), instanceSpec.marks = OrderedMap.from(spec.marks || {}), this.nodes = NodeType.compile(this.spec.nodes, this);
        this.marks = MarkType.compile(this.spec.marks, this);
        var contentExprCache = /* @__PURE__ */ Object.create(null);
        for (var _prop in this.nodes) {
          if (_prop in this.marks) throw new RangeError(_prop + " can not be both a node and a mark");
          var type = this.nodes[_prop], contentExpr = type.spec.content || "", markExpr = type.spec.marks;
          type.contentMatch = contentExprCache[contentExpr] || (contentExprCache[contentExpr] = ContentMatch.parse(contentExpr, this.nodes));
          type.inlineContent = type.contentMatch.inlineContent;
          if (type.spec.linebreakReplacement) {
            if (this.linebreakReplacement) throw new RangeError("Multiple linebreak nodes defined");
            if (!type.isInline || !type.isLeaf) throw new RangeError("Linebreak replacement nodes must be inline leaf nodes");
            this.linebreakReplacement = type;
          }
          type.markSet = markExpr == "_" ? null : markExpr ? gatherMarks(this, markExpr.split(" ")) : markExpr == "" || !type.inlineContent ? [] : null;
        }
        for (var _prop2 in this.marks) {
          var _type2 = this.marks[_prop2], excl = _type2.spec.excludes;
          _type2.excluded = excl == null ? [_type2] : excl == "" ? [] : gatherMarks(this, excl.split(" "));
        }
        this.nodeFromJSON = this.nodeFromJSON.bind(this);
        this.markFromJSON = this.markFromJSON.bind(this);
        this.topNodeType = this.nodes[this.spec.topNode || "doc"];
        this.cached.wrappings = /* @__PURE__ */ Object.create(null);
      }
      _createClass(Schema2, [{
        key: "node",
        value: function node(type) {
          var attrs = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
          var content = arguments.length > 2 ? arguments[2] : void 0;
          var marks = arguments.length > 3 ? arguments[3] : void 0;
          if (typeof type == "string") type = this.nodeType(type);
          else if (!(type instanceof NodeType)) throw new RangeError("Invalid node type: " + type);
          else if (type.schema != this) throw new RangeError("Node type from different schema used (" + type.name + ")");
          return type.createChecked(attrs, content, marks);
        }
      }, {
        key: "text",
        value: function text(_text, marks) {
          var type = this.nodes.text;
          return new TextNode(type, type.defaultAttrs, _text, Mark.setFrom(marks));
        }
      }, {
        key: "mark",
        value: function mark(type, attrs) {
          if (typeof type == "string") type = this.marks[type];
          return type.create(attrs);
        }
      }, {
        key: "nodeFromJSON",
        value: function nodeFromJSON(json) {
          return Node2.fromJSON(this, json);
        }
      }, {
        key: "markFromJSON",
        value: function markFromJSON(json) {
          return Mark.fromJSON(this, json);
        }
      }, {
        key: "nodeType",
        value: function nodeType(name) {
          var found2 = this.nodes[name];
          if (!found2) throw new RangeError("Unknown node type: " + name);
          return found2;
        }
      }]);
      return Schema2;
    })();
    function gatherMarks(schema, marks) {
      var found2 = [];
      for (var i = 0; i < marks.length; i++) {
        var name = marks[i], mark = schema.marks[name], ok = mark;
        if (mark) {
          found2.push(mark);
        } else {
          for (var prop in schema.marks) {
            var _mark = schema.marks[prop];
            if (name == "_" || _mark.spec.group && _mark.spec.group.split(" ").indexOf(name) > -1) found2.push(ok = _mark);
          }
        }
        if (!ok) throw new SyntaxError("Unknown mark type: '" + marks[i] + "'");
      }
      return found2;
    }
    function isTagRule(rule) {
      return rule.tag != null;
    }
    function isStyleRule(rule) {
      return rule.style != null;
    }
    var DOMParser = (function() {
      function DOMParser2(schema, rules) {
        var _this2 = this;
        _classCallCheck(this, DOMParser2);
        this.schema = schema;
        this.rules = rules;
        this.tags = [];
        this.styles = [];
        var matchedStyles = this.matchedStyles = [];
        rules.forEach(function(rule) {
          if (isTagRule(rule)) {
            _this2.tags.push(rule);
          } else if (isStyleRule(rule)) {
            var prop = /[^=]*/.exec(rule.style)[0];
            if (matchedStyles.indexOf(prop) < 0) matchedStyles.push(prop);
            _this2.styles.push(rule);
          }
        });
        this.normalizeLists = !this.tags.some(function(r) {
          if (!/^(ul|ol)\b/.test(r.tag) || !r.node) return false;
          var node = schema.nodes[r.node];
          return node.contentMatch.matchType(node);
        });
      }
      _createClass(DOMParser2, [{
        key: "parse",
        value: function parse(dom) {
          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          var context = new ParseContext(this, options, false);
          context.addAll(dom, Mark.none, options.from, options.to);
          return context.finish();
        }
      }, {
        key: "parseSlice",
        value: function parseSlice(dom) {
          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          var context = new ParseContext(this, options, true);
          context.addAll(dom, Mark.none, options.from, options.to);
          return Slice.maxOpen(context.finish());
        }
      }, {
        key: "matchTag",
        value: function matchTag(dom, context, after) {
          for (var i = after ? this.tags.indexOf(after) + 1 : 0; i < this.tags.length; i++) {
            var rule = this.tags[i];
            if (matches(dom, rule.tag) && (rule.namespace === void 0 || dom.namespaceURI == rule.namespace) && (!rule.context || context.matchesContext(rule.context))) {
              if (rule.getAttrs) {
                var result = rule.getAttrs(dom);
                if (result === false) continue;
                rule.attrs = result || void 0;
              }
              return rule;
            }
          }
        }
      }, {
        key: "matchStyle",
        value: function matchStyle(prop, value, context, after) {
          for (var i = after ? this.styles.indexOf(after) + 1 : 0; i < this.styles.length; i++) {
            var rule = this.styles[i], style = rule.style;
            if (style.indexOf(prop) != 0 || rule.context && !context.matchesContext(rule.context) || style.length > prop.length && (style.charCodeAt(prop.length) != 61 || style.slice(prop.length + 1) != value)) continue;
            if (rule.getAttrs) {
              var result = rule.getAttrs(value);
              if (result === false) continue;
              rule.attrs = result || void 0;
            }
            return rule;
          }
        }
      }], [{
        key: "schemaRules",
        value: function schemaRules(schema) {
          var result = [];
          function insert(rule) {
            var priority = rule.priority == null ? 50 : rule.priority, i = 0;
            for (; i < result.length; i++) {
              var next = result[i], nextPriority = next.priority == null ? 50 : next.priority;
              if (nextPriority < priority) break;
            }
            result.splice(i, 0, rule);
          }
          var _loop2 = function _loop22(name2) {
            var rules = schema.marks[name2].spec.parseDOM;
            if (rules) rules.forEach(function(rule) {
              insert(rule = copy(rule));
              if (!(rule.mark || rule.ignore || rule.clearMark)) rule.mark = name2;
            });
          };
          for (var name in schema.marks) {
            _loop2(name);
          }
          var _loop3 = function _loop32(_name32) {
            var rules = schema.nodes[_name32].spec.parseDOM;
            if (rules) rules.forEach(function(rule) {
              insert(rule = copy(rule));
              if (!(rule.node || rule.ignore || rule.mark)) rule.node = _name32;
            });
          };
          for (var _name3 in schema.nodes) {
            _loop3(_name3);
          }
          return result;
        }
      }, {
        key: "fromSchema",
        value: function fromSchema(schema) {
          return schema.cached.domParser || (schema.cached.domParser = new DOMParser2(schema, DOMParser2.schemaRules(schema)));
        }
      }]);
      return DOMParser2;
    })();
    var blockTags = {
      address: true,
      article: true,
      aside: true,
      blockquote: true,
      canvas: true,
      dd: true,
      div: true,
      dl: true,
      fieldset: true,
      figcaption: true,
      figure: true,
      footer: true,
      form: true,
      h1: true,
      h2: true,
      h3: true,
      h4: true,
      h5: true,
      h6: true,
      header: true,
      hgroup: true,
      hr: true,
      li: true,
      noscript: true,
      ol: true,
      output: true,
      p: true,
      pre: true,
      section: true,
      table: true,
      tfoot: true,
      ul: true
    };
    var ignoreTags = {
      head: true,
      noscript: true,
      object: true,
      script: true,
      style: true,
      title: true
    };
    var listTags = {
      ol: true,
      ul: true
    };
    var OPT_PRESERVE_WS = 1;
    var OPT_PRESERVE_WS_FULL = 2;
    var OPT_OPEN_LEFT = 4;
    function wsOptionsFor(type, preserveWhitespace, base) {
      if (preserveWhitespace != null) return (preserveWhitespace ? OPT_PRESERVE_WS : 0) | (preserveWhitespace === "full" ? OPT_PRESERVE_WS_FULL : 0);
      return type && type.whitespace == "pre" ? OPT_PRESERVE_WS | OPT_PRESERVE_WS_FULL : base & ~OPT_OPEN_LEFT;
    }
    var NodeContext = (function() {
      function NodeContext2(type, attrs, marks, solid, match, options) {
        _classCallCheck(this, NodeContext2);
        this.type = type;
        this.attrs = attrs;
        this.marks = marks;
        this.solid = solid;
        this.options = options;
        this.content = [];
        this.activeMarks = Mark.none;
        this.match = match || (options & OPT_OPEN_LEFT ? null : type.contentMatch);
      }
      _createClass(NodeContext2, [{
        key: "findWrapping",
        value: function findWrapping(node) {
          if (!this.match) {
            if (!this.type) return [];
            var fill = this.type.contentMatch.fillBefore(Fragment.from(node));
            if (fill) {
              this.match = this.type.contentMatch.matchFragment(fill);
            } else {
              var start = this.type.contentMatch, wrap;
              if (wrap = start.findWrapping(node.type)) {
                this.match = start;
                return wrap;
              } else {
                return null;
              }
            }
          }
          return this.match.findWrapping(node.type);
        }
      }, {
        key: "finish",
        value: function finish(openEnd) {
          if (!(this.options & OPT_PRESERVE_WS)) {
            var last = this.content[this.content.length - 1], m;
            if (last && last.isText && (m = /[ \t\r\n\u000c]+$/.exec(last.text))) {
              var text = last;
              if (last.text.length == m[0].length) this.content.pop();
              else this.content[this.content.length - 1] = text.withText(text.text.slice(0, text.text.length - m[0].length));
            }
          }
          var content = Fragment.from(this.content);
          if (!openEnd && this.match) content = content.append(this.match.fillBefore(Fragment.empty, true));
          return this.type ? this.type.create(this.attrs, content, this.marks) : content;
        }
      }, {
        key: "inlineContext",
        value: function inlineContext(node) {
          if (this.type) return this.type.inlineContent;
          if (this.content.length) return this.content[0].isInline;
          return node.parentNode && !blockTags.hasOwnProperty(node.parentNode.nodeName.toLowerCase());
        }
      }]);
      return NodeContext2;
    })();
    var ParseContext = (function() {
      function ParseContext2(parser, options, isOpen) {
        _classCallCheck(this, ParseContext2);
        this.parser = parser;
        this.options = options;
        this.isOpen = isOpen;
        this.open = 0;
        this.localPreserveWS = false;
        var topNode = options.topNode, topContext;
        var topOptions = wsOptionsFor(null, options.preserveWhitespace, 0) | (isOpen ? OPT_OPEN_LEFT : 0);
        if (topNode) topContext = new NodeContext(topNode.type, topNode.attrs, Mark.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
        else if (isOpen) topContext = new NodeContext(null, null, Mark.none, true, null, topOptions);
        else topContext = new NodeContext(parser.schema.topNodeType, null, Mark.none, true, null, topOptions);
        this.nodes = [topContext];
        this.find = options.findPositions;
        this.needsBlock = false;
      }
      _createClass(ParseContext2, [{
        key: "top",
        get: function get() {
          return this.nodes[this.open];
        }
      }, {
        key: "addDOM",
        value: function addDOM(dom, marks) {
          if (dom.nodeType == 3) this.addTextNode(dom, marks);
          else if (dom.nodeType == 1) this.addElement(dom, marks);
        }
      }, {
        key: "addTextNode",
        value: function addTextNode(dom, marks) {
          var value = dom.nodeValue;
          var top = this.top, preserveWS = top.options & OPT_PRESERVE_WS_FULL ? "full" : this.localPreserveWS || (top.options & OPT_PRESERVE_WS) > 0;
          if (preserveWS === "full" || top.inlineContext(dom) || /[^ \t\r\n\u000c]/.test(value)) {
            if (!preserveWS) {
              value = value.replace(/[ \t\r\n\u000c]+/g, " ");
              if (/^[ \t\r\n\u000c]/.test(value) && this.open == this.nodes.length - 1) {
                var nodeBefore = top.content[top.content.length - 1];
                var domNodeBefore = dom.previousSibling;
                if (!nodeBefore || domNodeBefore && domNodeBefore.nodeName == "BR" || nodeBefore.isText && /[ \t\r\n\u000c]$/.test(nodeBefore.text)) value = value.slice(1);
              }
            } else if (preserveWS !== "full") {
              value = value.replace(/\r?\n|\r/g, " ");
            } else {
              value = value.replace(/\r\n?/g, "\n");
            }
            if (value) this.insertNode(this.parser.schema.text(value), marks);
            this.findInText(dom);
          } else {
            this.findInside(dom);
          }
        }
      }, {
        key: "addElement",
        value: function addElement(dom, marks, matchAfter) {
          var outerWS = this.localPreserveWS, top = this.top;
          if (dom.tagName == "PRE" || /pre/.test(dom.style && dom.style.whiteSpace)) this.localPreserveWS = true;
          var name = dom.nodeName.toLowerCase(), ruleID;
          if (listTags.hasOwnProperty(name) && this.parser.normalizeLists) normalizeList(dom);
          var rule = this.options.ruleFromNode && this.options.ruleFromNode(dom) || (ruleID = this.parser.matchTag(dom, this, matchAfter));
          out: if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
            this.findInside(dom);
            this.ignoreFallback(dom, marks);
          } else if (!rule || rule.skip || rule.closeParent) {
            if (rule && rule.closeParent) this.open = Math.max(0, this.open - 1);
            else if (rule && rule.skip.nodeType) dom = rule.skip;
            var sync, oldNeedsBlock = this.needsBlock;
            if (blockTags.hasOwnProperty(name)) {
              if (top.content.length && top.content[0].isInline && this.open) {
                this.open--;
                top = this.top;
              }
              sync = true;
              if (!top.type) this.needsBlock = true;
            } else if (!dom.firstChild) {
              this.leafFallback(dom, marks);
              break out;
            }
            var innerMarks = rule && rule.skip ? marks : this.readStyles(dom, marks);
            if (innerMarks) this.addAll(dom, innerMarks);
            if (sync) this.sync(top);
            this.needsBlock = oldNeedsBlock;
          } else {
            var _innerMarks = this.readStyles(dom, marks);
            if (_innerMarks) this.addElementByRule(dom, rule, _innerMarks, rule.consuming === false ? ruleID : void 0);
          }
          this.localPreserveWS = outerWS;
        }
      }, {
        key: "leafFallback",
        value: function leafFallback(dom, marks) {
          if (dom.nodeName == "BR" && this.top.type && this.top.type.inlineContent) this.addTextNode(dom.ownerDocument.createTextNode("\n"), marks);
        }
      }, {
        key: "ignoreFallback",
        value: function ignoreFallback(dom, marks) {
          if (dom.nodeName == "BR" && (!this.top.type || !this.top.type.inlineContent)) this.findPlace(this.parser.schema.text("-"), marks);
        }
      }, {
        key: "readStyles",
        value: function readStyles(dom, marks) {
          var _this3 = this;
          var styles = dom.style;
          if (styles && styles.length) for (var i = 0; i < this.parser.matchedStyles.length; i++) {
            var name = this.parser.matchedStyles[i], value = styles.getPropertyValue(name);
            if (value) {
              var _loop4 = function _loop42(_after) {
                var rule = _this3.parser.matchStyle(name, value, _this3, _after);
                if (!rule) {
                  after = _after;
                  return 0;
                }
                if (rule.ignore) return {
                  v: null
                };
                if (rule.clearMark) marks = marks.filter(function(m) {
                  return !rule.clearMark(m);
                });
                else marks = marks.concat(_this3.parser.schema.marks[rule.mark].create(rule.attrs));
                if (rule.consuming === false) _after = rule;
                else {
                  after = _after;
                  return 0;
                }
                after = _after;
              }, _ret;
              for (var after = void 0; ; ) {
                _ret = _loop4(after);
                if (_ret === 0) break;
                if (_ret) return _ret.v;
              }
            }
          }
          return marks;
        }
      }, {
        key: "addElementByRule",
        value: function addElementByRule(dom, rule, marks, continueAfter) {
          var _this4 = this;
          var sync, nodeType;
          if (rule.node) {
            nodeType = this.parser.schema.nodes[rule.node];
            if (!nodeType.isLeaf) {
              var inner = this.enter(nodeType, rule.attrs || null, marks, rule.preserveWhitespace);
              if (inner) {
                sync = true;
                marks = inner;
              }
            } else if (!this.insertNode(nodeType.create(rule.attrs), marks)) {
              this.leafFallback(dom, marks);
            }
          } else {
            var markType = this.parser.schema.marks[rule.mark];
            marks = marks.concat(markType.create(rule.attrs));
          }
          var startIn = this.top;
          if (nodeType && nodeType.isLeaf) {
            this.findInside(dom);
          } else if (continueAfter) {
            this.addElement(dom, marks, continueAfter);
          } else if (rule.getContent) {
            this.findInside(dom);
            rule.getContent(dom, this.parser.schema).forEach(function(node) {
              return _this4.insertNode(node, marks);
            });
          } else {
            var contentDOM = dom;
            if (typeof rule.contentElement == "string") contentDOM = dom.querySelector(rule.contentElement);
            else if (typeof rule.contentElement == "function") contentDOM = rule.contentElement(dom);
            else if (rule.contentElement) contentDOM = rule.contentElement;
            this.findAround(dom, contentDOM, true);
            this.addAll(contentDOM, marks);
            this.findAround(dom, contentDOM, false);
          }
          if (sync && this.sync(startIn)) this.open--;
        }
      }, {
        key: "addAll",
        value: function addAll(parent, marks, startIndex, endIndex) {
          var index = startIndex || 0;
          for (var dom = startIndex ? parent.childNodes[startIndex] : parent.firstChild, end = endIndex == null ? null : parent.childNodes[endIndex]; dom != end; dom = dom.nextSibling, ++index) {
            this.findAtPoint(parent, index);
            this.addDOM(dom, marks);
          }
          this.findAtPoint(parent, index);
        }
      }, {
        key: "findPlace",
        value: function findPlace(node, marks) {
          var route, sync;
          for (var depth = this.open; depth >= 0; depth--) {
            var cx = this.nodes[depth];
            var _found2 = cx.findWrapping(node);
            if (_found2 && (!route || route.length > _found2.length)) {
              route = _found2;
              sync = cx;
              if (!_found2.length) break;
            }
            if (cx.solid) break;
          }
          if (!route) return null;
          this.sync(sync);
          for (var i = 0; i < route.length; i++) marks = this.enterInner(route[i], null, marks, false);
          return marks;
        }
      }, {
        key: "insertNode",
        value: function insertNode(node, marks) {
          if (node.isInline && this.needsBlock && !this.top.type) {
            var block = this.textblockFromContext();
            if (block) marks = this.enterInner(block, null, marks);
          }
          var innerMarks = this.findPlace(node, marks);
          if (innerMarks) {
            this.closeExtra();
            var top = this.top;
            if (top.match) top.match = top.match.matchType(node.type);
            var nodeMarks = Mark.none;
            var _iterator = _createForOfIteratorHelper(innerMarks.concat(node.marks)), _step;
            try {
              for (_iterator.s(); !(_step = _iterator.n()).done; ) {
                var m = _step.value;
                if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, node.type)) nodeMarks = m.addToSet(nodeMarks);
              }
            } catch (err) {
              _iterator.e(err);
            } finally {
              _iterator.f();
            }
            top.content.push(node.mark(nodeMarks));
            return true;
          }
          return false;
        }
      }, {
        key: "enter",
        value: function enter(type, attrs, marks, preserveWS) {
          var innerMarks = this.findPlace(type.create(attrs), marks);
          if (innerMarks) innerMarks = this.enterInner(type, attrs, marks, true, preserveWS);
          return innerMarks;
        }
      }, {
        key: "enterInner",
        value: function enterInner(type, attrs, marks) {
          var solid = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
          var preserveWS = arguments.length > 4 ? arguments[4] : void 0;
          this.closeExtra();
          var top = this.top;
          top.match = top.match && top.match.matchType(type);
          var options = wsOptionsFor(type, preserveWS, top.options);
          if (top.options & OPT_OPEN_LEFT && top.content.length == 0) options |= OPT_OPEN_LEFT;
          var applyMarks = Mark.none;
          marks = marks.filter(function(m) {
            if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, type)) {
              applyMarks = m.addToSet(applyMarks);
              return false;
            }
            return true;
          });
          this.nodes.push(new NodeContext(type, attrs, applyMarks, solid, null, options));
          this.open++;
          return marks;
        }
      }, {
        key: "closeExtra",
        value: function closeExtra() {
          var openEnd = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
          var i = this.nodes.length - 1;
          if (i > this.open) {
            for (; i > this.open; i--) this.nodes[i - 1].content.push(this.nodes[i].finish(openEnd));
            this.nodes.length = this.open + 1;
          }
        }
      }, {
        key: "finish",
        value: function finish() {
          this.open = 0;
          this.closeExtra(this.isOpen);
          return this.nodes[0].finish(!!(this.isOpen || this.options.topOpen));
        }
      }, {
        key: "sync",
        value: function sync(to) {
          for (var i = this.open; i >= 0; i--) {
            if (this.nodes[i] == to) {
              this.open = i;
              return true;
            } else if (this.localPreserveWS) {
              this.nodes[i].options |= OPT_PRESERVE_WS;
            }
          }
          return false;
        }
      }, {
        key: "currentPos",
        get: function get() {
          this.closeExtra();
          var pos = 0;
          for (var i = this.open; i >= 0; i--) {
            var content = this.nodes[i].content;
            for (var j = content.length - 1; j >= 0; j--) pos += content[j].nodeSize;
            if (i) pos++;
          }
          return pos;
        }
      }, {
        key: "findAtPoint",
        value: function findAtPoint(parent, offset) {
          if (this.find) for (var i = 0; i < this.find.length; i++) {
            if (this.find[i].node == parent && this.find[i].offset == offset) this.find[i].pos = this.currentPos;
          }
        }
      }, {
        key: "findInside",
        value: function findInside(parent) {
          if (this.find) for (var i = 0; i < this.find.length; i++) {
            if (this.find[i].pos == null && parent.nodeType == 1 && parent.contains(this.find[i].node)) this.find[i].pos = this.currentPos;
          }
        }
      }, {
        key: "findAround",
        value: function findAround(parent, content, before) {
          if (parent != content && this.find) for (var i = 0; i < this.find.length; i++) {
            if (this.find[i].pos == null && parent.nodeType == 1 && parent.contains(this.find[i].node)) {
              var pos = content.compareDocumentPosition(this.find[i].node);
              if (pos & (before ? 2 : 4)) this.find[i].pos = this.currentPos;
            }
          }
        }
      }, {
        key: "findInText",
        value: function findInText(textNode) {
          if (this.find) for (var i = 0; i < this.find.length; i++) {
            if (this.find[i].node == textNode) this.find[i].pos = this.currentPos - (textNode.nodeValue.length - this.find[i].offset);
          }
        }
      }, {
        key: "matchesContext",
        value: function matchesContext(context) {
          var _this5 = this;
          if (context.indexOf("|") > -1) return context.split(/\s*\|\s*/).some(this.matchesContext, this);
          var parts = context.split("/");
          var option = this.options.context;
          var useRoot = !this.isOpen && (!option || option.parent.type == this.nodes[0].type);
          var minDepth = -(option ? option.depth + 1 : 0) + (useRoot ? 0 : 1);
          var match = function match2(i, depth) {
            for (; i >= 0; i--) {
              var part = parts[i];
              if (part == "") {
                if (i == parts.length - 1 || i == 0) continue;
                for (; depth >= minDepth; depth--) if (match2(i - 1, depth)) return true;
                return false;
              } else {
                var next = depth > 0 || depth == 0 && useRoot ? _this5.nodes[depth].type : option && depth >= minDepth ? option.node(depth - minDepth).type : null;
                if (!next || next.name != part && !next.isInGroup(part)) return false;
                depth--;
              }
            }
            return true;
          };
          return match(parts.length - 1, this.open);
        }
      }, {
        key: "textblockFromContext",
        value: function textblockFromContext() {
          var $context = this.options.context;
          if ($context) for (var d = $context.depth; d >= 0; d--) {
            var deflt = $context.node(d).contentMatchAt($context.indexAfter(d)).defaultType;
            if (deflt && deflt.isTextblock && deflt.defaultAttrs) return deflt;
          }
          for (var name in this.parser.schema.nodes) {
            var type = this.parser.schema.nodes[name];
            if (type.isTextblock && type.defaultAttrs) return type;
          }
        }
      }]);
      return ParseContext2;
    })();
    function normalizeList(dom) {
      for (var child = dom.firstChild, prevItem = null; child; child = child.nextSibling) {
        var name = child.nodeType == 1 ? child.nodeName.toLowerCase() : null;
        if (name && listTags.hasOwnProperty(name) && prevItem) {
          prevItem.appendChild(child);
          child = prevItem;
        } else if (name == "li") {
          prevItem = child;
        } else if (name) {
          prevItem = null;
        }
      }
    }
    function matches(dom, selector) {
      return (dom.matches || dom.msMatchesSelector || dom.webkitMatchesSelector || dom.mozMatchesSelector).call(dom, selector);
    }
    function copy(obj) {
      var copy2 = {};
      for (var prop in obj) copy2[prop] = obj[prop];
      return copy2;
    }
    function markMayApply(markType, nodeType) {
      var nodes = nodeType.schema.nodes;
      var _loop5 = function _loop52() {
        var parent = nodes[name];
        if (!parent.allowsMarkType(markType)) return 0;
        var seen = [], scan = function scan2(match) {
          seen.push(match);
          for (var i = 0; i < match.edgeCount; i++) {
            var _match$edge = match.edge(i), type = _match$edge.type, next = _match$edge.next;
            if (type == nodeType) return true;
            if (seen.indexOf(next) < 0 && scan2(next)) return true;
          }
        };
        if (scan(parent.contentMatch)) return {
          v: true
        };
      }, _ret2;
      for (var name in nodes) {
        _ret2 = _loop5();
        if (_ret2 === 0) continue;
        if (_ret2) return _ret2.v;
      }
    }
    var DOMSerializer = (function() {
      function DOMSerializer2(nodes, marks) {
        _classCallCheck(this, DOMSerializer2);
        this.nodes = nodes;
        this.marks = marks;
      }
      _createClass(DOMSerializer2, [{
        key: "serializeFragment",
        value: function serializeFragment(fragment) {
          var _this6 = this;
          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          var target = arguments.length > 2 ? arguments[2] : void 0;
          if (!target) target = doc(options).createDocumentFragment();
          var top = target, active = [];
          fragment.forEach(function(node) {
            if (active.length || node.marks.length) {
              var keep = 0, rendered = 0;
              while (keep < active.length && rendered < node.marks.length) {
                var next = node.marks[rendered];
                if (!_this6.marks[next.type.name]) {
                  rendered++;
                  continue;
                }
                if (!next.eq(active[keep][0]) || next.type.spec.spanning === false) break;
                keep++;
                rendered++;
              }
              while (keep < active.length) top = active.pop()[1];
              while (rendered < node.marks.length) {
                var add = node.marks[rendered++];
                var markDOM = _this6.serializeMark(add, node.isInline, options);
                if (markDOM) {
                  active.push([add, top]);
                  top.appendChild(markDOM.dom);
                  top = markDOM.contentDOM || markDOM.dom;
                }
              }
            }
            top.appendChild(_this6.serializeNodeInner(node, options));
          });
          return target;
        }
      }, {
        key: "serializeNodeInner",
        value: function serializeNodeInner(node, options) {
          var _renderSpec2 = _renderSpec(doc(options), this.nodes[node.type.name](node), null, node.attrs), dom = _renderSpec2.dom, contentDOM = _renderSpec2.contentDOM;
          if (contentDOM) {
            if (node.isLeaf) throw new RangeError("Content hole not allowed in a leaf node spec");
            this.serializeFragment(node.content, options, contentDOM);
          }
          return dom;
        }
      }, {
        key: "serializeNode",
        value: function serializeNode(node) {
          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          var dom = this.serializeNodeInner(node, options);
          for (var i = node.marks.length - 1; i >= 0; i--) {
            var wrap = this.serializeMark(node.marks[i], node.isInline, options);
            if (wrap) {
              (wrap.contentDOM || wrap.dom).appendChild(dom);
              dom = wrap.dom;
            }
          }
          return dom;
        }
      }, {
        key: "serializeMark",
        value: function serializeMark(mark, inline) {
          var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
          var toDOM = this.marks[mark.type.name];
          return toDOM && _renderSpec(doc(options), toDOM(mark, inline), null, mark.attrs);
        }
      }], [{
        key: "renderSpec",
        value: function renderSpec(doc2, structure) {
          var xmlNS = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
          var blockArraysIn = arguments.length > 3 ? arguments[3] : void 0;
          return _renderSpec(doc2, structure, xmlNS, blockArraysIn);
        }
      }, {
        key: "fromSchema",
        value: function fromSchema(schema) {
          return schema.cached.domSerializer || (schema.cached.domSerializer = new DOMSerializer2(this.nodesFromSchema(schema), this.marksFromSchema(schema)));
        }
      }, {
        key: "nodesFromSchema",
        value: function nodesFromSchema(schema) {
          var result = gatherToDOM(schema.nodes);
          if (!result.text) result.text = function(node) {
            return node.text;
          };
          return result;
        }
      }, {
        key: "marksFromSchema",
        value: function marksFromSchema(schema) {
          return gatherToDOM(schema.marks);
        }
      }]);
      return DOMSerializer2;
    })();
    function gatherToDOM(obj) {
      var result = {};
      for (var name in obj) {
        var toDOM = obj[name].spec.toDOM;
        if (toDOM) result[name] = toDOM;
      }
      return result;
    }
    function doc(options) {
      return options.document || window.document;
    }
    var suspiciousAttributeCache = /* @__PURE__ */ new WeakMap();
    function suspiciousAttributes(attrs) {
      var value = suspiciousAttributeCache.get(attrs);
      if (value === void 0) suspiciousAttributeCache.set(attrs, value = suspiciousAttributesInner(attrs));
      return value;
    }
    function suspiciousAttributesInner(attrs) {
      var result = null;
      function scan(value) {
        if (value && _typeof(value) == "object") {
          if (Array.isArray(value)) {
            if (typeof value[0] == "string") {
              if (!result) result = [];
              result.push(value);
            } else {
              for (var i = 0; i < value.length; i++) scan(value[i]);
            }
          } else {
            for (var prop in value) scan(value[prop]);
          }
        }
      }
      scan(attrs);
      return result;
    }
    function _renderSpec(doc2, structure, xmlNS, blockArraysIn) {
      if (typeof structure == "string") return {
        dom: doc2.createTextNode(structure)
      };
      if (structure.nodeType != null) return {
        dom: structure
      };
      if (structure.dom && structure.dom.nodeType != null) return structure;
      var tagName = structure[0], suspicious;
      if (typeof tagName != "string") throw new RangeError("Invalid array passed to renderSpec");
      if (blockArraysIn && (suspicious = suspiciousAttributes(blockArraysIn)) && suspicious.indexOf(structure) > -1) throw new RangeError("Using an array from an attribute object as a DOM spec. This may be an attempted cross site scripting attack.");
      var space = tagName.indexOf(" ");
      if (space > 0) {
        xmlNS = tagName.slice(0, space);
        tagName = tagName.slice(space + 1);
      }
      var contentDOM;
      var dom = xmlNS ? doc2.createElementNS(xmlNS, tagName) : doc2.createElement(tagName);
      var attrs = structure[1], start = 1;
      if (attrs && _typeof(attrs) == "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
        start = 2;
        for (var name in attrs) if (attrs[name] != null) {
          var _space = name.indexOf(" ");
          if (_space > 0) dom.setAttributeNS(name.slice(0, _space), name.slice(_space + 1), attrs[name]);
          else dom.setAttribute(name, attrs[name]);
        }
      }
      for (var i = start; i < structure.length; i++) {
        var child = structure[i];
        if (child === 0) {
          if (i < structure.length - 1 || i > start) throw new RangeError("Content hole must be the only child of its parent node");
          return {
            dom,
            contentDOM: dom
          };
        } else {
          var _renderSpec3 = _renderSpec(doc2, child, xmlNS, blockArraysIn), inner = _renderSpec3.dom, innerContent = _renderSpec3.contentDOM;
          dom.appendChild(inner);
          if (innerContent) {
            if (contentDOM) throw new RangeError("Multiple content holes");
            contentDOM = innerContent;
          }
        }
      }
      return {
        dom,
        contentDOM
      };
    }
    exports2.ContentMatch = ContentMatch;
    exports2.DOMParser = DOMParser;
    exports2.DOMSerializer = DOMSerializer;
    exports2.Fragment = Fragment;
    exports2.Mark = Mark;
    exports2.MarkType = MarkType;
    exports2.Node = Node2;
    exports2.NodeRange = NodeRange;
    exports2.NodeType = NodeType;
    exports2.ReplaceError = ReplaceError;
    exports2.ResolvedPos = ResolvedPos;
    exports2.Schema = Schema;
    exports2.Slice = Slice;
  }
});

// node_modules/@atlaskit/editor-prosemirror/dist/cjs/model.js
var require_model = __commonJS({
  "node_modules/@atlaskit/editor-prosemirror/dist/cjs/model.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "ContentMatch", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.ContentMatch;
      }
    });
    Object.defineProperty(exports2, "DOMParser", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.DOMParser;
      }
    });
    Object.defineProperty(exports2, "DOMSerializer", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.DOMSerializer;
      }
    });
    Object.defineProperty(exports2, "Fragment", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.Fragment;
      }
    });
    Object.defineProperty(exports2, "Mark", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.Mark;
      }
    });
    Object.defineProperty(exports2, "MarkType", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.MarkType;
      }
    });
    Object.defineProperty(exports2, "Node", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.Node;
      }
    });
    Object.defineProperty(exports2, "NodeRange", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.NodeRange;
      }
    });
    Object.defineProperty(exports2, "NodeType", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.NodeType;
      }
    });
    Object.defineProperty(exports2, "ReplaceError", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.ReplaceError;
      }
    });
    Object.defineProperty(exports2, "ResolvedPos", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.ResolvedPos;
      }
    });
    Object.defineProperty(exports2, "Schema", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.Schema;
      }
    });
    Object.defineProperty(exports2, "Slice", {
      enumerable: true,
      get: function get() {
        return _prosemirrorModel.Slice;
      }
    });
    var _prosemirrorModel = require_dist2();
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/code-block.js
var require_code_block = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/code-block.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.toJSON = exports2.codeBlockWithLocalId = exports2.codeBlock = void 0;
    var _model = require_model();
    var _nodeTypes = require_nodeTypes();
    var _utils = require_utils();
    var getLanguageFromEditorStyle = function getLanguageFromEditorStyle2(dom) {
      return dom.getAttribute("data-language") || void 0;
    };
    var getLanguageFromBitbucketStyle = function getLanguageFromBitbucketStyle2(dom) {
      if (dom && dom.classList.contains("codehilite")) {
        return extractLanguageFromClass(dom.className);
      }
      return;
    };
    var getLanguageFromCode = function getLanguageFromCode2(dom) {
      var firstChild = dom.firstElementChild;
      if (firstChild && firstChild.nodeName === "CODE") {
        return firstChild.getAttribute("data-language") || void 0;
      }
    };
    var extractLanguageFromClass = function extractLanguageFromClass2(className) {
      var languageRegex = /(?:^|\s)language-([^\s]+)/;
      var result = languageRegex.exec(className);
      if (result && result[1]) {
        return result[1];
      }
      return;
    };
    var removeLastNewLine = function removeLastNewLine2(dom) {
      var parent = dom && dom.parentElement;
      if (parent && parent.classList.contains("codehilite")) {
        dom.textContent = dom.textContent.replace(/\n$/, "");
      }
      return dom;
    };
    function parseCodeFromHtml(node) {
      var code = "";
      node.childNodes.forEach(function(child) {
        if (child.nodeType === Node.TEXT_NODE) {
          code += child.nodeValue;
        } else if (child.nodeType === Node.ELEMENT_NODE && child instanceof Element) {
          var tagName = child.tagName.toLowerCase();
          if (tagName === "div" || tagName === "p") {
            if (child.previousElementSibling !== null) {
              code += "\n";
            }
          }
          if (tagName === "br") {
            code += "\n";
          } else {
            code += parseCodeFromHtml(child);
          }
        }
      });
      return code;
    }
    var codeBlock = exports2.codeBlock = (0, _nodeTypes.codeBlock)({
      parseDOM: [
        {
          tag: "pre",
          preserveWhitespace: "full",
          getAttrs: function getAttrs(domNode) {
            var dom = domNode;
            var language = getLanguageFromBitbucketStyle(dom.parentElement) || getLanguageFromEditorStyle(dom.parentElement) || getLanguageFromCode(dom) || dom.getAttribute("data-language");
            dom = removeLastNewLine(dom);
            return {
              language
            };
          }
        },
        // Handle VSCode, Android Studio paste
        // Checking `white-space: pre-wrap` is too aggressive @see ED-2627
        {
          tag: "div[style]",
          preserveWhitespace: "full",
          getAttrs: function getAttrs(domNode) {
            var dom = domNode;
            if (dom.style.whiteSpace === "pre" || dom.style.fontFamily && dom.style.fontFamily.toLowerCase().indexOf("monospace") > -1) {
              return {};
            }
            return false;
          },
          getContent: function getContent(domNode, schema) {
            var code = parseCodeFromHtml(domNode);
            return code ? _model.Fragment.from(schema.text(code)) : _model.Fragment.empty;
          }
        },
        // Handle GitHub/Gist paste
        {
          tag: "table[style]",
          preserveWhitespace: "full",
          getAttrs: function getAttrs(dom) {
            if (dom.querySelector('td[class*="blob-code"]')) {
              return {};
            }
            return false;
          }
        },
        {
          tag: "div.code-block",
          preserveWhitespace: "full",
          getAttrs: function getAttrs(domNode) {
            var dom = domNode;
            var lineNumber = dom.querySelectorAll(".react-syntax-highlighter-line-number");
            if (lineNumber.length > 0) {
              lineNumber.forEach(function(line) {
                return line.remove();
              });
            }
            return {};
          }
        }
      ],
      toDOM: function toDOM(node) {
        return ["pre", ["code", {
          "data-language": node.attrs.language
        }, 0]];
      }
    });
    var toJSON = exports2.toJSON = function toJSON2(node) {
      return {
        attrs: Object.keys(node.attrs).reduce(function(memo, key) {
          if (key === "uniqueId") {
            return memo;
          }
          if (key === "language" && node.attrs.language === null) {
            return memo;
          }
          memo[key] = node.attrs[key];
          return memo;
        }, {})
      };
    };
    var codeBlockWithLocalId = exports2.codeBlockWithLocalId = (0, _nodeTypes.codeBlock)({
      parseDOM: [
        {
          tag: "pre",
          preserveWhitespace: "full",
          getAttrs: function getAttrs(domNode) {
            var dom = domNode;
            var language = getLanguageFromBitbucketStyle(dom.parentElement) || getLanguageFromEditorStyle(dom.parentElement) || getLanguageFromCode(dom) || dom.getAttribute("data-language");
            dom = removeLastNewLine(dom);
            return {
              language,
              localId: _utils.uuid.generate()
            };
          }
        },
        // Handle VSCode, Android Studio paste
        // Checking `white-space: pre-wrap` is too aggressive @see ED-2627
        {
          tag: "div[style]",
          preserveWhitespace: "full",
          getAttrs: function getAttrs(domNode) {
            var dom = domNode;
            if (dom.style.whiteSpace === "pre" || dom.style.fontFamily && dom.style.fontFamily.toLowerCase().indexOf("monospace") > -1) {
              return {};
            }
            return false;
          },
          getContent: function getContent(domNode, schema) {
            var code = parseCodeFromHtml(domNode);
            return code ? _model.Fragment.from(schema.text(code)) : _model.Fragment.empty;
          }
        },
        // Handle GitHub/Gist paste
        {
          tag: "table[style]",
          preserveWhitespace: "full",
          getAttrs: function getAttrs(dom) {
            if (dom.querySelector('td[class*="blob-code"]')) {
              return {};
            }
            return false;
          }
        },
        {
          tag: "div.code-block",
          preserveWhitespace: "full",
          getAttrs: function getAttrs(domNode) {
            var dom = domNode;
            var lineNumber = dom.querySelectorAll(".react-syntax-highlighter-line-number");
            if (lineNumber.length > 0) {
              lineNumber.forEach(function(line) {
                return line.remove();
              });
            }
            return {};
          }
        }
      ],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var attrs = {
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        };
        return ["pre", attrs, ["code", {
          "data-language": node.attrs.language
        }, 0]];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/hard-break.js
var require_hard_break = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/hard-break.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.hardBreak = void 0;
    var _nodeTypes = require_nodeTypes();
    var hardBreak = exports2.hardBreak = (0, _nodeTypes.hardBreak)({
      parseDOM: [{
        tag: "br"
      }],
      toDOM: function toDOM() {
        return ["br"];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/heading.js
var require_heading = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/heading.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.heading = void 0;
    var _nodeTypes = require_nodeTypes();
    var getAttrs = function getAttrs2(level) {
      return function(domNode) {
        var _heading$attrs, _heading$attrs$localI;
        return {
          level,
          localId: domNode.getAttribute("data-local-id") || ((_heading$attrs = heading.attrs) === null || _heading$attrs === void 0 ? void 0 : (_heading$attrs$localI = _heading$attrs.localId) === null || _heading$attrs$localI === void 0 ? void 0 : _heading$attrs$localI.default)
        };
      };
    };
    var heading = exports2.heading = (0, _nodeTypes.heading)({
      parseDOM: [{
        tag: "h1",
        getAttrs: getAttrs(1)
      }, {
        tag: "h2",
        getAttrs: getAttrs(2)
      }, {
        tag: "h3",
        getAttrs: getAttrs(3)
      }, {
        tag: "h4",
        getAttrs: getAttrs(4)
      }, {
        tag: "h5",
        getAttrs: getAttrs(5)
      }, {
        tag: "h6",
        getAttrs: getAttrs(6)
      }],
      toDOM: function toDOM(node) {
        var _node$attrs = node.attrs, level = _node$attrs.level, localId = _node$attrs.localId;
        var name = "h" + level;
        var attrs = localId !== void 0 && localId !== null ? [{
          "data-local-id": localId
        }] : [];
        return [name].concat(attrs, [0]);
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/rule.js
var require_rule = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/rule.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.ruleWithLocalId = exports2.rule = void 0;
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    var hrDOM = ["hr"];
    var rule = exports2.rule = (0, _nodeTypes.rule)({
      parseDOM: [{
        tag: "hr"
      }],
      toDOM: function toDOM() {
        return hrDOM;
      }
    });
    var ruleWithLocalId = exports2.ruleWithLocalId = (0, _nodeTypes.rule)({
      parseDOM: [{
        tag: "hr",
        getAttrs: function getAttrs() {
          return {
            localId: _uuid.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        return ["hr", {
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        }];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/ordered-list.js
var require_ordered_list = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/ordered-list.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.orderedListWithOrderAndLocalId = exports2.orderedListWithOrder = exports2.orderedListWithLocalId = exports2.orderedListSelector = exports2.orderedList = void 0;
    var _utils = require_utils();
    var _nodeTypes = require_nodeTypes();
    var orderedListSelector = exports2.orderedListSelector = ".ak-ol";
    var orderedList = exports2.orderedList = (0, _nodeTypes.orderedList)({
      parseDOM: [{
        tag: "ol"
      }],
      toDOM: function toDOM() {
        var attrs = {
          class: orderedListSelector.substr(1)
        };
        return ["ol", attrs, 0];
      }
    });
    var orderedListWithLocalId = exports2.orderedListWithLocalId = (0, _nodeTypes.orderedList)({
      parseDOM: [{
        tag: "ol",
        getAttrs: function getAttrs() {
          return {
            localId: _utils.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var attrs = {
          class: orderedListSelector.substr(1),
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        };
        return ["ol", attrs, 0];
      }
    });
    var resolveStart = function resolveStart2(start) {
      var num = Number(start);
      if (Number.isNaN(num)) {
        return;
      }
      if (num < 0) {
        return;
      }
      return Math.floor(Math.max(num, 0));
    };
    var orderedListWithOrder = exports2.orderedListWithOrder = (0, _nodeTypes.orderedList)({
      parseDOM: [{
        tag: "ol",
        getAttrs: function getAttrs(domNode) {
          var dom = domNode;
          var startDOMAttr = dom.getAttribute("start");
          if (startDOMAttr) {
            var start = resolveStart(startDOMAttr);
            if (typeof start === "number") {
              return {
                order: start
              };
            }
          }
          return null;
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs2;
        var start = resolveStart(node === null || node === void 0 ? void 0 : (_node$attrs2 = node.attrs) === null || _node$attrs2 === void 0 ? void 0 : _node$attrs2.order);
        var attrs = {
          start: typeof start === "number" ? String(start) : void 0,
          class: orderedListSelector.substr(1)
        };
        return ["ol", attrs, 0];
      }
    });
    var orderedListWithOrderAndLocalId = exports2.orderedListWithOrderAndLocalId = (0, _nodeTypes.orderedList)({
      parseDOM: [{
        tag: "ol",
        getAttrs: function getAttrs(domNode) {
          var dom = domNode;
          var startDOMAttr = dom.getAttribute("start");
          var localId = _utils.uuid.generate();
          if (startDOMAttr) {
            var start = resolveStart(startDOMAttr);
            if (typeof start === "number") {
              return {
                order: start,
                localId
              };
            }
          }
          return {
            localId
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs3, _node$attrs4;
        var start = resolveStart(node === null || node === void 0 ? void 0 : (_node$attrs3 = node.attrs) === null || _node$attrs3 === void 0 ? void 0 : _node$attrs3.order);
        var attrs = {
          start: typeof start === "number" ? String(start) : void 0,
          class: orderedListSelector.substr(1),
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs4 = node.attrs) === null || _node$attrs4 === void 0 ? void 0 : _node$attrs4.localId) || void 0
        };
        return ["ol", attrs, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/paragraph.js
var require_paragraph = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/paragraph.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.paragraph = void 0;
    var _nodeTypes = require_nodeTypes();
    var paragraph = exports2.paragraph = (0, _nodeTypes.paragraph)({
      parseDOM: [{
        tag: "p",
        getAttrs: function getAttrs(domNode) {
          var _paragraph$attrs, _paragraph$attrs$loca;
          var dom = domNode;
          var attrs = {
            localId: dom.getAttribute("data-local-id") || ((_paragraph$attrs = paragraph.attrs) === null || _paragraph$attrs === void 0 ? void 0 : (_paragraph$attrs$loca = _paragraph$attrs.localId) === null || _paragraph$attrs$loca === void 0 ? void 0 : _paragraph$attrs$loca.default)
          };
          return attrs;
        }
      }],
      toDOM: function toDOM(node) {
        var localId = node.attrs.localId;
        var name = "p";
        var attrs = localId !== void 0 && localId !== null ? [{
          "data-local-id": localId
        }] : [];
        return [name].concat(attrs, [0]);
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/emoji.js
var require_emoji2 = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/emoji.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.emojiWithLocalId = exports2.emoji = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _emoji = require_emoji();
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var emoji = exports2.emoji = (0, _nodeTypes.emoji)({
      parseDOM: [
        // Handle copy/paste beautiful panel from renderer />
        {
          tag: "div.ak-editor-panel__icon span",
          ignore: true
        },
        {
          tag: "span[data-emoji-short-name]",
          getAttrs: function getAttrs(domNode) {
            var dom = domNode;
            return {
              shortName: dom.getAttribute("data-emoji-short-name") || emoji.attrs.shortName.default,
              id: dom.getAttribute("data-emoji-id") || emoji.attrs.id.default,
              text: dom.getAttribute("data-emoji-text") || emoji.attrs.text.default
            };
          }
        },
        // Handle copy/paste from old <ac:emoticon />
        {
          tag: "img[data-emoticon-name]",
          getAttrs: function getAttrs(dom) {
            return (0, _emoji.acNameToEmoji)(dom.getAttribute("data-emoticon-name"));
          }
        },
        // Handle copy/paste from old <ac:hipchat-emoticons />
        {
          tag: "img[data-hipchat-emoticon]",
          getAttrs: function getAttrs(dom) {
            return (0, _emoji.acShortcutToEmoji)(dom.getAttribute("data-hipchat-emoticon"));
          }
        },
        // Handle copy/paste from bitbucket's <img class="emoji" />
        {
          tag: "img.emoji[data-emoji-short-name]",
          getAttrs: function getAttrs(domNode) {
            var dom = domNode;
            return {
              shortName: dom.getAttribute("data-emoji-short-name") || emoji.attrs.shortName.default,
              id: dom.getAttribute("data-emoji-id") || emoji.attrs.id.default,
              text: dom.getAttribute("data-emoji-text") || emoji.attrs.text.default
            };
          }
        }
      ],
      toDOM: function toDOM(node) {
        var _node$attrs = node.attrs, shortName = _node$attrs.shortName, id = _node$attrs.id, text = _node$attrs.text;
        var attrs = {
          "data-emoji-short-name": shortName,
          "data-emoji-id": id,
          "data-emoji-text": text,
          contenteditable: "false"
        };
        return ["span", attrs, text];
      }
    });
    var emojiWithLocalId = exports2.emojiWithLocalId = (0, _nodeTypes.emoji)({
      parseDOM: [
        // Handle copy/paste beautiful panel from renderer />
        {
          tag: "div.ak-editor-panel__icon span",
          ignore: true
        },
        {
          tag: "span[data-emoji-short-name]",
          getAttrs: function getAttrs(domNode) {
            var dom = domNode;
            return {
              shortName: dom.getAttribute("data-emoji-short-name") || emoji.attrs.shortName.default,
              id: dom.getAttribute("data-emoji-id") || emoji.attrs.id.default,
              text: dom.getAttribute("data-emoji-text") || emoji.attrs.text.default,
              localId: _uuid.uuid.generate()
            };
          }
        },
        // Handle copy/paste from old <ac:emoticon />
        {
          tag: "img[data-emoticon-name]",
          getAttrs: function getAttrs(dom) {
            var attrs = (0, _emoji.acNameToEmoji)(dom.getAttribute("data-emoticon-name"));
            return _objectSpread(_objectSpread({}, attrs), {}, {
              localId: _uuid.uuid.generate()
            });
          }
        },
        // Handle copy/paste from old <ac:hipchat-emoticons />
        {
          tag: "img[data-hipchat-emoticon]",
          getAttrs: function getAttrs(dom) {
            var attrs = (0, _emoji.acShortcutToEmoji)(dom.getAttribute("data-hipchat-emoticon"));
            return _objectSpread(_objectSpread({}, attrs), {}, {
              localId: _uuid.uuid.generate()
            });
          }
        },
        // Handle copy/paste from bitbucket's <img class="emoji" />
        {
          tag: "img.emoji[data-emoji-short-name]",
          getAttrs: function getAttrs(domNode) {
            var dom = domNode;
            return {
              shortName: dom.getAttribute("data-emoji-short-name") || emoji.attrs.shortName.default,
              id: dom.getAttribute("data-emoji-id") || emoji.attrs.id.default,
              text: dom.getAttribute("data-emoji-text") || emoji.attrs.text.default,
              localId: _uuid.uuid.generate()
            };
          }
        }
      ],
      toDOM: function toDOM(node) {
        var _node$attrs3;
        var _node$attrs2 = node.attrs, shortName = _node$attrs2.shortName, id = _node$attrs2.id, text = _node$attrs2.text;
        var attrs = {
          "data-emoji-short-name": shortName,
          "data-emoji-id": id,
          "data-emoji-text": text,
          contenteditable: "false",
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs3 = node.attrs) === null || _node$attrs3 === void 0 ? void 0 : _node$attrs3.localId) || void 0
        };
        return ["span", attrs, text];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/image.js
var require_image = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/image.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.image = void 0;
    var _nodeTypes = require_nodeTypes();
    var image = exports2.image = (0, _nodeTypes.image)({
      parseDOM: [{
        tag: 'img[src^="data:image/"]',
        ignore: true
      }, {
        tag: "img[src]",
        getAttrs: function getAttrs(domNode) {
          var dom = domNode;
          return {
            src: dom.getAttribute("src"),
            alt: dom.getAttribute("alt"),
            title: dom.getAttribute("title")
          };
        }
      }],
      toDOM: function toDOM(node) {
        return ["img", node.attrs];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/mention.js
var require_mention = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/mention.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.toJSON = exports2.mention = exports2.USER_TYPES = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _utils = require_utils();
    var _nodeTypes = require_nodeTypes();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var USER_TYPES = exports2.USER_TYPES = /* @__PURE__ */ (function(USER_TYPES2) {
      USER_TYPES2["DEFAULT"] = "DEFAULT";
      USER_TYPES2["SPECIAL"] = "SPECIAL";
      USER_TYPES2["APP"] = "APP";
      return USER_TYPES2;
    })({});
    var mention = exports2.mention = (0, _nodeTypes.mention)({
      parseDOM: [{
        tag: "span[data-mention-id]",
        getAttrs: function getAttrs(domNode) {
          var dom = domNode;
          var attrs = {
            id: dom.getAttribute("data-mention-id") || mention.attrs.id.default,
            text: dom.textContent || mention.attrs.text.default,
            accessLevel: dom.getAttribute("data-access-level") || mention.attrs.accessLevel.default,
            localId: _utils.uuid.generate()
          };
          var userType = dom.getAttribute("data-user-type");
          if (USER_TYPES[userType]) {
            attrs.userType = userType;
          }
          return attrs;
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs = node.attrs, id = _node$attrs.id, accessLevel = _node$attrs.accessLevel, text = _node$attrs.text, userType = _node$attrs.userType, localId = _node$attrs.localId;
        var attrs = {
          "data-mention-id": id,
          "data-access-level": accessLevel,
          contenteditable: "false"
        };
        if (localId) {
          attrs["data-local-id"] = localId;
        }
        if (userType) {
          attrs["data-user-type"] = userType;
        }
        return ["span", attrs, text];
      }
    });
    var isOptional = function isOptional2(key) {
      return ["userType", "localId"].indexOf(key) > -1;
    };
    var toJSON = exports2.toJSON = function toJSON2(node) {
      return {
        attrs: Object.keys(node.attrs).reduce(function(obj, key) {
          if (isOptional(key) && !node.attrs[key]) {
            return obj;
          }
          return _objectSpread(_objectSpread({}, obj), {}, (0, _defineProperty2.default)({}, key, node.attrs[key]));
        }, {})
      };
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/list-item.js
var require_list_item = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/list-item.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.listItemWithNestedDecisionAndLocalIdStage0 = exports2.listItemWithLocalId = exports2.listItemWithDecisionStage0 = exports2.listItem = void 0;
    var _utils = require_utils();
    var _nodeTypes = require_nodeTypes();
    var listItem = exports2.listItem = (0, _nodeTypes.listItem)({
      parseDOM: [{
        tag: "li"
      }],
      toDOM: function toDOM() {
        return ["li", 0];
      }
    });
    var listItemWithLocalId = exports2.listItemWithLocalId = (0, _nodeTypes.listItem)({
      parseDOM: [{
        tag: "li",
        getAttrs: function getAttrs() {
          return {
            localId: _utils.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        return ["li", {
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        }, 0];
      }
    });
    var listItemWithDecisionStage0 = exports2.listItemWithDecisionStage0 = (0, _nodeTypes.listItemWithNestedDecisionStage0)({
      parseDOM: [{
        tag: "li"
      }],
      toDOM: function toDOM() {
        return ["li", 0];
      }
    });
    var listItemWithNestedDecisionAndLocalIdStage0 = exports2.listItemWithNestedDecisionAndLocalIdStage0 = (0, _nodeTypes.listItemWithNestedDecisionStage0)({
      parseDOM: [{
        tag: "li",
        getAttrs: function getAttrs() {
          return {
            localId: _utils.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs2;
        return ["li", {
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs2 = node.attrs) === null || _node$attrs2 === void 0 ? void 0 : _node$attrs2.localId) || void 0
        }, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/panel.js
var require_panel = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/panel.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.extendedPanelWithLocalId = exports2.extendedPanel = exports2.PanelType = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var PanelType = exports2.PanelType = /* @__PURE__ */ (function(PanelType2) {
      PanelType2["INFO"] = "info";
      PanelType2["NOTE"] = "note";
      PanelType2["TIP"] = "tip";
      PanelType2["WARNING"] = "warning";
      PanelType2["ERROR"] = "error";
      PanelType2["SUCCESS"] = "success";
      PanelType2["CUSTOM"] = "custom";
      return PanelType2;
    })({});
    var getDomAttrs = function getDomAttrs2(nodeAttrs) {
      var attrs = {
        "data-panel-type": nodeAttrs.panelType,
        "data-panel-icon": nodeAttrs.panelIcon,
        "data-panel-icon-id": nodeAttrs.panelIconId,
        "data-panel-icon-text": nodeAttrs.panelIconText,
        "data-panel-color": nodeAttrs.panelColor,
        "data-local-id": (nodeAttrs === null || nodeAttrs === void 0 ? void 0 : nodeAttrs.localId) || void 0
      };
      return attrs;
    };
    var getParseDOMAttrs = function getParseDOMAttrs2(allowCustomPanel, dom, generateLocalId) {
      var parseDOMAttrs = {
        panelType: dom.getAttribute("data-panel-type")
      };
      if (generateLocalId) {
        parseDOMAttrs.localId = _uuid.uuid.generate();
      }
      if (allowCustomPanel) {
        parseDOMAttrs = _objectSpread(_objectSpread({}, parseDOMAttrs), {}, {
          panelIcon: dom.getAttribute("data-panel-icon"),
          panelIconId: dom.getAttribute("data-panel-icon-id"),
          panelIconText: dom.getAttribute("data-panel-icon-text"),
          panelColor: dom.getAttribute("data-panel-color")
        });
      } else {
        parseDOMAttrs.panelType = parseDOMAttrs.panelType === PanelType.CUSTOM ? PanelType.INFO : parseDOMAttrs.panelType;
      }
      return parseDOMAttrs;
    };
    var createPanelNodeSpecOptions = function createPanelNodeSpecOptions2(allowCustomPanel, generateLocalId) {
      return {
        parseDOM: [{
          tag: "div[data-panel-type]",
          getAttrs: function getAttrs(dom) {
            return getParseDOMAttrs(allowCustomPanel, dom, generateLocalId);
          }
        }],
        toDOM: function toDOM(node) {
          var attrs = getDomAttrs(node.attrs);
          var contentAttrs = {
            "data-panel-content": "true"
          };
          return ["div", attrs, ["div", contentAttrs, 0]];
        }
      };
    };
    var extendedPanel = exports2.extendedPanel = function extendedPanel2(allowCustomPanel) {
      return (0, _nodeTypes.panel)(createPanelNodeSpecOptions(allowCustomPanel));
    };
    var extendedPanelWithLocalId = exports2.extendedPanelWithLocalId = function extendedPanelWithLocalId2(allowCustomPanel) {
      return (0, _nodeTypes.panel)(createPanelNodeSpecOptions(allowCustomPanel, true));
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/text.js
var require_text = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/text.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.text = void 0;
    var _nodeTypes = require_nodeTypes();
    var text = exports2.text = (0, _nodeTypes.text)({
      toDebugString: process.env.NODE_ENV !== "production" ? void 0 : function() {
        return "text_node";
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/unknown-block.js
var require_unknown_block = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/unknown-block.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = void 0;
    var name = "unknownBlock";
    var _default = exports2.default = {
      group: "block",
      content: "inline+",
      marks: "_",
      toDOM: function toDOM() {
        return ["div", {
          "data-node-type": name
        }, 0];
      },
      parseDOM: [{
        tag: 'div[data-node-type="'.concat(name, '"]')
      }]
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/caption.js
var require_caption = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/caption.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.captionWithLocalId = exports2.caption = void 0;
    var _nodeTypes = require_nodeTypes();
    var _utils = require_utils();
    var caption = exports2.caption = (0, _nodeTypes.caption)({
      parseDOM: [{
        tag: "figcaption[data-caption]"
      }],
      toDOM: function toDOM() {
        var attrs = {
          "data-caption": "true"
        };
        return ["figcaption", attrs, 0];
      }
    });
    var captionWithLocalId = exports2.captionWithLocalId = (0, _nodeTypes.caption)({
      parseDOM: [{
        tag: "figcaption[data-caption]",
        getAttrs: function getAttrs() {
          return {
            localId: _utils.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var attrs = {
          "data-caption": "true",
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        };
        return ["figcaption", attrs, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/media.js
var require_media = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/media.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.toJSON = exports2.mediaWithLocalId = exports2.media = exports2.defaultAttrs = exports2.createMediaSpec = exports2.copyPrivateAttributes = exports2.camelCaseToKebabCase = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _colors = require_colors();
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var defaultAttrs = exports2.defaultAttrs = (0, _nodeTypes.media)({}).attrs;
    var createMediaSpec = exports2.createMediaSpec = function createMediaSpec2(attributes) {
      var inline = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
      var generateLocalId = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
      var domNodeType = inline ? "span" : "div";
      var nodeName = inline ? "mediaInline" : "media";
      var parseDOM = [
        {
          tag: "".concat(domNodeType, '[data-node-type="').concat(nodeName, '"]'),
          getAttrs: function getAttrs(dom) {
            var attrs = {};
            if (attributes) {
              Object.keys(attributes).forEach(function(k) {
                var key = camelCaseToKebabCase(k).replace(/^__/, "");
                var value = dom.getAttribute("data-".concat(key)) || "";
                if (value) {
                  attrs[k] = value;
                }
              });
            }
            if (attrs.__fileSize) {
              attrs.__fileSize = +attrs.__fileSize;
            }
            var width = Number(attrs.width);
            if (typeof width !== "undefined" && !isNaN(width)) {
              attrs.width = width;
            }
            var height = Number(attrs.height);
            if (typeof height !== "undefined" && !isNaN(height)) {
              attrs.height = height;
            }
            if (generateLocalId) {
              attrs.localId = _uuid.uuid.generate();
            }
            return attrs;
          }
        },
        // Don't match data URI
        {
          tag: 'img[src^="data:image"]',
          ignore: true
        }
      ];
      var toDOM = function toDOM2(node) {
        var attrs = {
          "data-id": node.attrs.id,
          "data-node-type": "".concat(nodeName),
          "data-type": node.attrs.type,
          "data-collection": node.attrs.collection,
          "data-occurrence-key": node.attrs.occurrenceKey,
          "data-width": node.attrs.width,
          "data-height": node.attrs.height,
          "data-url": node.attrs.url,
          "data-alt": node.attrs.alt,
          "data-local-id": node.attrs.localId || void 0,
          // toDOM is used for static rendering as well as editor rendering. This comes into play for
          // emails, copy/paste, etc, so the title and styling here *is* useful (despite a React-based
          // node view being used for editing).
          title: "Attachment",
          // Manually kept in sync with the style of media cards. The goal is to render a plain gray
          // rectangle that provides an affordance for media.
          style: "display: inline-block; border-radius: 3px; background: ".concat(_colors.N30, "; box-shadow: 0 1px 1px rgba(9, 30, 66, 0.2), 0 0 1px 0 rgba(9, 30, 66, 0.24);")
        };
        copyPrivateAttributes(node.attrs, attrs, function(key) {
          return "data-".concat(camelCaseToKebabCase(key.slice(2)));
        });
        return ["".concat(domNodeType), attrs];
      };
      if (inline) {
        return (0, _nodeTypes.mediaInline)({
          parseDOM,
          toDOM
        });
      }
      return (0, _nodeTypes.media)({
        parseDOM: [].concat(parseDOM, [{
          // media-inline.ts uses this same function to generate the nodespec
          // this ensures that we don't make a media inline out of a copied image
          // https://product-fabric.atlassian.net/browse/EDM-2996
          tag: "img:not(.smart-link-icon)",
          getAttrs: function getAttrs(dom) {
            var attrs = {
              type: "external",
              url: dom.getAttribute("src") || "",
              alt: dom.getAttribute("alt") || ""
            };
            if (generateLocalId) {
              attrs.localId = _uuid.uuid.generate();
            }
            return attrs;
          }
        }]),
        toDOM
      });
    };
    var media = exports2.media = createMediaSpec(defaultAttrs, false, false);
    var mediaWithLocalId = exports2.mediaWithLocalId = createMediaSpec(_objectSpread(_objectSpread({}, defaultAttrs), {}, {
      localId: {
        default: _uuid.uuid.generate()
      }
    }), false, true);
    var camelCaseToKebabCase = exports2.camelCaseToKebabCase = function camelCaseToKebabCase2(str) {
      return str.replace(/([^A-Z]+)([A-Z])/g, function(_, x, y) {
        return "".concat(x, "-").concat(y.toLowerCase());
      });
    };
    var copyPrivateAttributes = exports2.copyPrivateAttributes = function copyPrivateAttributes2(from, to, map) {
      if (media.attrs) {
        Object.keys(media.attrs).forEach(function(key) {
          if (key[0] === "_" && key[1] === "_" && from[key]) {
            to[map ? map(key) : key] = from[key];
          }
        });
      }
    };
    var optionalAttributes = ["occurrenceKey", "width", "height", "url", "alt", "localId"];
    var externalOnlyAttributes = ["type", "url", "width", "height", "alt", "localId"];
    var toJSON = exports2.toJSON = function toJSON2(node) {
      return {
        attrs: Object.keys(node.attrs).filter(function(key) {
          return !(key[0] === "_" && key[1] === "_");
        }).reduce(function(obj, key) {
          if (node.attrs.type === "external" && externalOnlyAttributes.indexOf(key) === -1) {
            return obj;
          }
          if (optionalAttributes.indexOf(key) > -1 && (node.attrs[key] === null || node.attrs[key] === "")) {
            return obj;
          }
          if (["width", "height"].indexOf(key) !== -1) {
            obj[key] = Number(node.attrs[key]);
            return obj;
          }
          obj[key] = node.attrs[key];
          return obj;
        }, {})
      };
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/media-group.js
var require_media_group = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/media-group.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.mediaGroup = void 0;
    var _nodeTypes = require_nodeTypes();
    var mediaGroup = exports2.mediaGroup = (0, _nodeTypes.mediaGroup)({
      parseDOM: [{
        tag: 'div[data-node-type="mediaGroup"]'
      }, {
        tag: 'div[class="MediaGroup"]'
      }],
      toDOM: function toDOM() {
        return ["div", {
          "data-node-type": "mediaGroup"
        }, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/media-inline.js
var require_media_inline = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/media-inline.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.mediaInlineWithLocalId = exports2.mediaInline = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _media = require_media();
    var _uuid = require_uuid();
    var _nodeTypes = require_nodeTypes();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var mediaInline = exports2.mediaInline = (0, _media.createMediaSpec)((0, _nodeTypes.mediaInline)({}).attrs, true);
    var mediaInlineWithLocalId = exports2.mediaInlineWithLocalId = (0, _media.createMediaSpec)(_objectSpread(_objectSpread({}, (0, _nodeTypes.mediaInline)({}).attrs), {}, {
      localId: {
        default: _uuid.uuid.generate()
      }
    }), true, true);
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/types/rich-media-common.js
var require_rich_media_common = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/types/rich-media-common.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.WidthType = void 0;
    var WidthType = exports2.WidthType = /* @__PURE__ */ (function(WidthType2) {
      WidthType2["PIXEL"] = "pixel";
      WidthType2["PERCENTAGE"] = "percentage";
      return WidthType2;
    })({});
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/utils/parseDOM.js
var require_parseDOM = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/utils/parseDOM.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.isDOMElement = void 0;
    var isDOMElement = exports2.isDOMElement = function isDOMElement2(maybeNode) {
      return maybeNode instanceof Node && maybeNode.nodeType === Node.ELEMENT_NODE;
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/media-single.js
var require_media_single = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/media-single.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.toJSON = exports2.mediaSingleWithWidthType = exports2.mediaSingleWithCaption = exports2.mediaSingleSpec = exports2.mediaSingleFullWithLocalId = exports2.mediaSingleFull = exports2.mediaSingle = exports2.defaultAttrs = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _richMediaCommon = require_rich_media_common();
    var _parseDOM = require_parseDOM();
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var defaultAttrs = exports2.defaultAttrs = {
      width: {
        default: null
      },
      // null makes small images to have original size by default
      layout: {
        default: "center"
      }
    };
    var mediaSingleSpec = exports2.mediaSingleSpec = function mediaSingleSpec2(_ref) {
      var _ref$withCaption = _ref.withCaption, withCaption = _ref$withCaption === void 0 ? false : _ref$withCaption, _ref$withExtendedWidt = _ref.withExtendedWidthTypes, withExtendedWidthTypes = _ref$withExtendedWidt === void 0 ? false : _ref$withExtendedWidt, _ref$generateLocalId = _ref.generateLocalId, generateLocalId = _ref$generateLocalId === void 0 ? false : _ref$generateLocalId;
      var getAttrs = function getAttrs2(dom) {
        if (!(0, _parseDOM.isDOMElement)(dom)) {
          return {
            layout: "center"
          };
        }
        var layout = dom.getAttribute("data-layout") || "center";
        var width = Number(dom.getAttribute("data-width")) || null;
        var widthType = dom.getAttribute("data-width-type");
        if (generateLocalId) {
          return {
            layout,
            width,
            widthType,
            localId: _uuid.uuid.generate()
          };
        }
        if (withExtendedWidthTypes) {
          return {
            layout,
            width,
            widthType
          };
        } else if (widthType === _richMediaCommon.WidthType.PIXEL) {
          return {
            layout
          };
        } else {
          return {
            layout,
            width
          };
        }
      };
      var getAttrsFromNode = function getAttrsFromNode2(node) {
        var _node$attrs = node.attrs, layout = _node$attrs.layout, width = _node$attrs.width;
        var attrs = {
          "data-node-type": "mediaSingle",
          "data-layout": layout,
          "data-width": ""
        };
        if (generateLocalId) {
          var _node$attrs2;
          attrs["data-local-id"] = (node === null || node === void 0 ? void 0 : (_node$attrs2 = node.attrs) === null || _node$attrs2 === void 0 ? void 0 : _node$attrs2.localId) || void 0;
        }
        if (width) {
          attrs["data-width"] = isFinite(width) && Math.floor(width) === width ? width : width.toFixed(2);
        }
        if (withExtendedWidthTypes && node.attrs.widthType) {
          var widthType = node.attrs.widthType;
          return _objectSpread(_objectSpread({}, attrs), {}, {
            "data-width-type": widthType || _richMediaCommon.WidthType.PERCENTAGE
          });
        }
        return attrs;
      };
      if (withExtendedWidthTypes && withCaption) {
        return (0, _nodeTypes.mediaSingleFull)({
          parseDOM: [{
            tag: 'div[data-node-type="mediaSingle"]',
            getAttrs
          }],
          toDOM: function toDOM(node) {
            return ["div", getAttrsFromNode(node), 0];
          }
        });
      }
      if (withExtendedWidthTypes && !withCaption) {
        return (0, _nodeTypes.mediaSingleWidthType)({
          parseDOM: [{
            tag: 'div[data-node-type="mediaSingle"]',
            getAttrs
          }],
          toDOM: function toDOM(node) {
            return ["div", getAttrsFromNode(node), 0];
          }
        });
      }
      if (!withExtendedWidthTypes && withCaption) {
        return (0, _nodeTypes.mediaSingleCaption)({
          parseDOM: [{
            tag: 'div[data-node-type="mediaSingle"]',
            getAttrs
          }],
          toDOM: function toDOM(node) {
            return ["div", getAttrsFromNode(node), 0];
          }
        });
      }
      return (0, _nodeTypes.mediaSingle)({
        parseDOM: [{
          tag: 'div[data-node-type="mediaSingle"]',
          getAttrs
        }],
        toDOM: function toDOM(node) {
          return ["div", getAttrsFromNode(node), 0];
        }
      });
    };
    var mediaSingle = exports2.mediaSingle = mediaSingleSpec({
      withCaption: false,
      withExtendedWidthTypes: false
    });
    var mediaSingleWithCaption = exports2.mediaSingleWithCaption = mediaSingleSpec({
      withCaption: true,
      withExtendedWidthTypes: false
    });
    var mediaSingleWithWidthType = exports2.mediaSingleWithWidthType = mediaSingleSpec({
      withCaption: false,
      withExtendedWidthTypes: true
    });
    var mediaSingleFull = exports2.mediaSingleFull = mediaSingleSpec({
      withCaption: true,
      withExtendedWidthTypes: true
    });
    var mediaSingleFullWithLocalId = exports2.mediaSingleFullWithLocalId = mediaSingleSpec({
      withCaption: true,
      withExtendedWidthTypes: true,
      generateLocalId: true
    });
    var toJSON = exports2.toJSON = function toJSON2(node) {
      return {
        attrs: Object.keys(node.attrs).reduce(function(obj, key) {
          if (node.attrs[key] !== null) {
            obj[key] = node.attrs[key];
          }
          return obj;
        }, {})
      };
    };
  }
});

// node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js
var require_objectWithoutPropertiesLoose = __commonJS({
  "node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js"(exports2, module2) {
    function _objectWithoutPropertiesLoose(r, e) {
      if (null == r) return {};
      var t = {};
      for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
        if (-1 !== e.indexOf(n)) continue;
        t[n] = r[n];
      }
      return t;
    }
    module2.exports = _objectWithoutPropertiesLoose, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/objectWithoutProperties.js
var require_objectWithoutProperties = __commonJS({
  "node_modules/@babel/runtime/helpers/objectWithoutProperties.js"(exports2, module2) {
    var objectWithoutPropertiesLoose = require_objectWithoutPropertiesLoose();
    function _objectWithoutProperties(e, t) {
      if (null == e) return {};
      var o, r, i = objectWithoutPropertiesLoose(e, t);
      if (Object.getOwnPropertySymbols) {
        var n = Object.getOwnPropertySymbols(e);
        for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
      }
      return i;
    }
    module2.exports = _objectWithoutProperties, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/OverloadYield.js
var require_OverloadYield = __commonJS({
  "node_modules/@babel/runtime/helpers/OverloadYield.js"(exports2, module2) {
    function _OverloadYield(e, d) {
      this.v = e, this.k = d;
    }
    module2.exports = _OverloadYield, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/regeneratorDefine.js
var require_regeneratorDefine = __commonJS({
  "node_modules/@babel/runtime/helpers/regeneratorDefine.js"(exports2, module2) {
    function _regeneratorDefine(e, r, n, t) {
      var i = Object.defineProperty;
      try {
        i({}, "", {});
      } catch (e2) {
        i = 0;
      }
      module2.exports = _regeneratorDefine = function regeneratorDefine(e2, r2, n2, t2) {
        function o(r3, n3) {
          _regeneratorDefine(e2, r3, function(e3) {
            return this._invoke(r3, n3, e3);
          });
        }
        r2 ? i ? i(e2, r2, {
          value: n2,
          enumerable: !t2,
          configurable: !t2,
          writable: !t2
        }) : e2[r2] = n2 : (o("next", 0), o("throw", 1), o("return", 2));
      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _regeneratorDefine(e, r, n, t);
    }
    module2.exports = _regeneratorDefine, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/regenerator.js
var require_regenerator = __commonJS({
  "node_modules/@babel/runtime/helpers/regenerator.js"(exports2, module2) {
    var regeneratorDefine = require_regeneratorDefine();
    function _regenerator() {
      var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag";
      function i(r2, n2, o2, i2) {
        var c2 = n2 && n2.prototype instanceof Generator ? n2 : Generator, u2 = Object.create(c2.prototype);
        return regeneratorDefine(u2, "_invoke", (function(r3, n3, o3) {
          var i3, c3, u3, f2 = 0, p = o3 || [], y = false, G = {
            p: 0,
            n: 0,
            v: e,
            a: d,
            f: d.bind(e, 4),
            d: function d2(t2, r4) {
              return i3 = t2, c3 = 0, u3 = e, G.n = r4, a;
            }
          };
          function d(r4, n4) {
            for (c3 = r4, u3 = n4, t = 0; !y && f2 && !o4 && t < p.length; t++) {
              var o4, i4 = p[t], d2 = G.p, l = i4[2];
              r4 > 3 ? (o4 = l === n4) && (u3 = i4[(c3 = i4[4]) ? 5 : (c3 = 3, 3)], i4[4] = i4[5] = e) : i4[0] <= d2 && ((o4 = r4 < 2 && d2 < i4[1]) ? (c3 = 0, G.v = n4, G.n = i4[1]) : d2 < l && (o4 = r4 < 3 || i4[0] > n4 || n4 > l) && (i4[4] = r4, i4[5] = n4, G.n = l, c3 = 0));
            }
            if (o4 || r4 > 1) return a;
            throw y = true, n4;
          }
          return function(o4, p2, l) {
            if (f2 > 1) throw TypeError("Generator is already running");
            for (y && 1 === p2 && d(p2, l), c3 = p2, u3 = l; (t = c3 < 2 ? e : u3) || !y; ) {
              i3 || (c3 ? c3 < 3 ? (c3 > 1 && (G.n = -1), d(c3, u3)) : G.n = u3 : G.v = u3);
              try {
                if (f2 = 2, i3) {
                  if (c3 || (o4 = "next"), t = i3[o4]) {
                    if (!(t = t.call(i3, u3))) throw TypeError("iterator result is not an object");
                    if (!t.done) return t;
                    u3 = t.value, c3 < 2 && (c3 = 0);
                  } else 1 === c3 && (t = i3["return"]) && t.call(i3), c3 < 2 && (u3 = TypeError("The iterator does not provide a '" + o4 + "' method"), c3 = 1);
                  i3 = e;
                } else if ((t = (y = G.n < 0) ? u3 : r3.call(n3, G)) !== a) break;
              } catch (t2) {
                i3 = e, c3 = 1, u3 = t2;
              } finally {
                f2 = 1;
              }
            }
            return {
              value: t,
              done: y
            };
          };
        })(r2, o2, i2), true), u2;
      }
      var a = {};
      function Generator() {
      }
      function GeneratorFunction() {
      }
      function GeneratorFunctionPrototype() {
      }
      t = Object.getPrototypeOf;
      var c = [][n] ? t(t([][n]())) : (regeneratorDefine(t = {}, n, function() {
        return this;
      }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
      function f(e2) {
        return Object.setPrototypeOf ? Object.setPrototypeOf(e2, GeneratorFunctionPrototype) : (e2.__proto__ = GeneratorFunctionPrototype, regeneratorDefine(e2, o, "GeneratorFunction")), e2.prototype = Object.create(u), e2;
      }
      return GeneratorFunction.prototype = GeneratorFunctionPrototype, regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), regeneratorDefine(u), regeneratorDefine(u, o, "Generator"), regeneratorDefine(u, n, function() {
        return this;
      }), regeneratorDefine(u, "toString", function() {
        return "[object Generator]";
      }), (module2.exports = _regenerator = function _regenerator2() {
        return {
          w: i,
          m: f
        };
      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports)();
    }
    module2.exports = _regenerator, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js
var require_regeneratorAsyncIterator = __commonJS({
  "node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js"(exports2, module2) {
    var OverloadYield = require_OverloadYield();
    var regeneratorDefine = require_regeneratorDefine();
    function AsyncIterator(t, e) {
      function n(r2, o, i, f) {
        try {
          var c = t[r2](o), u = c.value;
          return u instanceof OverloadYield ? e.resolve(u.v).then(function(t2) {
            n("next", t2, i, f);
          }, function(t2) {
            n("throw", t2, i, f);
          }) : e.resolve(u).then(function(t2) {
            c.value = t2, i(c);
          }, function(t2) {
            return n("throw", t2, i, f);
          });
        } catch (t2) {
          f(t2);
        }
      }
      var r;
      this.next || (regeneratorDefine(AsyncIterator.prototype), regeneratorDefine(AsyncIterator.prototype, "function" == typeof Symbol && Symbol.asyncIterator || "@asyncIterator", function() {
        return this;
      })), regeneratorDefine(this, "_invoke", function(t2, o, i) {
        function f() {
          return new e(function(e2, r2) {
            n(t2, i, e2, r2);
          });
        }
        return r = r ? r.then(f, f) : f();
      }, true);
    }
    module2.exports = AsyncIterator, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js
var require_regeneratorAsyncGen = __commonJS({
  "node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js"(exports2, module2) {
    var regenerator = require_regenerator();
    var regeneratorAsyncIterator = require_regeneratorAsyncIterator();
    function _regeneratorAsyncGen(r, e, t, o, n) {
      return new regeneratorAsyncIterator(regenerator().w(r, e, t, o), n || Promise);
    }
    module2.exports = _regeneratorAsyncGen, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/regeneratorAsync.js
var require_regeneratorAsync = __commonJS({
  "node_modules/@babel/runtime/helpers/regeneratorAsync.js"(exports2, module2) {
    var regeneratorAsyncGen = require_regeneratorAsyncGen();
    function _regeneratorAsync(n, e, r, t, o) {
      var a = regeneratorAsyncGen(n, e, r, t, o);
      return a.next().then(function(n2) {
        return n2.done ? n2.value : a.next();
      });
    }
    module2.exports = _regeneratorAsync, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/regeneratorKeys.js
var require_regeneratorKeys = __commonJS({
  "node_modules/@babel/runtime/helpers/regeneratorKeys.js"(exports2, module2) {
    function _regeneratorKeys(e) {
      var n = Object(e), r = [];
      for (var t in n) r.unshift(t);
      return function e2() {
        for (; r.length; ) if ((t = r.pop()) in n) return e2.value = t, e2.done = false, e2;
        return e2.done = true, e2;
      };
    }
    module2.exports = _regeneratorKeys, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/regeneratorValues.js
var require_regeneratorValues = __commonJS({
  "node_modules/@babel/runtime/helpers/regeneratorValues.js"(exports2, module2) {
    var _typeof = require_typeof()["default"];
    function _regeneratorValues(e) {
      if (null != e) {
        var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"], r = 0;
        if (t) return t.call(e);
        if ("function" == typeof e.next) return e;
        if (!isNaN(e.length)) return {
          next: function next() {
            return e && r >= e.length && (e = void 0), {
              value: e && e[r++],
              done: !e
            };
          }
        };
      }
      throw new TypeError(_typeof(e) + " is not iterable");
    }
    module2.exports = _regeneratorValues, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/regeneratorRuntime.js
var require_regeneratorRuntime = __commonJS({
  "node_modules/@babel/runtime/helpers/regeneratorRuntime.js"(exports2, module2) {
    var OverloadYield = require_OverloadYield();
    var regenerator = require_regenerator();
    var regeneratorAsync = require_regeneratorAsync();
    var regeneratorAsyncGen = require_regeneratorAsyncGen();
    var regeneratorAsyncIterator = require_regeneratorAsyncIterator();
    var regeneratorKeys = require_regeneratorKeys();
    var regeneratorValues = require_regeneratorValues();
    function _regeneratorRuntime() {
      "use strict";
      var r = regenerator(), e = r.m(_regeneratorRuntime), t = (Object.getPrototypeOf ? Object.getPrototypeOf(e) : e.__proto__).constructor;
      function n(r2) {
        var e2 = "function" == typeof r2 && r2.constructor;
        return !!e2 && (e2 === t || "GeneratorFunction" === (e2.displayName || e2.name));
      }
      var o = {
        "throw": 1,
        "return": 2,
        "break": 3,
        "continue": 3
      };
      function a(r2) {
        var e2, t2;
        return function(n2) {
          e2 || (e2 = {
            stop: function stop() {
              return t2(n2.a, 2);
            },
            "catch": function _catch() {
              return n2.v;
            },
            abrupt: function abrupt(r3, e3) {
              return t2(n2.a, o[r3], e3);
            },
            delegateYield: function delegateYield(r3, o2, a2) {
              return e2.resultName = o2, t2(n2.d, regeneratorValues(r3), a2);
            },
            finish: function finish(r3) {
              return t2(n2.f, r3);
            }
          }, t2 = function t3(r3, _t, o2) {
            n2.p = e2.prev, n2.n = e2.next;
            try {
              return r3(_t, o2);
            } finally {
              e2.next = n2.n;
            }
          }), e2.resultName && (e2[e2.resultName] = n2.v, e2.resultName = void 0), e2.sent = n2.v, e2.next = n2.n;
          try {
            return r2.call(this, e2);
          } finally {
            n2.p = e2.prev, n2.n = e2.next;
          }
        };
      }
      return (module2.exports = _regeneratorRuntime = function _regeneratorRuntime2() {
        return {
          wrap: function wrap(e2, t2, n2, o2) {
            return r.w(a(e2), t2, n2, o2 && o2.reverse());
          },
          isGeneratorFunction: n,
          mark: r.m,
          awrap: function awrap(r2, e2) {
            return new OverloadYield(r2, e2);
          },
          AsyncIterator: regeneratorAsyncIterator,
          async: function async(r2, e2, t2, o2, u) {
            return (n(e2) ? regeneratorAsyncGen : regeneratorAsync)(a(r2), e2, t2, o2, u);
          },
          keys: regeneratorKeys,
          values: regeneratorValues
        };
      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports)();
    }
    module2.exports = _regeneratorRuntime, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/regenerator/index.js
var require_regenerator2 = __commonJS({
  "node_modules/@babel/runtime/regenerator/index.js"(exports2, module2) {
    var runtime = require_regeneratorRuntime()();
    module2.exports = runtime;
    try {
      regeneratorRuntime = runtime;
    } catch (accidentalStrictMode) {
      if (typeof globalThis === "object") {
        globalThis.regeneratorRuntime = runtime;
      } else {
        Function("r", "regeneratorRuntime = r")(runtime);
      }
    }
  }
});

// node_modules/@babel/runtime/helpers/asyncToGenerator.js
var require_asyncToGenerator = __commonJS({
  "node_modules/@babel/runtime/helpers/asyncToGenerator.js"(exports2, module2) {
    function asyncGeneratorStep(n, t, e, r, o, a, c) {
      try {
        var i = n[a](c), u = i.value;
      } catch (n2) {
        return void e(n2);
      }
      i.done ? t(u) : Promise.resolve(u).then(r, o);
    }
    function _asyncToGenerator(n) {
      return function() {
        var t = this, e = arguments;
        return new Promise(function(r, o) {
          var a = n.apply(t, e);
          function _next(n2) {
            asyncGeneratorStep(a, r, o, _next, _throw, "next", n2);
          }
          function _throw(n2) {
            asyncGeneratorStep(a, r, o, _next, _throw, "throw", n2);
          }
          _next(void 0);
        });
      };
    }
    module2.exports = _asyncToGenerator, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@statsig/client-core/src/Log.js
var require_Log = __commonJS({
  "node_modules/@statsig/client-core/src/Log.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Log = exports2.LogLevel = void 0;
    var DEBUG = " DEBUG ";
    var _INFO = "  INFO ";
    var _WARN = "  WARN ";
    var ERROR = " ERROR ";
    function addTag(args2) {
      args2.unshift("[Statsig]");
      return args2;
    }
    exports2.LogLevel = {
      None: 0,
      Error: 1,
      Warn: 2,
      Info: 3,
      Debug: 4
    };
    var Log = class _Log {
      static info(...args2) {
        if (_Log.level >= exports2.LogLevel.Info) {
          console.info(_INFO, ...addTag(args2));
        }
      }
      static debug(...args2) {
        if (_Log.level >= exports2.LogLevel.Debug) {
          console.debug(DEBUG, ...addTag(args2));
        }
      }
      static warn(...args2) {
        if (_Log.level >= exports2.LogLevel.Warn) {
          console.warn(_WARN, ...addTag(args2));
        }
      }
      static error(...args2) {
        if (_Log.level >= exports2.LogLevel.Error) {
          console.error(ERROR, ...addTag(args2));
        }
      }
    };
    exports2.Log = Log;
    Log.level = exports2.LogLevel.Warn;
  }
});

// node_modules/@statsig/client-core/src/$_StatsigGlobal.js
var require_StatsigGlobal = __commonJS({
  "node_modules/@statsig/client-core/src/$_StatsigGlobal.js"(exports2) {
    "use strict";
    var _a;
    var _b;
    var _c;
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._getInstance = exports2._getStatsigGlobalFlag = exports2._getStatsigGlobal = void 0;
    var Log_1 = require_Log();
    var _getStatsigGlobal = () => {
      try {
        return typeof __STATSIG__ !== "undefined" ? __STATSIG__ : statsigGlobal;
      } catch (e) {
        return statsigGlobal;
      }
    };
    exports2._getStatsigGlobal = _getStatsigGlobal;
    var _getStatsigGlobalFlag = (flag) => {
      return (0, exports2._getStatsigGlobal)()[flag];
    };
    exports2._getStatsigGlobalFlag = _getStatsigGlobalFlag;
    var _getInstance = (sdkKey) => {
      const gbl = (0, exports2._getStatsigGlobal)();
      if (!sdkKey) {
        if (gbl.instances && Object.keys(gbl.instances).length > 1) {
          Log_1.Log.warn("Call made to Statsig global instance without an SDK key but there is more than one client instance. If you are using mulitple clients, please specify the SDK key.");
        }
        return gbl.firstInstance;
      }
      return gbl.instances && gbl.instances[sdkKey];
    };
    exports2._getInstance = _getInstance;
    var GLOBAL_KEY = "__STATSIG__";
    var _window = typeof window !== "undefined" ? window : {};
    var _global = typeof global !== "undefined" ? global : {};
    var _globalThis = typeof globalThis !== "undefined" ? globalThis : {};
    var statsigGlobal = (_c = (_b = (_a = _window[GLOBAL_KEY]) !== null && _a !== void 0 ? _a : _global[GLOBAL_KEY]) !== null && _b !== void 0 ? _b : _globalThis[GLOBAL_KEY]) !== null && _c !== void 0 ? _c : {
      instance: exports2._getInstance
    };
    _window[GLOBAL_KEY] = statsigGlobal;
    _global[GLOBAL_KEY] = statsigGlobal;
    _globalThis[GLOBAL_KEY] = statsigGlobal;
  }
});

// node_modules/@statsig/client-core/src/Diagnostics.js
var require_Diagnostics = __commonJS({
  "node_modules/@statsig/client-core/src/Diagnostics.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Diagnostics = void 0;
    var MARKER_MAP = /* @__PURE__ */ new Map();
    var ACT_START = "start";
    var ACT_END = "end";
    var DIAGNOSTICS_EVENT = "statsig::diagnostics";
    exports2.Diagnostics = {
      _getMarkers: (sdkKey) => {
        return MARKER_MAP.get(sdkKey);
      },
      _markInitOverallStart: (sdkKey) => {
        _addMarker(sdkKey, _createMarker({}, ACT_START, "overall"));
      },
      _markInitOverallEnd: (sdkKey, success, evaluationDetails) => {
        _addMarker(sdkKey, _createMarker({
          success,
          error: success ? void 0 : { name: "InitializeError", message: "Failed to initialize" },
          evaluationDetails
        }, ACT_END, "overall"));
      },
      _markInitNetworkReqStart: (sdkKey, data) => {
        _addMarker(sdkKey, _createMarker(data, ACT_START, "initialize", "network_request"));
      },
      _markInitNetworkReqEnd: (sdkKey, data) => {
        _addMarker(sdkKey, _createMarker(data, ACT_END, "initialize", "network_request"));
      },
      _markInitProcessStart: (sdkKey) => {
        _addMarker(sdkKey, _createMarker({}, ACT_START, "initialize", "process"));
      },
      _markInitProcessEnd: (sdkKey, data) => {
        _addMarker(sdkKey, _createMarker(data, ACT_END, "initialize", "process"));
      },
      _clearMarkers: (sdkKey) => {
        MARKER_MAP.delete(sdkKey);
      },
      _formatError(e) {
        if (!(e && typeof e === "object")) {
          return;
        }
        return {
          code: _safeGetField(e, "code"),
          name: _safeGetField(e, "name"),
          message: _safeGetField(e, "message")
        };
      },
      _getDiagnosticsData(res, attempt, body, e) {
        var _a;
        return {
          success: (res === null || res === void 0 ? void 0 : res.ok) === true,
          statusCode: res === null || res === void 0 ? void 0 : res.status,
          sdkRegion: (_a = res === null || res === void 0 ? void 0 : res.headers) === null || _a === void 0 ? void 0 : _a.get("x-statsig-region"),
          isDelta: body.includes('"is_delta":true') === true ? true : void 0,
          attempt,
          error: exports2.Diagnostics._formatError(e)
        };
      },
      _enqueueDiagnosticsEvent(user, logger, sdk, options) {
        const markers = exports2.Diagnostics._getMarkers(sdk);
        if (markers == null || markers.length <= 0) {
          return -1;
        }
        const overallInitDuration = markers[markers.length - 1].timestamp - markers[0].timestamp;
        exports2.Diagnostics._clearMarkers(sdk);
        const event = _makeDiagnosticsEvent(user, {
          context: "initialize",
          markers: markers.slice(),
          statsigOptions: options
        });
        logger.enqueue(event);
        return overallInitDuration;
      }
    };
    function _createMarker(data, action, key, step) {
      return Object.assign({ key, action, step, timestamp: Date.now() }, data);
    }
    function _makeDiagnosticsEvent(user, data) {
      const latencyEvent = {
        eventName: DIAGNOSTICS_EVENT,
        user,
        value: null,
        metadata: data,
        time: Date.now()
      };
      return latencyEvent;
    }
    function _addMarker(sdkKey, marker) {
      var _a;
      const markers = (_a = MARKER_MAP.get(sdkKey)) !== null && _a !== void 0 ? _a : [];
      markers.push(marker);
      MARKER_MAP.set(sdkKey, markers);
    }
    function _safeGetField(data, field) {
      if (field in data) {
        return data[field];
      }
      return void 0;
    }
  }
});

// node_modules/@statsig/client-core/src/TypingUtils.js
var require_TypingUtils = __commonJS({
  "node_modules/@statsig/client-core/src/TypingUtils.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._isTypeMatch = exports2._typeOf = void 0;
    function _typeOf(input2) {
      return Array.isArray(input2) ? "array" : typeof input2;
    }
    exports2._typeOf = _typeOf;
    function _isTypeMatch(a, b) {
      const typeOf = (x) => Array.isArray(x) ? "array" : x === null ? "null" : typeof x;
      return typeOf(a) === typeOf(b);
    }
    exports2._isTypeMatch = _isTypeMatch;
  }
});

// node_modules/@statsig/client-core/src/Hashing.js
var require_Hashing = __commonJS({
  "node_modules/@statsig/client-core/src/Hashing.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._getSortedObject = exports2._DJB2Object = exports2._DJB2 = void 0;
    var TypingUtils_1 = require_TypingUtils();
    var _DJB2 = (value) => {
      let hash = 0;
      for (let i = 0; i < value.length; i++) {
        const character = value.charCodeAt(i);
        hash = (hash << 5) - hash + character;
        hash = hash & hash;
      }
      return String(hash >>> 0);
    };
    exports2._DJB2 = _DJB2;
    var _DJB2Object = (value, maxLevels) => {
      return (0, exports2._DJB2)(JSON.stringify((0, exports2._getSortedObject)(value, maxLevels)));
    };
    exports2._DJB2Object = _DJB2Object;
    var _getSortedObject = (object, maxDepth) => {
      if (object == null) {
        return null;
      }
      const keys = Object.keys(object).sort();
      const sortedObject = {};
      keys.forEach((key) => {
        const value = object[key];
        if (maxDepth === 0 || (0, TypingUtils_1._typeOf)(value) !== "object") {
          sortedObject[key] = value;
          return;
        }
        sortedObject[key] = (0, exports2._getSortedObject)(value, maxDepth != null ? maxDepth - 1 : maxDepth);
      });
      return sortedObject;
    };
    exports2._getSortedObject = _getSortedObject;
  }
});

// node_modules/@statsig/client-core/src/CacheKey.js
var require_CacheKey = __commonJS({
  "node_modules/@statsig/client-core/src/CacheKey.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._getStorageKey = exports2._getUserStorageKey = void 0;
    var Hashing_1 = require_Hashing();
    function _getUserStorageKey(sdkKey, user, customKeyGenerator) {
      var _a;
      if (customKeyGenerator) {
        return customKeyGenerator(sdkKey, user);
      }
      const cids = user && user.customIDs ? user.customIDs : {};
      const parts = [
        `uid:${(_a = user === null || user === void 0 ? void 0 : user.userID) !== null && _a !== void 0 ? _a : ""}`,
        `cids:${Object.keys(cids).sort((leftKey, rightKey) => leftKey.localeCompare(rightKey)).map((key) => `${key}-${cids[key]}`).join(",")}`,
        `k:${sdkKey}`
      ];
      return (0, Hashing_1._DJB2)(parts.join("|"));
    }
    exports2._getUserStorageKey = _getUserStorageKey;
    function _getStorageKey(sdkKey, user, customKeyGenerator) {
      if (user) {
        return _getUserStorageKey(sdkKey, user, customKeyGenerator);
      }
      return (0, Hashing_1._DJB2)(`k:${sdkKey}`);
    }
    exports2._getStorageKey = _getStorageKey;
  }
});

// node_modules/@statsig/client-core/src/NetworkConfig.js
var require_NetworkConfig = __commonJS({
  "node_modules/@statsig/client-core/src/NetworkConfig.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.NetworkParam = exports2.NetworkDefault = exports2.Endpoint = void 0;
    exports2.Endpoint = {
      _initialize: "initialize",
      _rgstr: "rgstr",
      _download_config_specs: "download_config_specs"
    };
    exports2.NetworkDefault = {
      [exports2.Endpoint._rgstr]: "https://prodregistryv2.org/v1",
      [exports2.Endpoint._initialize]: "https://featureassets.org/v1",
      [exports2.Endpoint._download_config_specs]: "https://api.statsigcdn.com/v1"
    };
    exports2.NetworkParam = {
      EventCount: "ec",
      SdkKey: "k",
      SdkType: "st",
      SdkVersion: "sv",
      Time: "t",
      SessionID: "sid",
      StatsigEncoded: "se",
      IsGzipped: "gz"
    };
  }
});

// node_modules/@statsig/client-core/src/SafeJs.js
var require_SafeJs = __commonJS({
  "node_modules/@statsig/client-core/src/SafeJs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._getUnloadEvent = exports2._getCurrentPageUrlSafe = exports2._addDocumentEventListenerSafe = exports2._addWindowEventListenerSafe = exports2._isServerEnv = exports2._getDocumentSafe = exports2._getWindowSafe = void 0;
    var _getWindowSafe = () => {
      return typeof window !== "undefined" ? window : null;
    };
    exports2._getWindowSafe = _getWindowSafe;
    var _getDocumentSafe = () => {
      var _a;
      const win = (0, exports2._getWindowSafe)();
      return (_a = win === null || win === void 0 ? void 0 : win.document) !== null && _a !== void 0 ? _a : null;
    };
    exports2._getDocumentSafe = _getDocumentSafe;
    var _isServerEnv = () => {
      if ((0, exports2._getDocumentSafe)() !== null) {
        return false;
      }
      const isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
      const isVercel = typeof EdgeRuntime === "string";
      return isVercel || isNode;
    };
    exports2._isServerEnv = _isServerEnv;
    var _addWindowEventListenerSafe = (key, listener) => {
      const win = (0, exports2._getWindowSafe)();
      if (typeof (win === null || win === void 0 ? void 0 : win.addEventListener) === "function") {
        win.addEventListener(key, listener);
      }
    };
    exports2._addWindowEventListenerSafe = _addWindowEventListenerSafe;
    var _addDocumentEventListenerSafe = (key, listener) => {
      const doc = (0, exports2._getDocumentSafe)();
      if (typeof (doc === null || doc === void 0 ? void 0 : doc.addEventListener) === "function") {
        doc.addEventListener(key, listener);
      }
    };
    exports2._addDocumentEventListenerSafe = _addDocumentEventListenerSafe;
    var _getCurrentPageUrlSafe = () => {
      var _a;
      try {
        return (_a = (0, exports2._getWindowSafe)()) === null || _a === void 0 ? void 0 : _a.location.href.split(/[?#]/)[0];
      } catch (_b) {
        return;
      }
    };
    exports2._getCurrentPageUrlSafe = _getCurrentPageUrlSafe;
    var _getUnloadEvent = () => {
      const win = (0, exports2._getWindowSafe)();
      if (!win) {
        return "beforeunload";
      }
      const eventType = "onpagehide" in win ? "pagehide" : "beforeunload";
      return eventType;
    };
    exports2._getUnloadEvent = _getUnloadEvent;
  }
});

// node_modules/@statsig/client-core/src/StatsigEvent.js
var require_StatsigEvent = __commonJS({
  "node_modules/@statsig/client-core/src/StatsigEvent.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._createLayerParameterExposure = exports2._createConfigExposure = exports2._mapExposures = exports2._createGateExposure = exports2._isExposureEvent = void 0;
    var CONFIG_EXPOSURE_NAME = "statsig::config_exposure";
    var GATE_EXPOSURE_NAME = "statsig::gate_exposure";
    var LAYER_EXPOSURE_NAME = "statsig::layer_exposure";
    var _createExposure = (eventName, user, details, metadata, secondaryExposures) => {
      if (details.bootstrapMetadata) {
        metadata["bootstrapMetadata"] = details.bootstrapMetadata;
      }
      return {
        eventName,
        user,
        value: null,
        metadata: _addEvaluationDetailsToMetadata(details, metadata),
        secondaryExposures,
        time: Date.now()
      };
    };
    var _isExposureEvent = ({ eventName }) => {
      return eventName === GATE_EXPOSURE_NAME || eventName === CONFIG_EXPOSURE_NAME || eventName === LAYER_EXPOSURE_NAME;
    };
    exports2._isExposureEvent = _isExposureEvent;
    var _createGateExposure = (user, gate, exposureMapping) => {
      var _a, _b, _c;
      const metadata = {
        gate: gate.name,
        gateValue: String(gate.value),
        ruleID: gate.ruleID
      };
      if (((_a = gate.__evaluation) === null || _a === void 0 ? void 0 : _a.version) != null) {
        metadata["configVersion"] = gate.__evaluation.version;
      }
      return _createExposure(GATE_EXPOSURE_NAME, user, gate.details, metadata, _mapExposures((_c = (_b = gate.__evaluation) === null || _b === void 0 ? void 0 : _b.secondary_exposures) !== null && _c !== void 0 ? _c : [], exposureMapping));
    };
    exports2._createGateExposure = _createGateExposure;
    function _mapExposures(exposures, exposureMapping) {
      return exposures.map((exposure) => {
        if (typeof exposure === "string") {
          return (exposureMapping !== null && exposureMapping !== void 0 ? exposureMapping : {})[exposure];
        }
        return exposure;
      }).filter((exposure) => exposure != null);
    }
    exports2._mapExposures = _mapExposures;
    var _createConfigExposure = (user, config, exposureMapping) => {
      var _a, _b, _c, _d;
      const metadata = {
        config: config.name,
        ruleID: config.ruleID
      };
      if (((_a = config.__evaluation) === null || _a === void 0 ? void 0 : _a.version) != null) {
        metadata["configVersion"] = config.__evaluation.version;
      }
      if (((_b = config.__evaluation) === null || _b === void 0 ? void 0 : _b.passed) != null) {
        metadata["rulePassed"] = String(config.__evaluation.passed);
      }
      return _createExposure(CONFIG_EXPOSURE_NAME, user, config.details, metadata, _mapExposures((_d = (_c = config.__evaluation) === null || _c === void 0 ? void 0 : _c.secondary_exposures) !== null && _d !== void 0 ? _d : [], exposureMapping));
    };
    exports2._createConfigExposure = _createConfigExposure;
    var _createLayerParameterExposure = (user, layer, parameterName, exposureMapping) => {
      var _a, _b, _c, _d, _e, _f, _g;
      const evaluation = layer.__evaluation;
      const isExplicit = ((_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.explicit_parameters) === null || _a === void 0 ? void 0 : _a.includes(parameterName)) === true;
      let allocatedExperiment = "";
      let secondaryExposures = (_b = evaluation === null || evaluation === void 0 ? void 0 : evaluation.undelegated_secondary_exposures) !== null && _b !== void 0 ? _b : [];
      if (isExplicit) {
        allocatedExperiment = (_c = evaluation.allocated_experiment_name) !== null && _c !== void 0 ? _c : "";
        secondaryExposures = (_d = evaluation.secondary_exposures) !== null && _d !== void 0 ? _d : [];
      }
      const parameterRuleIDs = (_e = layer.__evaluation) === null || _e === void 0 ? void 0 : _e.parameter_rule_ids;
      const metadata = {
        config: layer.name,
        parameterName,
        ruleID: (_f = parameterRuleIDs === null || parameterRuleIDs === void 0 ? void 0 : parameterRuleIDs[parameterName]) !== null && _f !== void 0 ? _f : layer.ruleID,
        allocatedExperiment,
        isExplicitParameter: String(isExplicit)
      };
      if (((_g = layer.__evaluation) === null || _g === void 0 ? void 0 : _g.version) != null) {
        metadata["configVersion"] = layer.__evaluation.version;
      }
      return _createExposure(LAYER_EXPOSURE_NAME, user, layer.details, metadata, _mapExposures(secondaryExposures, exposureMapping));
    };
    exports2._createLayerParameterExposure = _createLayerParameterExposure;
    var _addEvaluationDetailsToMetadata = (details, metadata) => {
      metadata["reason"] = details.reason;
      if (details.lcut) {
        metadata["lcut"] = String(details.lcut);
      }
      if (details.receivedAt) {
        metadata["receivedAt"] = String(details.receivedAt);
      }
      return metadata;
    };
  }
});

// node_modules/@statsig/client-core/src/StatsigOptionsCommon.js
var require_StatsigOptionsCommon = __commonJS({
  "node_modules/@statsig/client-core/src/StatsigOptionsCommon.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.LoggingEnabledOption = exports2.LogEventCompressionMode = void 0;
    exports2.LogEventCompressionMode = {
      /** Do not compress request bodies */
      Disabled: "d",
      /** Compress request bodies unless a network proxy is configured */
      Enabled: "e",
      /** Always compress request bodies, even when a proxy is configured */
      Forced: "f"
    };
    exports2.LoggingEnabledOption = {
      disabled: "disabled",
      browserOnly: "browser-only",
      always: "always"
    };
  }
});

// node_modules/@statsig/client-core/src/StorageProvider.js
var require_StorageProvider = __commonJS({
  "node_modules/@statsig/client-core/src/StorageProvider.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._setObjectInStorage = exports2._getObjectFromStorage = exports2.Storage = void 0;
    var Log_1 = require_Log();
    var SafeJs_1 = require_SafeJs();
    var inMemoryStore = {};
    var _inMemoryProvider = {
      isReady: () => true,
      isReadyResolver: () => null,
      getProviderName: () => "InMemory",
      getItem: (key) => inMemoryStore[key] ? inMemoryStore[key] : null,
      setItem: (key, value) => {
        inMemoryStore[key] = value;
      },
      removeItem: (key) => {
        delete inMemoryStore[key];
      },
      getAllKeys: () => Object.keys(inMemoryStore)
    };
    var _localStorageProvider = null;
    try {
      const win = (0, SafeJs_1._getWindowSafe)();
      if (win && win.localStorage && typeof win.localStorage.getItem === "function") {
        _localStorageProvider = {
          isReady: () => true,
          isReadyResolver: () => null,
          getProviderName: () => "LocalStorage",
          getItem: (key) => win.localStorage.getItem(key),
          setItem: (key, value) => win.localStorage.setItem(key, value),
          removeItem: (key) => win.localStorage.removeItem(key),
          getAllKeys: () => Object.keys(win.localStorage)
        };
      }
    } catch (error) {
      Log_1.Log.warn("Failed to setup localStorageProvider.");
    }
    var _main = _localStorageProvider !== null && _localStorageProvider !== void 0 ? _localStorageProvider : _inMemoryProvider;
    var _current = _main;
    function _inMemoryBreaker(action) {
      try {
        return action();
      } catch (error) {
        if (error instanceof Error && error.name === "SecurityError") {
          exports2.Storage._setProvider(_inMemoryProvider);
          return null;
        }
        if (error instanceof Error && error.name === "QuotaExceededError") {
          const allKeys = exports2.Storage.getAllKeys();
          const statsigKeys = allKeys.filter((key) => key.startsWith("statsig."));
          error.message = `${error.message}. Statsig Keys: ${statsigKeys.length}`;
        }
        throw error;
      }
    }
    exports2.Storage = {
      isReady: () => _current.isReady(),
      isReadyResolver: () => _current.isReadyResolver(),
      getProviderName: () => _current.getProviderName(),
      getItem: (key) => _inMemoryBreaker(() => _current.getItem(key)),
      setItem: (key, value) => _inMemoryBreaker(() => _current.setItem(key, value)),
      removeItem: (key) => _current.removeItem(key),
      getAllKeys: () => _current.getAllKeys(),
      // StorageProviderManagment
      _setProvider: (newProvider) => {
        _main = newProvider;
        _current = newProvider;
      },
      _setDisabled: (isDisabled) => {
        if (isDisabled) {
          _current = _inMemoryProvider;
        } else {
          _current = _main;
        }
      }
    };
    function _getObjectFromStorage(key) {
      const value = exports2.Storage.getItem(key);
      return JSON.parse(value !== null && value !== void 0 ? value : "null");
    }
    exports2._getObjectFromStorage = _getObjectFromStorage;
    function _setObjectInStorage(key, obj) {
      exports2.Storage.setItem(key, JSON.stringify(obj));
    }
    exports2._setObjectInStorage = _setObjectInStorage;
  }
});

// node_modules/@statsig/client-core/src/UrlConfiguration.js
var require_UrlConfiguration = __commonJS({
  "node_modules/@statsig/client-core/src/UrlConfiguration.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.UrlConfiguration = void 0;
    var Hashing_1 = require_Hashing();
    var NetworkConfig_1 = require_NetworkConfig();
    var ENDPOINT_DNS_KEY_MAP = {
      [NetworkConfig_1.Endpoint._initialize]: "i",
      [NetworkConfig_1.Endpoint._rgstr]: "e",
      [NetworkConfig_1.Endpoint._download_config_specs]: "d"
    };
    var UrlConfiguration = class {
      constructor(endpoint, customUrl, customApi, fallbackUrls) {
        this.customUrl = null;
        this.fallbackUrls = null;
        this.endpoint = endpoint;
        this.endpointDnsKey = ENDPOINT_DNS_KEY_MAP[endpoint];
        if (customUrl) {
          this.customUrl = customUrl;
        }
        if (!customUrl && customApi) {
          this.customUrl = customApi.endsWith("/") ? `${customApi}${endpoint}` : `${customApi}/${endpoint}`;
        }
        if (fallbackUrls) {
          this.fallbackUrls = fallbackUrls;
        }
        const defaultApi = NetworkConfig_1.NetworkDefault[endpoint];
        this.defaultUrl = `${defaultApi}/${endpoint}`;
      }
      getUrl() {
        var _a;
        return (_a = this.customUrl) !== null && _a !== void 0 ? _a : this.defaultUrl;
      }
      getChecksum() {
        var _a;
        const fallbacks = ((_a = this.fallbackUrls) !== null && _a !== void 0 ? _a : []).sort().join(",");
        return (0, Hashing_1._DJB2)(this.customUrl + fallbacks);
      }
    };
    exports2.UrlConfiguration = UrlConfiguration;
  }
});

// node_modules/@statsig/client-core/src/VisibilityObserving.js
var require_VisibilityObserving = __commonJS({
  "node_modules/@statsig/client-core/src/VisibilityObserving.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._notifyVisibilityChanged = exports2._subscribeToVisiblityChanged = exports2._isUnloading = exports2._isCurrentlyVisible = void 0;
    var SafeJs_1 = require_SafeJs();
    var FOREGROUND = "foreground";
    var BACKGROUND = "background";
    var LISTENERS = [];
    var current = FOREGROUND;
    var isUnloading = false;
    var _isCurrentlyVisible = () => {
      return current === FOREGROUND;
    };
    exports2._isCurrentlyVisible = _isCurrentlyVisible;
    var _isUnloading = () => isUnloading;
    exports2._isUnloading = _isUnloading;
    var _subscribeToVisiblityChanged = (listener) => {
      LISTENERS.unshift(listener);
    };
    exports2._subscribeToVisiblityChanged = _subscribeToVisiblityChanged;
    var _notifyVisibilityChanged = (visibility) => {
      if (visibility === current) {
        return;
      }
      current = visibility;
      LISTENERS.forEach((l) => l(visibility));
    };
    exports2._notifyVisibilityChanged = _notifyVisibilityChanged;
    (0, SafeJs_1._addWindowEventListenerSafe)("focus", () => {
      isUnloading = false;
      (0, exports2._notifyVisibilityChanged)(FOREGROUND);
    });
    (0, SafeJs_1._addWindowEventListenerSafe)("blur", () => (0, exports2._notifyVisibilityChanged)(BACKGROUND));
    (0, SafeJs_1._addDocumentEventListenerSafe)("visibilitychange", () => {
      (0, exports2._notifyVisibilityChanged)(document.visibilityState === "visible" ? FOREGROUND : BACKGROUND);
    });
    (0, SafeJs_1._addWindowEventListenerSafe)((0, SafeJs_1._getUnloadEvent)(), () => {
      isUnloading = true;
      (0, exports2._notifyVisibilityChanged)(BACKGROUND);
    });
  }
});

// node_modules/@statsig/client-core/src/EventLogger.js
var require_EventLogger = __commonJS({
  "node_modules/@statsig/client-core/src/EventLogger.js"(exports2) {
    "use strict";
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function(resolve) {
          resolve(value);
        });
      }
      return new (P || (P = Promise))(function(resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }
        function step(result) {
          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.EventLogger = void 0;
    var CacheKey_1 = require_CacheKey();
    var Hashing_1 = require_Hashing();
    var Log_1 = require_Log();
    var NetworkConfig_1 = require_NetworkConfig();
    var SafeJs_1 = require_SafeJs();
    var StatsigEvent_1 = require_StatsigEvent();
    var StatsigOptionsCommon_1 = require_StatsigOptionsCommon();
    var StorageProvider_1 = require_StorageProvider();
    var UrlConfiguration_1 = require_UrlConfiguration();
    var VisibilityObserving_1 = require_VisibilityObserving();
    var DEFAULT_QUEUE_SIZE = 100;
    var DEFAULT_FLUSH_INTERVAL_MS = 1e4;
    var MAX_DEDUPER_KEYS = 1e3;
    var DEDUPER_WINDOW_DURATION_MS = 6e5;
    var MAX_FAILED_LOGS = 500;
    var QUICK_FLUSH_WINDOW_MS = 200;
    var EVENT_LOGGER_MAP = {};
    var RetryFailedLogsTrigger = {
      Startup: "startup",
      GainedFocus: "gained_focus"
    };
    var EventLogger = class _EventLogger {
      static _safeFlushAndForget(sdkKey) {
        var _a;
        (_a = EVENT_LOGGER_MAP[sdkKey]) === null || _a === void 0 ? void 0 : _a.flush().catch(() => {
        });
      }
      static _safeRetryFailedLogs(sdkKey) {
        var _a;
        (_a = EVENT_LOGGER_MAP[sdkKey]) === null || _a === void 0 ? void 0 : _a._retryFailedLogs(RetryFailedLogsTrigger.GainedFocus);
      }
      constructor(_sdkKey, _emitter, _network, _options) {
        var _a, _b;
        this._sdkKey = _sdkKey;
        this._emitter = _emitter;
        this._network = _network;
        this._options = _options;
        this._queue = [];
        this._lastExposureTimeMap = {};
        this._nonExposedChecks = {};
        this._hasRunQuickFlush = false;
        this._creationTime = Date.now();
        this._loggingEnabled = (_a = _options === null || _options === void 0 ? void 0 : _options.loggingEnabled) !== null && _a !== void 0 ? _a : (_options === null || _options === void 0 ? void 0 : _options.disableLogging) === true ? StatsigOptionsCommon_1.LoggingEnabledOption.disabled : StatsigOptionsCommon_1.LoggingEnabledOption.browserOnly;
        if ((_options === null || _options === void 0 ? void 0 : _options.loggingEnabled) && _options.disableLogging !== void 0) {
          Log_1.Log.warn("Detected both loggingEnabled and disableLogging options. loggingEnabled takes precedence - please remove disableLogging.");
        }
        this._maxQueueSize = (_b = _options === null || _options === void 0 ? void 0 : _options.loggingBufferMaxSize) !== null && _b !== void 0 ? _b : DEFAULT_QUEUE_SIZE;
        const config = _options === null || _options === void 0 ? void 0 : _options.networkConfig;
        this._logEventUrlConfig = new UrlConfiguration_1.UrlConfiguration(NetworkConfig_1.Endpoint._rgstr, config === null || config === void 0 ? void 0 : config.logEventUrl, config === null || config === void 0 ? void 0 : config.api, config === null || config === void 0 ? void 0 : config.logEventFallbackUrls);
      }
      setLogEventCompressionMode(mode) {
        this._network.setLogEventCompressionMode(mode);
      }
      setLoggingEnabled(loggingEnabled) {
        if (this._loggingEnabled === "disabled" && loggingEnabled !== "disabled") {
          const storageKey = this._getStorageKey();
          const events = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
          if (events) {
            this._queue.push(...events);
          }
          StorageProvider_1.Storage.removeItem(storageKey);
        }
        this._loggingEnabled = loggingEnabled;
      }
      enqueue(event) {
        if (!this._shouldLogEvent(event)) {
          return;
        }
        this._normalizeAndAppendEvent(event);
        this._quickFlushIfNeeded();
        if (this._queue.length > this._maxQueueSize) {
          _EventLogger._safeFlushAndForget(this._sdkKey);
        }
      }
      incrementNonExposureCount(name) {
        var _a;
        const current = (_a = this._nonExposedChecks[name]) !== null && _a !== void 0 ? _a : 0;
        this._nonExposedChecks[name] = current + 1;
      }
      reset() {
        this.flush().catch(() => {
        });
        this._lastExposureTimeMap = {};
      }
      start() {
        var _a;
        const isServerEnv = (0, SafeJs_1._isServerEnv)();
        if (isServerEnv && ((_a = this._options) === null || _a === void 0 ? void 0 : _a.loggingEnabled) !== "always") {
          return;
        }
        EVENT_LOGGER_MAP[this._sdkKey] = this;
        if (!isServerEnv) {
          (0, VisibilityObserving_1._subscribeToVisiblityChanged)((visibility) => {
            if (visibility === "background") {
              _EventLogger._safeFlushAndForget(this._sdkKey);
            } else if (visibility === "foreground") {
              _EventLogger._safeRetryFailedLogs(this._sdkKey);
            }
          });
        }
        this._retryFailedLogs(RetryFailedLogsTrigger.Startup);
        this._startBackgroundFlushInterval();
      }
      stop() {
        return __awaiter(this, void 0, void 0, function* () {
          if (this._flushIntervalId) {
            clearInterval(this._flushIntervalId);
            this._flushIntervalId = null;
          }
          delete EVENT_LOGGER_MAP[this._sdkKey];
          yield this.flush();
        });
      }
      flush() {
        return __awaiter(this, void 0, void 0, function* () {
          this._appendAndResetNonExposedChecks();
          if (this._queue.length === 0) {
            return;
          }
          const events = this._queue;
          this._queue = [];
          yield this._sendEvents(events);
        });
      }
      /**
       * We 'Quick Flush' following the very first event enqueued
       * within the quick flush window
       */
      _quickFlushIfNeeded() {
        if (this._hasRunQuickFlush) {
          return;
        }
        this._hasRunQuickFlush = true;
        if (Date.now() - this._creationTime > QUICK_FLUSH_WINDOW_MS) {
          return;
        }
        setTimeout(() => _EventLogger._safeFlushAndForget(this._sdkKey), QUICK_FLUSH_WINDOW_MS);
      }
      _shouldLogEvent(event) {
        var _a;
        if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.loggingEnabled) !== "always" && (0, SafeJs_1._isServerEnv)()) {
          return false;
        }
        if (!(0, StatsigEvent_1._isExposureEvent)(event)) {
          return true;
        }
        const user = event.user ? event.user : { statsigEnvironment: void 0 };
        const userKey = (0, CacheKey_1._getUserStorageKey)(this._sdkKey, user);
        const metadata = event.metadata ? event.metadata : {};
        const key = [
          event.eventName,
          userKey,
          metadata["gate"],
          metadata["config"],
          metadata["ruleID"],
          metadata["allocatedExperiment"],
          metadata["parameterName"],
          String(metadata["isExplicitParameter"]),
          metadata["reason"]
        ].join("|");
        const previous = this._lastExposureTimeMap[key];
        const now = Date.now();
        if (previous && now - previous < DEDUPER_WINDOW_DURATION_MS) {
          return false;
        }
        if (Object.keys(this._lastExposureTimeMap).length > MAX_DEDUPER_KEYS) {
          this._lastExposureTimeMap = {};
        }
        this._lastExposureTimeMap[key] = now;
        return true;
      }
      _sendEvents(events) {
        return __awaiter(this, void 0, void 0, function* () {
          var _a, _b;
          if (this._loggingEnabled === "disabled") {
            this._saveFailedLogsToStorage(events);
            return false;
          }
          try {
            const isClosing = (0, VisibilityObserving_1._isUnloading)();
            const shouldUseBeacon = isClosing && this._network.isBeaconSupported() && ((_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.networkConfig) === null || _b === void 0 ? void 0 : _b.networkOverrideFunc) == null;
            this._emitter({
              name: "pre_logs_flushed",
              events
            });
            const response = shouldUseBeacon ? this._sendEventsViaBeacon(events) : yield this._sendEventsViaPost(events);
            if (response.success) {
              this._emitter({
                name: "logs_flushed",
                events
              });
              return true;
            } else {
              Log_1.Log.warn("Failed to flush events.");
              this._saveFailedLogsToStorage(events);
              return false;
            }
          } catch (_c) {
            Log_1.Log.warn("Failed to flush events.");
            return false;
          }
        });
      }
      _sendEventsViaPost(events) {
        return __awaiter(this, void 0, void 0, function* () {
          var _a;
          const result = yield this._network.post(this._getRequestData(events));
          const code = (_a = result === null || result === void 0 ? void 0 : result.code) !== null && _a !== void 0 ? _a : -1;
          return { success: code >= 200 && code < 300 };
        });
      }
      _sendEventsViaBeacon(events) {
        return {
          success: this._network.beacon(this._getRequestData(events))
        };
      }
      _getRequestData(events) {
        return {
          sdkKey: this._sdkKey,
          data: {
            events
          },
          urlConfig: this._logEventUrlConfig,
          retries: 3,
          isCompressable: true,
          params: {
            [NetworkConfig_1.NetworkParam.EventCount]: String(events.length)
          },
          credentials: "same-origin"
        };
      }
      _saveFailedLogsToStorage(events) {
        while (events.length > MAX_FAILED_LOGS) {
          events.shift();
        }
        const storageKey = this._getStorageKey();
        try {
          const savedEvents = this._getFailedLogsFromStorage(storageKey);
          (0, StorageProvider_1._setObjectInStorage)(storageKey, [...savedEvents, ...events]);
        } catch (_a) {
          Log_1.Log.warn("Unable to save failed logs to storage");
        }
      }
      _getFailedLogsFromStorage(storageKey) {
        let savedEvents = [];
        try {
          const retrieved = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
          if (Array.isArray(retrieved)) {
            savedEvents = retrieved;
          }
          return savedEvents;
        } catch (_a) {
          return [];
        }
      }
      _retryFailedLogs(trigger) {
        const storageKey = this._getStorageKey();
        (() => __awaiter(this, void 0, void 0, function* () {
          if (!StorageProvider_1.Storage.isReady()) {
            yield StorageProvider_1.Storage.isReadyResolver();
          }
          const events = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
          if (!events) {
            return;
          }
          if (trigger === RetryFailedLogsTrigger.Startup) {
            StorageProvider_1.Storage.removeItem(storageKey);
          }
          const isSuccess = yield this._sendEvents(events);
          if (isSuccess && trigger === RetryFailedLogsTrigger.GainedFocus) {
            StorageProvider_1.Storage.removeItem(storageKey);
          }
        }))().catch(() => {
          Log_1.Log.warn("Failed to flush stored logs");
        });
      }
      _getStorageKey() {
        return `statsig.failed_logs.${(0, Hashing_1._DJB2)(this._sdkKey)}`;
      }
      _normalizeAndAppendEvent(event) {
        if (event.user) {
          event.user = Object.assign({}, event.user);
          delete event.user.privateAttributes;
        }
        const extras = {};
        const currentPage = this._getCurrentPageUrl();
        if (currentPage) {
          extras.statsigMetadata = { currentPage };
        }
        const final = Object.assign(Object.assign({}, event), extras);
        Log_1.Log.debug("Enqueued Event:", final);
        this._queue.push(final);
      }
      _appendAndResetNonExposedChecks() {
        if (Object.keys(this._nonExposedChecks).length === 0) {
          return;
        }
        this._normalizeAndAppendEvent({
          eventName: "statsig::non_exposed_checks",
          user: null,
          time: Date.now(),
          metadata: {
            checks: Object.assign({}, this._nonExposedChecks)
          }
        });
        this._nonExposedChecks = {};
      }
      _getCurrentPageUrl() {
        var _a;
        if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.includeCurrentPageUrlWithEvents) === false) {
          return;
        }
        return (0, SafeJs_1._getCurrentPageUrlSafe)();
      }
      _startBackgroundFlushInterval() {
        var _a, _b;
        const flushInterval = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.loggingIntervalMs) !== null && _b !== void 0 ? _b : DEFAULT_FLUSH_INTERVAL_MS;
        const intervalId = setInterval(() => {
          const logger = EVENT_LOGGER_MAP[this._sdkKey];
          if (!logger || logger._flushIntervalId !== intervalId) {
            clearInterval(intervalId);
          } else {
            _EventLogger._safeFlushAndForget(this._sdkKey);
          }
        }, flushInterval);
        this._flushIntervalId = intervalId;
      }
    };
    exports2.EventLogger = EventLogger;
  }
});

// node_modules/@statsig/client-core/src/StatsigMetadata.js
var require_StatsigMetadata = __commonJS({
  "node_modules/@statsig/client-core/src/StatsigMetadata.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.StatsigMetadataProvider = exports2.SDK_VERSION = void 0;
    exports2.SDK_VERSION = "3.25.3";
    var metadata = {
      sdkVersion: exports2.SDK_VERSION,
      sdkType: "js-mono"
      // js-mono is overwritten by Precomp and OnDevice clients
    };
    exports2.StatsigMetadataProvider = {
      get: () => metadata,
      add: (additions) => {
        metadata = Object.assign(Object.assign({}, metadata), additions);
      }
    };
  }
});

// node_modules/@statsig/client-core/src/ClientInterfaces.js
var require_ClientInterfaces = __commonJS({
  "node_modules/@statsig/client-core/src/ClientInterfaces.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// node_modules/@statsig/client-core/src/UUID.js
var require_UUID = __commonJS({
  "node_modules/@statsig/client-core/src/UUID.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getUUID = void 0;
    function getUUID() {
      if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
        return crypto.randomUUID();
      }
      let d = (/* @__PURE__ */ new Date()).getTime();
      let d2 = typeof performance !== "undefined" && performance.now && performance.now() * 1e3 || 0;
      const y = "89ab"[Math.floor(Math.random() * 4)];
      return `xxxxxxxx-xxxx-4xxx-${y}xxx-xxxxxxxxxxxx`.replace(/[xy]/g, (c) => {
        let r = Math.random() * 16;
        if (d > 0) {
          r = (d + r) % 16 | 0;
          d = Math.floor(d / 16);
        } else {
          r = (d2 + r) % 16 | 0;
          d2 = Math.floor(d2 / 16);
        }
        return (c === "x" ? r : r & 7 | 8).toString(16);
      });
    }
    exports2.getUUID = getUUID;
  }
});

// node_modules/@statsig/client-core/src/StableID.js
var require_StableID = __commonJS({
  "node_modules/@statsig/client-core/src/StableID.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getCookieName = exports2.StableID = void 0;
    var CacheKey_1 = require_CacheKey();
    var Log_1 = require_Log();
    var SafeJs_1 = require_SafeJs();
    var StorageProvider_1 = require_StorageProvider();
    var UUID_1 = require_UUID();
    var PROMISE_MAP = {};
    var COOKIE_ENABLED_MAP = {};
    var DISABLED_MAP = {};
    exports2.StableID = {
      cookiesEnabled: false,
      randomID: Math.random().toString(36),
      get: (sdkKey) => {
        if (DISABLED_MAP[sdkKey]) {
          return null;
        }
        if (PROMISE_MAP[sdkKey] != null) {
          return PROMISE_MAP[sdkKey];
        }
        let stableID = null;
        stableID = _loadFromCookie(sdkKey);
        if (stableID != null) {
          PROMISE_MAP[sdkKey] = stableID;
          _persistToStorage(stableID, sdkKey);
          return stableID;
        }
        stableID = _loadFromStorage(sdkKey);
        if (stableID == null) {
          stableID = (0, UUID_1.getUUID)();
        }
        _persistToStorage(stableID, sdkKey);
        _persistToCookie(stableID, sdkKey);
        PROMISE_MAP[sdkKey] = stableID;
        return stableID;
      },
      setOverride: (override, sdkKey) => {
        PROMISE_MAP[sdkKey] = override;
        _persistToStorage(override, sdkKey);
        _persistToCookie(override, sdkKey);
      },
      _setCookiesEnabled: (sdkKey, cookiesEnabled) => {
        COOKIE_ENABLED_MAP[sdkKey] = cookiesEnabled;
      },
      _setDisabled: (sdkKey, disabled) => {
        DISABLED_MAP[sdkKey] = disabled;
      }
    };
    function _getStableIDStorageKey(sdkKey) {
      return `statsig.stable_id.${(0, CacheKey_1._getStorageKey)(sdkKey)}`;
    }
    function _persistToStorage(stableID, sdkKey) {
      const storageKey = _getStableIDStorageKey(sdkKey);
      try {
        (0, StorageProvider_1._setObjectInStorage)(storageKey, stableID);
      } catch (e) {
        Log_1.Log.warn("Failed to save StableID to storage");
      }
    }
    function _loadFromStorage(sdkKey) {
      const storageKey = _getStableIDStorageKey(sdkKey);
      return (0, StorageProvider_1._getObjectFromStorage)(storageKey);
    }
    function _loadFromCookie(sdkKey) {
      if (!COOKIE_ENABLED_MAP[sdkKey] || (0, SafeJs_1._getDocumentSafe)() == null) {
        return null;
      }
      const cookies = document.cookie.split(";");
      for (const cookie of cookies) {
        const [key, value] = cookie.trim().split("=");
        if (key === getCookieName(sdkKey)) {
          return decodeURIComponent(value);
        }
      }
      return null;
    }
    function _persistToCookie(stableID, sdkKey) {
      if (!COOKIE_ENABLED_MAP[sdkKey] || (0, SafeJs_1._getDocumentSafe)() == null) {
        return;
      }
      const expiryDate = /* @__PURE__ */ new Date();
      expiryDate.setFullYear(expiryDate.getFullYear() + 1);
      document.cookie = `${getCookieName(sdkKey)}=${encodeURIComponent(stableID)}; expires=${expiryDate.toUTCString()}; path=/`;
    }
    function getCookieName(sdkKey) {
      return `statsig.stable_id.${(0, CacheKey_1._getStorageKey)(sdkKey)}`;
    }
    exports2.getCookieName = getCookieName;
  }
});

// node_modules/@statsig/client-core/src/StatsigUser.js
var require_StatsigUser = __commonJS({
  "node_modules/@statsig/client-core/src/StatsigUser.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._getFullUserHash = exports2._normalizeUser = void 0;
    var Hashing_1 = require_Hashing();
    var Log_1 = require_Log();
    function _normalizeUser(original, options, fallbackEnvironment) {
      try {
        const copy = JSON.parse(JSON.stringify(original));
        if (options != null && options.environment != null) {
          copy.statsigEnvironment = options.environment;
        } else if (fallbackEnvironment != null) {
          copy.statsigEnvironment = { tier: fallbackEnvironment };
        }
        return copy;
      } catch (error) {
        Log_1.Log.error("Failed to JSON.stringify user");
        return { statsigEnvironment: void 0 };
      }
    }
    exports2._normalizeUser = _normalizeUser;
    function _getFullUserHash(user) {
      return user ? (0, Hashing_1._DJB2Object)(user) : null;
    }
    exports2._getFullUserHash = _getFullUserHash;
  }
});

// node_modules/@statsig/client-core/src/TypedJsonParse.js
var require_TypedJsonParse = __commonJS({
  "node_modules/@statsig/client-core/src/TypedJsonParse.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._typedJsonParse = void 0;
    var Log_1 = require_Log();
    function _typedJsonParse(data, guard, typeName) {
      try {
        const result = JSON.parse(data);
        if (result && typeof result === "object" && guard in result) {
          return result;
        }
      } catch (_a) {
      }
      Log_1.Log.error(`Failed to parse ${typeName}`);
      return null;
    }
    exports2._typedJsonParse = _typedJsonParse;
  }
});

// node_modules/@statsig/client-core/src/DataAdapterCore.js
var require_DataAdapterCore = __commonJS({
  "node_modules/@statsig/client-core/src/DataAdapterCore.js"(exports2) {
    "use strict";
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function(resolve) {
          resolve(value);
        });
      }
      return new (P || (P = Promise))(function(resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }
        function step(result) {
          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._makeDataAdapterResult = exports2.DataAdapterCore = void 0;
    var Log_1 = require_Log();
    var StableID_1 = require_StableID();
    var StatsigUser_1 = require_StatsigUser();
    var StorageProvider_1 = require_StorageProvider();
    var TypedJsonParse_1 = require_TypedJsonParse();
    var CACHE_LIMIT = 10;
    var MAX_CACHE_WRITE_ATTEMPTS = 8;
    var DataAdapterCore = class {
      constructor(_adapterName, _cacheSuffix) {
        this._adapterName = _adapterName;
        this._cacheSuffix = _cacheSuffix;
        this._options = null;
        this._sdkKey = null;
        this._cacheLimit = CACHE_LIMIT;
        this._lastModifiedStoreKey = `statsig.last_modified_time.${_cacheSuffix}`;
        this._inMemoryCache = new InMemoryCache();
      }
      attach(sdkKey, options, _network) {
        this._sdkKey = sdkKey;
        this._options = options;
      }
      getDataSync(user) {
        const normalized = user && (0, StatsigUser_1._normalizeUser)(user, this._options);
        const cacheKey = this._getCacheKey(normalized);
        const inMem = this._inMemoryCache.get(cacheKey, normalized);
        if (inMem && this._getIsCacheValueValid(inMem)) {
          return inMem;
        }
        const cache = this._loadFromCache(cacheKey);
        if (cache && this._getIsCacheValueValid(cache)) {
          this._inMemoryCache.add(cacheKey, cache, this._cacheLimit);
          return this._inMemoryCache.get(cacheKey, normalized);
        }
        return null;
      }
      setData(data, user) {
        const normalized = user && (0, StatsigUser_1._normalizeUser)(user, this._options);
        const cacheKey = this._getCacheKey(normalized);
        this._inMemoryCache.add(cacheKey, _makeDataAdapterResult("Bootstrap", data, null, normalized), this._cacheLimit);
      }
      _getIsCacheValueValid(current) {
        return current.stableID == null || current.stableID === StableID_1.StableID.get(this._getSdkKey());
      }
      _getDataAsyncImpl(current, user, options) {
        return __awaiter(this, void 0, void 0, function* () {
          if (!StorageProvider_1.Storage.isReady()) {
            yield StorageProvider_1.Storage.isReadyResolver();
          }
          const cache = current !== null && current !== void 0 ? current : this.getDataSync(user);
          const ops = [this._fetchAndPrepFromNetwork(cache, user, options)];
          if (options === null || options === void 0 ? void 0 : options.timeoutMs) {
            ops.push(new Promise((r) => setTimeout(r, options.timeoutMs)).then(() => {
              Log_1.Log.debug("Fetching latest value timed out");
              return null;
            }));
          }
          return yield Promise.race(ops);
        });
      }
      _prefetchDataImpl(user, options) {
        return __awaiter(this, void 0, void 0, function* () {
          const normalized = user && (0, StatsigUser_1._normalizeUser)(user, this._options);
          const cacheKey = this._getCacheKey(normalized);
          const result = yield this._getDataAsyncImpl(null, normalized, options);
          if (result) {
            this._inMemoryCache.add(cacheKey, Object.assign(Object.assign({}, result), { source: "Prefetch" }), this._cacheLimit);
          }
        });
      }
      _fetchAndPrepFromNetwork(cachedResult, user, options) {
        return __awaiter(this, void 0, void 0, function* () {
          var _a;
          const cachedData = (_a = cachedResult === null || cachedResult === void 0 ? void 0 : cachedResult.data) !== null && _a !== void 0 ? _a : null;
          const isCacheValidFor204 = cachedResult != null && this._isCachedResultValidFor204(cachedResult, user);
          const latest = yield this._fetchFromNetwork(cachedData, user, options, isCacheValidFor204);
          if (!latest) {
            Log_1.Log.debug("No response returned for latest value");
            return null;
          }
          const response = (0, TypedJsonParse_1._typedJsonParse)(latest, "has_updates", "Response");
          const sdkKey = this._getSdkKey();
          const stableID = StableID_1.StableID.get(sdkKey);
          let result = null;
          if ((response === null || response === void 0 ? void 0 : response.has_updates) === true) {
            result = _makeDataAdapterResult("Network", latest, stableID, user);
          } else if (cachedData && (response === null || response === void 0 ? void 0 : response.has_updates) === false) {
            result = _makeDataAdapterResult("NetworkNotModified", cachedData, stableID, user);
          } else {
            return null;
          }
          const cacheKey = this._getCacheKey(user);
          this._inMemoryCache.add(cacheKey, result, this._cacheLimit);
          this._writeToCache(cacheKey, result);
          return result;
        });
      }
      _getSdkKey() {
        if (this._sdkKey != null) {
          return this._sdkKey;
        }
        Log_1.Log.error(`${this._adapterName} is not attached to a Client`);
        return "";
      }
      _loadFromCache(cacheKey) {
        var _a;
        const cache = (_a = StorageProvider_1.Storage.getItem) === null || _a === void 0 ? void 0 : _a.call(StorageProvider_1.Storage, cacheKey);
        if (cache == null) {
          return null;
        }
        const result = (0, TypedJsonParse_1._typedJsonParse)(cache, "source", "Cached Result");
        return result ? Object.assign(Object.assign({}, result), { source: "Cache" }) : null;
      }
      _writeToCache(cacheKey, result) {
        const resultString = JSON.stringify(result);
        for (let i = 0; i < MAX_CACHE_WRITE_ATTEMPTS; i++) {
          try {
            StorageProvider_1.Storage.setItem(cacheKey, resultString);
            break;
          } catch (error) {
            if (!(error instanceof Error) || error.name !== "QuotaExceededError" || this._cacheLimit <= 1) {
              throw error;
            }
            this._cacheLimit = Math.ceil(this._cacheLimit / 2);
            this._runLocalStorageCacheEviction(cacheKey, this._cacheLimit - 1);
          }
        }
        this._runLocalStorageCacheEviction(cacheKey);
      }
      _runLocalStorageCacheEviction(cacheKey, cacheLimit = this._cacheLimit) {
        var _a;
        const lastModifiedTimeMap = (_a = (0, StorageProvider_1._getObjectFromStorage)(this._lastModifiedStoreKey)) !== null && _a !== void 0 ? _a : {};
        lastModifiedTimeMap[cacheKey] = Date.now();
        const evictableKeys = _getEvictableKeys(lastModifiedTimeMap, cacheLimit);
        for (const evictable of evictableKeys) {
          delete lastModifiedTimeMap[evictable];
          StorageProvider_1.Storage.removeItem(evictable);
        }
        (0, StorageProvider_1._setObjectInStorage)(this._lastModifiedStoreKey, lastModifiedTimeMap);
      }
    };
    exports2.DataAdapterCore = DataAdapterCore;
    function _makeDataAdapterResult(source, data, stableID, user) {
      return {
        source,
        data,
        receivedAt: Date.now(),
        stableID,
        fullUserHash: (0, StatsigUser_1._getFullUserHash)(user)
      };
    }
    exports2._makeDataAdapterResult = _makeDataAdapterResult;
    var InMemoryCache = class {
      constructor() {
        this._data = {};
      }
      get(cacheKey, user) {
        var _a;
        const result = this._data[cacheKey];
        const cached = result === null || result === void 0 ? void 0 : result.stableID;
        const provided = (_a = user === null || user === void 0 ? void 0 : user.customIDs) === null || _a === void 0 ? void 0 : _a.stableID;
        if (provided && cached && provided !== cached) {
          Log_1.Log.warn("'StatsigUser.customIDs.stableID' mismatch");
          return null;
        }
        return result;
      }
      add(cacheKey, value, cacheLimit) {
        const evictableKeys = _getEvictableKeys(this._data, cacheLimit - 1);
        for (const evictable of evictableKeys) {
          delete this._data[evictable];
        }
        this._data[cacheKey] = value;
      }
      merge(values) {
        this._data = Object.assign(Object.assign({}, this._data), values);
      }
    };
    function _getEvictableKeys(data, limit) {
      const keys = Object.keys(data);
      if (keys.length <= limit) {
        return [];
      }
      if (limit === 0) {
        return keys;
      }
      return keys.sort((keyA, keyB) => {
        const valueA = data[keyA];
        const valueB = data[keyB];
        if (typeof valueA === "object" && typeof valueB === "object") {
          return valueA.receivedAt - valueB.receivedAt;
        }
        return valueA - valueB;
      }).slice(0, keys.length - limit);
    }
  }
});

// node_modules/@statsig/client-core/src/DownloadConfigSpecsResponse.js
var require_DownloadConfigSpecsResponse = __commonJS({
  "node_modules/@statsig/client-core/src/DownloadConfigSpecsResponse.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// node_modules/@statsig/client-core/src/SDKType.js
var require_SDKType = __commonJS({
  "node_modules/@statsig/client-core/src/SDKType.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SDKType = void 0;
    var SDK_CLIENT = {};
    var suffix;
    exports2.SDKType = {
      _get: (sdkKey) => {
        var _a;
        return ((_a = SDK_CLIENT[sdkKey]) !== null && _a !== void 0 ? _a : "js-mono") + (suffix !== null && suffix !== void 0 ? suffix : "");
      },
      _setClientType(sdkKey, client) {
        SDK_CLIENT[sdkKey] = client;
      },
      _setBindingType(binding) {
        if (!suffix || suffix === "-react") {
          suffix = "-" + binding;
        }
      }
    };
  }
});

// node_modules/@statsig/client-core/src/ErrorBoundary.js
var require_ErrorBoundary = __commonJS({
  "node_modules/@statsig/client-core/src/ErrorBoundary.js"(exports2) {
    "use strict";
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function(resolve) {
          resolve(value);
        });
      }
      return new (P || (P = Promise))(function(resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }
        function step(result) {
          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ErrorBoundary = exports2.EXCEPTION_ENDPOINT = void 0;
    var Log_1 = require_Log();
    var SDKType_1 = require_SDKType();
    var StatsigMetadata_1 = require_StatsigMetadata();
    exports2.EXCEPTION_ENDPOINT = "https://statsigapi.net/v1/sdk_exception";
    var UNKNOWN_ERROR = "[Statsig] UnknownError";
    var ErrorBoundary = class {
      constructor(_sdkKey, _options, _emitter, _lastSeenError) {
        this._sdkKey = _sdkKey;
        this._options = _options;
        this._emitter = _emitter;
        this._lastSeenError = _lastSeenError;
        this._seen = /* @__PURE__ */ new Set();
      }
      wrap(instance, namePrefix) {
        try {
          const obj = instance;
          _getAllInstanceMethodNames(obj).forEach((name) => {
            const original = obj[name];
            if ("$EB" in original) {
              return;
            }
            obj[name] = (...args2) => {
              return this._capture(namePrefix ? `${namePrefix}:${name}` : name, () => original.apply(instance, args2));
            };
            obj[name].$EB = true;
          });
        } catch (err) {
          this._onError("eb:wrap", err);
        }
      }
      logError(tag, error) {
        this._onError(tag, error);
      }
      getLastSeenErrorAndReset() {
        const tempError = this._lastSeenError;
        this._lastSeenError = void 0;
        return tempError !== null && tempError !== void 0 ? tempError : null;
      }
      attachErrorIfNoneExists(error) {
        if (this._lastSeenError) {
          return;
        }
        this._lastSeenError = _resolveError(error);
      }
      _capture(tag, task) {
        try {
          const res = task();
          if (res && res instanceof Promise) {
            return res.catch((err) => this._onError(tag, err));
          }
          return res;
        } catch (error) {
          this._onError(tag, error);
          return null;
        }
      }
      _onError(tag, error) {
        try {
          Log_1.Log.warn(`Caught error in ${tag}`, { error });
          const impl = () => __awaiter(this, void 0, void 0, function* () {
            var _a, _b, _c, _d, _e, _f, _g;
            const unwrapped = error ? error : Error(UNKNOWN_ERROR);
            const isError = unwrapped instanceof Error;
            const name = isError ? unwrapped.name : "No Name";
            const resolvedError = _resolveError(unwrapped);
            this._lastSeenError = resolvedError;
            if (this._seen.has(name)) {
              return;
            }
            this._seen.add(name);
            if ((_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.networkConfig) === null || _b === void 0 ? void 0 : _b.preventAllNetworkTraffic) {
              (_c = this._emitter) === null || _c === void 0 ? void 0 : _c.call(this, {
                name: "error",
                error,
                tag
              });
              return;
            }
            const sdkType = SDKType_1.SDKType._get(this._sdkKey);
            const statsigMetadata = StatsigMetadata_1.StatsigMetadataProvider.get();
            const info = isError ? unwrapped.stack : _getDescription(unwrapped);
            const body = Object.assign({ tag, exception: name, info, statsigOptions: _getStatsigOptionLoggingCopy(this._options) }, Object.assign(Object.assign({}, statsigMetadata), { sdkType }));
            const func = (_f = (_e = (_d = this._options) === null || _d === void 0 ? void 0 : _d.networkConfig) === null || _e === void 0 ? void 0 : _e.networkOverrideFunc) !== null && _f !== void 0 ? _f : fetch;
            yield func(exports2.EXCEPTION_ENDPOINT, {
              method: "POST",
              headers: {
                "STATSIG-API-KEY": this._sdkKey,
                "STATSIG-SDK-TYPE": String(sdkType),
                "STATSIG-SDK-VERSION": String(statsigMetadata.sdkVersion),
                "Content-Type": "application/json"
              },
              body: JSON.stringify(body)
            });
            (_g = this._emitter) === null || _g === void 0 ? void 0 : _g.call(this, {
              name: "error",
              error,
              tag
            });
          });
          impl().then(() => {
          }).catch(() => {
          });
        } catch (_error) {
        }
      }
    };
    exports2.ErrorBoundary = ErrorBoundary;
    function _resolveError(error) {
      if (error instanceof Error) {
        return error;
      } else if (typeof error === "string") {
        return new Error(error);
      } else {
        return new Error("An unknown error occurred.");
      }
    }
    function _getDescription(obj) {
      try {
        return JSON.stringify(obj);
      } catch (_a) {
        return UNKNOWN_ERROR;
      }
    }
    function _getAllInstanceMethodNames(instance) {
      const names = /* @__PURE__ */ new Set();
      let proto = Object.getPrototypeOf(instance);
      while (proto && proto !== Object.prototype) {
        Object.getOwnPropertyNames(proto).filter((prop) => typeof (proto === null || proto === void 0 ? void 0 : proto[prop]) === "function").forEach((name) => names.add(name));
        proto = Object.getPrototypeOf(proto);
      }
      return Array.from(names);
    }
    function _getStatsigOptionLoggingCopy(options) {
      if (!options) {
        return {};
      }
      const loggingCopy = {};
      Object.keys(options).forEach((key) => {
        const option = key;
        const value = options[option];
        const valueType = typeof value;
        switch (valueType) {
          case "number":
          case "bigint":
          case "boolean":
            loggingCopy[String(option)] = value;
            break;
          case "string":
            if (value.length < 50) {
              loggingCopy[String(option)] = value;
            } else {
              loggingCopy[String(option)] = "set";
            }
            break;
          case "object":
            if (option === "environment") {
              loggingCopy["environment"] = value;
            } else if (option === "networkConfig") {
              loggingCopy["networkConfig"] = value;
            } else {
              loggingCopy[String(option)] = value != null ? "set" : "unset";
            }
            break;
          default:
        }
      });
      return loggingCopy;
    }
  }
});

// node_modules/@statsig/client-core/src/EvaluationOptions.js
var require_EvaluationOptions = __commonJS({
  "node_modules/@statsig/client-core/src/EvaluationOptions.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// node_modules/@statsig/client-core/src/EvaluationTypes.js
var require_EvaluationTypes = __commonJS({
  "node_modules/@statsig/client-core/src/EvaluationTypes.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// node_modules/@statsig/client-core/src/InitializeResponse.js
var require_InitializeResponse = __commonJS({
  "node_modules/@statsig/client-core/src/InitializeResponse.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// node_modules/@statsig/client-core/src/MemoKey.js
var require_MemoKey = __commonJS({
  "node_modules/@statsig/client-core/src/MemoKey.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createMemoKey = exports2.MemoPrefix = void 0;
    exports2.MemoPrefix = {
      _gate: "g",
      _dynamicConfig: "c",
      _experiment: "e",
      _configList: "cl",
      _layer: "l",
      _paramStore: "p"
    };
    var EXIST_KEYS = /* @__PURE__ */ new Set([
      // Add keys that should be memoized based only on their existence, not their value
    ]);
    var DO_NOT_MEMO_KEYS = /* @__PURE__ */ new Set([
      // Add keys that if exist, should not be memoized
      "userPersistedValues"
    ]);
    function createMemoKey(prefix, name, options) {
      let cacheKey = `${prefix}|${name}`;
      if (!options) {
        return cacheKey;
      }
      for (const key of Object.keys(options)) {
        if (DO_NOT_MEMO_KEYS.has(key)) {
          return void 0;
        }
        if (EXIST_KEYS.has(key)) {
          cacheKey += `|${key}=true`;
        } else {
          cacheKey += `|${key}=${options[key]}`;
        }
      }
      return cacheKey;
    }
    exports2.createMemoKey = createMemoKey;
  }
});

// node_modules/@statsig/client-core/src/DnsTxtQuery.js
var require_DnsTxtQuery = __commonJS({
  "node_modules/@statsig/client-core/src/DnsTxtQuery.js"(exports2) {
    "use strict";
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function(resolve) {
          resolve(value);
        });
      }
      return new (P || (P = Promise))(function(resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }
        function step(result) {
          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._fetchTxtRecords = void 0;
    var FEATURE_ASSETS_DNS_QUERY = new Uint8Array([
      0,
      0,
      1,
      0,
      0,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      13,
      102,
      101,
      97,
      116,
      117,
      114,
      101,
      97,
      115,
      115,
      101,
      116,
      115,
      3,
      111,
      114,
      103,
      0,
      0,
      16,
      0,
      1
    ]);
    var DNS_QUERY_ENDPOINT = "https://cloudflare-dns.com/dns-query";
    var DOMAIN_CHARS = [
      "i",
      // initialize
      "e",
      // events
      "d"
      // dcs
    ];
    var MAX_START_LOOKUP = 200;
    function _fetchTxtRecords(networkFunc) {
      return __awaiter(this, void 0, void 0, function* () {
        const response = yield networkFunc(DNS_QUERY_ENDPOINT, {
          method: "POST",
          headers: {
            "Content-Type": "application/dns-message",
            Accept: "application/dns-message"
          },
          body: FEATURE_ASSETS_DNS_QUERY
        });
        if (!response.ok) {
          const err = new Error("Failed to fetch TXT records from DNS");
          err.name = "DnsTxtFetchError";
          throw err;
        }
        const data = yield response.arrayBuffer();
        const bytes = new Uint8Array(data);
        return _parseDnsResponse(bytes);
      });
    }
    exports2._fetchTxtRecords = _fetchTxtRecords;
    function _parseDnsResponse(input2) {
      const start = input2.findIndex((byte, index) => index < MAX_START_LOOKUP && String.fromCharCode(byte) === "=" && DOMAIN_CHARS.includes(String.fromCharCode(input2[index - 1])));
      if (start === -1) {
        const err = new Error("Failed to parse TXT records from DNS");
        err.name = "DnsTxtParseError";
        throw err;
      }
      let result = "";
      for (let i = start - 1; i < input2.length; i++) {
        result += String.fromCharCode(input2[i]);
      }
      return result.split(",");
    }
  }
});

// node_modules/@statsig/client-core/src/NetworkFallbackResolver.js
var require_NetworkFallbackResolver = __commonJS({
  "node_modules/@statsig/client-core/src/NetworkFallbackResolver.js"(exports2) {
    "use strict";
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function(resolve) {
          resolve(value);
        });
      }
      return new (P || (P = Promise))(function(resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }
        function step(result) {
          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._isDomainFailure = exports2.NetworkFallbackResolver = void 0;
    var DnsTxtQuery_1 = require_DnsTxtQuery();
    var Hashing_1 = require_Hashing();
    var Log_1 = require_Log();
    var StorageProvider_1 = require_StorageProvider();
    var DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
    var COOLDOWN_TIME_MS = 4 * 60 * 60 * 1e3;
    var NetworkFallbackResolver = class {
      constructor(options) {
        var _a;
        this._fallbackInfo = null;
        this._errorBoundary = null;
        this._dnsQueryCooldowns = {};
        this._networkOverrideFunc = (_a = options.networkConfig) === null || _a === void 0 ? void 0 : _a.networkOverrideFunc;
      }
      setErrorBoundary(errorBoundary) {
        this._errorBoundary = errorBoundary;
      }
      tryBumpExpiryTime(sdkKey, urlConfig) {
        var _a;
        const info = (_a = this._fallbackInfo) === null || _a === void 0 ? void 0 : _a[urlConfig.endpoint];
        if (!info) {
          return;
        }
        info.expiryTime = Date.now() + DEFAULT_TTL_MS;
        _tryWriteFallbackInfoToCache(sdkKey, Object.assign(Object.assign({}, this._fallbackInfo), { [urlConfig.endpoint]: info }));
      }
      getActiveFallbackUrl(sdkKey, urlConfig) {
        var _a, _b;
        if (urlConfig.customUrl != null && urlConfig.fallbackUrls != null) {
          return null;
        }
        let info = this._fallbackInfo;
        if (info == null) {
          info = (_a = _readFallbackInfoFromCache(sdkKey)) !== null && _a !== void 0 ? _a : {};
          this._fallbackInfo = info;
        }
        const entry = info[urlConfig.endpoint];
        if (!entry || Date.now() > ((_b = entry.expiryTime) !== null && _b !== void 0 ? _b : 0) || urlConfig.getChecksum() !== entry.urlConfigChecksum) {
          delete info[urlConfig.endpoint];
          this._fallbackInfo = info;
          _tryWriteFallbackInfoToCache(sdkKey, this._fallbackInfo);
          return null;
        }
        if (entry.url) {
          return entry.url;
        }
        return null;
      }
      tryFetchUpdatedFallbackInfo(sdkKey, urlConfig, errorMessage, timedOut) {
        return __awaiter(this, void 0, void 0, function* () {
          var _a, _b;
          try {
            if (!_isDomainFailure(errorMessage, timedOut)) {
              return false;
            }
            const canUseNetworkFallbacks = urlConfig.customUrl == null && urlConfig.fallbackUrls == null;
            const urls = canUseNetworkFallbacks ? yield this._tryFetchFallbackUrlsFromNetwork(urlConfig) : urlConfig.fallbackUrls;
            const newUrl = this._pickNewFallbackUrl((_a = this._fallbackInfo) === null || _a === void 0 ? void 0 : _a[urlConfig.endpoint], urls);
            if (!newUrl) {
              return false;
            }
            this._updateFallbackInfoWithNewUrl(sdkKey, urlConfig, newUrl);
            return true;
          } catch (error) {
            (_b = this._errorBoundary) === null || _b === void 0 ? void 0 : _b.logError("tryFetchUpdatedFallbackInfo", error);
            return false;
          }
        });
      }
      _updateFallbackInfoWithNewUrl(sdkKey, urlConfig, newUrl) {
        var _a, _b, _c;
        const newFallbackInfo = {
          urlConfigChecksum: urlConfig.getChecksum(),
          url: newUrl,
          expiryTime: Date.now() + DEFAULT_TTL_MS,
          previous: []
        };
        const endpoint = urlConfig.endpoint;
        const previousInfo = (_a = this._fallbackInfo) === null || _a === void 0 ? void 0 : _a[endpoint];
        if (previousInfo) {
          newFallbackInfo.previous.push(...previousInfo.previous);
        }
        if (newFallbackInfo.previous.length > 10) {
          newFallbackInfo.previous = [];
        }
        const previousUrl = (_c = (_b = this._fallbackInfo) === null || _b === void 0 ? void 0 : _b[endpoint]) === null || _c === void 0 ? void 0 : _c.url;
        if (previousUrl != null) {
          newFallbackInfo.previous.push(previousUrl);
        }
        this._fallbackInfo = Object.assign(Object.assign({}, this._fallbackInfo), { [endpoint]: newFallbackInfo });
        _tryWriteFallbackInfoToCache(sdkKey, this._fallbackInfo);
      }
      _tryFetchFallbackUrlsFromNetwork(urlConfig) {
        return __awaiter(this, void 0, void 0, function* () {
          var _a;
          const cooldown = this._dnsQueryCooldowns[urlConfig.endpoint];
          if (cooldown && Date.now() < cooldown) {
            return null;
          }
          this._dnsQueryCooldowns[urlConfig.endpoint] = Date.now() + COOLDOWN_TIME_MS;
          const result = [];
          const records = yield (0, DnsTxtQuery_1._fetchTxtRecords)((_a = this._networkOverrideFunc) !== null && _a !== void 0 ? _a : fetch);
          const path = _extractPathFromUrl(urlConfig.defaultUrl);
          for (const record of records) {
            if (!record.startsWith(urlConfig.endpointDnsKey + "=")) {
              continue;
            }
            const parts = record.split("=");
            if (parts.length > 1) {
              let baseUrl = parts[1];
              if (baseUrl.endsWith("/")) {
                baseUrl = baseUrl.slice(0, -1);
              }
              result.push(`https://${baseUrl}${path}`);
            }
          }
          return result;
        });
      }
      _pickNewFallbackUrl(currentFallbackInfo, urls) {
        var _a;
        if (urls == null) {
          return null;
        }
        const previouslyUsed = new Set((_a = currentFallbackInfo === null || currentFallbackInfo === void 0 ? void 0 : currentFallbackInfo.previous) !== null && _a !== void 0 ? _a : []);
        const currentFallbackUrl = currentFallbackInfo === null || currentFallbackInfo === void 0 ? void 0 : currentFallbackInfo.url;
        let found = null;
        for (const loopUrl of urls) {
          const url = loopUrl.endsWith("/") ? loopUrl.slice(0, -1) : loopUrl;
          if (!previouslyUsed.has(loopUrl) && url !== currentFallbackUrl) {
            found = url;
            break;
          }
        }
        return found;
      }
    };
    exports2.NetworkFallbackResolver = NetworkFallbackResolver;
    function _isDomainFailure(errorMsg, timedOut) {
      var _a;
      const lowerErrorMsg = (_a = errorMsg === null || errorMsg === void 0 ? void 0 : errorMsg.toLowerCase()) !== null && _a !== void 0 ? _a : "";
      return timedOut || lowerErrorMsg.includes("uncaught exception") || lowerErrorMsg.includes("failed to fetch") || lowerErrorMsg.includes("networkerror when attempting to fetch resource");
    }
    exports2._isDomainFailure = _isDomainFailure;
    function _getFallbackInfoStorageKey(sdkKey) {
      return `statsig.network_fallback.${(0, Hashing_1._DJB2)(sdkKey)}`;
    }
    function _tryWriteFallbackInfoToCache(sdkKey, info) {
      const hashKey = _getFallbackInfoStorageKey(sdkKey);
      if (!info || Object.keys(info).length === 0) {
        StorageProvider_1.Storage.removeItem(hashKey);
        return;
      }
      StorageProvider_1.Storage.setItem(hashKey, JSON.stringify(info));
    }
    function _readFallbackInfoFromCache(sdkKey) {
      const hashKey = _getFallbackInfoStorageKey(sdkKey);
      const data = StorageProvider_1.Storage.getItem(hashKey);
      if (!data) {
        return null;
      }
      try {
        return JSON.parse(data);
      } catch (_a) {
        Log_1.Log.error("Failed to parse FallbackInfo");
        return null;
      }
    }
    function _extractPathFromUrl(urlString) {
      try {
        const url = new URL(urlString);
        return url.pathname;
      } catch (error) {
        return null;
      }
    }
  }
});

// node_modules/@statsig/client-core/src/SDKFlags.js
var require_SDKFlags = __commonJS({
  "node_modules/@statsig/client-core/src/SDKFlags.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SDKFlags = void 0;
    var FLAGMAP = {};
    exports2.SDKFlags = {
      setFlags: (sdkKey, flags) => {
        FLAGMAP[sdkKey] = flags;
      },
      get: (sdkKey, flagKey) => {
        var _a, _b;
        return (_b = (_a = FLAGMAP[sdkKey]) === null || _a === void 0 ? void 0 : _a[flagKey]) !== null && _b !== void 0 ? _b : false;
      }
    };
  }
});

// node_modules/@statsig/client-core/src/SessionID.js
var require_SessionID = __commonJS({
  "node_modules/@statsig/client-core/src/SessionID.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.StatsigSession = exports2.SessionID = void 0;
    var __StatsigGlobal_1 = require_StatsigGlobal();
    var CacheKey_1 = require_CacheKey();
    var Log_1 = require_Log();
    var StorageProvider_1 = require_StorageProvider();
    var UUID_1 = require_UUID();
    var MAX_SESSION_IDLE_TIME = 30 * 60 * 1e3;
    var MAX_SESSION_AGE = 4 * 60 * 60 * 1e3;
    var PROMISE_MAP = {};
    exports2.SessionID = {
      get: (sdkKey) => {
        return exports2.StatsigSession.get(sdkKey).data.sessionID;
      }
    };
    exports2.StatsigSession = {
      get: (sdkKey) => {
        if (PROMISE_MAP[sdkKey] == null) {
          PROMISE_MAP[sdkKey] = _loadSession(sdkKey);
        }
        const session = PROMISE_MAP[sdkKey];
        return _bumpSession(session);
      },
      overrideInitialSessionID: (override, sdkKey) => {
        PROMISE_MAP[sdkKey] = _overrideSessionId(override, sdkKey);
      }
    };
    function _loadSession(sdkKey) {
      let data = _loadFromStorage(sdkKey);
      const now = Date.now();
      if (!data) {
        data = {
          sessionID: (0, UUID_1.getUUID)(),
          startTime: now,
          lastUpdate: now
        };
      }
      return {
        data,
        sdkKey
      };
    }
    function _overrideSessionId(override, sdkKey) {
      const now = Date.now();
      return {
        data: {
          sessionID: override,
          startTime: now,
          lastUpdate: now
        },
        sdkKey
      };
    }
    function _bumpSession(session) {
      const now = Date.now();
      const data = session.data;
      const sdkKey = session.sdkKey;
      if (_isIdle(data) || _hasRunTooLong(data)) {
        data.sessionID = (0, UUID_1.getUUID)();
        data.startTime = now;
        const client = __STATSIG__ === null || __STATSIG__ === void 0 ? void 0 : __STATSIG__.instance(sdkKey);
        if (client) {
          client.$emt({ name: "session_expired" });
        }
      }
      data.lastUpdate = now;
      _persistToStorage(data, session.sdkKey);
      clearTimeout(session.idleTimeoutID);
      clearTimeout(session.ageTimeoutID);
      const lifetime = now - data.startTime;
      session.idleTimeoutID = _createSessionTimeout(sdkKey, MAX_SESSION_IDLE_TIME);
      session.ageTimeoutID = _createSessionTimeout(sdkKey, MAX_SESSION_AGE - lifetime);
      return session;
    }
    function _createSessionTimeout(sdkKey, duration) {
      return setTimeout(() => {
        var _a;
        const client = (_a = (0, __StatsigGlobal_1._getStatsigGlobal)()) === null || _a === void 0 ? void 0 : _a.instance(sdkKey);
        if (client) {
          client.$emt({ name: "session_expired" });
        }
      }, duration);
    }
    function _isIdle({ lastUpdate }) {
      return Date.now() - lastUpdate > MAX_SESSION_IDLE_TIME;
    }
    function _hasRunTooLong({ startTime }) {
      return Date.now() - startTime > MAX_SESSION_AGE;
    }
    function _getSessionIDStorageKey(sdkKey) {
      return `statsig.session_id.${(0, CacheKey_1._getStorageKey)(sdkKey)}`;
    }
    function _persistToStorage(session, sdkKey) {
      const storageKey = _getSessionIDStorageKey(sdkKey);
      try {
        (0, StorageProvider_1._setObjectInStorage)(storageKey, session);
      } catch (e) {
        Log_1.Log.warn("Failed to save SessionID");
      }
    }
    function _loadFromStorage(sdkKey) {
      const storageKey = _getSessionIDStorageKey(sdkKey);
      return (0, StorageProvider_1._getObjectFromStorage)(storageKey);
    }
  }
});

// node_modules/@statsig/client-core/src/StatsigClientEventEmitter.js
var require_StatsigClientEventEmitter = __commonJS({
  "node_modules/@statsig/client-core/src/StatsigClientEventEmitter.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ErrorTag = void 0;
    exports2.ErrorTag = {
      NetworkError: "NetworkError"
    };
  }
});

// node_modules/@statsig/client-core/src/NetworkCore.js
var require_NetworkCore = __commonJS({
  "node_modules/@statsig/client-core/src/NetworkCore.js"(exports2) {
    "use strict";
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function(resolve) {
          resolve(value);
        });
      }
      return new (P || (P = Promise))(function(resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }
        function step(result) {
          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.NetworkCore = void 0;
    require_StatsigGlobal();
    var __StatsigGlobal_1 = require_StatsigGlobal();
    var Diagnostics_1 = require_Diagnostics();
    var Log_1 = require_Log();
    var NetworkConfig_1 = require_NetworkConfig();
    var NetworkFallbackResolver_1 = require_NetworkFallbackResolver();
    var SDKFlags_1 = require_SDKFlags();
    var SDKType_1 = require_SDKType();
    var SafeJs_1 = require_SafeJs();
    var SessionID_1 = require_SessionID();
    var StableID_1 = require_StableID();
    var StatsigClientEventEmitter_1 = require_StatsigClientEventEmitter();
    var StatsigMetadata_1 = require_StatsigMetadata();
    var StatsigOptionsCommon_1 = require_StatsigOptionsCommon();
    var VisibilityObserving_1 = require_VisibilityObserving();
    var DEFAULT_TIMEOUT_MS = 1e4;
    var BACKOFF_BASE_MS = 500;
    var BACKOFF_MAX_MS = 3e4;
    var RATE_LIMIT_WINDOW_MS = 1e3;
    var RATE_LIMIT_MAX_REQ_COUNT = 50;
    var LEAK_RATE = RATE_LIMIT_MAX_REQ_COUNT / RATE_LIMIT_WINDOW_MS;
    var RETRYABLE_CODES = /* @__PURE__ */ new Set([408, 500, 502, 503, 504, 522, 524, 599]);
    var NetworkCore = class {
      constructor(options, _emitter) {
        this._emitter = _emitter;
        this._errorBoundary = null;
        this._timeout = DEFAULT_TIMEOUT_MS;
        this._netConfig = {};
        this._options = {};
        this._leakyBucket = {};
        this._lastUsedInitUrl = null;
        if (options) {
          this._options = options;
        }
        if (this._options.networkConfig) {
          this._netConfig = this._options.networkConfig;
        }
        if (this._netConfig.networkTimeoutMs) {
          this._timeout = this._netConfig.networkTimeoutMs;
        }
        this._fallbackResolver = new NetworkFallbackResolver_1.NetworkFallbackResolver(this._options);
        this.setLogEventCompressionMode(this._getLogEventCompressionMode(options));
      }
      setLogEventCompressionMode(mode) {
        this._options.logEventCompressionMode = mode;
      }
      setErrorBoundary(errorBoundary) {
        this._errorBoundary = errorBoundary;
        this._errorBoundary.wrap(this);
        this._errorBoundary.wrap(this._fallbackResolver);
        this._fallbackResolver.setErrorBoundary(errorBoundary);
      }
      isBeaconSupported() {
        return typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function";
      }
      getLastUsedInitUrlAndReset() {
        const tempUrl = this._lastUsedInitUrl;
        this._lastUsedInitUrl = null;
        return tempUrl;
      }
      beacon(args2) {
        if (!_ensureValidSdkKey(args2)) {
          return false;
        }
        const argsInternal = this._getInternalRequestArgs("POST", args2);
        const url = this._getPopulatedURL(argsInternal);
        const nav = navigator;
        return nav.sendBeacon.bind(nav)(url, argsInternal.body);
      }
      post(args2) {
        return __awaiter(this, void 0, void 0, function* () {
          const argsInternal = this._getInternalRequestArgs("POST", args2);
          this._tryEncodeBody(argsInternal);
          yield this._tryToCompressBody(argsInternal);
          return this._sendRequest(argsInternal);
        });
      }
      get(args2) {
        const argsInternal = this._getInternalRequestArgs("GET", args2);
        return this._sendRequest(argsInternal);
      }
      _sendRequest(args2) {
        return __awaiter(this, void 0, void 0, function* () {
          var _a, _b, _c, _d;
          if (!_ensureValidSdkKey(args2)) {
            return null;
          }
          if (this._netConfig.preventAllNetworkTraffic) {
            return null;
          }
          const { method, body, retries, attempt } = args2;
          const endpoint = args2.urlConfig.endpoint;
          if (this._isRateLimited(endpoint)) {
            Log_1.Log.warn(`Request to ${endpoint} was blocked because you are making requests too frequently.`);
            return null;
          }
          const currentAttempt = attempt !== null && attempt !== void 0 ? attempt : 1;
          const abortController = typeof AbortController !== "undefined" ? new AbortController() : null;
          const timeoutHandle = setTimeout(() => {
            abortController === null || abortController === void 0 ? void 0 : abortController.abort(`Timeout of ${this._timeout}ms expired.`);
          }, this._timeout);
          const populatedUrl = this._getPopulatedURL(args2);
          let response = null;
          const keepalive = (0, VisibilityObserving_1._isUnloading)();
          try {
            const config = {
              method,
              body,
              headers: Object.assign({}, args2.headers),
              signal: abortController === null || abortController === void 0 ? void 0 : abortController.signal,
              priority: args2.priority,
              keepalive
            };
            _tryMarkInitStart(args2, currentAttempt);
            const bucket = this._leakyBucket[endpoint];
            if (bucket) {
              bucket.lastRequestTime = Date.now();
              this._leakyBucket[endpoint] = bucket;
            }
            const func = (_a = this._netConfig.networkOverrideFunc) !== null && _a !== void 0 ? _a : fetch;
            response = yield func(populatedUrl, config);
            clearTimeout(timeoutHandle);
            if (!response.ok) {
              const text2 = yield response.text().catch(() => "No Text");
              const err = new Error(`NetworkError: ${populatedUrl} ${text2}`);
              err.name = "NetworkError";
              throw err;
            }
            const text = yield response.text();
            _tryMarkInitEnd(args2, response, currentAttempt, text);
            this._fallbackResolver.tryBumpExpiryTime(args2.sdkKey, args2.urlConfig);
            return {
              body: text,
              code: response.status
            };
          } catch (error) {
            const errorMessage = _getErrorMessage(abortController, error);
            const timedOut = _didTimeout(abortController);
            _tryMarkInitEnd(args2, response, currentAttempt, "", error);
            const fallbackUpdated = yield this._fallbackResolver.tryFetchUpdatedFallbackInfo(args2.sdkKey, args2.urlConfig, errorMessage, timedOut);
            if (fallbackUpdated) {
              args2.fallbackUrl = this._fallbackResolver.getActiveFallbackUrl(args2.sdkKey, args2.urlConfig);
            }
            if (!retries || currentAttempt > retries || !RETRYABLE_CODES.has((_b = response === null || response === void 0 ? void 0 : response.status) !== null && _b !== void 0 ? _b : 500)) {
              (_c = this._emitter) === null || _c === void 0 ? void 0 : _c.call(this, {
                name: "error",
                error,
                tag: StatsigClientEventEmitter_1.ErrorTag.NetworkError,
                requestArgs: args2
              });
              const formattedErrorMsg = `A networking error occurred during ${method} request to ${populatedUrl}.`;
              Log_1.Log.error(formattedErrorMsg, errorMessage, error);
              (_d = this._errorBoundary) === null || _d === void 0 ? void 0 : _d.attachErrorIfNoneExists(formattedErrorMsg);
              return null;
            }
            yield _exponentialBackoff(currentAttempt);
            return this._sendRequest(Object.assign(Object.assign({}, args2), { retries, attempt: currentAttempt + 1 }));
          }
        });
      }
      _getLogEventCompressionMode(options) {
        let compressionMode = options === null || options === void 0 ? void 0 : options.logEventCompressionMode;
        if (!compressionMode && (options === null || options === void 0 ? void 0 : options.disableCompression) === true) {
          compressionMode = StatsigOptionsCommon_1.LogEventCompressionMode.Disabled;
        }
        if (!compressionMode) {
          compressionMode = StatsigOptionsCommon_1.LogEventCompressionMode.Enabled;
        }
        return compressionMode;
      }
      _isRateLimited(endpoint) {
        var _a;
        const now = Date.now();
        const bucket = (_a = this._leakyBucket[endpoint]) !== null && _a !== void 0 ? _a : {
          count: 0,
          lastRequestTime: now
        };
        const elapsed = now - bucket.lastRequestTime;
        const leakedRequests = Math.floor(elapsed * LEAK_RATE);
        bucket.count = Math.max(0, bucket.count - leakedRequests);
        if (bucket.count >= RATE_LIMIT_MAX_REQ_COUNT) {
          return true;
        }
        bucket.count += 1;
        bucket.lastRequestTime = now;
        this._leakyBucket[endpoint] = bucket;
        return false;
      }
      _getPopulatedURL(args2) {
        var _a;
        const url = (_a = args2.fallbackUrl) !== null && _a !== void 0 ? _a : args2.urlConfig.getUrl();
        if (args2.urlConfig.endpoint === NetworkConfig_1.Endpoint._initialize || args2.urlConfig.endpoint === NetworkConfig_1.Endpoint._download_config_specs) {
          this._lastUsedInitUrl = url;
        }
        const params = Object.assign({ [NetworkConfig_1.NetworkParam.SdkKey]: args2.sdkKey, [NetworkConfig_1.NetworkParam.SdkType]: SDKType_1.SDKType._get(args2.sdkKey), [NetworkConfig_1.NetworkParam.SdkVersion]: StatsigMetadata_1.SDK_VERSION, [NetworkConfig_1.NetworkParam.Time]: String(Date.now()), [NetworkConfig_1.NetworkParam.SessionID]: SessionID_1.SessionID.get(args2.sdkKey) }, args2.params);
        const query = Object.keys(params).map((key) => {
          return `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`;
        }).join("&");
        return `${url}${query ? `?${query}` : ""}`;
      }
      _tryEncodeBody(args2) {
        var _a;
        const win = (0, SafeJs_1._getWindowSafe)();
        const body = args2.body;
        if (!args2.isStatsigEncodable || this._options.disableStatsigEncoding || typeof body !== "string" || (0, __StatsigGlobal_1._getStatsigGlobalFlag)("no-encode") != null || !(win === null || win === void 0 ? void 0 : win.btoa)) {
          return;
        }
        try {
          args2.body = win.btoa(body).split("").reverse().join("");
          args2.params = Object.assign(Object.assign({}, (_a = args2.params) !== null && _a !== void 0 ? _a : {}), { [NetworkConfig_1.NetworkParam.StatsigEncoded]: "1" });
        } catch (e) {
          Log_1.Log.warn(`Request encoding failed for ${args2.urlConfig.getUrl()}`, e);
        }
      }
      _tryToCompressBody(args2) {
        return __awaiter(this, void 0, void 0, function* () {
          var _a;
          const body = args2.body;
          if (typeof body !== "string" || !_allowCompression(args2, this._options)) {
            return;
          }
          try {
            const bytes = new TextEncoder().encode(body);
            const stream = new CompressionStream("gzip");
            const writer = stream.writable.getWriter();
            writer.write(bytes).catch(Log_1.Log.error);
            writer.close().catch(Log_1.Log.error);
            const reader = stream.readable.getReader();
            const chunks = [];
            let result;
            while (!(result = yield reader.read()).done) {
              chunks.push(result.value);
            }
            const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
            const combined = new Uint8Array(totalLength);
            let offset = 0;
            for (const chunk of chunks) {
              combined.set(chunk, offset);
              offset += chunk.length;
            }
            args2.body = combined;
            args2.params = Object.assign(Object.assign({}, (_a = args2.params) !== null && _a !== void 0 ? _a : {}), { [NetworkConfig_1.NetworkParam.IsGzipped]: "1" });
          } catch (e) {
            Log_1.Log.warn(`Request compression failed for ${args2.urlConfig.getUrl()}`, e);
          }
        });
      }
      _getInternalRequestArgs(method, args2) {
        const fallbackUrl = this._fallbackResolver.getActiveFallbackUrl(args2.sdkKey, args2.urlConfig);
        const result = Object.assign(Object.assign({}, args2), {
          method,
          fallbackUrl
        });
        if ("data" in args2) {
          _populateRequestBody(result, args2.data);
        }
        return result;
      }
    };
    exports2.NetworkCore = NetworkCore;
    var _ensureValidSdkKey = (args2) => {
      if (!args2.sdkKey) {
        Log_1.Log.warn("Unable to make request without an SDK key");
        return false;
      }
      return true;
    };
    var _populateRequestBody = (args2, data) => {
      const { sdkKey, fallbackUrl } = args2;
      const stableID = StableID_1.StableID.get(sdkKey);
      const sessionID = SessionID_1.SessionID.get(sdkKey);
      const sdkType = SDKType_1.SDKType._get(sdkKey);
      args2.body = JSON.stringify(Object.assign(Object.assign({}, data), { statsigMetadata: Object.assign(Object.assign({}, StatsigMetadata_1.StatsigMetadataProvider.get()), {
        stableID,
        sessionID,
        sdkType,
        fallbackUrl
      }) }));
    };
    function _allowCompression(args2, options) {
      if (!args2.isCompressable) {
        return false;
      }
      if ((0, __StatsigGlobal_1._getStatsigGlobalFlag)("no-compress") != null || typeof CompressionStream === "undefined" || typeof TextEncoder === "undefined") {
        return false;
      }
      const isProxy = args2.urlConfig.customUrl != null || args2.urlConfig.fallbackUrls != null;
      const flagEnabled = SDKFlags_1.SDKFlags.get(args2.sdkKey, "enable_log_event_compression") === true;
      switch (options.logEventCompressionMode) {
        case StatsigOptionsCommon_1.LogEventCompressionMode.Disabled:
          return false;
        case StatsigOptionsCommon_1.LogEventCompressionMode.Enabled:
          if (isProxy && !flagEnabled) {
            return false;
          }
          return true;
        case StatsigOptionsCommon_1.LogEventCompressionMode.Forced:
          return true;
        default:
          return false;
      }
    }
    function _getErrorMessage(controller, error) {
      if ((controller === null || controller === void 0 ? void 0 : controller.signal.aborted) && typeof controller.signal.reason === "string") {
        return controller.signal.reason;
      }
      if (typeof error === "string") {
        return error;
      }
      if (error instanceof Error) {
        return `${error.name}: ${error.message}`;
      }
      return "Unknown Error";
    }
    function _didTimeout(controller) {
      const timeout = (controller === null || controller === void 0 ? void 0 : controller.signal.aborted) && typeof controller.signal.reason === "string" && controller.signal.reason.includes("Timeout");
      return timeout || false;
    }
    function _tryMarkInitStart(args2, attempt) {
      if (args2.urlConfig.endpoint !== NetworkConfig_1.Endpoint._initialize) {
        return;
      }
      Diagnostics_1.Diagnostics._markInitNetworkReqStart(args2.sdkKey, {
        attempt
      });
    }
    function _tryMarkInitEnd(args2, response, attempt, body, err) {
      if (args2.urlConfig.endpoint !== NetworkConfig_1.Endpoint._initialize) {
        return;
      }
      Diagnostics_1.Diagnostics._markInitNetworkReqEnd(args2.sdkKey, Diagnostics_1.Diagnostics._getDiagnosticsData(response, attempt, body, err));
    }
    function _exponentialBackoff(attempt) {
      return __awaiter(this, void 0, void 0, function* () {
        yield new Promise((r) => setTimeout(r, Math.min(BACKOFF_BASE_MS * (attempt * attempt), BACKOFF_MAX_MS)));
      });
    }
  }
});

// node_modules/@statsig/client-core/src/OverrideAdapter.js
var require_OverrideAdapter = __commonJS({
  "node_modules/@statsig/client-core/src/OverrideAdapter.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// node_modules/@statsig/client-core/src/ParamStoreTypes.js
var require_ParamStoreTypes = __commonJS({
  "node_modules/@statsig/client-core/src/ParamStoreTypes.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// node_modules/@statsig/client-core/src/SizeOf.js
var require_SizeOf = __commonJS({
  "node_modules/@statsig/client-core/src/SizeOf.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._fastApproxSizeOf = void 0;
    var CURLY_AND_SQUARE_BRACKET_SIZE = 2;
    var APPROX_ADDITIONAL_SIZE = 1;
    var _fastApproxSizeOf = (obj, max) => {
      let size = 0;
      const keys = Object.keys(obj);
      for (let i = 0; i < keys.length; i++) {
        const key = keys[i];
        const value = obj[key];
        size += key.length;
        if (typeof value === "object" && value !== null) {
          size += (0, exports2._fastApproxSizeOf)(value, max) + CURLY_AND_SQUARE_BRACKET_SIZE;
        } else {
          size += String(value).length + APPROX_ADDITIONAL_SIZE;
        }
        if (size >= max) {
          return size;
        }
      }
      return size;
    };
    exports2._fastApproxSizeOf = _fastApproxSizeOf;
  }
});

// node_modules/@statsig/client-core/src/StatsigClientBase.js
var require_StatsigClientBase = __commonJS({
  "node_modules/@statsig/client-core/src/StatsigClientBase.js"(exports2) {
    "use strict";
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function(resolve) {
          resolve(value);
        });
      }
      return new (P || (P = Promise))(function(resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }
        function step(result) {
          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.StatsigClientBase = void 0;
    require_StatsigGlobal();
    var __StatsigGlobal_1 = require_StatsigGlobal();
    var ErrorBoundary_1 = require_ErrorBoundary();
    var EventLogger_1 = require_EventLogger();
    var Log_1 = require_Log();
    var MemoKey_1 = require_MemoKey();
    var SafeJs_1 = require_SafeJs();
    var SessionID_1 = require_SessionID();
    var StableID_1 = require_StableID();
    var StatsigOptionsCommon_1 = require_StatsigOptionsCommon();
    var StorageProvider_1 = require_StorageProvider();
    var MAX_MEMO_CACHE_SIZE = 3e3;
    var StatsigClientBase = class {
      constructor(sdkKey, adapter, network, options) {
        var _a, _b, _c, _d;
        this.loadingStatus = "Uninitialized";
        this._initializePromise = null;
        this._listeners = {};
        const emitter = this.$emt.bind(this);
        (options === null || options === void 0 ? void 0 : options.logLevel) != null && (Log_1.Log.level = options.logLevel);
        (options === null || options === void 0 ? void 0 : options.disableStorage) && StorageProvider_1.Storage._setDisabled(true);
        (options === null || options === void 0 ? void 0 : options.initialSessionID) && SessionID_1.StatsigSession.overrideInitialSessionID(options.initialSessionID, sdkKey);
        (options === null || options === void 0 ? void 0 : options.storageProvider) && StorageProvider_1.Storage._setProvider(options.storageProvider);
        (options === null || options === void 0 ? void 0 : options.enableCookies) && StableID_1.StableID._setCookiesEnabled(sdkKey, options.enableCookies);
        (options === null || options === void 0 ? void 0 : options.disableStableID) && StableID_1.StableID._setDisabled(sdkKey, true);
        this._sdkKey = sdkKey;
        this._options = options !== null && options !== void 0 ? options : {};
        this._memoCache = {};
        this.overrideAdapter = (_a = options === null || options === void 0 ? void 0 : options.overrideAdapter) !== null && _a !== void 0 ? _a : null;
        this._logger = new EventLogger_1.EventLogger(sdkKey, emitter, network, options);
        this._errorBoundary = new ErrorBoundary_1.ErrorBoundary(sdkKey, options, emitter);
        this._errorBoundary.wrap(this);
        this._errorBoundary.wrap(adapter);
        this._errorBoundary.wrap(this._logger);
        network.setErrorBoundary(this._errorBoundary);
        this.dataAdapter = adapter;
        this.dataAdapter.attach(sdkKey, options, network);
        this.storageProvider = StorageProvider_1.Storage;
        (_d = (_c = (_b = this.overrideAdapter) === null || _b === void 0 ? void 0 : _b.loadFromStorage) === null || _c === void 0 ? void 0 : _c.call(_b)) === null || _d === void 0 ? void 0 : _d.catch((e) => this._errorBoundary.logError("OA::loadFromStorage", e));
        this._primeReadyRipcord();
        _assignGlobalInstance(sdkKey, this);
      }
      /**
       * Updates runtime configuration options for the SDK, allowing toggling of certain behaviors such as logging and storage to comply with user preferences or regulations such as GDPR.
       *
       * @param {StatsigRuntimeMutableOptions} options - The configuration options that dictate the runtime behavior of the SDK.
       */
      updateRuntimeOptions(options) {
        if (options.loggingEnabled) {
          this._options.loggingEnabled = options.loggingEnabled;
          this._logger.setLoggingEnabled(options.loggingEnabled);
        } else if (options.disableLogging != null) {
          this._options.disableLogging = options.disableLogging;
          this._logger.setLoggingEnabled(options.disableLogging ? "disabled" : "browser-only");
        }
        if (options.disableStorage != null) {
          this._options.disableStorage = options.disableStorage;
          StorageProvider_1.Storage._setDisabled(options.disableStorage);
        }
        if (options.enableCookies != null) {
          this._options.enableCookies = options.enableCookies;
          StableID_1.StableID._setCookiesEnabled(this._sdkKey, options.enableCookies);
        }
        if (options.logEventCompressionMode) {
          this._logger.setLogEventCompressionMode(options.logEventCompressionMode);
        } else if (options.disableCompression) {
          this._logger.setLogEventCompressionMode(StatsigOptionsCommon_1.LogEventCompressionMode.Disabled);
        }
      }
      /**
       * Flushes any currently queued events.
       */
      flush() {
        return this._logger.flush();
      }
      /**
       * Gracefully shuts down the SDK, ensuring that all pending events are send before the SDK stops.
       * This function emits a 'pre_shutdown' event and then waits for the logger to complete its shutdown process.
       *
       * @returns {Promise<void>} A promise that resolves when all shutdown procedures, including logging shutdown, have been completed.
       */
      shutdown() {
        return __awaiter(this, void 0, void 0, function* () {
          this.$emt({ name: "pre_shutdown" });
          this._setStatus("Uninitialized", null);
          this._initializePromise = null;
          yield this._logger.stop();
        });
      }
      /**
       * Subscribes a callback function to a specific {@link StatsigClientEvent} or all StatsigClientEvents if the wildcard '*' is used.
       * Once subscribed, the listener callback will be invoked whenever the specified event is emitted.
       *
       * @param {StatsigClientEventName} event - The name of the event to subscribe to, or '*' to subscribe to all events.
       * @param {StatsigClientEventCallback<T>} listener - The callback function to execute when the event occurs. The function receives event-specific data as its parameter.
       * @see {@link off} for unsubscribing from events.
       */
      on(event, listener) {
        if (!this._listeners[event]) {
          this._listeners[event] = [];
        }
        this._listeners[event].push(listener);
      }
      /**
       * Unsubscribes a previously registered callback function from a specific {@link StatsigClientEvent} or all StatsigClientEvents if the wildcard '*' is used.
       *
       * @param {StatsigClientEventName} event - The name of the event from which to unsubscribe, or '*' to unsubscribe from all events.
       * @param {StatsigClientEventCallback<T>} listener - The callback function to remove from the event's notification list.
       * @see {@link on} for subscribing to events.
       */
      off(event, listener) {
        if (this._listeners[event]) {
          const index = this._listeners[event].indexOf(listener);
          if (index !== -1) {
            this._listeners[event].splice(index, 1);
          }
        }
      }
      $on(event, listener) {
        listener.__isInternal = true;
        this.on(event, listener);
      }
      $emt(event) {
        var _a;
        const barrier = (listener) => {
          try {
            listener(event);
          } catch (error) {
            if (listener.__isInternal === true) {
              this._errorBoundary.logError(`__emit:${event.name}`, error);
              return;
            }
            Log_1.Log.error(`An error occurred in a StatsigClientEvent listener. This is not an issue with Statsig.`, event);
          }
        };
        if (this._listeners[event.name]) {
          this._listeners[event.name].forEach((l) => barrier(l));
        }
        (_a = this._listeners["*"]) === null || _a === void 0 ? void 0 : _a.forEach(barrier);
      }
      _setStatus(newStatus, values) {
        this.loadingStatus = newStatus;
        this._memoCache = {};
        this.$emt({ name: "values_updated", status: newStatus, values });
      }
      _enqueueExposure(name, exposure, options) {
        if ((options === null || options === void 0 ? void 0 : options.disableExposureLog) === true) {
          this._logger.incrementNonExposureCount(name);
          return;
        }
        this._logger.enqueue(exposure);
      }
      _memoize(prefix, fn) {
        return (name, options) => {
          if (this._options.disableEvaluationMemoization) {
            return fn(name, options);
          }
          const memoKey = (0, MemoKey_1.createMemoKey)(prefix, name, options);
          if (!memoKey) {
            return fn(name, options);
          }
          if (!(memoKey in this._memoCache)) {
            if (Object.keys(this._memoCache).length >= MAX_MEMO_CACHE_SIZE) {
              this._memoCache = {};
            }
            this._memoCache[memoKey] = fn(name, options);
          }
          return this._memoCache[memoKey];
        };
      }
    };
    exports2.StatsigClientBase = StatsigClientBase;
    function _assignGlobalInstance(sdkKey, client) {
      var _a;
      if ((0, SafeJs_1._isServerEnv)()) {
        return;
      }
      const statsigGlobal = (0, __StatsigGlobal_1._getStatsigGlobal)();
      const instances = (_a = statsigGlobal.instances) !== null && _a !== void 0 ? _a : {};
      const inst = client;
      if (instances[sdkKey] != null) {
        Log_1.Log.warn("Creating multiple Statsig clients with the same SDK key can lead to unexpected behavior. Multi-instance support requires different SDK keys.");
      }
      instances[sdkKey] = inst;
      if (!statsigGlobal.firstInstance) {
        statsigGlobal.firstInstance = inst;
      }
      statsigGlobal.instances = instances;
      __STATSIG__ = statsigGlobal;
    }
  }
});

// node_modules/@statsig/client-core/src/StatsigDataAdapter.js
var require_StatsigDataAdapter = __commonJS({
  "node_modules/@statsig/client-core/src/StatsigDataAdapter.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.DataAdapterCachePrefix = void 0;
    exports2.DataAdapterCachePrefix = "statsig.cached";
  }
});

// node_modules/@statsig/client-core/src/StatsigPlugin.js
var require_StatsigPlugin = __commonJS({
  "node_modules/@statsig/client-core/src/StatsigPlugin.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// node_modules/@statsig/client-core/src/StatsigTypeFactories.js
var require_StatsigTypeFactories = __commonJS({
  "node_modules/@statsig/client-core/src/StatsigTypeFactories.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._makeTypedGet = exports2._mergeOverride = exports2._makeLayer = exports2._makeExperiment = exports2._makeDynamicConfig = exports2._makeFeatureGate = void 0;
    var Log_1 = require_Log();
    var TypingUtils_1 = require_TypingUtils();
    function _makeEvaluation(name, details, evaluation, value) {
      var _a;
      return {
        name,
        details,
        ruleID: (_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.rule_id) !== null && _a !== void 0 ? _a : "",
        __evaluation: evaluation,
        value
      };
    }
    function _makeFeatureGate(name, details, evaluation) {
      var _a;
      return Object.assign(Object.assign({}, _makeEvaluation(name, details, evaluation, (evaluation === null || evaluation === void 0 ? void 0 : evaluation.value) === true)), { idType: (_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.id_type) !== null && _a !== void 0 ? _a : null });
    }
    exports2._makeFeatureGate = _makeFeatureGate;
    function _makeDynamicConfig(name, details, evaluation) {
      var _a;
      const value = (_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.value) !== null && _a !== void 0 ? _a : {};
      return Object.assign(Object.assign({}, _makeEvaluation(name, details, evaluation, value)), { get: _makeTypedGet(name, evaluation === null || evaluation === void 0 ? void 0 : evaluation.value) });
    }
    exports2._makeDynamicConfig = _makeDynamicConfig;
    function _makeExperiment(name, details, evaluation) {
      var _a;
      const result = _makeDynamicConfig(name, details, evaluation);
      return Object.assign(Object.assign({}, result), { groupName: (_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.group_name) !== null && _a !== void 0 ? _a : null });
    }
    exports2._makeExperiment = _makeExperiment;
    function _makeLayer(name, details, evaluation, exposeFunc) {
      var _a, _b;
      return Object.assign(Object.assign({}, _makeEvaluation(name, details, evaluation, void 0)), { get: _makeTypedGet(name, evaluation === null || evaluation === void 0 ? void 0 : evaluation.value, exposeFunc), groupName: (_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.group_name) !== null && _a !== void 0 ? _a : null, __value: (_b = evaluation === null || evaluation === void 0 ? void 0 : evaluation.value) !== null && _b !== void 0 ? _b : {} });
    }
    exports2._makeLayer = _makeLayer;
    function _mergeOverride(original, overridden, value, exposeFunc) {
      return Object.assign(Object.assign(Object.assign({}, original), overridden), { get: _makeTypedGet(original.name, value, exposeFunc) });
    }
    exports2._mergeOverride = _mergeOverride;
    function _makeTypedGet(name, value, exposeFunc) {
      return (param, fallback) => {
        var _a;
        const found = (_a = value === null || value === void 0 ? void 0 : value[param]) !== null && _a !== void 0 ? _a : null;
        if (found == null) {
          return fallback !== null && fallback !== void 0 ? fallback : null;
        }
        if (fallback != null && !(0, TypingUtils_1._isTypeMatch)(found, fallback)) {
          Log_1.Log.warn(`Parameter type mismatch. '${name}.${param}' was found to be type '${typeof found}' but fallback/return type is '${typeof fallback}'. See https://docs.statsig.com/client/javascript-sdk/#typed-getters`);
          return fallback !== null && fallback !== void 0 ? fallback : null;
        }
        exposeFunc === null || exposeFunc === void 0 ? void 0 : exposeFunc(param);
        return found;
      };
    }
    exports2._makeTypedGet = _makeTypedGet;
  }
});

// node_modules/@statsig/client-core/src/StatsigTypes.js
var require_StatsigTypes = __commonJS({
  "node_modules/@statsig/client-core/src/StatsigTypes.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// node_modules/@statsig/client-core/src/StatsigUpdateDetails.js
var require_StatsigUpdateDetails = __commonJS({
  "node_modules/@statsig/client-core/src/StatsigUpdateDetails.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.UPDATE_DETAIL_ERROR_MESSAGES = exports2.createUpdateDetails = void 0;
    var createUpdateDetails = (success, source, initDuration, error, sourceUrl, warnings) => {
      return {
        duration: initDuration,
        source,
        success,
        error,
        sourceUrl,
        warnings
      };
    };
    exports2.createUpdateDetails = createUpdateDetails;
    exports2.UPDATE_DETAIL_ERROR_MESSAGES = {
      NO_NETWORK_DATA: "No data was returned from the network. This may be due to a network timeout if a timeout value was specified in the options or ad blocker error."
    };
  }
});

// node_modules/@statsig/client-core/src/index.js
var require_src = __commonJS({
  "node_modules/@statsig/client-core/src/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Storage = exports2.Log = exports2.EventLogger = exports2.Diagnostics = void 0;
    require_StatsigGlobal();
    var __StatsigGlobal_1 = require_StatsigGlobal();
    var Diagnostics_1 = require_Diagnostics();
    Object.defineProperty(exports2, "Diagnostics", { enumerable: true, get: function() {
      return Diagnostics_1.Diagnostics;
    } });
    var EventLogger_1 = require_EventLogger();
    Object.defineProperty(exports2, "EventLogger", { enumerable: true, get: function() {
      return EventLogger_1.EventLogger;
    } });
    var Log_1 = require_Log();
    Object.defineProperty(exports2, "Log", { enumerable: true, get: function() {
      return Log_1.Log;
    } });
    var StatsigMetadata_1 = require_StatsigMetadata();
    var StorageProvider_1 = require_StorageProvider();
    Object.defineProperty(exports2, "Storage", { enumerable: true, get: function() {
      return StorageProvider_1.Storage;
    } });
    __exportStar(require_StatsigGlobal(), exports2);
    __exportStar(require_CacheKey(), exports2);
    __exportStar(require_ClientInterfaces(), exports2);
    __exportStar(require_DataAdapterCore(), exports2);
    __exportStar(require_Diagnostics(), exports2);
    __exportStar(require_DownloadConfigSpecsResponse(), exports2);
    __exportStar(require_ErrorBoundary(), exports2);
    __exportStar(require_EvaluationOptions(), exports2);
    __exportStar(require_EvaluationTypes(), exports2);
    __exportStar(require_Hashing(), exports2);
    __exportStar(require_InitializeResponse(), exports2);
    __exportStar(require_Log(), exports2);
    __exportStar(require_MemoKey(), exports2);
    __exportStar(require_NetworkConfig(), exports2);
    __exportStar(require_NetworkCore(), exports2);
    __exportStar(require_OverrideAdapter(), exports2);
    __exportStar(require_ParamStoreTypes(), exports2);
    __exportStar(require_SafeJs(), exports2);
    __exportStar(require_SDKType(), exports2);
    __exportStar(require_SessionID(), exports2);
    __exportStar(require_SizeOf(), exports2);
    __exportStar(require_StableID(), exports2);
    __exportStar(require_StatsigClientBase(), exports2);
    __exportStar(require_StatsigClientEventEmitter(), exports2);
    __exportStar(require_StatsigDataAdapter(), exports2);
    __exportStar(require_StatsigEvent(), exports2);
    __exportStar(require_StatsigMetadata(), exports2);
    __exportStar(require_StatsigOptionsCommon(), exports2);
    __exportStar(require_StatsigPlugin(), exports2);
    __exportStar(require_StatsigTypeFactories(), exports2);
    __exportStar(require_StatsigTypes(), exports2);
    __exportStar(require_StatsigUser(), exports2);
    __exportStar(require_StorageProvider(), exports2);
    __exportStar(require_TypedJsonParse(), exports2);
    __exportStar(require_TypingUtils(), exports2);
    __exportStar(require_UrlConfiguration(), exports2);
    __exportStar(require_UUID(), exports2);
    __exportStar(require_VisibilityObserving(), exports2);
    __exportStar(require_StatsigUpdateDetails(), exports2);
    __exportStar(require_SDKFlags(), exports2);
    Object.assign((0, __StatsigGlobal_1._getStatsigGlobal)(), { Log: Log_1.Log, SDK_VERSION: StatsigMetadata_1.SDK_VERSION });
  }
});

// node_modules/@statsig/js-client/src/EvaluationStore.js
var require_EvaluationStore = __commonJS({
  "node_modules/@statsig/js-client/src/EvaluationStore.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var client_core_1 = require_src();
    var EvaluationStore = class {
      constructor(_sdkKey) {
        this._sdkKey = _sdkKey;
        this._rawValues = null;
        this._values = null;
        this._source = "Uninitialized";
        this._lcut = 0;
        this._receivedAt = 0;
        this._bootstrapMetadata = null;
        this._warnings = /* @__PURE__ */ new Set();
      }
      reset() {
        this._values = null;
        this._rawValues = null;
        this._source = "Loading";
        this._lcut = 0;
        this._receivedAt = 0;
        this._bootstrapMetadata = null;
        this._warnings.clear();
      }
      finalize() {
        if (this._values) {
          return;
        }
        this._source = "NoValues";
      }
      getValues() {
        return this._rawValues ? (0, client_core_1._typedJsonParse)(this._rawValues, "has_updates", "EvaluationStoreValues") : null;
      }
      setValues(result, user) {
        var _a;
        if (!result) {
          return false;
        }
        const values = (0, client_core_1._typedJsonParse)(result.data, "has_updates", "EvaluationResponse");
        if (values == null) {
          return false;
        }
        this._source = result.source;
        if ((values === null || values === void 0 ? void 0 : values.has_updates) !== true) {
          return true;
        }
        this._rawValues = result.data;
        this._lcut = values.time;
        this._receivedAt = result.receivedAt;
        this._values = values;
        this._bootstrapMetadata = this._extractBootstrapMetadata(result.source, values);
        if (result.source && values.user) {
          this._setWarningState(user, values);
        }
        client_core_1.SDKFlags.setFlags(this._sdkKey, (_a = values.sdk_flags) !== null && _a !== void 0 ? _a : {});
        return true;
      }
      getWarnings() {
        if (this._warnings.size === 0) {
          return void 0;
        }
        return Array.from(this._warnings);
      }
      getGate(name) {
        var _a;
        return this._getDetailedStoreResult((_a = this._values) === null || _a === void 0 ? void 0 : _a.feature_gates, name);
      }
      getConfig(name) {
        var _a;
        return this._getDetailedStoreResult((_a = this._values) === null || _a === void 0 ? void 0 : _a.dynamic_configs, name);
      }
      getConfigList() {
        var _a;
        if (!((_a = this._values) === null || _a === void 0 ? void 0 : _a.dynamic_configs)) {
          return [];
        }
        return Object.values(this._values.dynamic_configs).map((config) => config.name);
      }
      getLayer(name) {
        var _a;
        return this._getDetailedStoreResult((_a = this._values) === null || _a === void 0 ? void 0 : _a.layer_configs, name);
      }
      getParamStore(name) {
        var _a;
        return this._getDetailedStoreResult((_a = this._values) === null || _a === void 0 ? void 0 : _a.param_stores, name);
      }
      getSource() {
        return this._source;
      }
      getExposureMapping() {
        var _a;
        return (_a = this._values) === null || _a === void 0 ? void 0 : _a.exposures;
      }
      _extractBootstrapMetadata(source, values) {
        if (source !== "Bootstrap") {
          return null;
        }
        const bootstrapMetadata = {};
        if (values.user) {
          bootstrapMetadata.user = values.user;
        }
        if (values.sdkInfo) {
          bootstrapMetadata.generatorSDKInfo = values.sdkInfo;
        }
        bootstrapMetadata.lcut = values.time;
        return bootstrapMetadata;
      }
      _getDetailedStoreResult(lookup, name) {
        let result = null;
        if (lookup) {
          result = lookup[name] ? lookup[name] : lookup[(0, client_core_1._DJB2)(name)];
        }
        return {
          result,
          details: this._getDetails(result == null)
        };
      }
      _setWarningState(user, values) {
        var _a, _b;
        const stableID = client_core_1.StableID.get(this._sdkKey);
        if (((_a = user.customIDs) === null || _a === void 0 ? void 0 : _a.stableID) !== stableID && // don't throw if they're both undefined
        (((_b = user.customIDs) === null || _b === void 0 ? void 0 : _b.stableID) || stableID)) {
          this._warnings.add("StableIDMismatch");
          return;
        }
        if ("user" in values) {
          const bootstrapUser = values["user"];
          const userForComparison = Object.assign(Object.assign({}, user), { analyticsOnlyMetadata: void 0, privateAttributes: void 0 });
          if ((0, client_core_1._getFullUserHash)(userForComparison) !== (0, client_core_1._getFullUserHash)(bootstrapUser)) {
            this._warnings.add("PartialUserMatch");
          }
        }
      }
      getCurrentSourceDetails() {
        if (this._source === "Uninitialized" || this._source === "NoValues") {
          return { reason: this._source };
        }
        const sourceDetails = {
          reason: this._source,
          lcut: this._lcut,
          receivedAt: this._receivedAt
        };
        if (this._warnings.size > 0) {
          sourceDetails.warnings = Array.from(this._warnings);
        }
        return sourceDetails;
      }
      _getDetails(isUnrecognized) {
        var _a, _b;
        const sourceDetails = this.getCurrentSourceDetails();
        let reason = sourceDetails.reason;
        const warnings = (_a = sourceDetails.warnings) !== null && _a !== void 0 ? _a : [];
        if (this._source === "Bootstrap" && warnings.length > 0) {
          reason = reason + warnings[0];
        }
        if (reason !== "Uninitialized" && reason !== "NoValues") {
          const subreason = isUnrecognized ? "Unrecognized" : "Recognized";
          reason = `${reason}:${subreason}`;
        }
        const bootstrapMetadata = this._source === "Bootstrap" ? (_b = this._bootstrapMetadata) !== null && _b !== void 0 ? _b : void 0 : void 0;
        if (bootstrapMetadata) {
          sourceDetails.bootstrapMetadata = bootstrapMetadata;
        }
        return Object.assign(Object.assign({}, sourceDetails), { reason });
      }
    };
    exports2.default = EvaluationStore;
  }
});

// node_modules/@statsig/js-client/src/EvaluationResponseDeltas.js
var require_EvaluationResponseDeltas = __commonJS({
  "node_modules/@statsig/js-client/src/EvaluationResponseDeltas.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._resolveDeltasResponse = void 0;
    var client_core_1 = require_src();
    var MAX_DELTAS_SORT_DEPTH = 2;
    function _resolveDeltasResponse(cache, deltasString) {
      const deltas = (0, client_core_1._typedJsonParse)(deltasString, "checksum", "DeltasEvaluationResponse");
      if (!deltas) {
        return {
          hadBadDeltaChecksum: true
        };
      }
      const merged = _mergeDeltasIntoCache(cache, deltas);
      const resolved = _handleDeletedEntries(merged);
      const actualChecksum = (0, client_core_1._DJB2Object)({
        feature_gates: resolved.feature_gates,
        dynamic_configs: resolved.dynamic_configs,
        layer_configs: resolved.layer_configs
      }, MAX_DELTAS_SORT_DEPTH);
      const isMatch = actualChecksum === deltas.checksumV2;
      if (!isMatch) {
        return {
          hadBadDeltaChecksum: true,
          badChecksum: actualChecksum,
          badMergedConfigs: resolved,
          badFullResponse: deltas.deltas_full_response
        };
      }
      return JSON.stringify(resolved);
    }
    exports2._resolveDeltasResponse = _resolveDeltasResponse;
    function _mergeDeltasIntoCache(cache, deltas) {
      return Object.assign(Object.assign(Object.assign({}, cache), deltas), { feature_gates: Object.assign(Object.assign({}, cache.feature_gates), deltas.feature_gates), layer_configs: Object.assign(Object.assign({}, cache.layer_configs), deltas.layer_configs), dynamic_configs: Object.assign(Object.assign({}, cache.dynamic_configs), deltas.dynamic_configs) });
    }
    function _handleDeletedEntries(deltas) {
      const result = deltas;
      _deleteEntriesInRecord(deltas.deleted_gates, result.feature_gates);
      delete result.deleted_gates;
      _deleteEntriesInRecord(deltas.deleted_configs, result.dynamic_configs);
      delete result.deleted_configs;
      _deleteEntriesInRecord(deltas.deleted_layers, result.layer_configs);
      delete result.deleted_layers;
      return result;
    }
    function _deleteEntriesInRecord(keys, values) {
      keys === null || keys === void 0 ? void 0 : keys.forEach((key) => {
        delete values[key];
      });
    }
  }
});

// node_modules/@statsig/js-client/src/Network.js
var require_Network = __commonJS({
  "node_modules/@statsig/js-client/src/Network.js"(exports2) {
    "use strict";
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function(resolve) {
          resolve(value);
        });
      }
      return new (P || (P = Promise))(function(resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }
        function step(result) {
          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var client_core_1 = require_src();
    var EvaluationResponseDeltas_1 = require_EvaluationResponseDeltas();
    var StatsigNetwork = class extends client_core_1.NetworkCore {
      constructor(options, emitter) {
        super(options, emitter);
        const config = options === null || options === void 0 ? void 0 : options.networkConfig;
        this._option = options;
        this._initializeUrlConfig = new client_core_1.UrlConfiguration(client_core_1.Endpoint._initialize, config === null || config === void 0 ? void 0 : config.initializeUrl, config === null || config === void 0 ? void 0 : config.api, config === null || config === void 0 ? void 0 : config.initializeFallbackUrls);
      }
      fetchEvaluations(sdkKey, current, priority, user, isCacheValidFor204) {
        return __awaiter(this, void 0, void 0, function* () {
          var _a, _b, _c, _d, _e, _f;
          const cache = current ? (0, client_core_1._typedJsonParse)(current, "has_updates", "InitializeResponse") : null;
          let data = {
            user,
            hash: (_c = (_b = (_a = this._option) === null || _a === void 0 ? void 0 : _a.networkConfig) === null || _b === void 0 ? void 0 : _b.initializeHashAlgorithm) !== null && _c !== void 0 ? _c : "djb2",
            deltasResponseRequested: false,
            full_checksum: null
          };
          if (cache === null || cache === void 0 ? void 0 : cache.has_updates) {
            const hasHashChanged = (cache === null || cache === void 0 ? void 0 : cache.hash_used) !== ((_f = (_e = (_d = this._option) === null || _d === void 0 ? void 0 : _d.networkConfig) === null || _e === void 0 ? void 0 : _e.initializeHashAlgorithm) !== null && _f !== void 0 ? _f : "djb2");
            data = Object.assign(Object.assign({}, data), { sinceTime: isCacheValidFor204 && !hasHashChanged ? cache.time : 0, previousDerivedFields: "derived_fields" in cache && isCacheValidFor204 ? cache.derived_fields : {}, deltasResponseRequested: true, full_checksum: cache.full_checksum, partialUserMatchSinceTime: !hasHashChanged ? cache.time : 0 });
          }
          return this._fetchEvaluations(sdkKey, cache, data, priority);
        });
      }
      _fetchEvaluations(sdkKey, cache, data, priority) {
        return __awaiter(this, void 0, void 0, function* () {
          var _a, _b;
          const response = yield this.post({
            sdkKey,
            urlConfig: this._initializeUrlConfig,
            data,
            retries: 2,
            isStatsigEncodable: true,
            priority
          });
          if ((response === null || response === void 0 ? void 0 : response.code) === 204) {
            return '{"has_updates": false}';
          }
          if ((response === null || response === void 0 ? void 0 : response.code) !== 200) {
            return (_a = response === null || response === void 0 ? void 0 : response.body) !== null && _a !== void 0 ? _a : null;
          }
          if ((cache === null || cache === void 0 ? void 0 : cache.has_updates) !== true || ((_b = response.body) === null || _b === void 0 ? void 0 : _b.includes('"is_delta":true')) !== true || data.deltasResponseRequested !== true) {
            return response.body;
          }
          const result = (0, EvaluationResponseDeltas_1._resolveDeltasResponse)(cache, response.body);
          if (typeof result === "string") {
            return result;
          }
          return this._fetchEvaluations(sdkKey, cache, Object.assign(Object.assign(Object.assign({}, data), result), { deltasResponseRequested: false }), priority);
        });
      }
    };
    exports2.default = StatsigNetwork;
  }
});

// node_modules/@statsig/js-client/src/ParamStoreGetterFactory.js
var require_ParamStoreGetterFactory = __commonJS({
  "node_modules/@statsig/js-client/src/ParamStoreGetterFactory.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._makeParamStoreGetter = void 0;
    var client_core_1 = require_src();
    var NO_EXPOSURE_OPT = {
      disableExposureLog: true
    };
    function _shouldLogExposure(options) {
      return options == null || options.disableExposureLog === false;
    }
    function _shouldReturnFallback(value, fallback) {
      return fallback != null && !(0, client_core_1._isTypeMatch)(value, fallback);
    }
    function _getMappedStaticValue(param, _options) {
      return param.value;
    }
    function _getMappedGateValue(client, param, options) {
      const gate = client.getFeatureGate(param.gate_name, _shouldLogExposure(options) ? void 0 : NO_EXPOSURE_OPT);
      if (gate.value) {
        return param.pass_value;
      }
      return param.fail_value;
    }
    function _getMappedDynamicConfigValue(client, param, fallback, options) {
      const config = client.getDynamicConfig(param.config_name, _shouldLogExposure(options) ? void 0 : NO_EXPOSURE_OPT);
      const value = config.get(param.param_name);
      if (_shouldReturnFallback(value, fallback)) {
        return fallback;
      }
      return value;
    }
    function _getMappedExperimentValue(client, param, fallback, options) {
      const experiment = client.getExperiment(param.experiment_name, _shouldLogExposure(options) ? void 0 : NO_EXPOSURE_OPT);
      const value = experiment.get(param.param_name);
      if (_shouldReturnFallback(value, fallback)) {
        return fallback;
      }
      return value;
    }
    function _getMappedLayerValue(client, param, fallback, options) {
      const layer = client.getLayer(param.layer_name, _shouldLogExposure(options) ? void 0 : NO_EXPOSURE_OPT);
      const value = layer.get(param.param_name);
      if (_shouldReturnFallback(value, fallback)) {
        return fallback;
      }
      return value;
    }
    function _makeParamStoreGetter(client, config, options) {
      return (paramName, fallback) => {
        if (config == null) {
          return fallback;
        }
        const param = config[paramName];
        if (param == null || fallback != null && (0, client_core_1._typeOf)(fallback) !== param.param_type) {
          return fallback;
        }
        switch (param.ref_type) {
          case "static":
            return _getMappedStaticValue(param, options);
          case "gate":
            return _getMappedGateValue(client, param, options);
          case "dynamic_config":
            return _getMappedDynamicConfigValue(client, param, fallback, options);
          case "experiment":
            return _getMappedExperimentValue(client, param, fallback, options);
          case "layer":
            return _getMappedLayerValue(client, param, fallback, options);
          default:
            return fallback;
        }
      };
    }
    exports2._makeParamStoreGetter = _makeParamStoreGetter;
  }
});

// node_modules/@statsig/js-client/src/StatsigEvaluationsDataAdapter.js
var require_StatsigEvaluationsDataAdapter = __commonJS({
  "node_modules/@statsig/js-client/src/StatsigEvaluationsDataAdapter.js"(exports2) {
    "use strict";
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function(resolve) {
          resolve(value);
        });
      }
      return new (P || (P = Promise))(function(resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }
        function step(result) {
          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.StatsigEvaluationsDataAdapter = void 0;
    var client_core_1 = require_src();
    var Network_1 = require_Network();
    var StatsigEvaluationsDataAdapter = class extends client_core_1.DataAdapterCore {
      constructor() {
        super("EvaluationsDataAdapter", "evaluations");
        this._network = null;
        this._options = null;
      }
      attach(sdkKey, options, network) {
        super.attach(sdkKey, options, network);
        if (network !== null && network instanceof Network_1.default) {
          this._network = network;
        } else {
          this._network = new Network_1.default(options !== null && options !== void 0 ? options : {});
        }
      }
      getDataAsync(current, user, options) {
        return this._getDataAsyncImpl(current, (0, client_core_1._normalizeUser)(user, this._options), options);
      }
      prefetchData(user, options) {
        return this._prefetchDataImpl(user, options);
      }
      setData(data) {
        const values = (0, client_core_1._typedJsonParse)(data, "has_updates", "data");
        if (values && "user" in values) {
          super.setData(data, values.user);
        } else {
          client_core_1.Log.error("StatsigUser not found. You may be using an older server SDK version. Please upgrade your SDK or use setDataLegacy.");
        }
      }
      setDataLegacy(data, user) {
        super.setData(data, user);
      }
      _fetchFromNetwork(current, user, options, isCacheValidFor204) {
        return __awaiter(this, void 0, void 0, function* () {
          var _a;
          const result = yield (_a = this._network) === null || _a === void 0 ? void 0 : _a.fetchEvaluations(this._getSdkKey(), current, options === null || options === void 0 ? void 0 : options.priority, user, isCacheValidFor204);
          return result !== null && result !== void 0 ? result : null;
        });
      }
      _getCacheKey(user) {
        var _a;
        const key = (0, client_core_1._getStorageKey)(this._getSdkKey(), user, (_a = this._options) === null || _a === void 0 ? void 0 : _a.customUserCacheKeyFunc);
        return `${client_core_1.DataAdapterCachePrefix}.${this._cacheSuffix}.${key}`;
      }
      _isCachedResultValidFor204(result, user) {
        return result.fullUserHash != null && result.fullUserHash === (0, client_core_1._getFullUserHash)(user);
      }
    };
    exports2.StatsigEvaluationsDataAdapter = StatsigEvaluationsDataAdapter;
  }
});

// node_modules/@statsig/js-client/src/StatsigClient.js
var require_StatsigClient = __commonJS({
  "node_modules/@statsig/js-client/src/StatsigClient.js"(exports2) {
    "use strict";
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function(resolve) {
          resolve(value);
        });
      }
      return new (P || (P = Promise))(function(resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }
        function step(result) {
          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var client_core_1 = require_src();
    var EvaluationStore_1 = require_EvaluationStore();
    var Network_1 = require_Network();
    var ParamStoreGetterFactory_1 = require_ParamStoreGetterFactory();
    var StatsigEvaluationsDataAdapter_1 = require_StatsigEvaluationsDataAdapter();
    var StatsigClient = class _StatsigClient extends client_core_1.StatsigClientBase {
      /**
       * Retrieves an instance of the StatsigClient based on the provided SDK key.
       *  If no SDK key is provided, the method returns the most recently created instance of the StatsigClient.
       *  The method ensures that each unique SDK key corresponds to a single instance of StatsigClient, effectively implementing a singleton pattern for each key.
       *  If no instance exists for the given SDK key, a new StatsigClient instance will be created and returned.
       *
       * @param {string} [sdkKey] - Optional. The SDK key used to identify a specific instance of the StatsigClient. If omitted, the method returns the last created instance.
       * @returns {StatsigClient} Returns the StatsigClient instance associated with the given SDK key, creating a new one if needed.
       */
      static instance(sdkKey) {
        const instance = (0, client_core_1._getStatsigGlobal)().instance(sdkKey);
        if (instance instanceof _StatsigClient) {
          return instance;
        }
        client_core_1.Log.warn((0, client_core_1._isServerEnv)() ? "StatsigClient.instance is not supported in server environments" : "Unable to find StatsigClient instance");
        return new _StatsigClient(sdkKey !== null && sdkKey !== void 0 ? sdkKey : "", {});
      }
      /**
       * StatsigClient constructor
       *
       * @param {string} sdkKey A Statsig client SDK key. eg "client-xyz123..."
       * @param {StatsigUser} user StatsigUser object containing various attributes related to a user.
       * @param {StatsigOptions | null} options StatsigOptions, used to customize the behavior of the SDK.
       */
      constructor(sdkKey, user, options = null) {
        var _a, _b;
        client_core_1.SDKType._setClientType(sdkKey, "javascript-client");
        const network = new Network_1.default(options, (e) => {
          this.$emt(e);
        });
        super(sdkKey, (_a = options === null || options === void 0 ? void 0 : options.dataAdapter) !== null && _a !== void 0 ? _a : new StatsigEvaluationsDataAdapter_1.StatsigEvaluationsDataAdapter(), network, options);
        this._possibleFirstTouchMetadata = {};
        this.getFeatureGate = this._memoize(client_core_1.MemoPrefix._gate, this._getFeatureGateImpl.bind(this));
        this.getDynamicConfig = this._memoize(client_core_1.MemoPrefix._dynamicConfig, this._getDynamicConfigImpl.bind(this));
        this.getExperiment = this._memoize(client_core_1.MemoPrefix._experiment, this._getExperimentImpl.bind(this));
        this.getConfigList = this._memoize(client_core_1.MemoPrefix._configList, this._getConfigListImpl.bind(this));
        this.getLayer = this._memoize(client_core_1.MemoPrefix._layer, this._getLayerImpl.bind(this));
        this.getParameterStore = this._memoize(client_core_1.MemoPrefix._paramStore, this._getParameterStoreImpl.bind(this));
        this._store = new EvaluationStore_1.default(sdkKey);
        this._network = network;
        this._user = this._configureUser(user, options);
        this._sdkInstanceID = (0, client_core_1.getUUID)();
        const plugins = (_b = options === null || options === void 0 ? void 0 : options.plugins) !== null && _b !== void 0 ? _b : [];
        for (const plugin of plugins) {
          plugin.bind(this);
        }
      }
      /**
       * Initializes the StatsigClient using cached values. This method sets up the client synchronously by utilizing previously cached values.
       * After initialization, cache values are updated in the background for future use, either in subsequent sessions or when `updateUser` is called.
       * This is useful for quickly starting with the last-known-good configurations while refreshing data to keep settings up-to-date.
       *
       * @see {@link initializeAsync} for the asynchronous version of this method.
       */
      initializeSync(options) {
        var _a;
        if (this.loadingStatus !== "Uninitialized") {
          return (0, client_core_1.createUpdateDetails)(true, this._store.getSource(), -1, null, null, ["MultipleInitializations", ...(_a = this._store.getWarnings()) !== null && _a !== void 0 ? _a : []]);
        }
        this._logger.start();
        return this.updateUserSync(this._user, options);
      }
      /**
       * Initializes the StatsigClient asynchronously by first using cached values and then updating to the latest values from the network.
       * Once the network values are fetched, they replace the existing cached values. If this method's promise is not awaited,
       * there might be a transition from cached to network values during the session, which can affect consistency.
       * This method is useful when it's acceptable to begin with potentially stale data and switch to the latest configuration as it becomes available.
       *
       * @param {AsyncUpdateOptions} [options] - Optional. Additional options to customize the method call.
       * @returns {Promise<void>} A promise that resolves once the client is fully initialized with the latest values from the network or a timeout (if set) is hit.
       * @see {@link initializeSync} for the synchronous version of this method.
       */
      initializeAsync(options) {
        return __awaiter(this, void 0, void 0, function* () {
          if (this._initializePromise) {
            return this._initializePromise;
          }
          this._initializePromise = this._initializeAsyncImpl(options);
          return this._initializePromise;
        });
      }
      /**
       * Synchronously updates the user in the Statsig client and switches the internal state to use cached values for the newly specified user.
       * After the initial switch to cached values, this method updates these values in the background, preparing them for future sessions or subsequent calls to updateUser.
       * This method ensures the client is quickly ready with available data.
       *
       * @param {StatsigUser} user - The new StatsigUser for which the client should update its internal state.
       * @see {@link updateUserAsync} for the asynchronous version of this method.
       */
      updateUserSync(user, options) {
        const startTime = performance.now();
        try {
          return this._updateUserSyncImpl(user, options, startTime);
        } catch (e) {
          const err = e instanceof Error ? e : new Error(String(e));
          return this._createErrorUpdateDetails(err, startTime);
        }
      }
      _updateUserSyncImpl(user, options, startTime) {
        var _a;
        const warnings = [...(_a = this._store.getWarnings()) !== null && _a !== void 0 ? _a : []];
        this._resetForUser(user);
        const result = this.dataAdapter.getDataSync(this._user);
        if (result == null) {
          warnings.push("NoCachedValues");
        }
        this._store.setValues(result, this._user);
        this._finalizeUpdate(result);
        const disable = options === null || options === void 0 ? void 0 : options.disableBackgroundCacheRefresh;
        if (disable === true || disable == null && (result === null || result === void 0 ? void 0 : result.source) === "Bootstrap") {
          return (0, client_core_1.createUpdateDetails)(true, this._store.getSource(), performance.now() - startTime, this._errorBoundary.getLastSeenErrorAndReset(), this._network.getLastUsedInitUrlAndReset(), warnings);
        }
        this._runPostUpdate(result !== null && result !== void 0 ? result : null, this._user);
        return (0, client_core_1.createUpdateDetails)(true, this._store.getSource(), performance.now() - startTime, this._errorBoundary.getLastSeenErrorAndReset(), this._network.getLastUsedInitUrlAndReset(), warnings);
      }
      /**
       * Asynchronously updates the user in the Statsig client by initially using cached values and then fetching the latest values from the network.
       * When the latest values are fetched, they replace the cached values. If the promise returned by this method is not awaited,
       * the client's state may shift from cached to updated network values during the session, potentially affecting consistency.
       * This method is best used in scenarios where up-to-date configuration is critical and initial delays are acceptable.
       *
       * @param {StatsigUser} user - The new StatsigUser for which the client should update its internal state.
       * @param {AsyncUpdateOptions} [options] - Optional. Additional options to customize the method call.
       * @returns {Promise<void>} A promise that resolves once the client is fully updated with the latest values from the network or a timeout (if set) is hit.
       * @see {@link updateUserSync} for the synchronous version of this method.
       */
      updateUserAsync(user, options) {
        return __awaiter(this, void 0, void 0, function* () {
          const startTime = performance.now();
          try {
            return yield this._updateUserAsyncImpl(user, options);
          } catch (e) {
            const err = e instanceof Error ? e : new Error(String(e));
            return this._createErrorUpdateDetails(err, startTime);
          }
        });
      }
      _updateUserAsyncImpl(user, options) {
        return __awaiter(this, void 0, void 0, function* () {
          this._resetForUser(user);
          const initiator = this._user;
          client_core_1.Diagnostics._markInitOverallStart(this._sdkKey);
          let result = this.dataAdapter.getDataSync(initiator);
          this._store.setValues(result, this._user);
          this._setStatus("Loading", result);
          result = yield this.dataAdapter.getDataAsync(result, initiator, options);
          if (initiator !== this._user) {
            return (0, client_core_1.createUpdateDetails)(false, this._store.getSource(), -1, new Error("User changed during update"), this._network.getLastUsedInitUrlAndReset());
          }
          let isUsingNetworkValues = false;
          if (result != null) {
            client_core_1.Diagnostics._markInitProcessStart(this._sdkKey);
            isUsingNetworkValues = this._store.setValues(result, this._user);
            client_core_1.Diagnostics._markInitProcessEnd(this._sdkKey, {
              success: isUsingNetworkValues
            });
          }
          this._finalizeUpdate(result);
          if (!isUsingNetworkValues) {
            this._errorBoundary.attachErrorIfNoneExists(client_core_1.UPDATE_DETAIL_ERROR_MESSAGES.NO_NETWORK_DATA);
            this.$emt({ name: "initialization_failure" });
          }
          client_core_1.Diagnostics._markInitOverallEnd(this._sdkKey, isUsingNetworkValues, this._store.getCurrentSourceDetails());
          const initDuration = client_core_1.Diagnostics._enqueueDiagnosticsEvent(this._user, this._logger, this._sdkKey, this._options);
          return (0, client_core_1.createUpdateDetails)(isUsingNetworkValues, this._store.getSource(), initDuration, this._errorBoundary.getLastSeenErrorAndReset(), this._network.getLastUsedInitUrlAndReset(), this._store.getWarnings());
        });
      }
      /**
       * Retrieves a synchronous context containing data currently being used by the SDK. Represented as a {@link PrecomputedEvaluationsContext} object.
       *
       * @returns {PrecomputedEvaluationsContext} The current synchronous context for the this StatsigClient instance.
       */
      getContext() {
        return {
          sdkKey: this._sdkKey,
          options: this._options,
          values: this._store.getValues(),
          user: JSON.parse(JSON.stringify(this._user)),
          errorBoundary: this._errorBoundary,
          session: client_core_1.StatsigSession.get(this._sdkKey),
          stableID: client_core_1.StableID.get(this._sdkKey),
          sdkInstanceID: this._sdkInstanceID
        };
      }
      /**
       * Retrieves the value of a feature gate for the current user, represented as a simple boolean.
       *
       * @param {string} name - The name of the feature gate to retrieve.
       * @param {FeatureGateEvaluationOptions} [options] - Optional. Additional options to customize the method call.
       * @returns {boolean} - The boolean value representing the gate's current evaluation results for the user.
       */
      checkGate(name, options) {
        return this.getFeatureGate(name, options).value;
      }
      /**
       * Logs an event to the internal logging system. This function allows logging by either passing a fully formed event object or by specifying the event name with optional value and metadata.
       *
       * @param {StatsigEvent|string} eventOrName - The event object conforming to the StatsigEvent interface, or the name of the event as a string.
       * @param {string|number} value - Optional. The value associated with the event, which can be a string or a number. This parameter is ignored if the first parameter is a StatsigEvent object.
       * @param {Record<string, string>} metadata - Optional. A key-value record containing metadata about the event. This is also ignored if the first parameter is an event object.
       */
      logEvent(eventOrName, value, metadata) {
        const event = typeof eventOrName === "string" ? {
          eventName: eventOrName,
          value,
          metadata
        } : eventOrName;
        this.$emt({
          name: "log_event_called",
          event
        });
        this._logger.enqueue(Object.assign(Object.assign({}, event), { user: this._user, time: Date.now() }));
      }
      /**
       * Updates the user with analytics only metadata. This will override any existing analytics only metadata.
       *
       * @param {Record<string, string | number | boolean>} metadata - The metadata to add to the user.
       */
      updateUserWithAnalyticsOnlyMetadata(metadata) {
        this._user = this._configureUser(Object.assign(Object.assign({}, this._user), { analyticsOnlyMetadata: metadata }), this._options);
      }
      _primeReadyRipcord() {
        this.$on("error", () => {
          this.loadingStatus === "Loading" && this._finalizeUpdate(null);
        });
      }
      _initializeAsyncImpl(options) {
        return __awaiter(this, void 0, void 0, function* () {
          if (!client_core_1.Storage.isReady()) {
            yield client_core_1.Storage.isReadyResolver();
          }
          this._logger.start();
          return this.updateUserAsync(this._user, options);
        });
      }
      _createErrorUpdateDetails(error, startTime) {
        var _a;
        return (0, client_core_1.createUpdateDetails)(false, this._store.getSource(), performance.now() - startTime, error, null, [...(_a = this._store.getWarnings()) !== null && _a !== void 0 ? _a : []]);
      }
      _finalizeUpdate(values) {
        this._store.finalize();
        this._setStatus("Ready", values);
      }
      _runPostUpdate(current, user) {
        this.dataAdapter.getDataAsync(current, user, { priority: "low" }).catch((err) => {
          client_core_1.Log.error("An error occurred after update.", err);
        });
      }
      _resetForUser(user) {
        this._logger.reset();
        this._store.reset();
        this._user = this._configureUser(user, this._options);
      }
      _configureUser(originalUser, options) {
        var _a;
        const user = (0, client_core_1._normalizeUser)(originalUser, options);
        const stableIdOverride = (_a = user.customIDs) === null || _a === void 0 ? void 0 : _a.stableID;
        if (stableIdOverride) {
          client_core_1.StableID.setOverride(stableIdOverride, this._sdkKey);
        }
        if (Object.keys(this._possibleFirstTouchMetadata).length > 0) {
          user.analyticsOnlyMetadata = Object.assign(Object.assign({}, user.analyticsOnlyMetadata), this._possibleFirstTouchMetadata);
        }
        return user;
      }
      _getFeatureGateImpl(name, options) {
        var _a, _b;
        const { result: evaluation, details } = this._store.getGate(name);
        const gate = (0, client_core_1._makeFeatureGate)(name, details, evaluation);
        const overridden = (_b = (_a = this.overrideAdapter) === null || _a === void 0 ? void 0 : _a.getGateOverride) === null || _b === void 0 ? void 0 : _b.call(_a, gate, this._user, options);
        const result = overridden !== null && overridden !== void 0 ? overridden : gate;
        this._enqueueExposure(name, (0, client_core_1._createGateExposure)(this._user, result, this._store.getExposureMapping()), options);
        this.$emt({ name: "gate_evaluation", gate: result });
        return result;
      }
      _getDynamicConfigImpl(name, options) {
        var _a, _b;
        const { result: evaluation, details } = this._store.getConfig(name);
        const config = (0, client_core_1._makeDynamicConfig)(name, details, evaluation);
        const overridden = (_b = (_a = this.overrideAdapter) === null || _a === void 0 ? void 0 : _a.getDynamicConfigOverride) === null || _b === void 0 ? void 0 : _b.call(_a, config, this._user, options);
        const result = overridden !== null && overridden !== void 0 ? overridden : config;
        this._enqueueExposure(name, (0, client_core_1._createConfigExposure)(this._user, result, this._store.getExposureMapping()), options);
        this.$emt({ name: "dynamic_config_evaluation", dynamicConfig: result });
        return result;
      }
      _getExperimentImpl(name, options) {
        var _a, _b, _c, _d;
        const { result: evaluation, details } = this._store.getConfig(name);
        const experiment = (0, client_core_1._makeExperiment)(name, details, evaluation);
        if (experiment.__evaluation != null) {
          experiment.__evaluation.secondary_exposures = (0, client_core_1._mapExposures)((_b = (_a = experiment.__evaluation) === null || _a === void 0 ? void 0 : _a.secondary_exposures) !== null && _b !== void 0 ? _b : [], this._store.getExposureMapping());
        }
        const overridden = (_d = (_c = this.overrideAdapter) === null || _c === void 0 ? void 0 : _c.getExperimentOverride) === null || _d === void 0 ? void 0 : _d.call(_c, experiment, this._user, options);
        const result = overridden !== null && overridden !== void 0 ? overridden : experiment;
        this._enqueueExposure(name, (0, client_core_1._createConfigExposure)(this._user, result, this._store.getExposureMapping()), options);
        this.$emt({ name: "experiment_evaluation", experiment: result });
        return result;
      }
      _getConfigListImpl() {
        return this._store.getConfigList();
      }
      _getLayerImpl(name, options) {
        var _a, _b, _c;
        const { result: evaluation, details } = this._store.getLayer(name);
        const layer = (0, client_core_1._makeLayer)(name, details, evaluation);
        const overridden = (_b = (_a = this.overrideAdapter) === null || _a === void 0 ? void 0 : _a.getLayerOverride) === null || _b === void 0 ? void 0 : _b.call(_a, layer, this._user, options);
        if (options === null || options === void 0 ? void 0 : options.disableExposureLog) {
          this._logger.incrementNonExposureCount(name);
        }
        const result = (0, client_core_1._mergeOverride)(layer, overridden, (_c = overridden === null || overridden === void 0 ? void 0 : overridden.__value) !== null && _c !== void 0 ? _c : layer.__value, (param) => {
          if (options === null || options === void 0 ? void 0 : options.disableExposureLog) {
            return;
          }
          this._enqueueExposure(name, (0, client_core_1._createLayerParameterExposure)(this._user, result, param, this._store.getExposureMapping()), options);
        });
        this.$emt({ name: "layer_evaluation", layer: result });
        return result;
      }
      _getParameterStoreImpl(name, options) {
        var _a, _b;
        const { result: configuration, details } = this._store.getParamStore(name);
        this._logger.incrementNonExposureCount(name);
        const paramStore = {
          name,
          details,
          __configuration: configuration,
          get: (0, ParamStoreGetterFactory_1._makeParamStoreGetter)(this, configuration, options)
        };
        const overridden = (_b = (_a = this.overrideAdapter) === null || _a === void 0 ? void 0 : _a.getParamStoreOverride) === null || _b === void 0 ? void 0 : _b.call(_a, paramStore, options);
        if (overridden != null) {
          paramStore.__configuration = overridden.config;
          paramStore.details = overridden.details;
          paramStore.get = (0, ParamStoreGetterFactory_1._makeParamStoreGetter)(this, overridden.config, options);
        }
        return paramStore;
      }
    };
    exports2.default = StatsigClient;
  }
});

// node_modules/@statsig/js-client/src/index.js
var require_src2 = __commonJS({
  "node_modules/@statsig/js-client/src/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.StatsigClient = void 0;
    var client_core_1 = require_src();
    var StatsigClient_1 = require_StatsigClient();
    exports2.StatsigClient = StatsigClient_1.default;
    __exportStar(require_src(), exports2);
    var __STATSIG__2 = Object.assign((0, client_core_1._getStatsigGlobal)(), {
      StatsigClient: StatsigClient_1.default
    });
    exports2.default = __STATSIG__2;
  }
});

// node_modules/eventemitter2/lib/eventemitter2.js
var require_eventemitter2 = __commonJS({
  "node_modules/eventemitter2/lib/eventemitter2.js"(exports2, module2) {
    !(function(undefined2) {
      var isArray = Array.isArray ? Array.isArray : function _isArray(obj) {
        return Object.prototype.toString.call(obj) === "[object Array]";
      };
      var defaultMaxListeners = 10;
      function init() {
        this._events = {};
        if (this._conf) {
          configure.call(this, this._conf);
        }
      }
      function configure(conf) {
        if (conf) {
          this._conf = conf;
          conf.delimiter && (this.delimiter = conf.delimiter);
          this._maxListeners = conf.maxListeners !== undefined2 ? conf.maxListeners : defaultMaxListeners;
          conf.wildcard && (this.wildcard = conf.wildcard);
          conf.newListener && (this.newListener = conf.newListener);
          conf.verboseMemoryLeak && (this.verboseMemoryLeak = conf.verboseMemoryLeak);
          if (this.wildcard) {
            this.listenerTree = {};
          }
        } else {
          this._maxListeners = defaultMaxListeners;
        }
      }
      function logPossibleMemoryLeak(count, eventName) {
        var errorMsg = "(node) warning: possible EventEmitter memory leak detected. " + count + " listeners added. Use emitter.setMaxListeners() to increase limit.";
        if (this.verboseMemoryLeak) {
          errorMsg += " Event name: " + eventName + ".";
        }
        if (typeof process !== "undefined" && process.emitWarning) {
          var e = new Error(errorMsg);
          e.name = "MaxListenersExceededWarning";
          e.emitter = this;
          e.count = count;
          process.emitWarning(e);
        } else {
          console.error(errorMsg);
          if (console.trace) {
            console.trace();
          }
        }
      }
      function EventEmitter(conf) {
        this._events = {};
        this.newListener = false;
        this.verboseMemoryLeak = false;
        configure.call(this, conf);
      }
      EventEmitter.EventEmitter2 = EventEmitter;
      function searchListenerTree(handlers, type, tree, i) {
        if (!tree) {
          return [];
        }
        var listeners = [], leaf, len, branch, xTree, xxTree, isolatedBranch, endReached, typeLength = type.length, currentType = type[i], nextType = type[i + 1];
        if (i === typeLength && tree._listeners) {
          if (typeof tree._listeners === "function") {
            handlers && handlers.push(tree._listeners);
            return [tree];
          } else {
            for (leaf = 0, len = tree._listeners.length; leaf < len; leaf++) {
              handlers && handlers.push(tree._listeners[leaf]);
            }
            return [tree];
          }
        }
        if (currentType === "*" || currentType === "**" || tree[currentType]) {
          if (currentType === "*") {
            for (branch in tree) {
              if (branch !== "_listeners" && tree.hasOwnProperty(branch)) {
                listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i + 1));
              }
            }
            return listeners;
          } else if (currentType === "**") {
            endReached = i + 1 === typeLength || i + 2 === typeLength && nextType === "*";
            if (endReached && tree._listeners) {
              listeners = listeners.concat(searchListenerTree(handlers, type, tree, typeLength));
            }
            for (branch in tree) {
              if (branch !== "_listeners" && tree.hasOwnProperty(branch)) {
                if (branch === "*" || branch === "**") {
                  if (tree[branch]._listeners && !endReached) {
                    listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], typeLength));
                  }
                  listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i));
                } else if (branch === nextType) {
                  listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i + 2));
                } else {
                  listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i));
                }
              }
            }
            return listeners;
          }
          listeners = listeners.concat(searchListenerTree(handlers, type, tree[currentType], i + 1));
        }
        xTree = tree["*"];
        if (xTree) {
          searchListenerTree(handlers, type, xTree, i + 1);
        }
        xxTree = tree["**"];
        if (xxTree) {
          if (i < typeLength) {
            if (xxTree._listeners) {
              searchListenerTree(handlers, type, xxTree, typeLength);
            }
            for (branch in xxTree) {
              if (branch !== "_listeners" && xxTree.hasOwnProperty(branch)) {
                if (branch === nextType) {
                  searchListenerTree(handlers, type, xxTree[branch], i + 2);
                } else if (branch === currentType) {
                  searchListenerTree(handlers, type, xxTree[branch], i + 1);
                } else {
                  isolatedBranch = {};
                  isolatedBranch[branch] = xxTree[branch];
                  searchListenerTree(handlers, type, { "**": isolatedBranch }, i + 1);
                }
              }
            }
          } else if (xxTree._listeners) {
            searchListenerTree(handlers, type, xxTree, typeLength);
          } else if (xxTree["*"] && xxTree["*"]._listeners) {
            searchListenerTree(handlers, type, xxTree["*"], typeLength);
          }
        }
        return listeners;
      }
      function growListenerTree(type, listener) {
        type = typeof type === "string" ? type.split(this.delimiter) : type.slice();
        for (var i = 0, len = type.length; i + 1 < len; i++) {
          if (type[i] === "**" && type[i + 1] === "**") {
            return;
          }
        }
        var tree = this.listenerTree;
        var name = type.shift();
        while (name !== undefined2) {
          if (!tree[name]) {
            tree[name] = {};
          }
          tree = tree[name];
          if (type.length === 0) {
            if (!tree._listeners) {
              tree._listeners = listener;
            } else {
              if (typeof tree._listeners === "function") {
                tree._listeners = [tree._listeners];
              }
              tree._listeners.push(listener);
              if (!tree._listeners.warned && this._maxListeners > 0 && tree._listeners.length > this._maxListeners) {
                tree._listeners.warned = true;
                logPossibleMemoryLeak.call(this, tree._listeners.length, name);
              }
            }
            return true;
          }
          name = type.shift();
        }
        return true;
      }
      EventEmitter.prototype.delimiter = ".";
      EventEmitter.prototype.setMaxListeners = function(n) {
        if (n !== undefined2) {
          this._maxListeners = n;
          if (!this._conf) this._conf = {};
          this._conf.maxListeners = n;
        }
      };
      EventEmitter.prototype.event = "";
      EventEmitter.prototype.once = function(event, fn) {
        return this._once(event, fn, false);
      };
      EventEmitter.prototype.prependOnceListener = function(event, fn) {
        return this._once(event, fn, true);
      };
      EventEmitter.prototype._once = function(event, fn, prepend) {
        this._many(event, 1, fn, prepend);
        return this;
      };
      EventEmitter.prototype.many = function(event, ttl, fn) {
        return this._many(event, ttl, fn, false);
      };
      EventEmitter.prototype.prependMany = function(event, ttl, fn) {
        return this._many(event, ttl, fn, true);
      };
      EventEmitter.prototype._many = function(event, ttl, fn, prepend) {
        var self2 = this;
        if (typeof fn !== "function") {
          throw new Error("many only accepts instances of Function");
        }
        function listener() {
          if (--ttl === 0) {
            self2.off(event, listener);
          }
          return fn.apply(this, arguments);
        }
        listener._origin = fn;
        this._on(event, listener, prepend);
        return self2;
      };
      EventEmitter.prototype.emit = function() {
        this._events || init.call(this);
        var type = arguments[0];
        if (type === "newListener" && !this.newListener) {
          if (!this._events.newListener) {
            return false;
          }
        }
        var al = arguments.length;
        var args2, l, i, j;
        var handler;
        if (this._all && this._all.length) {
          handler = this._all.slice();
          if (al > 3) {
            args2 = new Array(al);
            for (j = 0; j < al; j++) args2[j] = arguments[j];
          }
          for (i = 0, l = handler.length; i < l; i++) {
            this.event = type;
            switch (al) {
              case 1:
                handler[i].call(this, type);
                break;
              case 2:
                handler[i].call(this, type, arguments[1]);
                break;
              case 3:
                handler[i].call(this, type, arguments[1], arguments[2]);
                break;
              default:
                handler[i].apply(this, args2);
            }
          }
        }
        if (this.wildcard) {
          handler = [];
          var ns = typeof type === "string" ? type.split(this.delimiter) : type.slice();
          searchListenerTree.call(this, handler, ns, this.listenerTree, 0);
        } else {
          handler = this._events[type];
          if (typeof handler === "function") {
            this.event = type;
            switch (al) {
              case 1:
                handler.call(this);
                break;
              case 2:
                handler.call(this, arguments[1]);
                break;
              case 3:
                handler.call(this, arguments[1], arguments[2]);
                break;
              default:
                args2 = new Array(al - 1);
                for (j = 1; j < al; j++) args2[j - 1] = arguments[j];
                handler.apply(this, args2);
            }
            return true;
          } else if (handler) {
            handler = handler.slice();
          }
        }
        if (handler && handler.length) {
          if (al > 3) {
            args2 = new Array(al - 1);
            for (j = 1; j < al; j++) args2[j - 1] = arguments[j];
          }
          for (i = 0, l = handler.length; i < l; i++) {
            this.event = type;
            switch (al) {
              case 1:
                handler[i].call(this);
                break;
              case 2:
                handler[i].call(this, arguments[1]);
                break;
              case 3:
                handler[i].call(this, arguments[1], arguments[2]);
                break;
              default:
                handler[i].apply(this, args2);
            }
          }
          return true;
        } else if (!this._all && type === "error") {
          if (arguments[1] instanceof Error) {
            throw arguments[1];
          } else {
            throw new Error("Uncaught, unspecified 'error' event.");
          }
          return false;
        }
        return !!this._all;
      };
      EventEmitter.prototype.emitAsync = function() {
        this._events || init.call(this);
        var type = arguments[0];
        if (type === "newListener" && !this.newListener) {
          if (!this._events.newListener) {
            return Promise.resolve([false]);
          }
        }
        var promises = [];
        var al = arguments.length;
        var args2, l, i, j;
        var handler;
        if (this._all) {
          if (al > 3) {
            args2 = new Array(al);
            for (j = 1; j < al; j++) args2[j] = arguments[j];
          }
          for (i = 0, l = this._all.length; i < l; i++) {
            this.event = type;
            switch (al) {
              case 1:
                promises.push(this._all[i].call(this, type));
                break;
              case 2:
                promises.push(this._all[i].call(this, type, arguments[1]));
                break;
              case 3:
                promises.push(this._all[i].call(this, type, arguments[1], arguments[2]));
                break;
              default:
                promises.push(this._all[i].apply(this, args2));
            }
          }
        }
        if (this.wildcard) {
          handler = [];
          var ns = typeof type === "string" ? type.split(this.delimiter) : type.slice();
          searchListenerTree.call(this, handler, ns, this.listenerTree, 0);
        } else {
          handler = this._events[type];
        }
        if (typeof handler === "function") {
          this.event = type;
          switch (al) {
            case 1:
              promises.push(handler.call(this));
              break;
            case 2:
              promises.push(handler.call(this, arguments[1]));
              break;
            case 3:
              promises.push(handler.call(this, arguments[1], arguments[2]));
              break;
            default:
              args2 = new Array(al - 1);
              for (j = 1; j < al; j++) args2[j - 1] = arguments[j];
              promises.push(handler.apply(this, args2));
          }
        } else if (handler && handler.length) {
          handler = handler.slice();
          if (al > 3) {
            args2 = new Array(al - 1);
            for (j = 1; j < al; j++) args2[j - 1] = arguments[j];
          }
          for (i = 0, l = handler.length; i < l; i++) {
            this.event = type;
            switch (al) {
              case 1:
                promises.push(handler[i].call(this));
                break;
              case 2:
                promises.push(handler[i].call(this, arguments[1]));
                break;
              case 3:
                promises.push(handler[i].call(this, arguments[1], arguments[2]));
                break;
              default:
                promises.push(handler[i].apply(this, args2));
            }
          }
        } else if (!this._all && type === "error") {
          if (arguments[1] instanceof Error) {
            return Promise.reject(arguments[1]);
          } else {
            return Promise.reject("Uncaught, unspecified 'error' event.");
          }
        }
        return Promise.all(promises);
      };
      EventEmitter.prototype.on = function(type, listener) {
        return this._on(type, listener, false);
      };
      EventEmitter.prototype.prependListener = function(type, listener) {
        return this._on(type, listener, true);
      };
      EventEmitter.prototype.onAny = function(fn) {
        return this._onAny(fn, false);
      };
      EventEmitter.prototype.prependAny = function(fn) {
        return this._onAny(fn, true);
      };
      EventEmitter.prototype.addListener = EventEmitter.prototype.on;
      EventEmitter.prototype._onAny = function(fn, prepend) {
        if (typeof fn !== "function") {
          throw new Error("onAny only accepts instances of Function");
        }
        if (!this._all) {
          this._all = [];
        }
        if (prepend) {
          this._all.unshift(fn);
        } else {
          this._all.push(fn);
        }
        return this;
      };
      EventEmitter.prototype._on = function(type, listener, prepend) {
        if (typeof type === "function") {
          this._onAny(type, listener);
          return this;
        }
        if (typeof listener !== "function") {
          throw new Error("on only accepts instances of Function");
        }
        this._events || init.call(this);
        this.emit("newListener", type, listener);
        if (this.wildcard) {
          growListenerTree.call(this, type, listener);
          return this;
        }
        if (!this._events[type]) {
          this._events[type] = listener;
        } else {
          if (typeof this._events[type] === "function") {
            this._events[type] = [this._events[type]];
          }
          if (prepend) {
            this._events[type].unshift(listener);
          } else {
            this._events[type].push(listener);
          }
          if (!this._events[type].warned && this._maxListeners > 0 && this._events[type].length > this._maxListeners) {
            this._events[type].warned = true;
            logPossibleMemoryLeak.call(this, this._events[type].length, type);
          }
        }
        return this;
      };
      EventEmitter.prototype.off = function(type, listener) {
        if (typeof listener !== "function") {
          throw new Error("removeListener only takes instances of Function");
        }
        var handlers, leafs = [];
        if (this.wildcard) {
          var ns = typeof type === "string" ? type.split(this.delimiter) : type.slice();
          leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0);
        } else {
          if (!this._events[type]) return this;
          handlers = this._events[type];
          leafs.push({ _listeners: handlers });
        }
        for (var iLeaf = 0; iLeaf < leafs.length; iLeaf++) {
          var leaf = leafs[iLeaf];
          handlers = leaf._listeners;
          if (isArray(handlers)) {
            var position = -1;
            for (var i = 0, length = handlers.length; i < length; i++) {
              if (handlers[i] === listener || handlers[i].listener && handlers[i].listener === listener || handlers[i]._origin && handlers[i]._origin === listener) {
                position = i;
                break;
              }
            }
            if (position < 0) {
              continue;
            }
            if (this.wildcard) {
              leaf._listeners.splice(position, 1);
            } else {
              this._events[type].splice(position, 1);
            }
            if (handlers.length === 0) {
              if (this.wildcard) {
                delete leaf._listeners;
              } else {
                delete this._events[type];
              }
            }
            this.emit("removeListener", type, listener);
            return this;
          } else if (handlers === listener || handlers.listener && handlers.listener === listener || handlers._origin && handlers._origin === listener) {
            if (this.wildcard) {
              delete leaf._listeners;
            } else {
              delete this._events[type];
            }
            this.emit("removeListener", type, listener);
          }
        }
        function recursivelyGarbageCollect(root) {
          if (root === undefined2) {
            return;
          }
          var keys = Object.keys(root);
          for (var i2 in keys) {
            var key = keys[i2];
            var obj = root[key];
            if (obj instanceof Function || typeof obj !== "object" || obj === null)
              continue;
            if (Object.keys(obj).length > 0) {
              recursivelyGarbageCollect(root[key]);
            }
            if (Object.keys(obj).length === 0) {
              delete root[key];
            }
          }
        }
        recursivelyGarbageCollect(this.listenerTree);
        return this;
      };
      EventEmitter.prototype.offAny = function(fn) {
        var i = 0, l = 0, fns;
        if (fn && this._all && this._all.length > 0) {
          fns = this._all;
          for (i = 0, l = fns.length; i < l; i++) {
            if (fn === fns[i]) {
              fns.splice(i, 1);
              this.emit("removeListenerAny", fn);
              return this;
            }
          }
        } else {
          fns = this._all;
          for (i = 0, l = fns.length; i < l; i++)
            this.emit("removeListenerAny", fns[i]);
          this._all = [];
        }
        return this;
      };
      EventEmitter.prototype.removeListener = EventEmitter.prototype.off;
      EventEmitter.prototype.removeAllListeners = function(type) {
        if (arguments.length === 0) {
          !this._events || init.call(this);
          return this;
        }
        if (this.wildcard) {
          var ns = typeof type === "string" ? type.split(this.delimiter) : type.slice();
          var leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0);
          for (var iLeaf = 0; iLeaf < leafs.length; iLeaf++) {
            var leaf = leafs[iLeaf];
            leaf._listeners = null;
          }
        } else if (this._events) {
          this._events[type] = null;
        }
        return this;
      };
      EventEmitter.prototype.listeners = function(type) {
        if (this.wildcard) {
          var handlers = [];
          var ns = typeof type === "string" ? type.split(this.delimiter) : type.slice();
          searchListenerTree.call(this, handlers, ns, this.listenerTree, 0);
          return handlers;
        }
        this._events || init.call(this);
        if (!this._events[type]) this._events[type] = [];
        if (!isArray(this._events[type])) {
          this._events[type] = [this._events[type]];
        }
        return this._events[type];
      };
      EventEmitter.prototype.eventNames = function() {
        return Object.keys(this._events);
      };
      EventEmitter.prototype.listenerCount = function(type) {
        return this.listeners(type).length;
      };
      EventEmitter.prototype.listenersAny = function() {
        if (this._all) {
          return this._all;
        } else {
          return [];
        }
      };
      if (typeof define === "function" && define.amd) {
        define(function() {
          return EventEmitter;
        });
      } else if (typeof exports2 === "object") {
        module2.exports = EventEmitter;
      } else {
        window.EventEmitter2 = EventEmitter;
      }
    })();
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/subscriptions/Subscriptions.js
var require_Subscriptions = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/subscriptions/Subscriptions.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = exports2.ALL_FEATURE_VALUES = void 0;
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _eventemitter = require_eventemitter2();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var ALL_FEATURE_VALUES = exports2.ALL_FEATURE_VALUES = "@all-features";
    var Subscriptions = exports2.default = /* @__PURE__ */ (function() {
      function Subscriptions2() {
        (0, _classCallCheck2.default)(this, Subscriptions2);
        (0, _defineProperty2.default)(this, "eventToValue", /* @__PURE__ */ new Map());
        this.emitter = new _eventemitter.EventEmitter2();
      }
      return (0, _createClass2.default)(Subscriptions2, [{
        key: "onGateUpdated",
        value: function onGateUpdated(gateName, callback, checkGate, options) {
          var _this = this;
          var value = checkGate(gateName, _objectSpread(_objectSpread({}, options), {}, {
            fireGateExposure: false
          }));
          if (this.eventToValue.get(callback) === void 0) {
            this.eventToValue.set(callback, value);
          }
          var wrapCallback = function wrapCallback2() {
            var value2 = checkGate(gateName, _objectSpread(_objectSpread({}, options), {}, {
              fireGateExposure: false
            }));
            var existingValue = _this.eventToValue.get(callback);
            if (existingValue !== value2) {
              _this.eventToValue.set(callback, value2);
              callback(value2);
            }
          };
          this.emitter.on(gateName, wrapCallback);
          return function() {
            _this.emitter.off(gateName, wrapCallback);
          };
        }
      }, {
        key: "onExperimentValueUpdated",
        value: function onExperimentValueUpdated(experimentName, parameterName, defaultValue, callback, getExperimentValue, options) {
          var _this2 = this;
          var experimentEventName = "".concat(experimentName, ".").concat(parameterName);
          var value = getExperimentValue(experimentName, parameterName, defaultValue, _objectSpread(_objectSpread({}, options), {}, {
            fireExperimentExposure: false
          }));
          if (this.eventToValue.get(callback) === void 0) {
            this.eventToValue.set(callback, value);
          }
          var wrapCallback = function wrapCallback2() {
            var value2 = getExperimentValue(experimentName, parameterName, defaultValue, _objectSpread(_objectSpread({}, options), {}, {
              fireExperimentExposure: false
            }));
            var existingValue = _this2.eventToValue.get(callback);
            if (existingValue !== value2) {
              _this2.eventToValue.set(callback, value2);
              callback(value2);
            }
          };
          this.emitter.on(experimentEventName, wrapCallback);
          return function() {
            _this2.emitter.off(experimentEventName, wrapCallback);
          };
        }
      }, {
        key: "onAnyUpdated",
        value: function onAnyUpdated(callback) {
          var _this3 = this;
          this.emitter.on(ALL_FEATURE_VALUES, callback);
          return function() {
            _this3.emitter.off(ALL_FEATURE_VALUES, callback);
          };
        }
      }, {
        key: "anyUpdated",
        value: function anyUpdated() {
          var _this4 = this;
          this.emitter.emit(ALL_FEATURE_VALUES);
          this.emitter.eventNames().filter(function(name) {
            return name !== ALL_FEATURE_VALUES;
          }).forEach(function(event) {
            _this4.emitter.emit(event);
          });
        }
      }]);
    })();
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/subscriptions/index.js
var require_subscriptions = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/subscriptions/index.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "default", {
      enumerable: true,
      get: function get() {
        return _Subscriptions.default;
      }
    });
    var _Subscriptions = _interopRequireDefault(require_Subscriptions());
  }
});

// node_modules/@atlaskit/atlassian-context/dist/cjs/common/constants/index.js
var require_constants = __commonJS({
  "node_modules/@atlaskit/atlassian-context/dist/cjs/common/constants/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.STAGING = exports2.PRODUCTION = exports2.FEDRAMP_MODERATE = exports2.FEDRAMP_FEDEX = exports2.DEV = exports2.COMMERCIAL = void 0;
    var FEDRAMP_MODERATE = exports2.FEDRAMP_MODERATE = "fedramp-moderate";
    var COMMERCIAL = exports2.COMMERCIAL = "commercial";
    var FEDRAMP_FEDEX = exports2.FEDRAMP_FEDEX = "fedramp-fedex";
    var STAGING = exports2.STAGING = "stg";
    var PRODUCTION = exports2.PRODUCTION = "prod";
    var DEV = exports2.DEV = "dev";
  }
});

// node_modules/@atlaskit/atlassian-context/dist/cjs/services/is-fedramp/index.js
var require_is_fedramp = __commonJS({
  "node_modules/@atlaskit/atlassian-context/dist/cjs/services/is-fedramp/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.isFedRamp = isFedRamp;
    var _constants = require_constants();
    function isFedRamp() {
      var _global$location;
      var global2 = globalThis;
      var env = global2.MICROS_PERIMETER || global2.UNSAFE_ATL_CONTEXT_BOUNDARY;
      if (env) {
        return env === _constants.FEDRAMP_MODERATE;
      }
      var matches = (_global$location = global2.location) === null || _global$location === void 0 || (_global$location = _global$location.hostname) === null || _global$location === void 0 ? void 0 : _global$location.match(/atlassian-us-gov-mod\.(com|net)|atlassian-us-gov\.(com|net)|atlassian-fex\.(com|net)|atlassian-stg-fedm\.(com|net)/);
      return matches ? matches.length > 0 : false;
    }
  }
});

// node_modules/@atlaskit/atlassian-context/dist/cjs/common/constants/domains.js
var require_domains = __commonJS({
  "node_modules/@atlaskit/atlassian-context/dist/cjs/common/constants/domains.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.subdomainOverride = exports2.fullDomainOverride = exports2.domainMap = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _index = require_constants();
    var domainMap = exports2.domainMap = (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _index.STAGING, "stg.atlassian.com"), _index.PRODUCTION, "atlassian.com")), _index.FEDRAMP_FEDEX, (0, _defineProperty2.default)({}, _index.STAGING, "atlassian-fex.com")), _index.FEDRAMP_MODERATE, (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _index.STAGING, "stg.atlassian-us-gov-mod.com"), _index.PRODUCTION, "atlassian-us-gov-mod.com"));
    var subdomainOverride = exports2.subdomainOverride = {};
    var fullDomainOverride = exports2.fullDomainOverride = {
      analytics: (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "analytics.atlassian.com")),
      // Marketing site
      confluence: (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "confluence.atlassian.com")),
      // Atlassian design system documentation
      design: (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "design.atlassian.com")),
      // Old staff intranet (now hello.atlassian.net)
      extranet: (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "extranet.atlassian.com")),
      // Go links
      go: (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "go.atlassian.com")),
      my: (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "my.atlassian.com")),
      schema: (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "schema.atlassian.com")),
      start: (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _index.PRODUCTION, "start.atlassian.com"), _index.STAGING, "start.stg.atlassian.com")), _index.FEDRAMP_MODERATE, (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _index.PRODUCTION, "start.atlassian-us-gov-mod.com"), _index.STAGING, "start.stg.atlassian-us-gov-mod.com")),
      surveys: (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "surveys.atlassian.com")),
      "wac-cdn": (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "wac-cdn.atlassian.com")),
      integrations: (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "integrations.atlassian.com")),
      permalink: (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "permalink.atlassian.com")),
      id: (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, _index.PRODUCTION, "id.atlassian.com"), _index.STAGING, "id.stg.internal.atlassian.com"), _index.DEV, "id.dev.internal.atlassian.com")), _index.FEDRAMP_MODERATE, (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _index.PRODUCTION, "id.atlassian-us-gov-mod.com"), _index.STAGING, "id.stg.atlassian-us-gov-mod.com")),
      support: (0, _defineProperty2.default)({}, _index.COMMERCIAL, (0, _defineProperty2.default)({}, _index.PRODUCTION, "support.atlassian.com"))
    };
  }
});

// node_modules/@atlaskit/atlassian-context/dist/cjs/common/types.js
var require_types = __commonJS({
  "node_modules/@atlaskit/atlassian-context/dist/cjs/common/types.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.AllowedDomains = void 0;
    var AllowedDomains = exports2.AllowedDomains = ["admin", "analytics", "api", "api.media", "api-private", "as", "atl-global", "atlaskit", "auth", "automation", "cassi.internal", "cc-import-sources.services", "confluence", "confluence-chats-integr.services", "confluence-cloud-bamboo.internal", "confluence-questions.services", "data-portal.internal", "design", "developer", "extranet", "go", "id", "id-mail-assets", "integrations", "ja", "jira", "jsd-widget", "jsd-widget-staging", "marketplace", "my", "my-reminders.services", "partners", "permalink", "permalink.stg", "schema", "start", "support", "surveys", "team", "wac-cdn", "xxid", "home"];
  }
});

// node_modules/@atlaskit/atlassian-context/dist/cjs/services/domain-lookup/index.js
var require_domain_lookup = __commonJS({
  "node_modules/@atlaskit/atlassian-context/dist/cjs/services/domain-lookup/index.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2._getEnvironmentFromDomain = _getEnvironmentFromDomain;
    exports2.configure = configure;
    exports2.getATLContextDomain = getATLContextDomain;
    exports2.getATLContextUrl = getATLContextUrl;
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _constants = require_constants();
    var _domains = require_domains();
    var _types = require_types();
    function configure(data) {
      if (!data || Object.keys(data).length < 1) {
        throw new Error("Data are not available");
      }
      globalThis.ATL_CONTEXT_DOMAIN = data;
    }
    function isValidDomainKey(domainKey) {
      if (!_types.AllowedDomains.includes(domainKey)) {
        return false;
      }
      return true;
    }
    function getATLContextDomain(domain, environment) {
      var _domainMap$perimeter$, _domainMap$perimeter, _subdomainOverride$do;
      if (!isValidDomainKey(domain)) {
        throw new Error("Domain ".concat(domain, " is not supported.\n      Supported domains: ").concat(_types.AllowedDomains.join(", ")));
      }
      var data = globalThis.ATL_CONTEXT_DOMAIN;
      if (data) {
        return data[domain];
      }
      var _ref = environment !== null && environment !== void 0 ? environment : _getEnvironmentFromDomain(), _ref2 = (0, _slicedToArray2.default)(_ref, 2), env = _ref2[0], perimeter = _ref2[1];
      var override = _domains.fullDomainOverride[domain];
      if (override) {
        var _override$perimeter$e, _override$perimeter;
        return (
          // Exact match preferred
          (_override$perimeter$e = (_override$perimeter = override[perimeter]) === null || _override$perimeter === void 0 ? void 0 : _override$perimeter[env]) !== null && _override$perimeter$e !== void 0 ? _override$perimeter$e : (
            // Fallback to mandatory commercial production
            override[_constants.COMMERCIAL][_constants.PRODUCTION]
          )
        );
      }
      var tld = (_domainMap$perimeter$ = (_domainMap$perimeter = _domains.domainMap[perimeter]) === null || _domainMap$perimeter === void 0 ? void 0 : _domainMap$perimeter[env]) !== null && _domainMap$perimeter$ !== void 0 ? _domainMap$perimeter$ : _domains.domainMap[_constants.COMMERCIAL][_constants.PRODUCTION];
      var subdomain = (_subdomainOverride$do = _domains.subdomainOverride[domain]) !== null && _subdomainOverride$do !== void 0 ? _subdomainOverride$do : domain;
      return "".concat(subdomain, ".").concat(tld);
    }
    function getATLContextUrl(domain) {
      return "".concat(globalThis.location.protocol, "//").concat(getATLContextDomain(domain));
    }
    function _getEnvironmentFromDomain() {
      var _globalThis$location;
      var hostname = (_globalThis$location = globalThis.location) === null || _globalThis$location === void 0 ? void 0 : _globalThis$location.hostname;
      if (!hostname) {
        return [_constants.PRODUCTION, _constants.COMMERCIAL];
      }
      if (hostname.match(/atlassian-fex\.com/)) {
        return [_constants.STAGING, _constants.FEDRAMP_FEDEX];
      }
      if (hostname.match(/stg\.atlassian-us-gov-mod\.(com|net)/)) {
        return [_constants.STAGING, _constants.FEDRAMP_MODERATE];
      }
      if (hostname.match(/atlassian-stg-fedm\.net/)) {
        return [_constants.STAGING, _constants.FEDRAMP_MODERATE];
      }
      if (hostname.match(/atlassian-us-gov-mod\.(com|net)/)) {
        return [_constants.PRODUCTION, _constants.FEDRAMP_MODERATE];
      }
      if (hostname.match(/stg(\.internal)?\.atlassian\.com/)) {
        return [_constants.STAGING, _constants.COMMERCIAL];
      }
      if (hostname.match(/jira-dev\.com/)) {
        return [_constants.STAGING, _constants.COMMERCIAL];
      }
      return [_constants.PRODUCTION, _constants.COMMERCIAL];
    }
  }
});

// node_modules/@atlaskit/atlassian-context/dist/cjs/index.js
var require_cjs = __commonJS({
  "node_modules/@atlaskit/atlassian-context/dist/cjs/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "getATLContextDomain", {
      enumerable: true,
      get: function get() {
        return _domainLookup.getATLContextDomain;
      }
    });
    Object.defineProperty(exports2, "getATLContextUrl", {
      enumerable: true,
      get: function get() {
        return _domainLookup.getATLContextUrl;
      }
    });
    Object.defineProperty(exports2, "isFedRamp", {
      enumerable: true,
      get: function get() {
        return _isFedramp.isFedRamp;
      }
    });
    var _isFedramp = require_is_fedramp();
    var _domainLookup = require_domain_lookup();
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/compat/types.js
var require_types2 = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/compat/types.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.EvaluationReason = void 0;
    var EvaluationReason = exports2.EvaluationReason = /* @__PURE__ */ (function(EvaluationReason2) {
      EvaluationReason2["Error"] = "Error";
      EvaluationReason2["LocalOverride"] = "LocalOverride";
      EvaluationReason2["Unrecognized"] = "Unrecognized";
      EvaluationReason2["Uninitialized"] = "Uninitialized";
      EvaluationReason2["NetworkNotModified"] = "NetworkNotModified";
      EvaluationReason2["Network"] = "Network";
      EvaluationReason2["InvalidBootstrap"] = "InvalidBootstrap";
      EvaluationReason2["Bootstrap"] = "Bootstrap";
      EvaluationReason2["Cache"] = "Cache";
      EvaluationReason2["Unknown"] = "Unknown";
      return EvaluationReason2;
    })({});
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/types.js
var require_types3 = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/types.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.PerimeterType = exports2.NON_BOOLEAN_VALUE = exports2.FeatureGateEnvironment = void 0;
    var FeatureGateEnvironment = exports2.FeatureGateEnvironment = /* @__PURE__ */ (function(FeatureGateEnvironment2) {
      FeatureGateEnvironment2["Development"] = "development";
      FeatureGateEnvironment2["Staging"] = "staging";
      FeatureGateEnvironment2["Production"] = "production";
      return FeatureGateEnvironment2;
    })({});
    var PerimeterType = exports2.PerimeterType = /* @__PURE__ */ (function(PerimeterType2) {
      PerimeterType2["COMMERCIAL"] = "commercial";
      PerimeterType2["FEDRAMP_MODERATE"] = "fedramp-moderate";
      return PerimeterType2;
    })({});
    var NON_BOOLEAN_VALUE = exports2.NON_BOOLEAN_VALUE = "non_boolean";
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/utils.js
var require_utils2 = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/utils.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.toStatsigUser = exports2.shallowEquals = exports2.migrateInitializationOptions = exports2.migrateEvaluationDetails = exports2.getOptionsWithDefaults = void 0;
    var _objectWithoutProperties2 = _interopRequireDefault(require_objectWithoutProperties());
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _jsClient = require_src2();
    var _atlassianContext = require_cjs();
    var _types = require_types2();
    var _types2 = require_types3();
    var _excluded = ["api", "disableCurrentPageLogging", "loggingIntervalMillis", "loggingBufferMaxSize", "localMode", "eventLoggingApi", "eventLoggingApiForRetries", "disableLocalStorage", "ignoreWindowUndefined", "disableAllLogging", "initTimeoutMs", "disableNetworkKeepalive", "overrideStableID", "disableErrorLogging", "disableAutoMetricsLogging"];
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var getOptionsWithDefaults = exports2.getOptionsWithDefaults = function getOptionsWithDefaults2(options) {
      return _objectSpread({
        /**
         * If more federal PerimeterTypes are added in the future, this should be updated so
         * that isFedRamp() === true always returns the strictest perimeter.
         */
        perimeter: (0, _atlassianContext.isFedRamp)() ? _types2.PerimeterType.FEDRAMP_MODERATE : _types2.PerimeterType.COMMERCIAL
      }, options);
    };
    var shallowEquals = exports2.shallowEquals = function shallowEquals2(objectA, objectB) {
      if (!objectA && !objectB) {
        return true;
      }
      if (!objectA || !objectB) {
        return false;
      }
      var aEntries = Object.entries(objectA);
      var bEntries = Object.entries(objectB);
      if (aEntries.length !== bEntries.length) {
        return false;
      }
      var ascendingKeyOrder = function ascendingKeyOrder2(_ref, _ref2) {
        var _ref3 = (0, _slicedToArray2.default)(_ref, 1), key1 = _ref3[0];
        var _ref4 = (0, _slicedToArray2.default)(_ref2, 1), key2 = _ref4[0];
        return key1.localeCompare(key2);
      };
      aEntries.sort(ascendingKeyOrder);
      bEntries.sort(ascendingKeyOrder);
      for (var i = 0; i < aEntries.length; i++) {
        var _aEntries$i = (0, _slicedToArray2.default)(aEntries[i], 2), aValue = _aEntries$i[1];
        var _bEntries$i = (0, _slicedToArray2.default)(bEntries[i], 2), bValue = _bEntries$i[1];
        if (aValue !== bValue) {
          return false;
        }
      }
      return true;
    };
    var toStatsigUser = exports2.toStatsigUser = function toStatsigUser2(identifiers, customAttributes, sdkKey) {
      var user = {
        customIDs: !(customAttributes !== null && customAttributes !== void 0 && customAttributes.stableID) && sdkKey ? _objectSpread({
          stableID: _jsClient.StableID.get(sdkKey)
        }, identifiers) : identifiers,
        custom: customAttributes
      };
      if (identifiers.atlassianAccountId) {
        user.userID = identifiers.atlassianAccountId;
      }
      return user;
    };
    var migrateInitializationOptions = exports2.migrateInitializationOptions = function migrateInitializationOptions2(options) {
      var api = options.api, disableCurrentPageLogging = options.disableCurrentPageLogging, loggingIntervalMillis = options.loggingIntervalMillis, loggingBufferMaxSize = options.loggingBufferMaxSize, localMode = options.localMode, eventLoggingApi = options.eventLoggingApi, eventLoggingApiForRetries = options.eventLoggingApiForRetries, disableLocalStorage = options.disableLocalStorage, ignoreWindowUndefined = options.ignoreWindowUndefined, disableAllLogging = options.disableAllLogging, _initTimeoutMs = options.initTimeoutMs, _disableNetworkKeepalive = options.disableNetworkKeepalive, _overrideStableID = options.overrideStableID, _disableErrorLogging = options.disableErrorLogging, _disableAutoMetricsLogging = options.disableAutoMetricsLogging, rest = (0, _objectWithoutProperties2.default)(options, _excluded);
      return _objectSpread(_objectSpread({}, rest), {}, {
        networkConfig: {
          api,
          logEventUrl: eventLoggingApi ? eventLoggingApi + "rgstr" : void 0,
          logEventFallbackUrls: eventLoggingApiForRetries ? [eventLoggingApiForRetries] : void 0,
          preventAllNetworkTraffic: localMode || !ignoreWindowUndefined && typeof window === "undefined"
        },
        includeCurrentPageUrlWithEvents: !disableCurrentPageLogging,
        loggingIntervalMs: loggingIntervalMillis,
        loggingBufferMaxSize,
        disableStorage: disableLocalStorage === void 0 ? localMode : disableLocalStorage,
        disableLogging: disableAllLogging === void 0 ? localMode : disableAllLogging
      });
    };
    var evaluationReasonMappings = Object.entries(_types.EvaluationReason).map(function(_ref5) {
      var _ref6 = (0, _slicedToArray2.default)(_ref5, 2), key = _ref6[0], value = _ref6[1];
      return [key.toLowerCase(), value];
    });
    var migrateEvaluationDetails = exports2.migrateEvaluationDetails = function migrateEvaluationDetails2(details) {
      var _evaluationReasonMapp, _evaluationReasonMapp2, _details$receivedAt;
      var reasonLower = details.reason.toLowerCase();
      return {
        reason: (_evaluationReasonMapp = (_evaluationReasonMapp2 = evaluationReasonMappings.find(function(_ref7) {
          var _ref8 = (0, _slicedToArray2.default)(_ref7, 1), key = _ref8[0];
          return reasonLower.includes(key);
        })) === null || _evaluationReasonMapp2 === void 0 ? void 0 : _evaluationReasonMapp2[1]) !== null && _evaluationReasonMapp !== void 0 ? _evaluationReasonMapp : _types.EvaluationReason.Unknown,
        time: (_details$receivedAt = details.receivedAt) !== null && _details$receivedAt !== void 0 ? _details$receivedAt : Date.now()
      };
    };
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/compat/DynamicConfig.js
var require_DynamicConfig = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/compat/DynamicConfig.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.DynamicConfig = void 0;
    var _typeof2 = _interopRequireDefault(require_typeof());
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _utils = require_utils2();
    var DynamicConfig = exports2.DynamicConfig = /* @__PURE__ */ (function() {
      function DynamicConfig2(configName, configValue, ruleID, evaluationDetails) {
        var secondaryExposures = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : [];
        var allocatedExperimentName = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : "";
        var onDefaultValueFallback = arguments.length > 6 && arguments[6] !== void 0 ? arguments[6] : null;
        (0, _classCallCheck2.default)(this, DynamicConfig2);
        this.value = configValue;
        this._name = configName;
        this._ruleID = ruleID;
        this._secondaryExposures = secondaryExposures;
        this._allocatedExperimentName = allocatedExperimentName;
        this._evaluationDetails = evaluationDetails;
        this._onDefaultValueFallback = onDefaultValueFallback;
      }
      return (0, _createClass2.default)(DynamicConfig2, [{
        key: "get",
        value: function get(key, defaultValue, typeGuard) {
          var _this$_onDefaultValue2;
          var val = this.getValue(key, defaultValue);
          if (val == null) {
            return defaultValue;
          }
          var expectedType = Array.isArray(defaultValue) ? "array" : (0, _typeof2.default)(defaultValue);
          var actualType = Array.isArray(val) ? "array" : (0, _typeof2.default)(val);
          if (typeGuard) {
            var _this$_onDefaultValue;
            if (typeGuard(val)) {
              this.fireExposure(key);
              return val;
            }
            (_this$_onDefaultValue = this._onDefaultValueFallback) === null || _this$_onDefaultValue === void 0 || _this$_onDefaultValue.call(this, this, key, expectedType, actualType);
            return defaultValue;
          }
          if (defaultValue == null || expectedType === actualType) {
            this.fireExposure(key);
            return val;
          }
          (_this$_onDefaultValue2 = this._onDefaultValueFallback) === null || _this$_onDefaultValue2 === void 0 || _this$_onDefaultValue2.call(this, this, key, expectedType, actualType);
          return defaultValue;
        }
      }, {
        key: "getValue",
        value: function getValue(key, defaultValue) {
          if (key == null) {
            return this.value;
          }
          if (defaultValue == null) {
            defaultValue = null;
          }
          if (this.value[key] == null) {
            return defaultValue;
          }
          this.fireExposure(key);
          return this.value[key];
        }
      }, {
        key: "fireExposure",
        value: function fireExposure(key) {
          if (this.experiment) {
            this.experiment.get(key);
          }
        }
      }], [{
        key: "fromExperiment",
        value: function fromExperiment(experiment) {
          var _experiment$__evaluat, _experiment$groupName;
          var config = new DynamicConfig2(experiment.name, experiment.value, experiment.ruleID, (0, _utils.migrateEvaluationDetails)(experiment.details), (_experiment$__evaluat = experiment.__evaluation) === null || _experiment$__evaluat === void 0 ? void 0 : _experiment$__evaluat.secondary_exposures, (_experiment$groupName = experiment.groupName) !== null && _experiment$groupName !== void 0 ? _experiment$groupName : void 0);
          config.experiment = experiment;
          return config;
        }
      }]);
    })();
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/compat/Layer.js
var require_Layer = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/compat/Layer.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.Layer = void 0;
    var _typeof2 = _interopRequireDefault(require_typeof());
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _utils = require_utils2();
    var Layer = exports2.Layer = /* @__PURE__ */ (function() {
      function Layer2(name, layerValue, ruleID, evaluationDetails) {
        var logParameterFunction = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : null;
        var secondaryExposures = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : [];
        var undelegatedSecondaryExposures = arguments.length > 6 && arguments[6] !== void 0 ? arguments[6] : [];
        var allocatedExperimentName = arguments.length > 7 && arguments[7] !== void 0 ? arguments[7] : "";
        var explicitParameters = arguments.length > 8 && arguments[8] !== void 0 ? arguments[8] : [];
        (0, _classCallCheck2.default)(this, Layer2);
        this._logParameterFunction = logParameterFunction;
        this._name = name;
        this._value = JSON.parse(JSON.stringify(layerValue !== null && layerValue !== void 0 ? layerValue : {}));
        this._ruleID = ruleID !== null && ruleID !== void 0 ? ruleID : "";
        this._evaluationDetails = evaluationDetails;
        this._secondaryExposures = secondaryExposures;
        this._undelegatedSecondaryExposures = undelegatedSecondaryExposures;
        this._allocatedExperimentName = allocatedExperimentName;
        this._explicitParameters = explicitParameters;
      }
      return (0, _createClass2.default)(Layer2, [{
        key: "get",
        value: function get(key, defaultValue, typeGuard) {
          var _this = this;
          var val = this._value[key];
          if (val == null) {
            return defaultValue;
          }
          var logAndReturn = function logAndReturn2() {
            _this._logLayerParameterExposure(key);
            return val;
          };
          if (typeGuard) {
            return typeGuard(val) ? logAndReturn() : defaultValue;
          }
          if (defaultValue == null) {
            return logAndReturn();
          }
          if ((0, _typeof2.default)(val) === (0, _typeof2.default)(defaultValue) && Array.isArray(defaultValue) === Array.isArray(val)) {
            return logAndReturn();
          }
          return defaultValue;
        }
      }, {
        key: "getValue",
        value: function getValue(key, defaultValue) {
          if (defaultValue == void 0) {
            defaultValue = null;
          }
          var val = this._value[key];
          if (val != null) {
            this._logLayerParameterExposure(key);
          }
          return val !== null && val !== void 0 ? val : defaultValue;
        }
      }, {
        key: "_logLayerParameterExposure",
        value: function _logLayerParameterExposure(parameterName) {
          var _this$_logParameterFu;
          (_this$_logParameterFu = this._logParameterFunction) === null || _this$_logParameterFu === void 0 || _this$_logParameterFu.call(this, this, parameterName);
        }
      }], [{
        key: "fromLayer",
        value: function fromLayer(layer) {
          var _layer$__evaluation, _layer$__evaluation2, _layer$__evaluation3, _layer$__evaluation4;
          var value = new Layer2(layer.name, layer.__value, layer.ruleID, (0, _utils.migrateEvaluationDetails)(layer.details), function(_layer, parameterName) {
            return layer.get(parameterName);
          }, (_layer$__evaluation = layer.__evaluation) === null || _layer$__evaluation === void 0 ? void 0 : _layer$__evaluation.secondary_exposures, (_layer$__evaluation2 = layer.__evaluation) === null || _layer$__evaluation2 === void 0 ? void 0 : _layer$__evaluation2.undelegated_secondary_exposures, (_layer$__evaluation3 = layer.__evaluation) === null || _layer$__evaluation3 === void 0 ? void 0 : _layer$__evaluation3.allocated_experiment_name, (_layer$__evaluation4 = layer.__evaluation) === null || _layer$__evaluation4 === void 0 ? void 0 : _layer$__evaluation4.explicit_parameters);
          return value;
        }
      }]);
    })();
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/version.js
var require_version = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/version.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.CLIENT_VERSION = void 0;
    var CLIENT_VERSION = exports2.CLIENT_VERSION = "4.26.5";
  }
});

// node_modules/@babel/runtime/helpers/assertThisInitialized.js
var require_assertThisInitialized = __commonJS({
  "node_modules/@babel/runtime/helpers/assertThisInitialized.js"(exports2, module2) {
    function _assertThisInitialized(e) {
      if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      return e;
    }
    module2.exports = _assertThisInitialized, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/possibleConstructorReturn.js
var require_possibleConstructorReturn = __commonJS({
  "node_modules/@babel/runtime/helpers/possibleConstructorReturn.js"(exports2, module2) {
    var _typeof = require_typeof()["default"];
    var assertThisInitialized = require_assertThisInitialized();
    function _possibleConstructorReturn(t, e) {
      if (e && ("object" == _typeof(e) || "function" == typeof e)) return e;
      if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
      return assertThisInitialized(t);
    }
    module2.exports = _possibleConstructorReturn, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/getPrototypeOf.js
var require_getPrototypeOf = __commonJS({
  "node_modules/@babel/runtime/helpers/getPrototypeOf.js"(exports2, module2) {
    function _getPrototypeOf(t) {
      return module2.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t2) {
        return t2.__proto__ || Object.getPrototypeOf(t2);
      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _getPrototypeOf(t);
    }
    module2.exports = _getPrototypeOf, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/setPrototypeOf.js
var require_setPrototypeOf = __commonJS({
  "node_modules/@babel/runtime/helpers/setPrototypeOf.js"(exports2, module2) {
    function _setPrototypeOf(t, e) {
      return module2.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
        return t2.__proto__ = e2, t2;
      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _setPrototypeOf(t, e);
    }
    module2.exports = _setPrototypeOf, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/inherits.js
var require_inherits = __commonJS({
  "node_modules/@babel/runtime/helpers/inherits.js"(exports2, module2) {
    var setPrototypeOf = require_setPrototypeOf();
    function _inherits(t, e) {
      if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
      t.prototype = Object.create(e && e.prototype, {
        constructor: {
          value: t,
          writable: true,
          configurable: true
        }
      }), Object.defineProperty(t, "prototype", {
        writable: false
      }), e && setPrototypeOf(t, e);
    }
    module2.exports = _inherits, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/isNativeFunction.js
var require_isNativeFunction = __commonJS({
  "node_modules/@babel/runtime/helpers/isNativeFunction.js"(exports2, module2) {
    function _isNativeFunction(t) {
      try {
        return -1 !== Function.toString.call(t).indexOf("[native code]");
      } catch (n) {
        return "function" == typeof t;
      }
    }
    module2.exports = _isNativeFunction, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js
var require_isNativeReflectConstruct = __commonJS({
  "node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js"(exports2, module2) {
    function _isNativeReflectConstruct() {
      try {
        var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
        }));
      } catch (t2) {
      }
      return (module2.exports = _isNativeReflectConstruct = function _isNativeReflectConstruct2() {
        return !!t;
      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports)();
    }
    module2.exports = _isNativeReflectConstruct, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/construct.js
var require_construct = __commonJS({
  "node_modules/@babel/runtime/helpers/construct.js"(exports2, module2) {
    var isNativeReflectConstruct = require_isNativeReflectConstruct();
    var setPrototypeOf = require_setPrototypeOf();
    function _construct(t, e, r) {
      if (isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
      var o = [null];
      o.push.apply(o, e);
      var p = new (t.bind.apply(t, o))();
      return r && setPrototypeOf(p, r.prototype), p;
    }
    module2.exports = _construct, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/wrapNativeSuper.js
var require_wrapNativeSuper = __commonJS({
  "node_modules/@babel/runtime/helpers/wrapNativeSuper.js"(exports2, module2) {
    var getPrototypeOf = require_getPrototypeOf();
    var setPrototypeOf = require_setPrototypeOf();
    var isNativeFunction = require_isNativeFunction();
    var construct = require_construct();
    function _wrapNativeSuper(t) {
      var r = "function" == typeof Map ? /* @__PURE__ */ new Map() : void 0;
      return module2.exports = _wrapNativeSuper = function _wrapNativeSuper2(t2) {
        if (null === t2 || !isNativeFunction(t2)) return t2;
        if ("function" != typeof t2) throw new TypeError("Super expression must either be null or a function");
        if (void 0 !== r) {
          if (r.has(t2)) return r.get(t2);
          r.set(t2, Wrapper);
        }
        function Wrapper() {
          return construct(t2, arguments, getPrototypeOf(this).constructor);
        }
        return Wrapper.prototype = Object.create(t2.prototype, {
          constructor: {
            value: Wrapper,
            enumerable: false,
            writable: true,
            configurable: true
          }
        }), setPrototypeOf(Wrapper, t2);
      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _wrapNativeSuper(t);
    }
    module2.exports = _wrapNativeSuper, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/fetcher/errors.js
var require_errors = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/fetcher/errors.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.ResponseError = void 0;
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _possibleConstructorReturn2 = _interopRequireDefault(require_possibleConstructorReturn());
    var _getPrototypeOf2 = _interopRequireDefault(require_getPrototypeOf());
    var _inherits2 = _interopRequireDefault(require_inherits());
    var _wrapNativeSuper2 = _interopRequireDefault(require_wrapNativeSuper());
    function _callSuper(t, o, e) {
      return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e));
    }
    function _isNativeReflectConstruct() {
      try {
        var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
        }));
      } catch (t2) {
      }
      return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
        return !!t;
      })();
    }
    var ResponseError = exports2.ResponseError = /* @__PURE__ */ (function(_Error) {
      function ResponseError2(message) {
        (0, _classCallCheck2.default)(this, ResponseError2);
        return _callSuper(this, ResponseError2, [message]);
      }
      (0, _inherits2.default)(ResponseError2, _Error);
      return (0, _createClass2.default)(ResponseError2);
    })(/* @__PURE__ */ (0, _wrapNativeSuper2.default)(Error));
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/fetcher/Fetcher.js
var require_Fetcher = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/fetcher/Fetcher.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = exports2.STAGING_BASE_URL = exports2.PROD_BASE_URL = exports2.GATEWAY_BASE_URL = exports2.FEDM_STAGING_BASE_URL = exports2.FEDM_PROD_BASE_URL = exports2.DEV_BASE_URL = void 0;
    var _regenerator = _interopRequireDefault(require_regenerator2());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _asyncToGenerator2 = _interopRequireDefault(require_asyncToGenerator());
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _types = require_types3();
    var _version = require_version();
    var _errors = require_errors();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var DEFAULT_REQUEST_TIMEOUT_MS = 5e3;
    var PROD_BASE_URL = exports2.PROD_BASE_URL = "https://api.atlassian.com/flags";
    var STAGING_BASE_URL = exports2.STAGING_BASE_URL = "https://api.stg.atlassian.com/flags";
    var DEV_BASE_URL = exports2.DEV_BASE_URL = "https://api.dev.atlassian.com/flags";
    var FEDM_STAGING_BASE_URL = exports2.FEDM_STAGING_BASE_URL = "https://api.stg.atlassian-us-gov-mod.com/flags";
    var FEDM_PROD_BASE_URL = exports2.FEDM_PROD_BASE_URL = "https://api.atlassian-us-gov-mod.com/flags";
    var GATEWAY_BASE_URL = exports2.GATEWAY_BASE_URL = "/gateway/api/flags";
    var Fetcher = exports2.default = /* @__PURE__ */ (function() {
      function Fetcher2() {
        (0, _classCallCheck2.default)(this, Fetcher2);
      }
      return (0, _createClass2.default)(Fetcher2, null, [{
        key: "fetchClientSdk",
        value: (function() {
          var _fetchClientSdk = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee(fetcherOptions) {
            var targetApp, url;
            return _regenerator.default.wrap(function _callee$(_context) {
              while (1) switch (_context.prev = _context.next) {
                case 0:
                  targetApp = fetcherOptions.targetApp;
                  url = "/api/v2/frontend/clientSdkKey/".concat(targetApp);
                  _context.prev = 2;
                  _context.next = 5;
                  return this.fetchRequest(url, "GET", fetcherOptions);
                case 5:
                  return _context.abrupt("return", _context.sent);
                case 8:
                  _context.prev = 8;
                  _context.t0 = _context["catch"](2);
                  if (!(_context.t0 instanceof Error)) {
                    _context.next = 12;
                    break;
                  }
                  throw _context.t0;
                case 12:
                  throw Error("Failed to retrieve client sdk key");
                case 13:
                case "end":
                  return _context.stop();
              }
            }, _callee, this, [[2, 8]]);
          }));
          function fetchClientSdk(_x) {
            return _fetchClientSdk.apply(this, arguments);
          }
          return fetchClientSdk;
        })()
      }, {
        key: "fetchExperimentValues",
        value: (function() {
          var _fetchExperimentValues = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee2(fetcherOptions, identifiers, customAttributes) {
            var requestBody;
            return _regenerator.default.wrap(function _callee2$(_context2) {
              while (1) switch (_context2.prev = _context2.next) {
                case 0:
                  requestBody = {
                    identifiers,
                    customAttributes,
                    targetApp: fetcherOptions.targetApp
                  };
                  _context2.prev = 1;
                  _context2.next = 4;
                  return this.fetchRequest("/api/v2/frontend/experimentValues", "POST", fetcherOptions, requestBody);
                case 4:
                  return _context2.abrupt("return", _context2.sent);
                case 7:
                  _context2.prev = 7;
                  _context2.t0 = _context2["catch"](1);
                  if (!(_context2.t0 instanceof Error)) {
                    _context2.next = 11;
                    break;
                  }
                  throw _context2.t0;
                case 11:
                  throw Error("Failed to retrieve experiment values");
                case 12:
                case "end":
                  return _context2.stop();
              }
            }, _callee2, this, [[1, 7]]);
          }));
          function fetchExperimentValues(_x2, _x3, _x4) {
            return _fetchExperimentValues.apply(this, arguments);
          }
          return fetchExperimentValues;
        })()
      }, {
        key: "handleResponseError",
        value: (function() {
          var _handleResponseError = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee3(response) {
            var body;
            return _regenerator.default.wrap(function _callee3$(_context3) {
              while (1) switch (_context3.prev = _context3.next) {
                case 0:
                  if (response.ok) {
                    _context3.next = 5;
                    break;
                  }
                  _context3.next = 3;
                  return response.text();
                case 3:
                  body = _context3.sent;
                  throw new _errors.ResponseError("Non 2xx response status received, status: ".concat(response.status, ", body: ").concat(JSON.stringify(body)));
                case 5:
                  if (!(response.status === 204)) {
                    _context3.next = 7;
                    break;
                  }
                  throw new _errors.ResponseError("Unexpected 204 response");
                case 7:
                case "end":
                  return _context3.stop();
              }
            }, _callee3);
          }));
          function handleResponseError(_x5) {
            return _handleResponseError.apply(this, arguments);
          }
          return handleResponseError;
        })()
      }, {
        key: "extractResponseBody",
        value: (function() {
          var _extractResponseBody = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee4(response) {
            var value;
            return _regenerator.default.wrap(function _callee4$(_context4) {
              while (1) switch (_context4.prev = _context4.next) {
                case 0:
                  _context4.next = 2;
                  return response.text();
                case 2:
                  value = _context4.sent;
                  return _context4.abrupt("return", JSON.parse(value));
                case 4:
                case "end":
                  return _context4.stop();
              }
            }, _callee4);
          }));
          function extractResponseBody(_x6) {
            return _extractResponseBody.apply(this, arguments);
          }
          return extractResponseBody;
        })()
      }, {
        key: "getBaseUrl",
        value: function getBaseUrl(serviceEnv) {
          var useGatewayUrl = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
          var perimeter = arguments.length > 2 ? arguments[2] : void 0;
          if (useGatewayUrl) {
            return GATEWAY_BASE_URL;
          }
          if (perimeter === _types.PerimeterType.FEDRAMP_MODERATE) {
            switch (serviceEnv) {
              case _types.FeatureGateEnvironment.Production:
                return FEDM_PROD_BASE_URL;
              case _types.FeatureGateEnvironment.Staging:
                return FEDM_STAGING_BASE_URL;
              default:
                throw new Error('Invalid environment "'.concat(serviceEnv, '" for "').concat(perimeter, '" perimeter'));
            }
          } else if (perimeter === _types.PerimeterType.COMMERCIAL) {
            switch (serviceEnv) {
              case _types.FeatureGateEnvironment.Development:
                return DEV_BASE_URL;
              case _types.FeatureGateEnvironment.Staging:
                return STAGING_BASE_URL;
              default:
                return PROD_BASE_URL;
            }
          } else {
            throw new Error('Invalid perimeter "'.concat(perimeter, '"'));
          }
        }
      }, {
        key: "fetchRequest",
        value: (function() {
          var _fetchRequest = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee5(path, method, fetcherOptions, body) {
            var baseUrl, fetchTimeout, abortSignal, abortController, response;
            return _regenerator.default.wrap(function _callee5$(_context5) {
              while (1) switch (_context5.prev = _context5.next) {
                case 0:
                  baseUrl = Fetcher2.getBaseUrl(fetcherOptions.environment, fetcherOptions.useGatewayURL, fetcherOptions.perimeter);
                  fetchTimeout = fetcherOptions.fetchTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS;
                  if (AbortSignal.timeout) {
                    abortSignal = AbortSignal.timeout(fetchTimeout);
                  } else if (AbortController) {
                    abortController = new AbortController();
                    abortSignal = abortController.signal;
                    setTimeout(function() {
                      return abortController.abort();
                    }, fetchTimeout);
                  }
                  _context5.next = 5;
                  return fetch("".concat(baseUrl).concat(path), _objectSpread({
                    method,
                    headers: {
                      "Content-Type": "application/json",
                      "X-Client-Name": "feature-gate-js-client",
                      "X-Client-Version": _version.CLIENT_VERSION,
                      "X-API-KEY": fetcherOptions.apiKey
                    },
                    signal: abortSignal
                  }, body && {
                    body: JSON.stringify(body)
                  }));
                case 5:
                  response = _context5.sent;
                  _context5.next = 8;
                  return this.handleResponseError(response);
                case 8:
                  _context5.next = 10;
                  return this.extractResponseBody(response);
                case 10:
                  return _context5.abrupt("return", _context5.sent);
                case 11:
                case "end":
                  return _context5.stop();
              }
            }, _callee5, this);
          }));
          function fetchRequest(_x7, _x8, _x9, _x10) {
            return _fetchRequest.apply(this, arguments);
          }
          return fetchRequest;
        })()
      }]);
    })();
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/fetcher/index.js
var require_fetcher = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/fetcher/index.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "default", {
      enumerable: true,
      get: function get() {
        return _Fetcher.default;
      }
    });
    var _Fetcher = _interopRequireDefault(require_Fetcher());
  }
});

// node_modules/@babel/runtime/helpers/superPropBase.js
var require_superPropBase = __commonJS({
  "node_modules/@babel/runtime/helpers/superPropBase.js"(exports2, module2) {
    var getPrototypeOf = require_getPrototypeOf();
    function _superPropBase(t, o) {
      for (; !{}.hasOwnProperty.call(t, o) && null !== (t = getPrototypeOf(t)); ) ;
      return t;
    }
    module2.exports = _superPropBase, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/get.js
var require_get = __commonJS({
  "node_modules/@babel/runtime/helpers/get.js"(exports2, module2) {
    var superPropBase = require_superPropBase();
    function _get() {
      return module2.exports = _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function(e, t, r) {
        var p = superPropBase(e, t);
        if (p) {
          var n = Object.getOwnPropertyDescriptor(p, t);
          return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;
        }
      }, module2.exports.__esModule = true, module2.exports["default"] = module2.exports, _get.apply(null, arguments);
    }
    module2.exports = _get, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/NoFetchDataAdapter.js
var require_NoFetchDataAdapter = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/NoFetchDataAdapter.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.NoFetchDataAdapter = void 0;
    var _regenerator = _interopRequireDefault(require_regenerator2());
    var _asyncToGenerator2 = _interopRequireDefault(require_asyncToGenerator());
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _possibleConstructorReturn2 = _interopRequireDefault(require_possibleConstructorReturn());
    var _getPrototypeOf2 = _interopRequireDefault(require_getPrototypeOf());
    var _get2 = _interopRequireDefault(require_get());
    var _inherits2 = _interopRequireDefault(require_inherits());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _jsClient = require_src2();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    function _callSuper(t, o, e) {
      return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e));
    }
    function _isNativeReflectConstruct() {
      try {
        var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
        }));
      } catch (t2) {
      }
      return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
        return !!t;
      })();
    }
    function _superPropGet(t, o, e, r) {
      var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e);
      return 2 & r && "function" == typeof p ? function(t2) {
        return p.apply(e, t2);
      } : p;
    }
    var NoFetchDataAdapter = exports2.NoFetchDataAdapter = /* @__PURE__ */ (function(_DataAdapterCore) {
      function NoFetchDataAdapter2() {
        var _this;
        (0, _classCallCheck2.default)(this, NoFetchDataAdapter2);
        _this = _callSuper(this, NoFetchDataAdapter2, ["NoFetchDataAdapter", "nofetch"]);
        (0, _defineProperty2.default)(_this, "bootstrapResult", null);
        return _this;
      }
      (0, _inherits2.default)(NoFetchDataAdapter2, _DataAdapterCore);
      return (0, _createClass2.default)(NoFetchDataAdapter2, [{
        key: "setBootstrapData",
        value: function setBootstrapData(data) {
          this.bootstrapResult = data ? {
            source: "Bootstrap",
            data: JSON.stringify(data),
            receivedAt: Date.now(),
            stableID: _jsClient.StableID.get(this._getSdkKey()),
            fullUserHash: null
          } : null;
        }
      }, {
        key: "prefetchData",
        value: (function() {
          var _prefetchData = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee(_user, _options) {
            return _regenerator.default.wrap(function _callee$(_context) {
              while (1) switch (_context.prev = _context.next) {
                case 0:
                case "end":
                  return _context.stop();
              }
            }, _callee);
          }));
          function prefetchData(_x, _x2) {
            return _prefetchData.apply(this, arguments);
          }
          return prefetchData;
        })()
      }, {
        key: "getDataAsync",
        value: (function() {
          var _getDataAsync = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee2(_current, user, _options) {
            return _regenerator.default.wrap(function _callee2$(_context2) {
              while (1) switch (_context2.prev = _context2.next) {
                case 0:
                  return _context2.abrupt("return", this.bootstrapResult && _objectSpread(_objectSpread({}, this.bootstrapResult), {}, {
                    fullUserHash: (0, _jsClient._getFullUserHash)(user)
                  }));
                case 1:
                case "end":
                  return _context2.stop();
              }
            }, _callee2, this);
          }));
          function getDataAsync(_x3, _x4, _x5) {
            return _getDataAsync.apply(this, arguments);
          }
          return getDataAsync;
        })()
      }, {
        key: "getDataSync",
        value: function getDataSync(user) {
          return this.bootstrapResult && _objectSpread(_objectSpread({}, this.bootstrapResult), {}, {
            fullUserHash: (0, _jsClient._getFullUserHash)(user)
          });
        }
      }, {
        key: "_fetchFromNetwork",
        value: (function() {
          var _fetchFromNetwork2 = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee3(_current, _user, _options) {
            return _regenerator.default.wrap(function _callee3$(_context3) {
              while (1) switch (_context3.prev = _context3.next) {
                case 0:
                  return _context3.abrupt("return", null);
                case 1:
                case "end":
                  return _context3.stop();
              }
            }, _callee3);
          }));
          function _fetchFromNetwork(_x6, _x7, _x8) {
            return _fetchFromNetwork2.apply(this, arguments);
          }
          return _fetchFromNetwork;
        })()
      }, {
        key: "_getCacheKey",
        value: function _getCacheKey(user) {
          var key = (0, _jsClient._getStorageKey)(this._getSdkKey(), user);
          return "".concat(_jsClient.DataAdapterCachePrefix, ".").concat(this._cacheSuffix, ".").concat(key);
        }
      }, {
        key: "_isCachedResultValidFor204",
        value: function _isCachedResultValidFor204(_result, _user) {
          return false;
        }
      }, {
        key: "setDataLegacy",
        value: function setDataLegacy(data, user) {
          _superPropGet(NoFetchDataAdapter2, "setData", this, 3)([data, user]);
        }
        // Do not stringify options property since that includes this adapter and will
        // cause a circular reference when Statsig sends diagnostic events and including
        // values is not necessary and makes the result huge
      }, {
        key: "toJSON",
        value: function toJSON() {
          var result = _objectSpread({}, this);
          delete result._options;
          delete result._inMemoryCache;
          delete result.bootstrapResult;
          return result;
        }
      }]);
    })(_jsClient.DataAdapterCore);
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/PersistentOverrideAdapter.js
var require_PersistentOverrideAdapter = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/PersistentOverrideAdapter.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.PersistentOverrideAdapter = exports2.LOCAL_STORAGE_KEY = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _clientCore = require_src();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    function _createForOfIteratorHelper(r, e) {
      var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
      if (!t) {
        if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
          t && (r = t);
          var _n = 0, F = function F2() {
          };
          return { s: F, n: function n() {
            return _n >= r.length ? { done: true } : { done: false, value: r[_n++] };
          }, e: function e2(r2) {
            throw r2;
          }, f: F };
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }
      var o, a = true, u = false;
      return { s: function s() {
        t = t.call(r);
      }, n: function n() {
        var r2 = t.next();
        return a = r2.done, r2;
      }, e: function e2(r2) {
        u = true, o = r2;
      }, f: function f() {
        try {
          a || null == t.return || t.return();
        } finally {
          if (u) throw o;
        }
      } };
    }
    function _unsupportedIterableToArray(r, a) {
      if (r) {
        if ("string" == typeof r) return _arrayLikeToArray(r, a);
        var t = {}.toString.call(r).slice(8, -1);
        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
      }
    }
    function _arrayLikeToArray(r, a) {
      (null == a || a > r.length) && (a = r.length);
      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
      return n;
    }
    var LOCAL_OVERRIDE_REASON = "LocalOverride:Recognized";
    var LOCAL_STORAGE_KEY = exports2.LOCAL_STORAGE_KEY = "STATSIG_OVERRIDES";
    var LEGACY_LOCAL_STORAGE_KEY = "STATSIG_JS_LITE_LOCAL_OVERRIDES";
    var makeEmptyStore = function makeEmptyStore2() {
      return {
        gates: {},
        configs: {},
        layers: {}
      };
    };
    var djb2MapKey = function djb2MapKey2(hash, kind) {
      return kind + ":" + hash;
    };
    var PersistentOverrideAdapter = exports2.PersistentOverrideAdapter = /* @__PURE__ */ (function() {
      function PersistentOverrideAdapter2(localStorageKey) {
        (0, _classCallCheck2.default)(this, PersistentOverrideAdapter2);
        this._overrides = makeEmptyStore();
        this._djb2Map = /* @__PURE__ */ new Map();
        this._localStorageKey = localStorageKey;
      }
      return (0, _createClass2.default)(PersistentOverrideAdapter2, [{
        key: "parseStoredOverrides",
        value: function parseStoredOverrides(localStorageKey) {
          try {
            var json = window.localStorage.getItem(localStorageKey);
            if (!json) {
              return makeEmptyStore();
            }
            return JSON.parse(json);
          } catch (_unused) {
            return makeEmptyStore();
          }
        }
      }, {
        key: "mergeOverrides",
        value: function mergeOverrides() {
          var merged = makeEmptyStore();
          for (var _len = arguments.length, allOverrides = new Array(_len), _key = 0; _key < _len; _key++) {
            allOverrides[_key] = arguments[_key];
          }
          for (var _i = 0, _allOverrides = allOverrides; _i < _allOverrides.length; _i++) {
            var overrides = _allOverrides[_i];
            for (var _i2 = 0, _Object$entries = Object.entries((_overrides$gates = overrides.gates) !== null && _overrides$gates !== void 0 ? _overrides$gates : {}); _i2 < _Object$entries.length; _i2++) {
              var _overrides$gates;
              var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i2], 2), name = _Object$entries$_i[0], value = _Object$entries$_i[1];
              merged.gates[name] = value;
            }
            for (var _i3 = 0, _Object$entries2 = Object.entries((_overrides$configs = overrides.configs) !== null && _overrides$configs !== void 0 ? _overrides$configs : {}); _i3 < _Object$entries2.length; _i3++) {
              var _overrides$configs;
              var _Object$entries2$_i = (0, _slicedToArray2.default)(_Object$entries2[_i3], 2), _name = _Object$entries2$_i[0], _value = _Object$entries2$_i[1];
              merged.configs[_name] = _value;
            }
            for (var _i4 = 0, _Object$entries3 = Object.entries((_overrides$layers = overrides.layers) !== null && _overrides$layers !== void 0 ? _overrides$layers : {}); _i4 < _Object$entries3.length; _i4++) {
              var _overrides$layers;
              var _Object$entries3$_i = (0, _slicedToArray2.default)(_Object$entries3[_i4], 2), _name2 = _Object$entries3$_i[0], _value2 = _Object$entries3$_i[1];
              merged.layers[_name2] = _value2;
            }
          }
          return merged;
        }
      }, {
        key: "initFromStoredOverrides",
        value: function initFromStoredOverrides() {
          var storedOverrides = this.mergeOverrides(this._overrides, this.parseStoredOverrides(LEGACY_LOCAL_STORAGE_KEY), this.parseStoredOverrides(this._localStorageKey));
          try {
            window.localStorage.removeItem(LEGACY_LOCAL_STORAGE_KEY);
          } catch (_unused2) {
          }
          for (var _i5 = 0, _Object$values = Object.values(storedOverrides); _i5 < _Object$values.length; _i5++) {
            var container = _Object$values[_i5];
            var allKeys = new Set(Object.keys(container));
            var _iterator = _createForOfIteratorHelper(allKeys), _step;
            try {
              for (_iterator.s(); !(_step = _iterator.n()).done; ) {
                var name = _step.value;
                var hash = (0, _clientCore._DJB2)(name);
                if (allKeys.has(hash)) {
                  delete container[hash];
                }
              }
            } catch (err) {
              _iterator.e(err);
            } finally {
              _iterator.f();
            }
          }
          this.applyOverrides(storedOverrides);
        }
      }, {
        key: "saveOverrides",
        value: function saveOverrides() {
          try {
            window.localStorage.setItem(this._localStorageKey, JSON.stringify(this._overrides));
          } catch (_unused3) {
          }
        }
      }, {
        key: "getOverrides",
        value: function getOverrides() {
          return this.mergeOverrides(this._overrides);
        }
      }, {
        key: "applyOverrides",
        value: function applyOverrides(overrides) {
          var newOverrides = _objectSpread(_objectSpread({}, makeEmptyStore()), overrides);
          this._djb2Map.clear();
          for (var _i6 = 0, _Object$entries4 = Object.entries(newOverrides); _i6 < _Object$entries4.length; _i6++) {
            var _Object$entries4$_i = (0, _slicedToArray2.default)(_Object$entries4[_i6], 2), containerName = _Object$entries4$_i[0], container = _Object$entries4$_i[1];
            for (var _i7 = 0, _Object$entries5 = Object.entries(container); _i7 < _Object$entries5.length; _i7++) {
              var _Object$entries5$_i = (0, _slicedToArray2.default)(_Object$entries5[_i7], 2), name = _Object$entries5$_i[0], value = _Object$entries5$_i[1];
              this._djb2Map.set(djb2MapKey((0, _clientCore._DJB2)(name), containerName), value);
            }
          }
          this._overrides = newOverrides;
        }
      }, {
        key: "setOverrides",
        value: function setOverrides(overrides) {
          this.applyOverrides(overrides);
          this.saveOverrides();
        }
      }, {
        key: "overrideGate",
        value: function overrideGate(name, value) {
          this._overrides.gates[name] = value;
          this._djb2Map.set(djb2MapKey((0, _clientCore._DJB2)(name), "gates"), value);
          this.saveOverrides();
        }
      }, {
        key: "removeGateOverride",
        value: function removeGateOverride(name) {
          delete this._overrides.gates[name];
          this._djb2Map.delete(djb2MapKey((0, _clientCore._DJB2)(name), "gates"));
          this.saveOverrides();
        }
      }, {
        key: "getGateOverride",
        value: function getGateOverride(current, _user) {
          var _this$_overrides$gate;
          var overridden = (_this$_overrides$gate = this._overrides.gates[current.name]) !== null && _this$_overrides$gate !== void 0 ? _this$_overrides$gate : this._djb2Map.get(djb2MapKey(current.name, "gates"));
          if (overridden == null) {
            return null;
          }
          return _objectSpread(_objectSpread({}, current), {}, {
            value: overridden,
            details: _objectSpread(_objectSpread({}, current.details), {}, {
              reason: LOCAL_OVERRIDE_REASON
            })
          });
        }
      }, {
        key: "overrideDynamicConfig",
        value: function overrideDynamicConfig(name, value) {
          this._overrides.configs[name] = value;
          this._djb2Map.set(djb2MapKey((0, _clientCore._DJB2)(name), "configs"), value);
          this.saveOverrides();
        }
      }, {
        key: "removeDynamicConfigOverride",
        value: function removeDynamicConfigOverride(name) {
          delete this._overrides.configs[name];
          this._djb2Map.delete(djb2MapKey((0, _clientCore._DJB2)(name), "configs"));
          this.saveOverrides();
        }
      }, {
        key: "getDynamicConfigOverride",
        value: function getDynamicConfigOverride(current, _user) {
          return this._getConfigOverride(current, this._overrides.configs);
        }
      }, {
        key: "overrideExperiment",
        value: function overrideExperiment(name, value) {
          this._overrides.configs[name] = value;
          this._djb2Map.set(djb2MapKey((0, _clientCore._DJB2)(name), "configs"), value);
          this.saveOverrides();
        }
      }, {
        key: "removeExperimentOverride",
        value: function removeExperimentOverride(name) {
          delete this._overrides.configs[name];
          this._djb2Map.delete(djb2MapKey((0, _clientCore._DJB2)(name), "configs"));
          this.saveOverrides();
        }
      }, {
        key: "getExperimentOverride",
        value: function getExperimentOverride(current, _user) {
          return this._getConfigOverride(current, this._overrides.configs);
        }
      }, {
        key: "overrideLayer",
        value: function overrideLayer(name, value) {
          this._overrides.layers[name] = value;
          this._djb2Map.set(djb2MapKey((0, _clientCore._DJB2)(name), "layers"), value);
          this.saveOverrides();
        }
      }, {
        key: "removeLayerOverride",
        value: function removeLayerOverride(name) {
          delete this._overrides.layers[name];
          this._djb2Map.delete(djb2MapKey((0, _clientCore._DJB2)(name), "layers"));
          this.saveOverrides();
        }
      }, {
        key: "removeAllOverrides",
        value: function removeAllOverrides() {
          this._overrides = makeEmptyStore();
          try {
            window.localStorage.removeItem(this._localStorageKey);
          } catch (_unused4) {
          }
        }
      }, {
        key: "getLayerOverride",
        value: function getLayerOverride(current, _user) {
          var _this$_overrides$laye;
          var overridden = (_this$_overrides$laye = this._overrides.layers[current.name]) !== null && _this$_overrides$laye !== void 0 ? _this$_overrides$laye : this._djb2Map.get(djb2MapKey(current.name, "layers"));
          if (overridden == null) {
            return null;
          }
          return _objectSpread(_objectSpread({}, current), {}, {
            __value: overridden,
            get: (0, _clientCore._makeTypedGet)(current.name, overridden),
            details: _objectSpread(_objectSpread({}, current.details), {}, {
              reason: LOCAL_OVERRIDE_REASON
            })
          });
        }
      }, {
        key: "_getConfigOverride",
        value: function _getConfigOverride(current, lookup) {
          var _lookup$current$name;
          var overridden = (_lookup$current$name = lookup[current.name]) !== null && _lookup$current$name !== void 0 ? _lookup$current$name : this._djb2Map.get(djb2MapKey(current.name, "configs"));
          if (overridden == null) {
            return null;
          }
          return _objectSpread(_objectSpread({}, current), {}, {
            value: overridden,
            get: (0, _clientCore._makeTypedGet)(current.name, overridden),
            details: _objectSpread(_objectSpread({}, current.details), {}, {
              reason: LOCAL_OVERRIDE_REASON
            })
          });
        }
      }]);
    })();
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/Client.js
var require_Client = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/Client.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.Client = void 0;
    var _objectWithoutProperties2 = _interopRequireDefault(require_objectWithoutProperties());
    var _regenerator = _interopRequireDefault(require_regenerator2());
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _asyncToGenerator2 = _interopRequireDefault(require_asyncToGenerator());
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _jsClient = require_src2();
    var _subscriptions = _interopRequireDefault(require_subscriptions());
    var _DynamicConfig = require_DynamicConfig();
    var _Layer = require_Layer();
    var _types = require_types2();
    var _fetcher = _interopRequireDefault(require_fetcher());
    var _NoFetchDataAdapter = require_NoFetchDataAdapter();
    var _PersistentOverrideAdapter = require_PersistentOverrideAdapter();
    var _types2 = require_types3();
    var _utils = require_utils2();
    var _version = require_version();
    var _excluded = ["sdkKey", "environment", "updateUserCompletionCallback", "perimeter"];
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var DEFAULT_CLIENT_KEY = "client-default-key";
    var DEFAULT_EVENT_LOGGING_API = "https://xp.atlassian.com/v1/rgstr";
    var Client = exports2.Client = /* @__PURE__ */ (function() {
      function Client2() {
        var _this = this;
        var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref$localStorageKey = _ref.localStorageKey, localStorageKey = _ref$localStorageKey === void 0 ? _PersistentOverrideAdapter.LOCAL_STORAGE_KEY : _ref$localStorageKey;
        (0, _classCallCheck2.default)(this, Client2);
        (0, _defineProperty2.default)(this, "initPromise", null);
        (0, _defineProperty2.default)(this, "initCompleted", false);
        (0, _defineProperty2.default)(this, "initWithDefaults", false);
        (0, _defineProperty2.default)(this, "hasCheckGateErrorOccurred", false);
        (0, _defineProperty2.default)(this, "hasGetExperimentErrorOccurred", false);
        (0, _defineProperty2.default)(this, "hasGetExperimentValueErrorOccurred", false);
        (0, _defineProperty2.default)(this, "hasGetLayerErrorOccurred", false);
        (0, _defineProperty2.default)(this, "hasGetLayerValueErrorOccurred", false);
        (0, _defineProperty2.default)(this, "subscriptions", new _subscriptions.default());
        (0, _defineProperty2.default)(this, "dataAdapter", new _NoFetchDataAdapter.NoFetchDataAdapter());
        (0, _defineProperty2.default)(this, "statsigValuesUpdated", function() {
          if (_this.user) {
            _this.statsigClient.updateUserSync(_this.user, {
              disableBackgroundCacheRefresh: true
            });
          }
          _this.subscriptions.anyUpdated();
        });
        this.overrideAdapter = new _PersistentOverrideAdapter.PersistentOverrideAdapter(localStorageKey);
      }
      return (0, _createClass2.default)(Client2, [{
        key: "initialize",
        value: (function() {
          var _initialize = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee(clientOptions, identifiers, customAttributes) {
            var _this2 = this;
            var clientOptionsWithDefaults, startTime;
            return _regenerator.default.wrap(function _callee$(_context) {
              while (1) switch (_context.prev = _context.next) {
                case 0:
                  clientOptionsWithDefaults = (0, _utils.getOptionsWithDefaults)(clientOptions);
                  if (!this.initPromise) {
                    _context.next = 4;
                    break;
                  }
                  if (!(0, _utils.shallowEquals)(clientOptionsWithDefaults, this.initOptions)) {
                    console.warn("Feature Gates client already initialized with different options. New options were not applied.");
                  }
                  return _context.abrupt("return", this.initPromise);
                case 4:
                  startTime = performance.now();
                  this.initOptions = clientOptionsWithDefaults;
                  this.initPromise = this.init(clientOptionsWithDefaults, identifiers, customAttributes).then(function() {
                    _this2.initCompleted = true;
                    _this2.initWithDefaults = true;
                  }).finally(function() {
                    var endTime = performance.now();
                    var totalTime = endTime - startTime;
                    _this2.fireClientEvent(startTime, totalTime, "initialize", _this2.initCompleted, clientOptionsWithDefaults.apiKey);
                  });
                  return _context.abrupt("return", this.initPromise);
                case 8:
                case "end":
                  return _context.stop();
              }
            }, _callee, this);
          }));
          function initialize(_x, _x2, _x3) {
            return _initialize.apply(this, arguments);
          }
          return initialize;
        })()
      }, {
        key: "initializeWithProvider",
        value: (function() {
          var _initializeWithProvider = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee2(clientOptions, provider, identifiers, customAttributes) {
            var _this3 = this;
            var clientOptionsWithDefaults, startTime;
            return _regenerator.default.wrap(function _callee2$(_context2) {
              while (1) switch (_context2.prev = _context2.next) {
                case 0:
                  clientOptionsWithDefaults = (0, _utils.getOptionsWithDefaults)(clientOptions);
                  if (!this.initPromise) {
                    _context2.next = 4;
                    break;
                  }
                  if (!(0, _utils.shallowEquals)(clientOptionsWithDefaults, this.initOptions)) {
                    console.warn("Feature Gates client already initialized with different options. New options were not applied.");
                  }
                  return _context2.abrupt("return", this.initPromise);
                case 4:
                  startTime = performance.now();
                  this.initOptions = clientOptionsWithDefaults;
                  this.provider = provider;
                  this.provider.setClientVersion(_version.CLIENT_VERSION);
                  if (this.provider.setApplyUpdateCallback) {
                    this.provider.setApplyUpdateCallback(this.applyUpdateCallback.bind(this));
                  }
                  this.initPromise = this.initWithProvider(clientOptionsWithDefaults, provider, identifiers, customAttributes).then(function() {
                    _this3.initCompleted = true;
                    _this3.initWithDefaults = true;
                  }).finally(function() {
                    var endTime = performance.now();
                    var totalTime = endTime - startTime;
                    _this3.fireClientEvent(startTime, totalTime, "initializeWithProvider", _this3.initCompleted, provider.getApiKey ? provider.getApiKey() : void 0);
                  });
                  return _context2.abrupt("return", this.initPromise);
                case 11:
                case "end":
                  return _context2.stop();
              }
            }, _callee2, this);
          }));
          function initializeWithProvider(_x4, _x5, _x6, _x7) {
            return _initializeWithProvider.apply(this, arguments);
          }
          return initializeWithProvider;
        })()
      }, {
        key: "applyUpdateCallback",
        value: function applyUpdateCallback(experimentsResult) {
          try {
            if (this.initCompleted || this.initWithDefaults) {
              this.assertInitialized(this.statsigClient);
              this.dataAdapter.setBootstrapData(experimentsResult.experimentValues);
              this.dataAdapter.setData(JSON.stringify(experimentsResult.experimentValues));
              this.statsigValuesUpdated();
            }
          } catch (error) {
            console.warn("Error when attempting to apply update", error);
          }
        }
      }, {
        key: "fireClientEvent",
        value: function fireClientEvent(startTime, totalTime, action, success) {
          var _analyticsWebClient, _this4 = this;
          var apiKey = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : void 0;
          (_analyticsWebClient = this.initOptions.analyticsWebClient) === null || _analyticsWebClient === void 0 || _analyticsWebClient.then(function(analyticsWebClient) {
            var attributes = _objectSpread({
              targetApp: _this4.initOptions.targetApp,
              clientVersion: _version.CLIENT_VERSION,
              success,
              startTime,
              totalTime
            }, apiKey && {
              apiKey
            });
            analyticsWebClient.sendOperationalEvent({
              action,
              actionSubject: "featureGatesClient",
              attributes,
              tags: ["measurement"],
              source: "@atlaskit/feature-gate-js-client"
            });
          }).catch(function(err) {
            if (_this4.initOptions.environment !== _types2.FeatureGateEnvironment.Production) {
              console.error("Analytics web client promise did not resolve", err);
            }
          });
        }
      }, {
        key: "initializeFromValues",
        value: (function() {
          var _initializeFromValues = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee3(clientOptions, identifiers, customAttributes) {
            var _this5 = this;
            var initializeValues, clientOptionsWithDefaults, startTime, _args3 = arguments;
            return _regenerator.default.wrap(function _callee3$(_context3) {
              while (1) switch (_context3.prev = _context3.next) {
                case 0:
                  initializeValues = _args3.length > 3 && _args3[3] !== void 0 ? _args3[3] : {};
                  clientOptionsWithDefaults = (0, _utils.getOptionsWithDefaults)(clientOptions);
                  if (!this.initPromise) {
                    _context3.next = 5;
                    break;
                  }
                  if (!(0, _utils.shallowEquals)(clientOptionsWithDefaults, this.initOptions)) {
                    console.warn("Feature Gates client already initialized with different options. New options were not applied.");
                  }
                  return _context3.abrupt("return", this.initPromise);
                case 5:
                  if (!Object.prototype.hasOwnProperty.call(initializeValues, "has_updates")) {
                    initializeValues["has_updates"] = true;
                  }
                  startTime = performance.now();
                  this.initOptions = clientOptionsWithDefaults;
                  this.initPromise = this.initFromValues(clientOptionsWithDefaults, identifiers, customAttributes, initializeValues).then(function() {
                    _this5.initCompleted = true;
                    _this5.initWithDefaults = true;
                  }).finally(function() {
                    var endTime = performance.now();
                    var totalTime = endTime - startTime;
                    _this5.fireClientEvent(startTime, totalTime, "initializeFromValues", _this5.initCompleted);
                  });
                  return _context3.abrupt("return", this.initPromise);
                case 10:
                case "end":
                  return _context3.stop();
              }
            }, _callee3, this);
          }));
          function initializeFromValues(_x8, _x9, _x10) {
            return _initializeFromValues.apply(this, arguments);
          }
          return initializeFromValues;
        })()
      }, {
        key: "assertInitialized",
        value: function assertInitialized(statsigClient) {
          if (!statsigClient) {
            throw new Error("Client must be initialized before using this method");
          }
        }
        /**
         * This method updates the user using a network call to fetch the new set of values.
         * @param fetchOptions {FetcherOptions}
         * @param identifiers {Identifiers}
         * @param customAttributes {CustomAttributes}
         */
      }, {
        key: "updateUser",
        value: (function() {
          var _updateUser = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee4(fetchOptions, identifiers, customAttributes) {
            var fetchOptionsWithDefaults, initializeValuesProducer;
            return _regenerator.default.wrap(function _callee4$(_context4) {
              while (1) switch (_context4.prev = _context4.next) {
                case 0:
                  this.assertInitialized(this.statsigClient);
                  fetchOptionsWithDefaults = (0, _utils.getOptionsWithDefaults)(fetchOptions);
                  initializeValuesProducer = function initializeValuesProducer2() {
                    return _fetcher.default.fetchExperimentValues(fetchOptionsWithDefaults, identifiers, customAttributes).then(function(_ref2) {
                      var experimentValues = _ref2.experimentValues, customAttributes2 = _ref2.customAttributes;
                      return {
                        experimentValues,
                        customAttributesFromFetch: customAttributes2
                      };
                    });
                  };
                  _context4.next = 5;
                  return this.updateUserUsingInitializeValuesProducer(initializeValuesProducer, identifiers, customAttributes);
                case 5:
                case "end":
                  return _context4.stop();
              }
            }, _callee4, this);
          }));
          function updateUser(_x11, _x12, _x13) {
            return _updateUser.apply(this, arguments);
          }
          return updateUser;
        })()
      }, {
        key: "updateUserWithProvider",
        value: (function() {
          var _updateUserWithProvider = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee5(identifiers, customAttributes) {
            var _this6 = this;
            return _regenerator.default.wrap(function _callee5$(_context5) {
              while (1) switch (_context5.prev = _context5.next) {
                case 0:
                  this.assertInitialized(this.statsigClient);
                  if (this.provider) {
                    _context5.next = 3;
                    break;
                  }
                  throw new Error("Cannot update user using provider as the client was not initialised with a provider");
                case 3:
                  _context5.next = 5;
                  return this.provider.setProfile(this.initOptions, identifiers, customAttributes);
                case 5:
                  _context5.next = 7;
                  return this.updateUserUsingInitializeValuesProducer(function() {
                    return _this6.provider.getExperimentValues();
                  }, identifiers, customAttributes);
                case 7:
                case "end":
                  return _context5.stop();
              }
            }, _callee5, this);
          }));
          function updateUserWithProvider(_x14, _x15) {
            return _updateUserWithProvider.apply(this, arguments);
          }
          return updateUserWithProvider;
        })()
      }, {
        key: "updateUserWithValues",
        value: (function() {
          var _updateUserWithValues = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee6(identifiers, customAttributes) {
            var initializeValues, initializeValuesProducer, _args6 = arguments;
            return _regenerator.default.wrap(function _callee6$(_context6) {
              while (1) switch (_context6.prev = _context6.next) {
                case 0:
                  initializeValues = _args6.length > 2 && _args6[2] !== void 0 ? _args6[2] : {};
                  this.assertInitialized(this.statsigClient);
                  initializeValuesProducer = function initializeValuesProducer2() {
                    return Promise.resolve({
                      experimentValues: initializeValues,
                      customAttributesFromFetch: customAttributes
                    });
                  };
                  _context6.next = 5;
                  return this.updateUserUsingInitializeValuesProducer(initializeValuesProducer, identifiers, customAttributes);
                case 5:
                case "end":
                  return _context6.stop();
              }
            }, _callee6, this);
          }));
          function updateUserWithValues(_x16, _x17) {
            return _updateUserWithValues.apply(this, arguments);
          }
          return updateUserWithValues;
        })()
      }, {
        key: "initializeCalled",
        value: function initializeCalled() {
          return this.initPromise != null;
        }
      }, {
        key: "initializeCompleted",
        value: function initializeCompleted() {
          return this.initCompleted;
        }
        /**
         * Returns the value for a feature gate. Returns false if there are errors.
         * @param {string} gateName - The name of the feature gate.
         * @param {Object} options
         * @param {boolean} options.fireGateExposure
         *        Whether or not to fire the exposure event for the gate. Defaults to true.
         *        To log an exposure event manually at a later time, use {@link Client.manuallyLogGateExposure}
         *        (see [Statsig docs about manually logging exposures](https://docs.statsig.com/client/jsClientSDK#manual-exposures-)).
         */
      }, {
        key: "checkGate",
        value: function checkGate(gateName) {
          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          try {
            this.assertInitialized(this.statsigClient);
            var _options$fireGateExpo = options.fireGateExposure, fireGateExposure = _options$fireGateExpo === void 0 ? true : _options$fireGateExpo;
            return this.statsigClient.checkGate(gateName, {
              disableExposureLog: !fireGateExposure
            });
          } catch (error) {
            if (!this.hasCheckGateErrorOccurred) {
              console.warn({
                msg: "An error has occurred checking the feature gate. Only the first occurrence of this error is logged.",
                gateName,
                error
              });
              this.hasCheckGateErrorOccurred = true;
            }
            return false;
          }
        }
      }, {
        key: "isGateExist",
        value: function isGateExist(gateName) {
          try {
            this.assertInitialized(this.statsigClient);
            var gate = this.statsigClient.getFeatureGate(gateName, {
              disableExposureLog: true
            });
            return !gate.details.reason.includes("Unrecognized");
          } catch (error) {
            console.error("Error occurred when trying to check FeatureGate: ".concat(error));
            return true;
          }
        }
      }, {
        key: "isExperimentExist",
        value: function isExperimentExist(experimentName) {
          try {
            this.assertInitialized(this.statsigClient);
            var config = this.statsigClient.getExperiment(experimentName, {
              disableExposureLog: true
            });
            return !config.details.reason.includes("Unrecognized");
          } catch (error) {
            console.error("Error occurred when trying to check Experiment: ".concat(error));
            return true;
          }
        }
        /**
         * Manually log a gate exposure (see [Statsig docs about manually logging exposures](https://docs.statsig.com/client/jsClientSDK#manual-exposures-)).
         * This is useful if you have evaluated a gate earlier via {@link Client.checkGate} where
         * <code>options.fireGateExposure</code> is false.
         * @param gateName
         */
      }, {
        key: "manuallyLogGateExposure",
        value: function manuallyLogGateExposure(gateName) {
          this.assertInitialized(this.statsigClient);
          this.statsigClient.checkGate(gateName);
        }
        /**
         * Returns the entire config for a given experiment.
         *
         * @param {string} experimentName - The name of the experiment
         * @param {Object} options
         * @param {boolean} options.fireExperimentExposure - Whether or not to fire the exposure event
         * for the experiment. Defaults to true. To log an exposure event manually at a later time, use
         * {@link Client.manuallyLogExperimentExposure} (see [Statsig docs about manually logging exposures](https://docs.statsig.com/client/jsClientSDK#manual-exposures-)).
         * @returns The config for an experiment
         * @example
         * ```ts
         * const experimentConfig = client.getExperiment('example-experiment-name');
         * const backgroundColor: string = experimentConfig.get('backgroundColor', 'yellow');
         * ```
         */
      }, {
        key: "getExperiment",
        value: function getExperiment(experimentName) {
          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          try {
            this.assertInitialized(this.statsigClient);
            var _options$fireExperime = options.fireExperimentExposure, fireExperimentExposure = _options$fireExperime === void 0 ? true : _options$fireExperime;
            return _DynamicConfig.DynamicConfig.fromExperiment(this.statsigClient.getExperiment(experimentName, {
              disableExposureLog: !fireExperimentExposure
            }));
          } catch (error) {
            if (!this.hasGetExperimentErrorOccurred) {
              console.warn({
                msg: "An error has occurred getting the experiment. Only the first occurrence of this error is logged.",
                experimentName,
                error
              });
              this.hasGetExperimentErrorOccurred = true;
            }
            return new _DynamicConfig.DynamicConfig(experimentName, {}, "", {
              time: Date.now(),
              reason: _types.EvaluationReason.Error
            });
          }
        }
        /**
         * Returns the value of a given parameter in an experiment config.
         *
         * @template T
         * @param {string} experimentName - The name of the experiment
         * @param {string} parameterName - The name of the parameter to fetch from the experiment config
         * @param {T} defaultValue - The value to serve if the experiment or parameter do not exist, or
         * if the returned value does not match the expected type.
         * @param {Object} options
         * @param {boolean} options.fireExperimentExposure - Whether or not to fire the exposure event
         * for the experiment. Defaults to true. To log an exposure event manually at a later time, use
         * {@link Client.manuallyLogExperimentExposure} (see [Statsig docs about manually logging exposures](https://docs.statsig.com/client/jsClientSDK#manual-exposures-))
         * @param {function} options.typeGuard - A function that asserts that the return value has the
         * expected type. If this function returns false, then the default value will be returned
         * instead. This can be set to protect your code from unexpected values being set remotely. By
         * default, this will be done by asserting that the default value and value are the same primitive
         * type.
         * @returns The value of the parameter if the experiment and parameter both exist, otherwise the
         * default value.
         * @example
         ``` ts
         type ValidColor = 'blue' | 'red' | 'yellow';
         type ValidColorTypeCheck = (value: unknown) => value is ValidColor;
        	 const isValidColor: ValidColorTypeCheck =
        		(value: unknown) => typeof value === 'string' && ['blue', 'red', 'yellow'].includes(value);
        	 const buttonColor: ValidColor = client.getExperimentValue(
        		'example-experiment-name',
        		'backgroundColor',
        		'yellow',
        		{
        				typeGuard: isValidColor
        		}
         );
         ```
        */
      }, {
        key: "getExperimentValue",
        value: function getExperimentValue(experimentName, parameterName, defaultValue) {
          var options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
          var experiment = this.getExperiment(experimentName, options);
          try {
            var typeGuard = options.typeGuard;
            return experiment.get(parameterName, defaultValue, typeGuard);
          } catch (error) {
            if (!this.hasGetExperimentValueErrorOccurred) {
              console.warn({
                msg: "An error has occurred getting the experiment value. Only the first occurrence of this error is logged.",
                experimentName,
                defaultValue,
                options,
                error
              });
              this.hasGetExperimentValueErrorOccurred = true;
            }
            return defaultValue;
          }
        }
        /**
         * Manually log an experiment exposure (see [Statsig docs about manually logging exposures](https://docs.statsig.com/client/jsClientSDK#manual-exposures-)).
         * This is useful if you have evaluated an experiment earlier via {@link Client.getExperimentValue} or
         * {@link Client.getExperiment} where <code>options.fireExperimentExposure</code> is false.
         * @param experimentName
         */
      }, {
        key: "manuallyLogExperimentExposure",
        value: function manuallyLogExperimentExposure(experimentName) {
          this.assertInitialized(this.statsigClient);
          this.statsigClient.getExperiment(experimentName);
        }
        /**
         * Manually log a layer exposure (see [Statsig docs about manually logging exposures](https://docs.statsig.com/client/jsClientSDK#manual-exposures-)).
         * This is useful if you have evaluated a layer earlier via {@link Client.getLayerValue} where <code>options.fireExperimentExposure</code> is false.
         * @param layerName
         * @param parameterName
         */
      }, {
        key: "manuallyLogLayerExposure",
        value: function manuallyLogLayerExposure(layerName, parameterName) {
          var _this$statsigClient$g;
          this.assertInitialized(this.statsigClient);
          (_this$statsigClient$g = this.statsigClient.getLayer(layerName)) === null || _this$statsigClient$g === void 0 || _this$statsigClient$g.get(parameterName);
        }
      }, {
        key: "shutdownStatsig",
        value: function shutdownStatsig() {
          this.assertInitialized(this.statsigClient);
          this.statsigClient.shutdown();
        }
        /**
         * Adds a new override for the given gate.
         *
         * This method is additive, meaning you can call it multiple times with different gate names to
         * build your full set of overrides.
         *
         * Overrides are persisted to the `STATSIG_OVERRIDES` key in localStorage, so they
         * will continue to affect every client that is initialized on the same domain after this method
         * is called. If you are using this API for testing purposes, you should call
         * {@link Client.clearGateOverride} after your tests are completed to remove this
         * localStorage entry.
         *
         * @param {string} gateName
         * @param {boolean} value
         */
      }, {
        key: "overrideGate",
        value: function overrideGate(gateName, value) {
          this.overrideAdapter.overrideGate(gateName, value);
          if (this.user) {
            var _this$statsigClient;
            (_this$statsigClient = this.statsigClient) === null || _this$statsigClient === void 0 || _this$statsigClient.updateUserSync(this.user, {
              disableBackgroundCacheRefresh: true
            });
          }
          this.statsigValuesUpdated();
        }
        /**
         * Removes any overrides that have been set for the given gate.
         */
      }, {
        key: "clearGateOverride",
        value: function clearGateOverride(gateName) {
          this.overrideAdapter.removeGateOverride(gateName);
          this.statsigValuesUpdated();
        }
        /**
         * Adds a new override for the given config (or experiment).
         *
         * This method is additive, meaning you can call it multiple times with different experiment
         * names to build your full set of overrides.
         *
         * Overrides are persisted to the `STATSIG_OVERRIDES` key in localStorage, so they
         * will continue to affect every client that is initialized on the same domain after this method
         * is called. If you are using this API for testing purposes, you should call
         * {@link Client.clearConfigOverride} after your tests are completed to remove this
         * localStorage entry.
         *
         * @param {string} experimentName
         * @param {object} values
         */
      }, {
        key: "overrideConfig",
        value: function overrideConfig(experimentName, values) {
          this.overrideAdapter.overrideDynamicConfig(experimentName, values);
          this.statsigValuesUpdated();
        }
        /**
         * Removes any overrides that have been set for the given experiment.
         * @param {string} experimentName
         */
      }, {
        key: "clearConfigOverride",
        value: function clearConfigOverride(experimentName) {
          this.overrideAdapter.removeDynamicConfigOverride(experimentName);
          this.statsigValuesUpdated();
        }
        /**
         * Set overrides for gates, experiments and layers in batch.
         *
         * Note that these overrides are **not** additive and will completely replace any that have been
         * added via prior calls to {@link Client.overrideConfig} or
         * {@link Client.overrideGate}.
         *
         * Overrides are persisted to the `STATSIG_OVERRIDES` key in localStorage, so they
         * will continue to affect every client that is initialized on the same domain after this method
         * is called. If you are using this API for testing purposes, you should call
         * {@link Client.clearAllOverrides} after your tests are completed to remove this
         * localStorage entry.
         */
      }, {
        key: "setOverrides",
        value: function setOverrides(overrides) {
          this.overrideAdapter.setOverrides(overrides);
          this.statsigValuesUpdated();
        }
        /**
         * @returns The current overrides for gates, configs (including experiments) and layers.
         */
      }, {
        key: "getOverrides",
        value: function getOverrides() {
          return this.overrideAdapter.getOverrides();
        }
        /**
         * Clears overrides for all gates, configs (including experiments) and layers.
         */
      }, {
        key: "clearAllOverrides",
        value: function clearAllOverrides() {
          this.overrideAdapter.removeAllOverrides();
          this.statsigValuesUpdated();
        }
        /**
         * Returns whether the given identifiers and customAttributes align with the current
         * set that is being used by the client.
         *
         * If this method returns false, then the {@link Client.updateUser},
         * {@link Client.updateUserWithValues} or {@link Client.updateUserWithProvider}
         * methods can be used to re-align these values.
         *
         * @param identifiers
         * @param customAttributes
         * @returns a flag indicating whether the clients current configuration aligns with the given values
         */
      }, {
        key: "isCurrentUser",
        value: function isCurrentUser(identifiers, customAttributes) {
          return (0, _utils.shallowEquals)(this.currentIdentifiers, identifiers) && (0, _utils.shallowEquals)(this.currentAttributes, customAttributes);
        }
        /**
         * Subscribe to updates where the given callback will be called with the current checkGate value
         * @param gateName
         * @param callback
         * @param options
         * @returns off function to unsubscribe from updates
         */
      }, {
        key: "onGateUpdated",
        value: function onGateUpdated(gateName, callback) {
          var _this7 = this;
          var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
          var wrapCallback = function wrapCallback2(value) {
            var _options$fireGateExpo2 = options.fireGateExposure, fireGateExposure = _options$fireGateExpo2 === void 0 ? true : _options$fireGateExpo2;
            if (fireGateExposure) {
              _this7.manuallyLogGateExposure(gateName);
            }
            try {
              callback(value);
            } catch (error) {
              console.warn("Error calling callback for gate ".concat(gateName, " with value ").concat(value), error);
            }
          };
          return this.subscriptions.onGateUpdated(gateName, wrapCallback, this.checkGate.bind(this), options);
        }
        /**
         * Subscribe to updates where the given callback will be called with the current experiment value
         * @param experimentName
         * @param parameterName
         * @param defaultValue
         * @param callback
         * @param options
         * @returns off function to unsubscribe from updates
         */
      }, {
        key: "onExperimentValueUpdated",
        value: function onExperimentValueUpdated(experimentName, parameterName, defaultValue, callback) {
          var _this8 = this;
          var options = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : {};
          var wrapCallback = function wrapCallback2(value) {
            var _options$fireExperime2 = options.fireExperimentExposure, fireExperimentExposure = _options$fireExperime2 === void 0 ? true : _options$fireExperime2;
            if (fireExperimentExposure) {
              _this8.manuallyLogExperimentExposure(experimentName);
            }
            try {
              callback(value);
            } catch (error) {
              console.warn("Error calling callback for experiment ".concat(experimentName, " with value ").concat(value), error);
            }
          };
          return this.subscriptions.onExperimentValueUpdated(experimentName, parameterName, defaultValue, wrapCallback, this.getExperimentValue.bind(this), options);
        }
        /**
         * Subscribe so on any update the callback will be called.
         * NOTE: The callback will be called whenever the values are updated even if the values have not
         * changed.
         * @param callback
         * @returns off function to unsubscribe from updates
         */
      }, {
        key: "onAnyUpdated",
        value: function onAnyUpdated(callback) {
          return this.subscriptions.onAnyUpdated(callback);
        }
        /**
         * This method initializes the client using a network call to fetch the bootstrap values for the
         * given user.
         *
         * @param clientOptions
         * @param identifiers
         * @param customAttributes
         * @private
         */
      }, {
        key: "init",
        value: (function() {
          var _init = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee7(clientOptions, identifiers, customAttributes) {
            var fromValuesClientOptions, experimentValues, customAttributesFromResult, clientSdkKeyPromise, experimentValuesPromise, _yield$Promise$all, _yield$Promise$all2, experimentValuesResult;
            return _regenerator.default.wrap(function _callee7$(_context7) {
              while (1) switch (_context7.prev = _context7.next) {
                case 0:
                  fromValuesClientOptions = _objectSpread({}, clientOptions);
                  _context7.prev = 1;
                  clientSdkKeyPromise = _fetcher.default.fetchClientSdk(clientOptions).then(function(value) {
                    return fromValuesClientOptions.sdkKey = value.clientSdkKey;
                  });
                  experimentValuesPromise = _fetcher.default.fetchExperimentValues(clientOptions, identifiers, customAttributes);
                  _context7.next = 6;
                  return Promise.all([clientSdkKeyPromise, experimentValuesPromise]);
                case 6:
                  _yield$Promise$all = _context7.sent;
                  _yield$Promise$all2 = (0, _slicedToArray2.default)(_yield$Promise$all, 2);
                  experimentValuesResult = _yield$Promise$all2[1];
                  experimentValues = experimentValuesResult.experimentValues;
                  customAttributesFromResult = experimentValuesResult.customAttributes;
                  _context7.next = 20;
                  break;
                case 13:
                  _context7.prev = 13;
                  _context7.t0 = _context7["catch"](1);
                  if (_context7.t0 instanceof Error) {
                    console.error("Error occurred when trying to fetch the Feature Gates client values, error: ".concat(_context7.t0 === null || _context7.t0 === void 0 ? void 0 : _context7.t0.message));
                  }
                  console.warn("Initialising Statsig client without values");
                  _context7.next = 19;
                  return this.initFromValues(fromValuesClientOptions, identifiers, customAttributes);
                case 19:
                  throw _context7.t0;
                case 20:
                  return _context7.abrupt("return", this.initFromValues(fromValuesClientOptions, identifiers, customAttributesFromResult, experimentValues));
                case 21:
                case "end":
                  return _context7.stop();
              }
            }, _callee7, this, [[1, 13]]);
          }));
          function init(_x18, _x19, _x20) {
            return _init.apply(this, arguments);
          }
          return init;
        })()
      }, {
        key: "initWithProvider",
        value: (function() {
          var _initWithProvider = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee8(baseClientOptions, provider, identifiers, customAttributes) {
            var fromValuesClientOptions, experimentValues, customAttributesFromResult, clientSdkKeyPromise, experimentValuesPromise, _yield$Promise$all3, _yield$Promise$all4, experimentValuesResult;
            return _regenerator.default.wrap(function _callee8$(_context8) {
              while (1) switch (_context8.prev = _context8.next) {
                case 0:
                  fromValuesClientOptions = _objectSpread(_objectSpread({}, baseClientOptions), {}, {
                    disableCurrentPageLogging: true
                  });
                  _context8.prev = 1;
                  _context8.next = 4;
                  return provider.setProfile(baseClientOptions, identifiers, customAttributes);
                case 4:
                  clientSdkKeyPromise = provider.getClientSdkKey().then(function(value) {
                    return fromValuesClientOptions.sdkKey = value;
                  });
                  experimentValuesPromise = provider.getExperimentValues();
                  _context8.next = 8;
                  return Promise.all([clientSdkKeyPromise, experimentValuesPromise]);
                case 8:
                  _yield$Promise$all3 = _context8.sent;
                  _yield$Promise$all4 = (0, _slicedToArray2.default)(_yield$Promise$all3, 2);
                  experimentValuesResult = _yield$Promise$all4[1];
                  experimentValues = experimentValuesResult.experimentValues;
                  customAttributesFromResult = experimentValuesResult.customAttributesFromFetch;
                  _context8.next = 22;
                  break;
                case 15:
                  _context8.prev = 15;
                  _context8.t0 = _context8["catch"](1);
                  if (_context8.t0 instanceof Error) {
                    console.error("Error occurred when trying to fetch the Feature Gates client values, error: ".concat(_context8.t0 === null || _context8.t0 === void 0 ? void 0 : _context8.t0.message));
                  }
                  console.warn("Initialising Statsig client without values");
                  _context8.next = 21;
                  return this.initFromValues(fromValuesClientOptions, identifiers, customAttributes);
                case 21:
                  throw _context8.t0;
                case 22:
                  return _context8.abrupt("return", this.initFromValues(fromValuesClientOptions, identifiers, customAttributesFromResult, experimentValues));
                case 23:
                case "end":
                  return _context8.stop();
              }
            }, _callee8, this, [[1, 15]]);
          }));
          function initWithProvider(_x21, _x22, _x23, _x24) {
            return _initWithProvider.apply(this, arguments);
          }
          return initWithProvider;
        })()
        /**
         * This method initializes the client using a set of boostrap values obtained from one of the
         * server-side SDKs.
         *
         * @param clientOptions
         * @param identifiers
         * @param customAttributes
         * @param initializeValues
         * @private
         */
      }, {
        key: "initFromValues",
        value: (function() {
          var _initFromValues = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee9(clientOptions, identifiers, customAttributes) {
            var _newClientOptions$net;
            var initializeValues, newClientOptions, sdkKey, environment, _updateUserCompletionCallback, _perimeter, restClientOptions, statsigOptions, _args9 = arguments;
            return _regenerator.default.wrap(function _callee9$(_context9) {
              while (1) switch (_context9.prev = _context9.next) {
                case 0:
                  initializeValues = _args9.length > 3 && _args9[3] !== void 0 ? _args9[3] : {};
                  this.overrideAdapter.initFromStoredOverrides();
                  this.currentIdentifiers = identifiers;
                  this.currentAttributes = customAttributes;
                  newClientOptions = (0, _utils.migrateInitializationOptions)(clientOptions);
                  if (!newClientOptions.sdkKey) {
                    newClientOptions.sdkKey = DEFAULT_CLIENT_KEY;
                  }
                  if (!((_newClientOptions$net = newClientOptions.networkConfig) !== null && _newClientOptions$net !== void 0 && _newClientOptions$net.logEventUrl)) {
                    newClientOptions.networkConfig = _objectSpread(_objectSpread({}, newClientOptions.networkConfig), {}, {
                      logEventUrl: DEFAULT_EVENT_LOGGING_API
                    });
                  }
                  if (newClientOptions.perimeter === _types2.PerimeterType.FEDRAMP_MODERATE) {
                    newClientOptions.disableLogging = true;
                  }
                  sdkKey = newClientOptions.sdkKey, environment = newClientOptions.environment, _updateUserCompletionCallback = newClientOptions.updateUserCompletionCallback, _perimeter = newClientOptions.perimeter, restClientOptions = (0, _objectWithoutProperties2.default)(newClientOptions, _excluded);
                  this.sdkKey = sdkKey;
                  this.user = (0, _utils.toStatsigUser)(identifiers, customAttributes, this.sdkKey);
                  statsigOptions = _objectSpread(_objectSpread({}, restClientOptions), {}, {
                    environment: {
                      tier: environment
                    },
                    includeCurrentPageUrlWithEvents: false,
                    dataAdapter: this.dataAdapter,
                    overrideAdapter: this.overrideAdapter
                  });
                  _context9.prev = 12;
                  this.statsigClient = new _jsClient.StatsigClient(sdkKey, this.user, statsigOptions);
                  this.dataAdapter.setBootstrapData(initializeValues);
                  _context9.next = 17;
                  return this.statsigClient.initializeAsync();
                case 17:
                  _context9.next = 29;
                  break;
                case 19:
                  _context9.prev = 19;
                  _context9.t0 = _context9["catch"](12);
                  if (_context9.t0 instanceof Error) {
                    console.error("Error occurred when trying to initialise the Statsig client, error: ".concat(_context9.t0 === null || _context9.t0 === void 0 ? void 0 : _context9.t0.message));
                  }
                  console.warn("Initialising Statsig client with default sdk key and without values");
                  this.statsigClient = new _jsClient.StatsigClient(DEFAULT_CLIENT_KEY, this.user, statsigOptions);
                  this.dataAdapter.setBootstrapData();
                  _context9.next = 27;
                  return this.statsigClient.initializeAsync();
                case 27:
                  this.initWithDefaults = true;
                  throw _context9.t0;
                case 29:
                case "end":
                  return _context9.stop();
              }
            }, _callee9, this, [[12, 19]]);
          }));
          function initFromValues(_x25, _x26, _x27) {
            return _initFromValues.apply(this, arguments);
          }
          return initFromValues;
        })()
      }, {
        key: "updateUserUsingInitializeValuesProducer",
        value: (function() {
          var _updateUserUsingInitializeValuesProducer = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee11(getInitializeValues, identifiers, customAttributes) {
            var _this9 = this;
            var originalInitPromise, initializeValuesPromise, updateUserPromise;
            return _regenerator.default.wrap(function _callee11$(_context11) {
              while (1) switch (_context11.prev = _context11.next) {
                case 0:
                  this.assertInitialized(this.statsigClient);
                  if (this.initPromise) {
                    _context11.next = 3;
                    break;
                  }
                  throw new Error("The client must be initialized before you can update the user.");
                case 3:
                  if (!this.isCurrentUser(identifiers, customAttributes)) {
                    _context11.next = 5;
                    break;
                  }
                  return _context11.abrupt("return", this.initPromise);
                case 5:
                  originalInitPromise = this.initPromise;
                  _context11.prev = 6;
                  _context11.next = 9;
                  return this.initPromise;
                case 9:
                  _context11.next = 13;
                  break;
                case 11:
                  _context11.prev = 11;
                  _context11.t0 = _context11["catch"](6);
                case 13:
                  initializeValuesPromise = getInitializeValues();
                  updateUserPromise = this.updateStatsigClientUser(initializeValuesPromise, identifiers, customAttributes);
                  this.initPromise = updateUserPromise.catch(/* @__PURE__ */ (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee10() {
                    return _regenerator.default.wrap(function _callee10$(_context10) {
                      while (1) switch (_context10.prev = _context10.next) {
                        case 0:
                          _this9.initPromise = originalInitPromise;
                          if (!_this9.provider) {
                            _context10.next = 4;
                            break;
                          }
                          _context10.next = 4;
                          return _this9.provider.setProfile(_this9.initOptions, _this9.currentIdentifiers, _this9.currentAttributes);
                        case 4:
                        case "end":
                          return _context10.stop();
                      }
                    }, _callee10);
                  })));
                  return _context11.abrupt("return", updateUserPromise);
                case 17:
                case "end":
                  return _context11.stop();
              }
            }, _callee11, this, [[6, 11]]);
          }));
          function updateUserUsingInitializeValuesProducer(_x28, _x29, _x30) {
            return _updateUserUsingInitializeValuesProducer.apply(this, arguments);
          }
          return updateUserUsingInitializeValuesProducer;
        })()
      }, {
        key: "updateStatsigClientUser",
        value: (function() {
          var _updateStatsigClientUser = (0, _asyncToGenerator2.default)(/* @__PURE__ */ _regenerator.default.mark(function _callee12(initializeValuesPromise, identifiers, customAttributes) {
            var _this$initOptions, _this$initOptions$upd;
            var initializeValues, user, _updateUserCompletion, _ref4, errMsg, success, errorMessage;
            return _regenerator.default.wrap(function _callee12$(_context12) {
              while (1) switch (_context12.prev = _context12.next) {
                case 0:
                  this.assertInitialized(this.statsigClient);
                  _context12.prev = 1;
                  _context12.next = 4;
                  return initializeValuesPromise;
                case 4:
                  initializeValues = _context12.sent;
                  user = (0, _utils.toStatsigUser)(identifiers, initializeValues.customAttributesFromFetch, this.sdkKey);
                  _context12.next = 13;
                  break;
                case 8:
                  _context12.prev = 8;
                  _context12.t0 = _context12["catch"](1);
                  errMsg = _context12.t0 instanceof Error ? _context12.t0.message : JSON.stringify(_context12.t0);
                  (_updateUserCompletion = (_ref4 = this.initOptions).updateUserCompletionCallback) === null || _updateUserCompletion === void 0 || _updateUserCompletion.call(_ref4, false, errMsg);
                  throw _context12.t0;
                case 13:
                  success = true;
                  errorMessage = null;
                  _context12.prev = 15;
                  this.dataAdapter.setBootstrapData(initializeValues.experimentValues);
                  this.user = user;
                  _context12.next = 20;
                  return this.statsigClient.updateUserAsync(this.user);
                case 20:
                  _context12.next = 26;
                  break;
                case 22:
                  _context12.prev = 22;
                  _context12.t1 = _context12["catch"](15);
                  success = false;
                  errorMessage = String(_context12.t1);
                case 26:
                  (_this$initOptions = this.initOptions) === null || _this$initOptions === void 0 || (_this$initOptions$upd = _this$initOptions.updateUserCompletionCallback) === null || _this$initOptions$upd === void 0 || _this$initOptions$upd.call(_this$initOptions, success, errorMessage);
                  if (!success) {
                    _context12.next = 33;
                    break;
                  }
                  this.currentIdentifiers = identifiers;
                  this.currentAttributes = customAttributes;
                  this.subscriptions.anyUpdated();
                  _context12.next = 34;
                  break;
                case 33:
                  throw new Error("Failed to update user. An unexpected error occured.");
                case 34:
                case "end":
                  return _context12.stop();
              }
            }, _callee12, this, [[1, 8], [15, 22]]);
          }));
          function updateStatsigClientUser(_x31, _x32, _x33) {
            return _updateStatsigClientUser.apply(this, arguments);
          }
          return updateStatsigClientUser;
        })()
      }, {
        key: "getPackageVersion",
        value: (
          /**
           * @returns string version of the current package in semver style.
           */
          function getPackageVersion() {
            return _version.CLIENT_VERSION;
          }
        )
        /**
         * Returns a specified layer otherwise returns an empty layer as a default value if the layer doesn't exist.
         *
         * @param {string} layerName - The name of the layer
         * @param {Object} options
         * @param {boolean} options.fireLayerExposure - Whether or not to fire the exposure event for the
         * layer. Defaults to true. To log an exposure event manually at a later time, use
         * {@link Client.manuallyLogLayerExposure} (see [Statsig docs about manually logging exposures](https://docs.statsig.com/client/jsClientSDK#manual-exposures-)).
         * @returns A layer
         * @example
         * ```ts
         * const layer = client.getLayer('example-layer-name');
         * const exampletitle: string = layer.get("title", "Welcome to Statsig!");
         * ```
         */
      }, {
        key: "getLayer",
        value: function getLayer(layerName) {
          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          try {
            this.assertInitialized(this.statsigClient);
            var _options$fireLayerExp = options.fireLayerExposure, fireLayerExposure = _options$fireLayerExp === void 0 ? true : _options$fireLayerExp;
            return _Layer.Layer.fromLayer(this.statsigClient.getLayer(layerName, {
              disableExposureLog: !fireLayerExposure
            }));
          } catch (error) {
            if (!this.hasGetLayerErrorOccurred) {
              console.warn({
                msg: "An error has occurred getting the layer. Only the first occurrence of this error is logged.",
                layerName,
                error
              });
              this.hasGetLayerErrorOccurred = true;
            }
            return _Layer.Layer.fromLayer((0, _jsClient._makeLayer)(layerName, {
              reason: "Error"
            }, null));
          }
        }
        /**
         * Returns the value of a given parameter in a layer config.
         *
         * @template T
         * @param {string} layerName - The name of the layer
         * @param {string} parameterName - The name of the parameter to fetch from the layer config
         * @param {T} defaultValue - The value to serve if the layer or parameter do not exist, or if the
         * returned value does not match the expected type.
         * @param {Object} options
         * @param {boolean} options.fireLayerExposure - Whether or not to fire the exposure event for the
         * layer. Defaults to true. To log an exposure event manually at a later time, use
         * {@link Client.manuallyLogLayerExposure} (see [Statsig docs about manually logging exposures](https://docs.statsig.com/client/jsClientSDK#manual-exposures-))
         * @param {function} options.typeGuard - A function that asserts that the return value has the expected type. If this function returns false, then the default value will be returned instead. This can be set to protect your code from unexpected values being set remotely. By default, this will be done by asserting that the default value and value are the same primitive type.
         * @returns The value of the parameter if the layer and parameter both exist, otherwise the default value.
         * @example
         * ``` ts
         * type ValidColor = 'blue' | 'red' | 'yellow';
         * type ValidColorTypeCheck = (value: unknown) => value is ValidColor;
         *
         * const isValidColor: ValidColorTypeCheck =
         *    (value: unknown) => typeof value === 'string' && ['blue', 'red', 'yellow'].includes(value);
         *
         * const buttonColor: ValidColor = client.getLayerValue(
         *    'example-layer-name',
         *    'backgroundColor',
         *    'yellow',
         *    {
         *        typeGuard: isValidColor
         *    }
         * );
         * ```
         */
      }, {
        key: "getLayerValue",
        value: function getLayerValue(layerName, parameterName, defaultValue) {
          var options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
          var layer = this.getLayer(layerName, options);
          try {
            var typeGuard = options.typeGuard;
            return layer.get(parameterName, defaultValue, typeGuard);
          } catch (error) {
            if (!this.hasGetLayerValueErrorOccurred) {
              console.warn({
                msg: "An error has occurred getting the layer value. Only the first occurrence of this error is logged.",
                layerName,
                defaultValue,
                options,
                error
              });
              this.hasGetLayerValueErrorOccurred = true;
            }
            return defaultValue;
          }
        }
      }]);
    })();
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/FeatureGates.js
var require_FeatureGates = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/client/FeatureGates.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "CLIENT_VERSION", {
      enumerable: true,
      get: function get() {
        return _version.CLIENT_VERSION;
      }
    });
    Object.defineProperty(exports2, "DynamicConfig", {
      enumerable: true,
      get: function get() {
        return _DynamicConfig.DynamicConfig;
      }
    });
    Object.defineProperty(exports2, "EvaluationReason", {
      enumerable: true,
      get: function get() {
        return _types.EvaluationReason;
      }
    });
    Object.defineProperty(exports2, "FeatureGateEnvironment", {
      enumerable: true,
      get: function get() {
        return _types2.FeatureGateEnvironment;
      }
    });
    Object.defineProperty(exports2, "PerimeterType", {
      enumerable: true,
      get: function get() {
        return _types2.PerimeterType;
      }
    });
    exports2.default = void 0;
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _Client = require_Client();
    var _version = require_version();
    var _types = require_types2();
    var _DynamicConfig = require_DynamicConfig();
    var _types2 = require_types3();
    var _FeatureGates;
    var FeatureGates = /* @__PURE__ */ (function() {
      function FeatureGates2() {
        (0, _classCallCheck2.default)(this, FeatureGates2);
      }
      return (0, _createClass2.default)(FeatureGates2, null, [{
        key: "isGateExists",
        value: function isGateExists(gateName) {
          return this.client.isGateExist(gateName);
        }
      }, {
        key: "isExperimentExists",
        value: function isExperimentExists(experimentName) {
          return this.client.isExperimentExist(experimentName);
        }
      }]);
    })();
    _FeatureGates = FeatureGates;
    (0, _defineProperty2.default)(FeatureGates, "client", new _Client.Client());
    (0, _defineProperty2.default)(FeatureGates, "hasCheckGateErrorOccurred", false);
    (0, _defineProperty2.default)(FeatureGates, "hasGetExperimentValueErrorOccurred", false);
    (0, _defineProperty2.default)(FeatureGates, "checkGate", function(gateName, options) {
      try {
        if (typeof window !== "undefined" && window.__CRITERION__ && typeof window.__CRITERION__.getFeatureFlagOverride === "function") {
          var overrideValue = window.__CRITERION__.getFeatureFlagOverride(gateName);
          if (overrideValue !== void 0) {
            return overrideValue;
          }
        }
      } catch (error) {
        if (!_FeatureGates.hasCheckGateErrorOccurred) {
          console.warn({
            msg: "An error has occurred checking the feature gate from criterion override. Only the first occurrence of this error is logged.",
            gateName,
            error
          });
          _FeatureGates.hasCheckGateErrorOccurred = true;
        }
      }
      return _FeatureGates.client.checkGate(gateName, options);
    });
    (0, _defineProperty2.default)(FeatureGates, "getExperimentValue", function(experimentName, parameterName, defaultValue, options) {
      try {
        if (typeof window !== "undefined" && window.__CRITERION__ && typeof window.__CRITERION__.getExperimentValueOverride === "function") {
          var overrideValue = window.__CRITERION__.getExperimentValueOverride(experimentName, parameterName);
          if (overrideValue !== void 0 && overrideValue !== null) {
            return overrideValue;
          }
        }
      } catch (error) {
        if (!_FeatureGates.hasGetExperimentValueErrorOccurred) {
          console.warn({
            msg: "An error has occurred getting the experiment value from criterion override. Only the first occurrence of this error is logged.",
            experimentName,
            defaultValue,
            options,
            error
          });
          _FeatureGates.hasGetExperimentValueErrorOccurred = true;
        }
        return defaultValue;
      }
      return _FeatureGates.client.getExperimentValue(experimentName, parameterName, defaultValue, options);
    });
    (0, _defineProperty2.default)(FeatureGates, "initializeCalled", _FeatureGates.client.initializeCalled.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "initializeCompleted", _FeatureGates.client.initializeCompleted.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "initialize", _FeatureGates.client.initialize.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "initializeWithProvider", _FeatureGates.client.initializeWithProvider.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "initializeFromValues", _FeatureGates.client.initializeFromValues.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "manuallyLogGateExposure", _FeatureGates.client.manuallyLogGateExposure.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "getExperiment", _FeatureGates.client.getExperiment.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "manuallyLogExperimentExposure", _FeatureGates.client.manuallyLogExperimentExposure.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "manuallyLogLayerExposure", _FeatureGates.client.manuallyLogLayerExposure.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "shutdownStatsig", _FeatureGates.client.shutdownStatsig.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "overrideGate", _FeatureGates.client.overrideGate.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "clearGateOverride", _FeatureGates.client.clearGateOverride.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "overrideConfig", _FeatureGates.client.overrideConfig.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "clearConfigOverride", _FeatureGates.client.clearConfigOverride.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "setOverrides", _FeatureGates.client.setOverrides.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "getOverrides", _FeatureGates.client.getOverrides.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "clearAllOverrides", _FeatureGates.client.clearAllOverrides.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "isCurrentUser", _FeatureGates.client.isCurrentUser.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "onGateUpdated", _FeatureGates.client.onGateUpdated.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "onExperimentValueUpdated", _FeatureGates.client.onExperimentValueUpdated.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "onAnyUpdated", _FeatureGates.client.onAnyUpdated.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "updateUser", _FeatureGates.client.updateUser.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "updateUserWithProvider", _FeatureGates.client.updateUserWithProvider.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "updateUserWithValues", _FeatureGates.client.updateUserWithValues.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "getPackageVersion", _FeatureGates.client.getPackageVersion.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "getLayer", _FeatureGates.client.getLayer.bind(_FeatureGates.client));
    (0, _defineProperty2.default)(FeatureGates, "getLayerValue", _FeatureGates.client.getLayerValue.bind(_FeatureGates.client));
    var boundFGJS = FeatureGates;
    if (typeof window !== "undefined") {
      if (window.__FEATUREGATES_JS__ === void 0) {
        window.__FEATUREGATES_JS__ = FeatureGates;
      } else {
        boundFGJS = window.__FEATUREGATES_JS__;
        boundVersion = ((_boundFGJS = boundFGJS) === null || _boundFGJS === void 0 || (_boundFGJS$getPackage = _boundFGJS.getPackageVersion) === null || _boundFGJS$getPackage === void 0 ? void 0 : _boundFGJS$getPackage.call(_boundFGJS)) || "4.10.0 or earlier";
        if (boundVersion !== _version.CLIENT_VERSION) {
          message = "Multiple versions of FeatureGateClients found on the current page.\n      The currently bound version is ".concat(boundVersion, " when module version ").concat(_version.CLIENT_VERSION, " was loading.");
          console.warn(message);
        }
      }
    }
    var _boundFGJS;
    var _boundFGJS$getPackage;
    var boundVersion;
    var message;
    var _default = exports2.default = boundFGJS;
  }
});

// node_modules/@atlaskit/feature-gate-js-client/dist/cjs/index.js
var require_cjs2 = __commonJS({
  "node_modules/@atlaskit/feature-gate-js-client/dist/cjs/index.js"(exports2) {
    "use strict";
    var _typeof = require_typeof();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "CLIENT_VERSION", {
      enumerable: true,
      get: function get() {
        return _FeatureGates.CLIENT_VERSION;
      }
    });
    Object.defineProperty(exports2, "DynamicConfig", {
      enumerable: true,
      get: function get() {
        return _DynamicConfig.DynamicConfig;
      }
    });
    Object.defineProperty(exports2, "EvaluationReason", {
      enumerable: true,
      get: function get() {
        return _types.EvaluationReason;
      }
    });
    Object.defineProperty(exports2, "FeatureGateEnvironment", {
      enumerable: true,
      get: function get() {
        return _FeatureGates.FeatureGateEnvironment;
      }
    });
    Object.defineProperty(exports2, "Layer", {
      enumerable: true,
      get: function get() {
        return _Layer.Layer;
      }
    });
    Object.defineProperty(exports2, "PerimeterType", {
      enumerable: true,
      get: function get() {
        return _FeatureGates.PerimeterType;
      }
    });
    Object.defineProperty(exports2, "default", {
      enumerable: true,
      get: function get() {
        return _FeatureGates.default;
      }
    });
    var _FeatureGates = _interopRequireWildcard(require_FeatureGates());
    var _DynamicConfig = require_DynamicConfig();
    var _Layer = require_Layer();
    var _types = require_types2();
    function _getRequireWildcardCache(e) {
      if ("function" != typeof WeakMap) return null;
      var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
      return (_getRequireWildcardCache = function _getRequireWildcardCache2(e2) {
        return e2 ? t : r;
      })(e);
    }
    function _interopRequireWildcard(e, r) {
      if (!r && e && e.__esModule) return e;
      if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e };
      var t = _getRequireWildcardCache(r);
      if (t && t.has(e)) return t.get(e);
      var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor;
      for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
        var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
        i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
      }
      return n.default = e, t && t.set(e, n), n;
    }
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/utils/editor-palette.js
var require_editor_palette = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/utils/editor-palette.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.editorTextPalette = exports2.editorBorderPalette = exports2.editorBackgroundPalette = void 0;
    exports2.hexToEditorBackgroundPaletteRawValue = hexToEditorBackgroundPaletteRawValue;
    exports2.hexToEditorBorderPaletteColor = hexToEditorBorderPaletteColor;
    exports2.hexToEditorTextBackgroundPaletteColor = hexToEditorTextBackgroundPaletteColor;
    exports2.hexToEditorTextPaletteColor = hexToEditorTextPaletteColor;
    exports2.textBackgroundColorPalette = void 0;
    var _featureGateJsClient = _interopRequireDefault(require_cjs2());
    function hexToEditorBorderPaletteColor(hexColor) {
      return hexColor ? editorBorderPalette[hexColor.toUpperCase()] : void 0;
    }
    var editorBorderPalette = exports2.editorBorderPalette = {
      /** gray - subtle */
      "#091E4224": "var(--ds-border, #091E4224)",
      /** gray */
      "#758195": "var(--ds-border-bold, #758195)",
      /** gray - bold */
      "#172B4D": "var(--ds-text, #172B4D)"
    };
    function hexToEditorTextPaletteColor(hexColor) {
      return hexColor ? editorTextPalette[hexColor.toUpperCase()] : void 0;
    }
    var editorTextPalette = exports2.editorTextPalette = {
      /** blue - light */
      "#B3D4FF": "var(--ds-background-accent-blue-subtler, #B3D4FF)",
      /** blue - medium */
      "#4C9AFF": "var(--ds-icon-accent-blue, #4C9AFF)",
      /** blue - strong */
      "#0747A6": "var(--ds-text-accent-blue, #0747A6)",
      /** teal - light */
      "#B3F5FF": "var(--ds-background-accent-teal-subtler, #B3F5FF)",
      /** teal - medium */
      "#00B8D9": "var(--ds-icon-accent-teal, #00B8D9)",
      /** teal - strong */
      "#008DA6": "var(--ds-text-accent-teal, #008DA6)",
      /** green - light */
      "#ABF5D1": "var(--ds-background-accent-green-subtler, #ABF5D1)",
      /** green - medium */
      "#36B37E": "var(--ds-icon-accent-green, #36B37E)",
      /** green - strong */
      "#006644": "var(--ds-text-accent-green, #006644)",
      /** yellowOrange - light */
      "#FFF0B3": "var(--ds-background-accent-yellow-subtler, #FFF0B3)",
      /** yellowOrange - medium */
      "#FFC400": "var(--ds-background-accent-orange-subtle, #FFC400)",
      /** yellowOrange - strong */
      "#FF991F": "var(--ds-icon-accent-orange, #FF991F)",
      /** red - light */
      "#FFBDAD": "var(--ds-background-accent-red-subtler, #FFBDAD)",
      /** red - medium */
      "#FF5630": "var(--ds-icon-accent-red, #FF5630)",
      /** red - strong */
      "#BF2600": "var(--ds-text-accent-red, #BF2600)",
      /** purple - light */
      "#EAE6FF": "var(--ds-background-accent-purple-subtler, #EAE6FF)",
      /** purple - medium */
      "#6554C0": "var(--ds-icon-accent-purple, #6554C0)",
      /** purple - strong */
      "#403294": "var(--ds-text-accent-purple, #403294)",
      /** whiteGray - light */
      "#FFFFFF": "var(--ds-text-inverse, #FFFFFF)",
      /** whiteGray - medium */
      "#97A0AF": "var(--ds-icon-accent-gray, #97A0AF)",
      /** whiteGray - strong */
      "#172B4D": "var(--ds-text, #172B4D)"
    };
    function hexToEditorTextBackgroundPaletteColor(hexColor) {
      if (_featureGateJsClient.default.getExperimentValue("platform_editor_add_orange_highlight_color", "cohort", "control") !== "test") {
        textBackgroundColorPalette["#FEDEC8"] = "var(--ds-background-accent-yellow-subtler, #F8E6A0)";
      }
      return hexColor ? textBackgroundColorPalette[hexColor.toUpperCase()] : void 0;
    }
    var textBackgroundColorPalette = exports2.textBackgroundColorPalette = {
      /** Gray - light */
      "#DCDFE4": "var(--ds-background-accent-gray-subtler, #DCDFE4)",
      /** Teal - light */
      "#C6EDFB": "var(--ds-background-accent-teal-subtler, #C6EDFB)",
      /** Lime - light */
      "#D3F1A7": "var(--ds-background-accent-lime-subtler, #D3F1A7)",
      /** Yellow - light */
      "#F8E6A0": "var(--ds-background-accent-yellow-subtler, #F8E6A0)",
      /** Orange - light */
      "#FEDEC8": "var(--ds-background-accent-orange-subtler, #FEDEC8)",
      /** Magenta - light */
      "#FDD0EC": "var(--ds-background-accent-magenta-subtler, #FDD0EC)",
      /** Purple - light */
      "#DFD8FD": "var(--ds-background-accent-purple-subtler, #DFD8FD)"
    };
    function hexToEditorBackgroundPaletteRawValue(hexColor) {
      var tokenData = hexColor ? editorBackgroundPalette[hexColor.toUpperCase()] : void 0;
      return tokenData ? tokenData.getValue(hexColor) : void 0;
    }
    var editorBackgroundPalette = exports2.editorBackgroundPalette = {
      /** blue - light */
      "#DEEBFF": {
        getValue: function getValue() {
          return "#DEEBFF";
        },
        token: "var(--ds-background-accent-blue-subtlest, #DEEBFF)"
      },
      /** blue - medium */
      "#B3D4FF": {
        getValue: function getValue() {
          return "#B3D4FF";
        },
        token: "var(--ds-background-accent-blue-subtler, #B3D4FF)"
      },
      /** blue - strong */
      "#4C9AFF": {
        getValue: function getValue() {
          return "#4C9AFF";
        },
        token: "var(--ds-background-accent-blue-subtle, #4C9AFF)"
      },
      /** teal - light */
      "#E6FCFF": {
        getValue: function getValue() {
          return "#E6FCFF";
        },
        token: "var(--ds-background-accent-teal-subtlest, #E6FCFF)"
      },
      /** teal - medium */
      "#B3F5FF": {
        getValue: function getValue() {
          return "#B3F5FF";
        },
        token: "var(--ds-background-accent-teal-subtler, #B3F5FF)"
      },
      /** teal - strong */
      "#79E2F2": {
        getValue: function getValue() {
          return "#79E2F2";
        },
        token: "var(--ds-background-accent-teal-subtle, #79E2F2)"
      },
      /** green - light */
      "#E3FCEF": {
        getValue: function getValue() {
          return "#E3FCEF";
        },
        token: "var(--ds-background-accent-green-subtlest, #E3FCEF)"
      },
      /** green - medium */
      "#ABF5D1": {
        getValue: function getValue() {
          return "#ABF5D1";
        },
        token: "var(--ds-background-accent-green-subtler, #ABF5D1)"
      },
      /** green - strong */
      "#57D9A3": {
        getValue: function getValue() {
          return "#57D9A3";
        },
        token: "var(--ds-background-accent-green-subtle, #57D9A3)"
      },
      /** yellowOrange - light */
      "#FFFAE6": {
        getValue: function getValue() {
          return "#FFFAE6";
        },
        token: "var(--ds-background-accent-yellow-subtlest, #FFFAE6)"
      },
      /** yellowOrange - medium */
      "#FFF0B3": {
        getValue: function getValue() {
          return "#FFF0B3";
        },
        token: "var(--ds-background-accent-yellow-subtler, #FFF0B3)"
      },
      /** yellowOrange - strong */
      "#FFC400": {
        getValue: function getValue() {
          return "#FFC400";
        },
        token: "var(--ds-background-accent-orange-subtle, #FFC400)"
      },
      /** red - light */
      "#FFEBE6": {
        getValue: function getValue() {
          return "#FFEBE6";
        },
        token: "var(--ds-background-accent-red-subtlest, #FFEBE6)"
      },
      /** red - medium */
      "#FFBDAD": {
        getValue: function getValue() {
          return "#FFBDAD";
        },
        token: "var(--ds-background-accent-red-subtler, #FFBDAD)"
      },
      /** red - strong */
      "#FF8F73": {
        getValue: function getValue() {
          return "#FF8F73";
        },
        token: "var(--ds-background-accent-red-subtle, #FF8F73)"
      },
      /** purple - light */
      "#EAE6FF": {
        getValue: function getValue() {
          return "#EAE6FF";
        },
        token: "var(--ds-background-accent-purple-subtlest, #EAE6FF)"
      },
      /** purple - medium */
      "#C0B6F2": {
        getValue: function getValue() {
          return "#C0B6F2";
        },
        token: "var(--ds-background-accent-purple-subtler, #C0B6F2)"
      },
      /** purple - strong */
      "#998DD9": {
        getValue: function getValue() {
          return "#998DD9";
        },
        token: "var(--ds-background-accent-purple-subtle, #998DD9)"
      },
      /** whiteGray - light */
      "#FFFFFF": {
        getValue: function getValue() {
          return "#FFFFFF";
        },
        token: "var(--ds-surface, #FFFFFF)"
      },
      /** whiteGray - medium */
      "#F4F5F7": {
        getValue: function getValue() {
          return "#F4F5F7";
        },
        token: "var(--ds-background-accent-gray-subtlest, #F4F5F7)"
      },
      /** whiteGray - strong */
      "#B3BAC5": {
        getValue: function getValue() {
          return "#B3BAC5";
        },
        token: "var(--ds-background-accent-gray-subtle, #B3BAC5)"
      }
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/tableNodes.js
var require_tableNodes = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/tableNodes.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.toJSONTableHeader = exports2.toJSONTableCell = exports2.tableWithNestedTable = exports2.tableWithCustomWidth = exports2.tableToJSON = exports2.tableStage0 = exports2.tableRowWithNestedTableWithLocalId = exports2.tableRowWithNestedTable = exports2.tableRowWithLocalId = exports2.tableRow = exports2.tablePrefixSelector = exports2.tableHeaderWithNestedTableWithLocalId = exports2.tableHeaderWithNestedTable = exports2.tableHeaderWithLocalId = exports2.tableHeaderSelector = exports2.tableHeader = exports2.tableCellWithNestedTableWithLocalId = exports2.tableCellWithNestedTable = exports2.tableCellWithLocalId = exports2.tableCellSelector = exports2.tableCellContentWrapperSelector = exports2.tableCellContentDomSelector = exports2.tableCell = exports2.tableBackgroundColorPalette = exports2.tableBackgroundColorNames = exports2.tableBackgroundBorderColor = exports2.table = exports2.setGlobalTheme = exports2.getCellDomAttrs = exports2.getCellAttrs = void 0;
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _editorPalette = require_editor_palette();
    var _colors = require_colors();
    var _uuid = require_uuid();
    var _lchColorInversion = require_lch_color_inversion();
    var _nodeTypes = require_nodeTypes();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var tablePrefixSelector = exports2.tablePrefixSelector = "pm-table";
    var tableCellSelector = exports2.tableCellSelector = "".concat(tablePrefixSelector, "-cell-content-wrap");
    var tableHeaderSelector = exports2.tableHeaderSelector = "".concat(tablePrefixSelector, "-header-content-wrap");
    var tableCellContentWrapperSelector = exports2.tableCellContentWrapperSelector = "".concat(tablePrefixSelector, "-cell-nodeview-wrapper");
    var tableCellContentDomSelector = exports2.tableCellContentDomSelector = "".concat(tablePrefixSelector, "-cell-nodeview-content-dom");
    var DEFAULT_TABLE_HEADER_CELL_BACKGROUND = _colors.N20.toLocaleLowerCase();
    var getCellAttrs = exports2.getCellAttrs = function getCellAttrs2(dom) {
      var defaultValues = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
      var widthAttr = dom.getAttribute("data-colwidth");
      var width = widthAttr && /^\d+(,\d+)*$/.test(widthAttr) ? widthAttr.split(",").map(function(str) {
        return Number(str);
      }) : null;
      var colspan = Number(dom.getAttribute("colspan") || 1);
      var backgroundColor = dom.style.backgroundColor;
      var dataCellBackground = dom.getAttribute("data-cell-background");
      var dataCellBackgroundHexCode = dataCellBackground && (0, _colors.isHex)(dataCellBackground) ? dataCellBackground : void 0;
      if (backgroundColor.includes("--ds-background-neutral")) {
        backgroundColor = "";
      } else {
        if (backgroundColor && (0, _colors.isRgb)(backgroundColor)) {
          var result = (0, _colors.rgbToHex)(backgroundColor);
          if (result !== null) {
            backgroundColor = result;
          }
        }
      }
      var backgroundHexCode = dataCellBackgroundHexCode || (backgroundColor && backgroundColor !== defaultValues["background"] ? backgroundColor : null);
      var localId = defaultValues === null || defaultValues === void 0 ? void 0 : defaultValues.localId;
      return _objectSpread({
        colspan,
        rowspan: Number(dom.getAttribute("rowspan") || 1),
        colwidth: width && width.length === colspan ? width : null,
        background: backgroundHexCode
      }, localId && {
        localId
      });
    };
    var testGlobalTheme;
    var setGlobalTheme = exports2.setGlobalTheme = function setGlobalTheme2(theme) {
      testGlobalTheme = theme;
    };
    var getGlobalTheme = function getGlobalTheme2() {
      if (testGlobalTheme) {
        return {
          colorMode: testGlobalTheme
        };
      }
      var element = document.documentElement;
      var colorMode = element.getAttribute("data-color-mode") || "";
      return {
        colorMode
      };
    };
    var cssVariablePattern = /^var\(--.*\)$/;
    var getCellDomAttrs = exports2.getCellDomAttrs = function getCellDomAttrs2(node) {
      var _node$attrs;
      var attrs = {};
      var nodeType = node.type.name;
      if (node.attrs.colspan !== 1) {
        attrs.colspan = node.attrs.colspan;
      }
      if (node.attrs.rowspan !== 1) {
        attrs.rowspan = node.attrs.rowspan;
      }
      if (node.attrs.colwidth) {
        attrs["data-colwidth"] = node.attrs.colwidth.join(",");
      }
      if (node.attrs.background) {
        var background = node.attrs.background;
        var ignored = nodeType === "tableHeader" && background === tableBackgroundColorNames.get("light gray") || nodeType === "tableCell" && background === tableBackgroundColorNames.get("white") || nodeType === "tableHeader" && background.includes("--ds-background-neutral");
        if (ignored) {
          attrs.style = "";
        } else {
          var color = (0, _colors.isRgb)(background) && (0, _colors.rgbToHex)(background) ? (0, _colors.rgbToHex)(background) : background;
          var tokenColor = (0, _editorPalette.hexToEditorBackgroundPaletteRawValue)(color);
          if (tokenColor) {
            attrs.style = "background-color: ".concat(tokenColor, ";");
          } else if (
            /**
             * There was previously a bug in dark mode where we would attempt to invert
             * a design token in `getDarkModeLCHColor` causing issues.
             * If it's a design token we should return it as is.
             */
            cssVariablePattern.test(color)
          ) {
            attrs.style = "background-color: ".concat(color, ";");
          } else {
            if (getGlobalTheme().colorMode === "dark") {
              attrs.style = "background-color: ".concat((0, _lchColorInversion.getDarkModeLCHColor)(color), ";");
            } else {
              attrs.style = "background-color: ".concat(background, ";");
            }
          }
          if (color) {
            attrs["data-cell-background"] = color;
          }
          if (typeof color === "string") {
            attrs.colorname = tableBackgroundColorPalette.get(color.toLowerCase());
          }
        }
      }
      if (nodeType === "tableHeader") {
        attrs.class = tableHeaderSelector;
      } else {
        attrs.class = tableCellSelector;
      }
      if (node !== null && node !== void 0 && (_node$attrs = node.attrs) !== null && _node$attrs !== void 0 && _node$attrs.localId) {
        attrs["data-local-id"] = node.attrs.localId;
      }
      return attrs;
    };
    var tableBackgroundColorPalette = exports2.tableBackgroundColorPalette = /* @__PURE__ */ new Map();
    var tableBackgroundBorderColor = exports2.tableBackgroundBorderColor = (0, _colors.hexToRgba)(_colors.N800, 0.12) || _colors.N0;
    var tableBackgroundColorNames = exports2.tableBackgroundColorNames = /* @__PURE__ */ new Map();
    [[_colors.N0, "White"], [_colors.B50, "Light blue"], [_colors.T50, "Light teal"], [_colors.G50, "Light green"], [_colors.Y50, "Light yellow"], [_colors.R50, "Light red"], [_colors.P50, "Light purple"], [_colors.N20, "Light gray"], [_colors.B75, "Blue"], [_colors.T75, "Teal"], [_colors.G75, "Green"], [_colors.Y75, "Yellow"], [_colors.R75, "Red"], [_colors.P75, "Purple"], [_colors.N60, "Gray"], [_colors.B100, "Dark blue"], [_colors.T100, "Dark teal"], [_colors.G200, "Dark green"], [_colors.Y200, "Dark yellow"], [_colors.R100, "Dark red"], [_colors.P100, "Dark purple"]].forEach(function(_ref) {
      var _ref2 = (0, _slicedToArray2.default)(_ref, 2), colorValue = _ref2[0], colorName = _ref2[1];
      tableBackgroundColorPalette.set(colorValue.toLowerCase(), colorName);
      tableBackgroundColorNames.set(colorName.toLowerCase(), colorValue.toLowerCase());
    });
    var tableNodeSpecOptions = {
      parseDOM: [{
        tag: "table",
        getAttrs: function getAttrs(node) {
          var _dom$parentElement;
          var dom = node;
          var breakoutWrapper = (_dom$parentElement = dom.parentElement) === null || _dom$parentElement === void 0 ? void 0 : _dom$parentElement.parentElement;
          return {
            isNumberColumnEnabled: dom.getAttribute("data-number-column") === "true",
            layout: (
              // copying from editor
              dom.getAttribute("data-layout") || // copying from renderer
              (breakoutWrapper === null || breakoutWrapper === void 0 ? void 0 : breakoutWrapper.getAttribute("data-layout")) || "default"
            ),
            __autoSize: dom.getAttribute("data-autosize") === "true",
            localId: dom.getAttribute("data-table-local-id") || _uuid.uuid.generate(),
            width: Number(dom.getAttribute("data-table-width")) || null,
            displayMode: dom.getAttribute("data-table-display-mode") || null
          };
        }
      }],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-number-column": node.attrs.isNumberColumnEnabled,
          "data-layout": node.attrs.layout,
          "data-autosize": node.attrs.__autoSize,
          "data-table-local-id": node.attrs.localId,
          "data-table-width": node.attrs.width,
          "data-table-display-mode": node.attrs.displayMode
        };
        return ["table", attrs, ["tbody", 0]];
      }
    };
    var createTableSpec = function createTableSpec2() {
      return (0, _nodeTypes.table)(tableNodeSpecOptions);
    };
    var table = exports2.table = createTableSpec();
    var tableWithCustomWidth = exports2.tableWithCustomWidth = createTableSpec();
    var tableStage0 = exports2.tableStage0 = createTableSpec();
    var shouldIncludeAttribute = function shouldIncludeAttribute2(key, value) {
      return !key.startsWith("__") && (key !== "localId" || !!value);
    };
    var tableToJSON = exports2.tableToJSON = function tableToJSON2(node) {
      return {
        attrs: Object.keys(node.attrs).filter(function(key) {
          return shouldIncludeAttribute(key, node.attrs[key]);
        }).reduce(function(obj, key) {
          return _objectSpread(_objectSpread({}, obj), {}, (0, _defineProperty2.default)({}, key, node.attrs[key]));
        }, {})
      };
    };
    var tableRowNodeSpecOptions = {
      parseDOM: [{
        tag: "tr"
      }],
      toDOM: function toDOM() {
        return ["tr", 0];
      }
    };
    var tableRow = exports2.tableRow = (0, _nodeTypes.tableRow)(tableRowNodeSpecOptions);
    var cellAttrs = {
      colspan: {
        default: 1
      },
      rowspan: {
        default: 1
      },
      colwidth: {
        default: null
      },
      background: {
        default: null
      },
      localId: {
        default: null,
        optional: true
      }
    };
    var tableCellNodeSpecOptions = {
      parseDOM: [
        // Ignore number cell copied from renderer
        {
          tag: ".ak-renderer-table-number-column",
          ignore: true
        },
        {
          tag: "td",
          getAttrs: function getAttrs(dom) {
            return getCellAttrs(dom);
          }
        }
      ],
      toDOM: function toDOM(node) {
        return ["td", getCellDomAttrs(node), 0];
      }
    };
    var tableCell = exports2.tableCell = (0, _nodeTypes.tableCell)(tableCellNodeSpecOptions);
    var toJSONTableCell = exports2.toJSONTableCell = function toJSONTableCell2(node) {
      return {
        attrs: Object.keys(node.attrs).reduce(function(obj, key) {
          if (cellAttrs[key] && cellAttrs[key].default !== node.attrs[key]) {
            obj[key] = node.attrs[key];
          }
          return obj;
        }, {})
      };
    };
    var tableHeaderNodeSpecOptions = {
      parseDOM: [{
        tag: "th",
        getAttrs: function getAttrs(dom) {
          return getCellAttrs(dom, {
            background: DEFAULT_TABLE_HEADER_CELL_BACKGROUND
          });
        }
      }],
      toDOM: function toDOM(node) {
        return ["th", getCellDomAttrs(node), 0];
      }
    };
    var tableHeader = exports2.tableHeader = (0, _nodeTypes.tableHeader)(tableHeaderNodeSpecOptions);
    var toJSONTableHeader = exports2.toJSONTableHeader = toJSONTableCell;
    var tableWithNestedTable = exports2.tableWithNestedTable = (0, _nodeTypes.tableWithNestedTable)(tableNodeSpecOptions);
    var tableRowWithNestedTable = exports2.tableRowWithNestedTable = (0, _nodeTypes.tableRowWithNestedTable)(tableRowNodeSpecOptions);
    var tableCellWithNestedTable = exports2.tableCellWithNestedTable = (0, _nodeTypes.tableCellWithNestedTable)(tableCellNodeSpecOptions);
    var tableHeaderWithNestedTable = exports2.tableHeaderWithNestedTable = (0, _nodeTypes.tableHeaderWithNestedTable)(tableHeaderNodeSpecOptions);
    var tableRowNodeSpecOptionsWithLocalId = {
      parseDOM: [{
        tag: "tr",
        getAttrs: function getAttrs() {
          return {
            localId: _uuid.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs2;
        return ["tr", {
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs2 = node.attrs) === null || _node$attrs2 === void 0 ? void 0 : _node$attrs2.localId) || void 0
        }, 0];
      }
    };
    var tableRowWithLocalId = exports2.tableRowWithLocalId = (0, _nodeTypes.tableRow)(tableRowNodeSpecOptionsWithLocalId);
    var tableCellNodeSpecOptionsWithLocalId = {
      parseDOM: [{
        tag: "td",
        getAttrs: function getAttrs(dom) {
          return getCellAttrs(dom, {
            localId: _uuid.uuid.generate()
          });
        }
      }],
      toDOM: function toDOM(node) {
        return ["td", getCellDomAttrs(node), 0];
      }
    };
    var tableCellWithLocalId = exports2.tableCellWithLocalId = (0, _nodeTypes.tableCell)(tableCellNodeSpecOptionsWithLocalId);
    var tableHeaderNodeSpecOptionsWithLocalId = {
      parseDOM: [{
        tag: "th",
        getAttrs: function getAttrs(dom) {
          return getCellAttrs(dom, {
            background: DEFAULT_TABLE_HEADER_CELL_BACKGROUND,
            localId: _uuid.uuid.generate()
          });
        }
      }],
      toDOM: function toDOM(node) {
        return ["th", getCellDomAttrs(node), 0];
      }
    };
    var tableHeaderWithLocalId = exports2.tableHeaderWithLocalId = (0, _nodeTypes.tableHeader)(tableHeaderNodeSpecOptionsWithLocalId);
    var tableRowWithNestedTableWithLocalId = exports2.tableRowWithNestedTableWithLocalId = (0, _nodeTypes.tableRowWithNestedTable)(tableRowNodeSpecOptionsWithLocalId);
    var tableCellWithNestedTableWithLocalId = exports2.tableCellWithNestedTableWithLocalId = (0, _nodeTypes.tableCellWithNestedTable)(tableCellNodeSpecOptionsWithLocalId);
    var tableHeaderWithNestedTableWithLocalId = exports2.tableHeaderWithNestedTableWithLocalId = (0, _nodeTypes.tableHeaderWithNestedTable)(tableHeaderNodeSpecOptionsWithLocalId);
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/decision-list.js
var require_decision_list = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/decision-list.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.decisionListSelector = exports2.decisionList = void 0;
    var _uuid = require_uuid();
    var _nodeTypes = require_nodeTypes();
    var name = "decisionList";
    var decisionListSelector = exports2.decisionListSelector = '[data-node-type="'.concat(name, '"]');
    var decisionList = exports2.decisionList = (0, _nodeTypes.decisionList)({
      parseDOM: [{
        tag: "ol".concat(decisionListSelector),
        // Default priority is 50. We normally don't change this but since this node type is
        // also used by ordered-list we need to make sure that we run this parser first.
        priority: 100,
        getAttrs: function getAttrs() {
          return {
            localId: _uuid.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var localId = node.attrs.localId;
        var attrs = {
          "data-node-type": name,
          "data-decision-list-local-id": localId || "local-decision-list",
          style: "list-style: none; padding-left: 0"
        };
        return ["ol", attrs, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/decision-item.js
var require_decision_item = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/decision-item.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.decisionItem = void 0;
    var _uuid = require_uuid();
    var _nodeTypes = require_nodeTypes();
    var decisionItem = exports2.decisionItem = (0, _nodeTypes.decisionItem)({
      parseDOM: [{
        tag: "li[data-decision-local-id]",
        // Default priority is 50. We normally don't change this but since this node type is
        // also used by list-item we need to make sure that we run this parser first.
        priority: 100,
        getAttrs: function getAttrs(dom) {
          return {
            localId: _uuid.uuid.generate(),
            state: dom.getAttribute("data-decision-state")
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs = node.attrs, localId = _node$attrs.localId, state = _node$attrs.state;
        var attrs = {
          "data-decision-local-id": localId || "local-decision",
          "data-decision-state": state
        };
        return ["li", attrs, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/task-list.js
var require_task_list = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/task-list.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.taskListSelector = exports2.taskList = void 0;
    var _uuid = require_uuid();
    var _nodeTypes = require_nodeTypes();
    var name = "actionList";
    var taskListSelector = exports2.taskListSelector = '[data-node-type="'.concat(name, '"]');
    var taskList = exports2.taskList = (0, _nodeTypes.taskList)({
      parseDOM: [{
        tag: "div".concat(taskListSelector),
        // Default priority is 50. We normally don't change this but since this node type is
        // also used by ordered-list we need to make sure that we run this parser first.
        priority: 100,
        getAttrs: function getAttrs() {
          return {
            localId: _uuid.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var localId = node.attrs.localId;
        var attrs = {
          "data-node-type": name,
          "data-task-list-local-id": localId || "local-task-list",
          style: "list-style: none; padding-left: 0"
        };
        return ["div", attrs, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/task-item.js
var require_task_item = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/task-item.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.taskItem = exports2.blockTaskItem = void 0;
    var _uuid = require_uuid();
    var _nodeTypes = require_nodeTypes();
    var taskItem = exports2.taskItem = (0, _nodeTypes.taskItem)({
      parseDOM: [{
        tag: "div[data-task-local-id]",
        // Default priority is 50. We normally don't change this but since this node type is
        // also used by list-item we need to make sure that we run this parser first.
        priority: 100,
        getAttrs: function getAttrs(dom) {
          return {
            localId: _uuid.uuid.generate(),
            state: dom.getAttribute("data-task-state") || "TODO"
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs = node.attrs, localId = _node$attrs.localId, state = _node$attrs.state;
        var attrs = {
          "data-task-local-id": localId || "local-task",
          "data-task-state": state || "TODO"
        };
        return ["div", attrs, 0];
      }
    });
    var blockTaskItem = exports2.blockTaskItem = (0, _nodeTypes.blockTaskItem)({
      parseDOM: [{
        tag: "div[data-task-is-block]",
        // Default priority is 50. We normally don't change this but since this node type is
        // also used by list-item we need to make sure that we run this parser first.
        priority: 100,
        getAttrs: function getAttrs(dom) {
          return {
            localId: _uuid.uuid.generate(),
            state: dom.getAttribute("data-task-state") || "TODO"
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs2 = node.attrs, localId = _node$attrs2.localId, state = _node$attrs2.state;
        var attrs = {
          "data-task-local-id": localId || "local-task",
          "data-task-state": state || "TODO",
          "data-task-is-block": "true"
        };
        return ["div", attrs, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/date.js
var require_date = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/date.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.dateWithLocalId = exports2.date = void 0;
    var _nodeTypes = require_nodeTypes();
    var _utils = require_utils();
    var date = exports2.date = (0, _nodeTypes.date)({
      parseDOM: [{
        tag: 'span[data-node-type="date"]',
        getAttrs: function getAttrs(dom) {
          return {
            timestamp: dom.getAttribute("data-timestamp")
          };
        }
      }],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-node-type": "date",
          "data-timestamp": node.attrs.timestamp
        };
        return ["span", attrs];
      }
    });
    var dateWithLocalId = exports2.dateWithLocalId = (0, _nodeTypes.date)({
      parseDOM: [{
        tag: 'span[data-node-type="date"]',
        getAttrs: function getAttrs(dom) {
          return {
            timestamp: dom.getAttribute("data-timestamp"),
            localId: _utils.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var attrs = {
          "data-node-type": "date",
          "data-timestamp": node.attrs.timestamp,
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        };
        return ["span", attrs];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/placeholder.js
var require_placeholder = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/placeholder.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.placeholderWithLocalId = exports2.placeholder = void 0;
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    var placeholder = exports2.placeholder = (0, _nodeTypes.placeholder)({
      parseDOM: [{
        tag: "span[data-placeholder]",
        getAttrs: function getAttrs(dom) {
          return {
            text: dom.getAttribute("data-placeholder") || placeholder.attrs.text.default
          };
        }
      }],
      toDOM: function toDOM(node) {
        var text = node.attrs.text;
        var attrs = {
          "data-placeholder": text,
          // Needs to be edtiable for mobile to not close keyboard
          contenteditable: "true"
        };
        return ["span", attrs, text];
      }
    });
    var placeholderWithLocalId = exports2.placeholderWithLocalId = (0, _nodeTypes.placeholder)({
      parseDOM: [{
        tag: "span[data-placeholder]",
        getAttrs: function getAttrs(dom) {
          return {
            text: dom.getAttribute("data-placeholder") || placeholder.attrs.text.default,
            localId: _uuid.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var text = node.attrs.text;
        var attrs = {
          "data-placeholder": text,
          // Needs to be edtiable for mobile to not close keyboard
          contenteditable: "true",
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        };
        return ["span", attrs, text];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/layout-section.js
var require_layout_section = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/layout-section.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.layoutSectionWithSingleColumnLocalId = exports2.layoutSectionWithSingleColumn = exports2.layoutSectionWithLocalId = exports2.layoutSectionFull = exports2.layoutSection = void 0;
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    var layoutSection = exports2.layoutSection = (0, _nodeTypes.layoutSection)({
      parseDOM: [{
        context: "layoutSection//|layoutColumn//",
        tag: "div[data-layout-section]",
        skip: true
      }, {
        tag: "div[data-layout-section]"
      }],
      toDOM: function toDOM() {
        var attrs = {
          "data-layout-section": "true"
        };
        return ["div", attrs, 0];
      }
    });
    var layoutSectionFull = exports2.layoutSectionFull = (0, _nodeTypes.layoutSectionFull)({
      parseDOM: [{
        context: "layoutSection//|layoutColumn//",
        tag: "div[data-layout-section]",
        skip: true
      }, {
        tag: "div[data-layout-section]"
      }],
      toDOM: function toDOM() {
        var attrs = {
          "data-layout-section": "true"
        };
        return ["div", attrs, 0];
      }
    });
    var layoutSectionWithSingleColumn = exports2.layoutSectionWithSingleColumn = (0, _nodeTypes.layoutSectionWithSingleColumnStage0)({
      parseDOM: [{
        context: "layoutSection//|layoutColumn//",
        tag: "div[data-layout-section]",
        skip: true
      }, {
        tag: "div[data-layout-section]",
        getAttrs: function getAttrs(dom) {
          var columnRuleStyle = dom.getAttribute("data-column-rule-style");
          return columnRuleStyle ? {
            columnRuleStyle
          } : {};
        }
      }],
      toDOM: function toDOM(node) {
        var columnRuleStyle = node.attrs.columnRuleStyle;
        var attrs = {
          "data-layout-section": "true",
          "data-column-rule-style": columnRuleStyle || void 0
        };
        return ["div", attrs, 0];
      }
    });
    var layoutSectionWithLocalId = exports2.layoutSectionWithLocalId = (0, _nodeTypes.layoutSection)({
      parseDOM: [{
        context: "layoutSection//|layoutColumn//",
        tag: "div[data-layout-section]",
        skip: true
      }, {
        tag: "div[data-layout-section]",
        getAttrs: function getAttrs() {
          var localId = _uuid.uuid.generate();
          return {
            localId
          };
        }
      }],
      toDOM: function toDOM(node) {
        var localId = node.attrs.localId;
        var attrs = {
          "data-layout-section": "true",
          "data-local-id": localId
        };
        return ["div", attrs, 0];
      }
    });
    var layoutSectionWithSingleColumnLocalId = exports2.layoutSectionWithSingleColumnLocalId = (0, _nodeTypes.layoutSectionWithSingleColumnStage0)({
      parseDOM: [{
        context: "layoutSection//|layoutColumn//",
        tag: "div[data-layout-section]",
        skip: true
      }, {
        tag: "div[data-layout-section]",
        getAttrs: function getAttrs(dom) {
          var columnRuleStyle = dom.getAttribute("data-column-rule-style");
          var localId = _uuid.uuid.generate();
          return columnRuleStyle ? {
            columnRuleStyle,
            localId
          } : {
            localId
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var columnRuleStyle = node.attrs.columnRuleStyle;
        var attrs = {
          "data-layout-section": "true",
          "data-column-rule-style": columnRuleStyle || void 0,
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        };
        return ["div", attrs, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/layout-column.js
var require_layout_column = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/layout-column.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.layoutColumnWithLocalId = exports2.layoutColumn = void 0;
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    var layoutColumn = exports2.layoutColumn = (0, _nodeTypes.layoutColumn)({
      parseDOM: [{
        context: "layoutColumn//",
        tag: "div[data-layout-column]",
        skip: true
      }, {
        tag: "div[data-layout-column]",
        getAttrs: function getAttrs(domNode) {
          var dom = domNode;
          return {
            width: Number(dom.getAttribute("data-column-width")) || void 0
          };
        }
      }],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-layout-column": "true"
        };
        var width = node.attrs.width;
        if (width) {
          attrs["style"] = "flex-basis: ".concat(width, "%");
          attrs["data-column-width"] = "".concat(width);
        }
        var contentAttrs = {
          "data-layout-content": "true"
        };
        return ["div", attrs, ["div", contentAttrs, 0]];
      }
    });
    var layoutColumnWithLocalId = exports2.layoutColumnWithLocalId = (0, _nodeTypes.layoutColumn)({
      parseDOM: [{
        context: "layoutColumn//",
        tag: "div[data-layout-column]",
        skip: true
      }, {
        tag: "div[data-layout-column]",
        getAttrs: function getAttrs(domNode) {
          var dom = domNode;
          return {
            width: Number(dom.getAttribute("data-column-width")) || void 0,
            localId: _uuid.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var attrs = {
          "data-layout-column": "true",
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        };
        var width = node.attrs.width;
        if (width) {
          attrs["style"] = "flex-basis: ".concat(width, "%");
          attrs["data-column-width"] = "".concat(width);
        }
        var contentAttrs = {
          "data-layout-content": "true"
        };
        return ["div", attrs, ["div", contentAttrs, 0]];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/inline-card.js
var require_inline_card = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/inline-card.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.inlineCardWithLocalId = exports2.inlineCard = void 0;
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    var inlineCard = exports2.inlineCard = (0, _nodeTypes.inlineCard)({
      parseDOM: [
        {
          tag: "a[data-inline-card], span[data-inline-card]",
          // bump priority higher than hyperlink
          priority: 100,
          getAttrs: function getAttrs(dom) {
            var anchor = dom;
            var data = anchor.getAttribute("data-card-data");
            return {
              url: anchor.getAttribute("href") || anchor.getAttribute("data-card-url") || null,
              data: data ? JSON.parse(data) : null
            };
          }
        },
        // for renderer
        {
          tag: "div[data-inline-card]",
          getAttrs: function getAttrs(dom) {
            var anchor = dom;
            var data = anchor.getAttribute("data-card-data");
            return {
              url: anchor.getAttribute("data-card-url"),
              data: data ? JSON.parse(data) : null
            };
          }
        }
      ],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-inline-card": "",
          href: node.attrs.url || "",
          "data-card-data": node.attrs.data ? JSON.stringify(node.attrs.data) : ""
        };
        if (node.attrs.url) {
          return ["a", attrs, node.attrs.url];
        } else {
          return ["a", attrs];
        }
      }
    });
    var inlineCardWithLocalId = exports2.inlineCardWithLocalId = (0, _nodeTypes.inlineCard)({
      parseDOM: [
        {
          tag: "a[data-inline-card], span[data-inline-card]",
          // bump priority higher than hyperlink
          priority: 100,
          getAttrs: function getAttrs(dom) {
            var anchor = dom;
            var data = anchor.getAttribute("data-card-data");
            return {
              url: anchor.getAttribute("href") || anchor.getAttribute("data-card-url") || null,
              data: data ? JSON.parse(data) : null,
              localId: _uuid.uuid.generate()
            };
          }
        },
        // for renderer
        {
          tag: "div[data-inline-card]",
          getAttrs: function getAttrs(dom) {
            var anchor = dom;
            var data = anchor.getAttribute("data-card-data");
            return {
              url: anchor.getAttribute("data-card-url"),
              data: data ? JSON.parse(data) : null,
              localId: _uuid.uuid.generate()
            };
          }
        }
      ],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var attrs = {
          "data-inline-card": "",
          href: node.attrs.url || "",
          "data-card-data": node.attrs.data ? JSON.stringify(node.attrs.data) : "",
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        };
        if (node.attrs.url) {
          return ["a", attrs, node.attrs.url];
        } else {
          return ["a", attrs];
        }
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/block-card.js
var require_block_card = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/block-card.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.blockCardWithLocalId = exports2.blockCard = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _nodeTypes = require_nodeTypes();
    var _utils = require_utils();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var getCommonAttributesFromDom = function getCommonAttributesFromDom2(dom) {
      var anchor = dom;
      var data = anchor.getAttribute("data-card-data");
      var datasource = anchor.getAttribute("data-datasource");
      return {
        data: data ? JSON.parse(data) : void 0,
        layout: datasource ? dom.getAttribute("data-layout") || void 0 : void 0,
        width: Number(dom.getAttribute("data-width")) || void 0,
        datasource: datasource ? JSON.parse(datasource) : void 0
      };
    };
    var blockCard = exports2.blockCard = (0, _nodeTypes.blockCard)({
      parseDOM: [{
        tag: "a[data-block-card]",
        // bump priority higher than hyperlink
        priority: 100,
        getAttrs: function getAttrs(dom) {
          var anchor = dom;
          return _objectSpread({
            url: anchor.getAttribute("href") || void 0
          }, getCommonAttributesFromDom(dom));
        }
      }, {
        tag: "div[data-block-card]",
        getAttrs: function getAttrs(dom) {
          var anchor = dom;
          return _objectSpread({
            url: anchor.getAttribute("data-card-url") || void 0
          }, getCommonAttributesFromDom(dom));
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var _ref = node.attrs, url = _ref.url;
        var _ref2 = node.attrs, data = _ref2.data;
        var _ref3 = node.attrs, layout = _ref3.layout, width = _ref3.width, datasource = _ref3.datasource;
        var attrs = {
          "data-block-card": "",
          href: url || "",
          "data-card-data": data ? JSON.stringify(data) : "",
          "data-datasource": datasource ? JSON.stringify(datasource) : "",
          "data-layout": layout,
          "data-width": "".concat(width)
        };
        return ["a", attrs, (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.url) || " "];
      }
    });
    var blockCardWithLocalId = exports2.blockCardWithLocalId = (0, _nodeTypes.blockCard)({
      parseDOM: [{
        tag: "a[data-block-card]",
        // bump priority higher than hyperlink
        priority: 100,
        getAttrs: function getAttrs(dom) {
          var anchor = dom;
          return _objectSpread(_objectSpread({
            url: anchor.getAttribute("href") || void 0
          }, getCommonAttributesFromDom(dom)), {}, {
            localId: _utils.uuid.generate()
          });
        }
      }, {
        tag: "div[data-block-card]",
        getAttrs: function getAttrs(dom) {
          var anchor = dom;
          return _objectSpread(_objectSpread({
            url: anchor.getAttribute("data-card-url") || void 0
          }, getCommonAttributesFromDom(dom)), {}, {
            localId: _utils.uuid.generate()
          });
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs2, _node$attrs3;
        var _ref4 = node.attrs, url = _ref4.url;
        var _ref5 = node.attrs, data = _ref5.data;
        var _ref6 = node.attrs, layout = _ref6.layout, width = _ref6.width, datasource = _ref6.datasource;
        var attrs = {
          "data-block-card": "",
          href: url || "",
          "data-card-data": data ? JSON.stringify(data) : "",
          "data-datasource": datasource ? JSON.stringify(datasource) : "",
          "data-layout": layout,
          "data-width": "".concat(width),
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs2 = node.attrs) === null || _node$attrs2 === void 0 ? void 0 : _node$attrs2.localId) || void 0
        };
        return ["a", attrs, (node === null || node === void 0 ? void 0 : (_node$attrs3 = node.attrs) === null || _node$attrs3 === void 0 ? void 0 : _node$attrs3.url) || " "];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/unsupported-block.js
var require_unsupported_block = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/unsupported-block.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.unsupportedBlock = void 0;
    var _nodeTypes = require_nodeTypes();
    var unsupportedBlock = exports2.unsupportedBlock = (0, _nodeTypes.unsupportedBlock)({
      parseDOM: [{
        tag: '[data-node-type="unsupportedBlock"]',
        getAttrs: function getAttrs(dom) {
          return {
            originalValue: JSON.parse(dom.getAttribute("data-original-value") || "{}")
          };
        }
      }],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-node-type": "unsupportedBlock",
          "data-original-value": JSON.stringify(node.attrs.originalValue)
        };
        return ["div", attrs, "Unsupported content"];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/unsupported-inline.js
var require_unsupported_inline = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/unsupported-inline.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.unsupportedInline = void 0;
    var _nodeTypes = require_nodeTypes();
    var unsupportedInline = exports2.unsupportedInline = (0, _nodeTypes.unsupportedInline)({
      parseDOM: [{
        tag: '[data-node-type="unsupportedInline"]',
        getAttrs: function getAttrs(dom) {
          return {
            originalValue: JSON.parse(dom.getAttribute("data-original-value") || "{}")
          };
        }
      }],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-node-type": "unsupportedInline",
          "data-original-value": JSON.stringify(node.attrs.originalValue)
        };
        return ["span", attrs, "Unsupported content"];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/status.js
var require_status = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/status.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.status = void 0;
    var _uuid = require_uuid();
    var _nodeTypes = require_nodeTypes();
    var status = exports2.status = (0, _nodeTypes.status)({
      parseDOM: [{
        tag: 'span[data-node-type="status"]',
        getAttrs: function getAttrs(domNode) {
          var dom = domNode;
          return {
            text: dom.textContent.replace(/\n/, "").trim(),
            color: dom.getAttribute("data-color"),
            localId: _uuid.uuid.generate(),
            style: dom.getAttribute("data-style")
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs = node.attrs, text = _node$attrs.text, color = _node$attrs.color, localId = _node$attrs.localId, style = _node$attrs.style;
        var attrs = {
          "data-node-type": "status",
          "data-color": color,
          "data-local-id": localId,
          "data-style": style,
          contenteditable: "false"
        };
        return ["span", attrs, text];
      }
    });
  }
});

// node_modules/@babel/runtime/helpers/arrayWithoutHoles.js
var require_arrayWithoutHoles = __commonJS({
  "node_modules/@babel/runtime/helpers/arrayWithoutHoles.js"(exports2, module2) {
    var arrayLikeToArray = require_arrayLikeToArray();
    function _arrayWithoutHoles(r) {
      if (Array.isArray(r)) return arrayLikeToArray(r);
    }
    module2.exports = _arrayWithoutHoles, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/iterableToArray.js
var require_iterableToArray = __commonJS({
  "node_modules/@babel/runtime/helpers/iterableToArray.js"(exports2, module2) {
    function _iterableToArray(r) {
      if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
    }
    module2.exports = _iterableToArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/nonIterableSpread.js
var require_nonIterableSpread = __commonJS({
  "node_modules/@babel/runtime/helpers/nonIterableSpread.js"(exports2, module2) {
    function _nonIterableSpread() {
      throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
    }
    module2.exports = _nonIterableSpread, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@babel/runtime/helpers/toConsumableArray.js
var require_toConsumableArray = __commonJS({
  "node_modules/@babel/runtime/helpers/toConsumableArray.js"(exports2, module2) {
    var arrayWithoutHoles = require_arrayWithoutHoles();
    var iterableToArray = require_iterableToArray();
    var unsupportedIterableToArray = require_unsupportedIterableToArray();
    var nonIterableSpread = require_nonIterableSpread();
    function _toConsumableArray(r) {
      return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();
    }
    module2.exports = _toConsumableArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/nested-expand.js
var require_nested_expand = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/nested-expand.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.nestedExpandWithLocalId = exports2.nestedExpand = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    function getExpandAttrs(domNode, generateLocalId) {
      var dom = domNode;
      return {
        title: dom.getAttribute("data-title"),
        __expanded: true,
        localId: generateLocalId ? _uuid.uuid.generate() : void 0
      };
    }
    var nestedExpandFactoryOptions = {
      parseDOM: [{
        context: "nestedExpand//",
        tag: '[data-node-type="nestedExpand"]',
        getAttrs: function getAttrs(domNode) {
          return getExpandAttrs(domNode, false);
        }
      }, {
        tag: '[data-node-type="nestedExpand"] button',
        ignore: true
      }, {
        tag: '[data-node-type="expand"] button',
        ignore: true
      }, {
        tag: 'div[data-node-type="nestedExpand"]',
        getAttrs: function getAttrs(domNode) {
          return getExpandAttrs(domNode, false);
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs;
        var attrs = {
          "data-node-type": "nestedExpand",
          "data-title": node.attrs.title,
          "data-expanded": node.attrs.__expanded,
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.localId) || void 0
        };
        return ["div", attrs, 0];
      }
    };
    var nestedExpand = exports2.nestedExpand = (0, _nodeTypes.nestedExpand)(nestedExpandFactoryOptions);
    var nestedExpandWithLocalId = exports2.nestedExpandWithLocalId = (0, _nodeTypes.nestedExpand)(_objectSpread(_objectSpread({}, nestedExpandFactoryOptions), {}, {
      parseDOM: [].concat((0, _toConsumableArray2.default)(nestedExpandFactoryOptions.parseDOM), [{
        context: "nestedExpand//",
        tag: '[data-node-type="nestedExpand"]',
        getAttrs: function getAttrs(domNode) {
          return getExpandAttrs(domNode, true);
        }
      }, {
        tag: '[data-node-type="nestedExpand"]',
        getAttrs: function getAttrs(domNode) {
          return getExpandAttrs(domNode, true);
        }
      }])
    }));
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/embed-card.js
var require_embed_card = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/embed-card.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.embedCardWithLocalId = exports2.embedCard = void 0;
    var _nodeTypes = require_nodeTypes();
    var _uuid = require_uuid();
    var embedCard = exports2.embedCard = (0, _nodeTypes.embedCard)({
      parseDOM: [{
        tag: "div[data-embed-card]",
        getAttrs: function getAttrs(dom) {
          return {
            url: dom.getAttribute("data-card-url"),
            layout: dom.getAttribute("data-layout") || "center",
            width: Number(dom.getAttribute("data-width")) || null,
            originalWidth: Number(dom.getAttribute("data-card-original-width")) || null,
            originalHeight: Number(dom.getAttribute("data-card-original-height")) || null
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs = node.attrs, url = _node$attrs.url, layout = _node$attrs.layout, width = _node$attrs.width, originalWidth = _node$attrs.originalWidth, originalHeight = _node$attrs.originalHeight;
        var attrs = {
          "data-embed-card": "",
          "data-card-url": url,
          "data-layout": layout,
          "data-width": width,
          "data-original-width": originalWidth,
          "data-original-height": originalHeight
        };
        return ["div", attrs];
      }
    });
    var embedCardWithLocalId = exports2.embedCardWithLocalId = (0, _nodeTypes.embedCard)({
      parseDOM: [{
        tag: "div[data-embed-card]",
        getAttrs: function getAttrs(dom) {
          return {
            url: dom.getAttribute("data-card-url"),
            layout: dom.getAttribute("data-layout") || "center",
            width: Number(dom.getAttribute("data-width")) || null,
            originalWidth: Number(dom.getAttribute("data-card-original-width")) || null,
            originalHeight: Number(dom.getAttribute("data-card-original-height")) || null,
            localId: _uuid.uuid.generate()
          };
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs3;
        var _node$attrs2 = node.attrs, url = _node$attrs2.url, layout = _node$attrs2.layout, width = _node$attrs2.width, originalWidth = _node$attrs2.originalWidth, originalHeight = _node$attrs2.originalHeight;
        var attrs = {
          "data-embed-card": "",
          "data-card-url": url,
          "data-layout": layout,
          "data-width": width,
          "data-original-width": originalWidth,
          "data-original-height": originalHeight,
          "data-local-id": (node === null || node === void 0 ? void 0 : (_node$attrs3 = node.attrs) === null || _node$attrs3 === void 0 ? void 0 : _node$attrs3.localId) || void 0
        };
        return ["div", attrs];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/utils/extensions.js
var require_extensions = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/utils/extensions.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.isValidLayout = exports2.getExtensionAttrs = void 0;
    var isValidLayout = exports2.isValidLayout = function isValidLayout2(name) {
      return !!name && ["default", "wide", "full-width"].includes(name);
    };
    var getExtensionAttrs = exports2.getExtensionAttrs = function getExtensionAttrs2(dom) {
      var isInline = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
      var extensionType = dom.getAttribute("data-extension-type");
      var extensionKey = dom.getAttribute("data-extension-key");
      if (!extensionType || !extensionKey) {
        return false;
      }
      var attrs = {
        extensionType,
        extensionKey,
        text: dom.getAttribute("data-text") || void 0,
        parameters: JSON.parse(dom.getAttribute("data-parameters") || "{}"),
        localId: dom.getAttribute("data-local-id") || void 0
      };
      if (!isInline) {
        var rawLayout = dom.getAttribute("data-layout");
        attrs.layout = isValidLayout(rawLayout) ? rawLayout : "default";
      }
      return attrs;
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/extension.js
var require_extension = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/extension.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.extension = void 0;
    var _extensions = require_extensions();
    var _nodeTypes = require_nodeTypes();
    var extension = exports2.extension = (0, _nodeTypes.extension)({
      parseDOM: [{
        tag: '[data-node-type="extension"]',
        getAttrs: function getAttrs(domNode) {
          return (0, _extensions.getExtensionAttrs)(domNode);
        }
      }],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-node-type": "extension",
          "data-extension-type": node.attrs.extensionType,
          "data-extension-key": node.attrs.extensionKey,
          "data-text": node.attrs.text,
          "data-parameters": JSON.stringify(node.attrs.parameters),
          "data-layout": node.attrs.layout,
          "data-local-id:": node.attrs.localId
        };
        return ["div", attrs];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/inline-extension.js
var require_inline_extension = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/inline-extension.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.inlineExtension = void 0;
    var _extensions = require_extensions();
    var _nodeTypes = require_nodeTypes();
    var inlineExtension = exports2.inlineExtension = (0, _nodeTypes.inlineExtensionWithMarks)({
      parseDOM: [{
        tag: "span[data-extension-type]",
        getAttrs: function getAttrs(domNode) {
          return (0, _extensions.getExtensionAttrs)(domNode, true);
        }
      }],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-extension-type": node.attrs.extensionType,
          "data-extension-key": node.attrs.extensionKey,
          "data-text": node.attrs.text,
          "data-parameters": JSON.stringify(node.attrs.parameters),
          "data-local-id:": node.attrs.localId,
          contenteditable: "false"
        };
        return ["span", attrs];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/bodied-extension.js
var require_bodied_extension = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/bodied-extension.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.bodiedExtension = void 0;
    var _extensions = require_extensions();
    var _nodeTypes = require_nodeTypes();
    var bodiedExtension = exports2.bodiedExtension = (0, _nodeTypes.bodiedExtension)({
      parseDOM: [{
        context: "bodiedExtension//",
        tag: '[data-node-type="bodied-extension"]',
        skip: true
      }, {
        tag: '[data-node-type="bodied-extension"]',
        getAttrs: function getAttrs(domNode) {
          return (0, _extensions.getExtensionAttrs)(domNode);
        }
      }],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-node-type": "bodied-extension",
          "data-extension-type": node.attrs.extensionType,
          "data-extension-key": node.attrs.extensionKey,
          "data-text": node.attrs.text,
          "data-parameters": JSON.stringify(node.attrs.parameters),
          "data-layout": node.attrs.layout,
          "data-local-id:": node.attrs.localId
        };
        return ["div", attrs, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/multi-bodied-extension.js
var require_multi_bodied_extension = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/multi-bodied-extension.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.multiBodiedExtension = exports2.extensionFrame = void 0;
    var _extensions = require_extensions();
    var _nodeTypes = require_nodeTypes();
    var extensionFrame = exports2.extensionFrame = (0, _nodeTypes.extensionFrameStage0)({
      parseDOM: [{
        context: "extensionFrame//",
        tag: "div[data-extension-frame]",
        skip: true
      }, {
        tag: "div[data-extension-frame]"
      }],
      toDOM: function toDOM() {
        var attrs = {
          "data-extension-frame": "true"
        };
        return ["div", attrs, 0];
      }
    });
    var multiBodiedExtension = exports2.multiBodiedExtension = (0, _nodeTypes.multiBodiedExtensionStage0)({
      parseDOM: [{
        context: "multiBodiedExtension//",
        tag: '[data-node-type="multi-bodied-extension"]',
        skip: true
      }, {
        tag: '[data-node-type="multi-bodied-extension"]',
        getAttrs: function getAttrs(domNode) {
          return (0, _extensions.getExtensionAttrs)(domNode);
        }
      }],
      toDOM: function toDOM(node) {
        var attrs = {
          "data-node-type": "multi-bodied-extension",
          "data-extension-type": node.attrs.extensionType,
          "data-extension-key": node.attrs.extensionKey,
          "data-text": node.attrs.text,
          "data-parameters": JSON.stringify(node.attrs.parameters),
          "data-layout": node.attrs.layout,
          "data-local-id:": node.attrs.localId
        };
        return ["div", attrs, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/sync-block.js
var require_sync_block = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/sync-block.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.syncBlock = void 0;
    var _nodeTypes = require_nodeTypes();
    var syncBlock = exports2.syncBlock = (0, _nodeTypes.syncBlockStage0)({
      parseDOM: [{
        tag: "div[data-sync-block]",
        getAttrs: function getAttrs(domNode) {
          var dom = domNode;
          var attrs = {
            localId: dom.getAttribute("data-local-id") || "",
            resourceId: dom.getAttribute("data-resource-id") || ""
          };
          return attrs;
        }
      }],
      toDOM: function toDOM(node) {
        var _node$attrs = node.attrs, localId = _node$attrs.localId, resourceId = _node$attrs.resourceId;
        var name = "div";
        var attrs = {
          "data-sync-block": "",
          "data-local-id": localId,
          "data-resource-id": resourceId
        };
        return [name, attrs];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/index.js
var require_nodes = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/nodes/index.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "PanelType", {
      enumerable: true,
      get: function get() {
        return _panel.PanelType;
      }
    });
    Object.defineProperty(exports2, "blockCard", {
      enumerable: true,
      get: function get() {
        return _blockCard.blockCard;
      }
    });
    Object.defineProperty(exports2, "blockCardWithLocalId", {
      enumerable: true,
      get: function get() {
        return _blockCard.blockCardWithLocalId;
      }
    });
    Object.defineProperty(exports2, "blockTaskItem", {
      enumerable: true,
      get: function get() {
        return _taskItem.blockTaskItem;
      }
    });
    Object.defineProperty(exports2, "blockquote", {
      enumerable: true,
      get: function get() {
        return _blockquote.blockquote;
      }
    });
    Object.defineProperty(exports2, "bodiedExtension", {
      enumerable: true,
      get: function get() {
        return _bodiedExtension.bodiedExtension;
      }
    });
    Object.defineProperty(exports2, "bulletList", {
      enumerable: true,
      get: function get() {
        return _bulletList.bulletList;
      }
    });
    Object.defineProperty(exports2, "bulletListSelector", {
      enumerable: true,
      get: function get() {
        return _bulletList.bulletListSelector;
      }
    });
    Object.defineProperty(exports2, "bulletListWithLocalId", {
      enumerable: true,
      get: function get() {
        return _bulletList.bulletListWithLocalId;
      }
    });
    Object.defineProperty(exports2, "caption", {
      enumerable: true,
      get: function get() {
        return _caption.caption;
      }
    });
    Object.defineProperty(exports2, "captionWithLocalId", {
      enumerable: true,
      get: function get() {
        return _caption.captionWithLocalId;
      }
    });
    Object.defineProperty(exports2, "codeBlock", {
      enumerable: true,
      get: function get() {
        return _codeBlock.codeBlock;
      }
    });
    Object.defineProperty(exports2, "codeBlockToJSON", {
      enumerable: true,
      get: function get() {
        return _codeBlock.toJSON;
      }
    });
    Object.defineProperty(exports2, "codeBlockWithLocalId", {
      enumerable: true,
      get: function get() {
        return _codeBlock.codeBlockWithLocalId;
      }
    });
    Object.defineProperty(exports2, "confluenceJiraIssue", {
      enumerable: true,
      get: function get() {
        return _confluenceJiraIssue.confluenceJiraIssue;
      }
    });
    Object.defineProperty(exports2, "confluenceUnsupportedBlock", {
      enumerable: true,
      get: function get() {
        return _confluenceUnsupportedBlock.confluenceUnsupportedBlock;
      }
    });
    Object.defineProperty(exports2, "confluenceUnsupportedInline", {
      enumerable: true,
      get: function get() {
        return _confluenceUnsupportedInline.confluenceUnsupportedInline;
      }
    });
    Object.defineProperty(exports2, "copyPrivateMediaAttributes", {
      enumerable: true,
      get: function get() {
        return _media.copyPrivateAttributes;
      }
    });
    Object.defineProperty(exports2, "date", {
      enumerable: true,
      get: function get() {
        return _date.date;
      }
    });
    Object.defineProperty(exports2, "dateWithLocalId", {
      enumerable: true,
      get: function get() {
        return _date.dateWithLocalId;
      }
    });
    Object.defineProperty(exports2, "decisionItem", {
      enumerable: true,
      get: function get() {
        return _decisionItem.decisionItem;
      }
    });
    Object.defineProperty(exports2, "decisionList", {
      enumerable: true,
      get: function get() {
        return _decisionList.decisionList;
      }
    });
    Object.defineProperty(exports2, "decisionListSelector", {
      enumerable: true,
      get: function get() {
        return _decisionList.decisionListSelector;
      }
    });
    Object.defineProperty(exports2, "doc", {
      enumerable: true,
      get: function get() {
        return _doc.doc;
      }
    });
    Object.defineProperty(exports2, "embedCard", {
      enumerable: true,
      get: function get() {
        return _embedCard.embedCard;
      }
    });
    Object.defineProperty(exports2, "embedCardWithLocalId", {
      enumerable: true,
      get: function get() {
        return _embedCard.embedCardWithLocalId;
      }
    });
    Object.defineProperty(exports2, "emoji", {
      enumerable: true,
      get: function get() {
        return _emoji.emoji;
      }
    });
    Object.defineProperty(exports2, "emojiWithLocalId", {
      enumerable: true,
      get: function get() {
        return _emoji.emojiWithLocalId;
      }
    });
    Object.defineProperty(exports2, "expandToJSON", {
      enumerable: true,
      get: function get() {
        return _expand.toJSON;
      }
    });
    Object.defineProperty(exports2, "expandWithNestedExpand", {
      enumerable: true,
      get: function get() {
        return _expand.expandWithNestedExpand;
      }
    });
    Object.defineProperty(exports2, "expandWithNestedExpandLocalId", {
      enumerable: true,
      get: function get() {
        return _expand.expandWithNestedExpandLocalId;
      }
    });
    Object.defineProperty(exports2, "extendedBlockquote", {
      enumerable: true,
      get: function get() {
        return _blockquote.extendedBlockquote;
      }
    });
    Object.defineProperty(exports2, "extendedBlockquoteWithLocalId", {
      enumerable: true,
      get: function get() {
        return _blockquote.extendedBlockquoteWithLocalId;
      }
    });
    Object.defineProperty(exports2, "extendedPanel", {
      enumerable: true,
      get: function get() {
        return _panel.extendedPanel;
      }
    });
    Object.defineProperty(exports2, "extendedPanelWithLocalId", {
      enumerable: true,
      get: function get() {
        return _panel.extendedPanelWithLocalId;
      }
    });
    Object.defineProperty(exports2, "extension", {
      enumerable: true,
      get: function get() {
        return _extension.extension;
      }
    });
    Object.defineProperty(exports2, "extensionFrame", {
      enumerable: true,
      get: function get() {
        return _multiBodiedExtension.extensionFrame;
      }
    });
    Object.defineProperty(exports2, "getCellAttrs", {
      enumerable: true,
      get: function get() {
        return _tableNodes.getCellAttrs;
      }
    });
    Object.defineProperty(exports2, "getCellDomAttrs", {
      enumerable: true,
      get: function get() {
        return _tableNodes.getCellDomAttrs;
      }
    });
    Object.defineProperty(exports2, "hardBreak", {
      enumerable: true,
      get: function get() {
        return _hardBreak.hardBreak;
      }
    });
    Object.defineProperty(exports2, "heading", {
      enumerable: true,
      get: function get() {
        return _heading.heading;
      }
    });
    Object.defineProperty(exports2, "image", {
      enumerable: true,
      get: function get() {
        return _image.image;
      }
    });
    Object.defineProperty(exports2, "inlineCard", {
      enumerable: true,
      get: function get() {
        return _inlineCard.inlineCard;
      }
    });
    Object.defineProperty(exports2, "inlineCardWithLocalId", {
      enumerable: true,
      get: function get() {
        return _inlineCard.inlineCardWithLocalId;
      }
    });
    Object.defineProperty(exports2, "inlineExtension", {
      enumerable: true,
      get: function get() {
        return _inlineExtension.inlineExtension;
      }
    });
    Object.defineProperty(exports2, "layoutColumn", {
      enumerable: true,
      get: function get() {
        return _layoutColumn.layoutColumn;
      }
    });
    Object.defineProperty(exports2, "layoutColumnWithLocalId", {
      enumerable: true,
      get: function get() {
        return _layoutColumn.layoutColumnWithLocalId;
      }
    });
    Object.defineProperty(exports2, "layoutSection", {
      enumerable: true,
      get: function get() {
        return _layoutSection.layoutSection;
      }
    });
    Object.defineProperty(exports2, "layoutSectionWithLocalId", {
      enumerable: true,
      get: function get() {
        return _layoutSection.layoutSectionWithLocalId;
      }
    });
    Object.defineProperty(exports2, "layoutSectionWithSingleColumn", {
      enumerable: true,
      get: function get() {
        return _layoutSection.layoutSectionWithSingleColumn;
      }
    });
    Object.defineProperty(exports2, "layoutSectionWithSingleColumnLocalId", {
      enumerable: true,
      get: function get() {
        return _layoutSection.layoutSectionWithSingleColumnLocalId;
      }
    });
    Object.defineProperty(exports2, "listItem", {
      enumerable: true,
      get: function get() {
        return _listItem.listItem;
      }
    });
    Object.defineProperty(exports2, "listItemWithDecisionStage0", {
      enumerable: true,
      get: function get() {
        return _listItem.listItemWithDecisionStage0;
      }
    });
    Object.defineProperty(exports2, "listItemWithLocalId", {
      enumerable: true,
      get: function get() {
        return _listItem.listItemWithLocalId;
      }
    });
    Object.defineProperty(exports2, "media", {
      enumerable: true,
      get: function get() {
        return _media.media;
      }
    });
    Object.defineProperty(exports2, "mediaGroup", {
      enumerable: true,
      get: function get() {
        return _mediaGroup.mediaGroup;
      }
    });
    Object.defineProperty(exports2, "mediaInline", {
      enumerable: true,
      get: function get() {
        return _mediaInline.mediaInline;
      }
    });
    Object.defineProperty(exports2, "mediaSingle", {
      enumerable: true,
      get: function get() {
        return _mediaSingle.mediaSingle;
      }
    });
    Object.defineProperty(exports2, "mediaSingleFull", {
      enumerable: true,
      get: function get() {
        return _mediaSingle.mediaSingleFull;
      }
    });
    Object.defineProperty(exports2, "mediaSingleFullWithLocalId", {
      enumerable: true,
      get: function get() {
        return _mediaSingle.mediaSingleFullWithLocalId;
      }
    });
    Object.defineProperty(exports2, "mediaSingleSpec", {
      enumerable: true,
      get: function get() {
        return _mediaSingle.mediaSingleSpec;
      }
    });
    Object.defineProperty(exports2, "mediaSingleToJSON", {
      enumerable: true,
      get: function get() {
        return _mediaSingle.toJSON;
      }
    });
    Object.defineProperty(exports2, "mediaSingleWithCaption", {
      enumerable: true,
      get: function get() {
        return _mediaSingle.mediaSingleWithCaption;
      }
    });
    Object.defineProperty(exports2, "mediaSingleWithWidthType", {
      enumerable: true,
      get: function get() {
        return _mediaSingle.mediaSingleWithWidthType;
      }
    });
    Object.defineProperty(exports2, "mediaToJSON", {
      enumerable: true,
      get: function get() {
        return _media.toJSON;
      }
    });
    Object.defineProperty(exports2, "mention", {
      enumerable: true,
      get: function get() {
        return _mention.mention;
      }
    });
    Object.defineProperty(exports2, "mentionToJSON", {
      enumerable: true,
      get: function get() {
        return _mention.toJSON;
      }
    });
    Object.defineProperty(exports2, "multiBodiedExtension", {
      enumerable: true,
      get: function get() {
        return _multiBodiedExtension.multiBodiedExtension;
      }
    });
    Object.defineProperty(exports2, "nestedExpand", {
      enumerable: true,
      get: function get() {
        return _nestedExpand.nestedExpand;
      }
    });
    Object.defineProperty(exports2, "nestedExpandWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nestedExpand.nestedExpandWithLocalId;
      }
    });
    Object.defineProperty(exports2, "orderedList", {
      enumerable: true,
      get: function get() {
        return _orderedList.orderedList;
      }
    });
    Object.defineProperty(exports2, "orderedListSelector", {
      enumerable: true,
      get: function get() {
        return _orderedList.orderedListSelector;
      }
    });
    Object.defineProperty(exports2, "orderedListWithLocalId", {
      enumerable: true,
      get: function get() {
        return _orderedList.orderedListWithLocalId;
      }
    });
    Object.defineProperty(exports2, "orderedListWithOrder", {
      enumerable: true,
      get: function get() {
        return _orderedList.orderedListWithOrder;
      }
    });
    Object.defineProperty(exports2, "orderedListWithOrderAndLocalId", {
      enumerable: true,
      get: function get() {
        return _orderedList.orderedListWithOrderAndLocalId;
      }
    });
    Object.defineProperty(exports2, "paragraph", {
      enumerable: true,
      get: function get() {
        return _paragraph.paragraph;
      }
    });
    Object.defineProperty(exports2, "placeholder", {
      enumerable: true,
      get: function get() {
        return _placeholder.placeholder;
      }
    });
    Object.defineProperty(exports2, "placeholderWithLocalId", {
      enumerable: true,
      get: function get() {
        return _placeholder.placeholderWithLocalId;
      }
    });
    Object.defineProperty(exports2, "rule", {
      enumerable: true,
      get: function get() {
        return _rule.rule;
      }
    });
    Object.defineProperty(exports2, "ruleWithLocalId", {
      enumerable: true,
      get: function get() {
        return _rule.ruleWithLocalId;
      }
    });
    Object.defineProperty(exports2, "status", {
      enumerable: true,
      get: function get() {
        return _status.status;
      }
    });
    Object.defineProperty(exports2, "syncBlock", {
      enumerable: true,
      get: function get() {
        return _syncBlock.syncBlock;
      }
    });
    Object.defineProperty(exports2, "table", {
      enumerable: true,
      get: function get() {
        return _tableNodes.table;
      }
    });
    Object.defineProperty(exports2, "tableBackgroundBorderColor", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableBackgroundBorderColor;
      }
    });
    Object.defineProperty(exports2, "tableBackgroundColorNames", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableBackgroundColorNames;
      }
    });
    Object.defineProperty(exports2, "tableBackgroundColorPalette", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableBackgroundColorPalette;
      }
    });
    Object.defineProperty(exports2, "tableCell", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableCell;
      }
    });
    Object.defineProperty(exports2, "tableCellContentDomSelector", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableCellContentDomSelector;
      }
    });
    Object.defineProperty(exports2, "tableCellContentWrapperSelector", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableCellContentWrapperSelector;
      }
    });
    Object.defineProperty(exports2, "tableCellSelector", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableCellSelector;
      }
    });
    Object.defineProperty(exports2, "tableCellWithLocalId", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableCellWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableCellWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableCellWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "tableCellWithNestedTableWithLocalId", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableCellWithNestedTableWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableHeader", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableHeader;
      }
    });
    Object.defineProperty(exports2, "tableHeaderSelector", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableHeaderSelector;
      }
    });
    Object.defineProperty(exports2, "tableHeaderWithLocalId", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableHeaderWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableHeaderWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableHeaderWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "tableHeaderWithNestedTableWithLocalId", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableHeaderWithNestedTableWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tablePrefixSelector", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tablePrefixSelector;
      }
    });
    Object.defineProperty(exports2, "tableRow", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableRow;
      }
    });
    Object.defineProperty(exports2, "tableRowWithLocalId", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableRowWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableRowWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableRowWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "tableRowWithNestedTableWithLocalId", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableRowWithNestedTableWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableStage0", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableStage0;
      }
    });
    Object.defineProperty(exports2, "tableToJSON", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableToJSON;
      }
    });
    Object.defineProperty(exports2, "tableWithCustomWidth", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableWithCustomWidth;
      }
    });
    Object.defineProperty(exports2, "tableWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _tableNodes.tableWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "taskItem", {
      enumerable: true,
      get: function get() {
        return _taskItem.taskItem;
      }
    });
    Object.defineProperty(exports2, "taskList", {
      enumerable: true,
      get: function get() {
        return _taskList.taskList;
      }
    });
    Object.defineProperty(exports2, "taskListSelector", {
      enumerable: true,
      get: function get() {
        return _taskList.taskListSelector;
      }
    });
    Object.defineProperty(exports2, "text", {
      enumerable: true,
      get: function get() {
        return _text.text;
      }
    });
    Object.defineProperty(exports2, "toJSONTableCell", {
      enumerable: true,
      get: function get() {
        return _tableNodes.toJSONTableCell;
      }
    });
    Object.defineProperty(exports2, "toJSONTableHeader", {
      enumerable: true,
      get: function get() {
        return _tableNodes.toJSONTableHeader;
      }
    });
    Object.defineProperty(exports2, "unknownBlock", {
      enumerable: true,
      get: function get() {
        return _unknownBlock.default;
      }
    });
    Object.defineProperty(exports2, "unsupportedBlock", {
      enumerable: true,
      get: function get() {
        return _unsupportedBlock.unsupportedBlock;
      }
    });
    Object.defineProperty(exports2, "unsupportedInline", {
      enumerable: true,
      get: function get() {
        return _unsupportedInline.unsupportedInline;
      }
    });
    var _expand = require_expand();
    var _confluenceJiraIssue = require_confluence_jira_issue();
    var _confluenceUnsupportedBlock = require_confluence_unsupported_block();
    var _confluenceUnsupportedInline = require_confluence_unsupported_inline();
    var _doc = require_doc();
    var _blockquote = require_blockquote();
    var _bulletList = require_bullet_list();
    var _codeBlock = require_code_block();
    var _hardBreak = require_hard_break();
    var _heading = require_heading();
    var _rule = require_rule();
    var _orderedList = require_ordered_list();
    var _paragraph = require_paragraph();
    var _emoji = require_emoji2();
    var _image = require_image();
    var _mention = require_mention();
    var _listItem = require_list_item();
    var _panel = require_panel();
    var _text = require_text();
    var _unknownBlock = _interopRequireDefault(require_unknown_block());
    var _caption = require_caption();
    var _media = require_media();
    var _mediaGroup = require_media_group();
    var _mediaInline = require_media_inline();
    var _mediaSingle = require_media_single();
    var _tableNodes = require_tableNodes();
    var _decisionList = require_decision_list();
    var _decisionItem = require_decision_item();
    var _taskList = require_task_list();
    var _taskItem = require_task_item();
    var _date = require_date();
    var _placeholder = require_placeholder();
    var _layoutSection = require_layout_section();
    var _layoutColumn = require_layout_column();
    var _inlineCard = require_inline_card();
    var _blockCard = require_block_card();
    var _unsupportedBlock = require_unsupported_block();
    var _unsupportedInline = require_unsupported_inline();
    var _status = require_status();
    var _nestedExpand = require_nested_expand();
    var _embedCard = require_embed_card();
    var _extension = require_extension();
    var _inlineExtension = require_inline_extension();
    var _bodiedExtension = require_bodied_extension();
    var _multiBodiedExtension = require_multi_bodied_extension();
    var _syncBlock = require_sync_block();
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/groups.js
var require_groups = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/groups.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.SEARCH_QUERY = exports2.LINK = exports2.INDENTATION = exports2.FONT_STYLE = exports2.COLOR = exports2.ALIGNMENT = void 0;
    var FONT_STYLE = exports2.FONT_STYLE = "fontStyle";
    var SEARCH_QUERY = exports2.SEARCH_QUERY = "searchQuery";
    var LINK = exports2.LINK = "link";
    var COLOR = exports2.COLOR = "color";
    var ALIGNMENT = exports2.ALIGNMENT = "alignment";
    var INDENTATION = exports2.INDENTATION = "indentation";
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/sanitizeNodes.js
var require_sanitizeNodes = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/sanitizeNodes.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.sanitizeNodes = sanitizeNodes;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    function sanitizeNodes(nodes, supportedMarks) {
      var nodeNames = Object.keys(nodes);
      nodeNames.forEach(function(nodeKey) {
        var nodeSpec = _objectSpread({}, nodes[nodeKey]);
        if (nodeSpec.marks && nodeSpec.marks !== "_") {
          nodeSpec.marks = nodeSpec.marks.split(" ").filter(function(mark) {
            return !!supportedMarks[mark];
          }).join(" ");
        }
        if (nodeSpec.content) {
          nodeSpec.content = sanitizeNodeSpecContent(nodes, nodeSpec.content);
        }
        nodes[nodeKey] = nodeSpec;
      });
      return nodes;
    }
    function sanitizeNodeSpecContent(nodes, rawContent) {
      var content = rawContent.replace(/\W/g, " ");
      var contentKeys = content.split(" ");
      var unsupportedContentKeys = contentKeys.filter(function(contentKey) {
        return !isContentSupported(nodes, contentKey);
      });
      return unsupportedContentKeys.reduce(function(newContent, nodeName) {
        return sanitizedContent(newContent, nodeName);
      }, rawContent);
    }
    function sanitizedContent(content, invalidContent) {
      if (!invalidContent.length) {
        return content || "";
      }
      if (!content || !content.match(/\w/)) {
        return "";
      }
      var pattern = "(".concat(invalidContent, "((\\s)*\\|)+)|((\\|(\\s)*)+").concat(invalidContent, "(\\+|\\*)?)|(").concat(invalidContent, "$)|(").concat(invalidContent, "(\\+|\\*))");
      return content.replace(new RegExp(pattern, "g"), "").replace("  ", " ").trim();
    }
    function isContentSupported(nodes, contentKey) {
      var nodeKeys = Object.keys(nodes);
      if (nodeKeys.indexOf(contentKey) > -1) {
        return true;
      }
      for (var supportedKey in nodes) {
        var nodeSpec = nodes[supportedKey];
        if (nodeSpec && nodeSpec.group === contentKey) {
          return true;
        }
      }
      return false;
    }
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/next-schema/generated/markTypes.js
var require_markTypes = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/next-schema/generated/markTypes.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.unsupportedNodeAttribute = exports2.unsupportedMark = exports2.underline = exports2.typeAheadQuery = exports2.textColor = exports2.subsup = exports2.strong = exports2.strike = exports2.link = exports2.indentation = exports2.fragment = exports2.em = exports2.dataConsumer = exports2.confluenceInlineComment = exports2.code = exports2.breakout = exports2.border = exports2.backgroundColor = exports2.annotation = exports2.alignment = void 0;
    var _createPMSpecFactory = require_createPMSpecFactory();
    var alignment = exports2.alignment = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        align: {}
      },
      excludes: "alignment indentation",
      group: "alignment"
    });
    var annotation = exports2.annotation = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        id: {
          default: ""
        },
        annotationType: {
          default: "inlineComment"
        }
      },
      inclusive: true,
      excludes: "",
      group: "annotation"
    });
    var backgroundColor = exports2.backgroundColor = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        color: {}
      },
      inclusive: true,
      excludes: "color",
      group: "color"
    });
    var border = exports2.border = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        size: {},
        color: {}
      },
      inclusive: false
    });
    var breakout = exports2.breakout = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        mode: {
          default: "wide"
        },
        width: {
          default: null
        }
      },
      inclusive: false,
      spanning: false
    });
    var code = exports2.code = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      inclusive: true,
      excludes: "fontStyle link searchQuery color"
    });
    var confluenceInlineComment = exports2.confluenceInlineComment = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        reference: {
          default: ""
        }
      },
      inclusive: false,
      excludes: ""
    });
    var dataConsumer = exports2.dataConsumer = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        sources: {
          default: []
        }
      }
    });
    var em = exports2.em = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      inclusive: true,
      group: "fontStyle"
    });
    var fragment = exports2.fragment = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        localId: {
          default: ""
        },
        name: {
          default: null
        }
      },
      inclusive: false,
      excludes: ""
    });
    var indentation = exports2.indentation = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        level: {}
      },
      excludes: "indentation alignment",
      group: "indentation"
    });
    var link = exports2.link = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        href: {},
        __confluenceMetadata: {
          default: null
        }
      },
      inclusive: false,
      excludes: "link",
      group: "link"
    });
    var strike = exports2.strike = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      inclusive: true,
      group: "fontStyle"
    });
    var strong = exports2.strong = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      inclusive: true,
      group: "fontStyle"
    });
    var subsup = exports2.subsup = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        type: {
          default: "sub"
        }
      },
      inclusive: true,
      group: "fontStyle"
    });
    var textColor = exports2.textColor = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        color: {}
      },
      inclusive: true,
      group: "color"
    });
    var typeAheadQuery = exports2.typeAheadQuery = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        trigger: {
          default: ""
        }
      },
      inclusive: true,
      group: "searchQuery"
    });
    var underline = exports2.underline = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      inclusive: true,
      group: "fontStyle"
    });
    var unsupportedMark = exports2.unsupportedMark = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        originalValue: {}
      },
      excludes: ""
    });
    var unsupportedNodeAttribute = exports2.unsupportedNodeAttribute = (0, _createPMSpecFactory.createPMMarkSpecFactory)({
      attrs: {
        unsupported: {},
        type: {}
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/em.js
var require_em = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/em.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.em = void 0;
    var _markTypes = require_markTypes();
    var emDOM = ["em"];
    var em = exports2.em = (0, _markTypes.em)({
      parseDOM: [{
        tag: "i"
      }, {
        tag: "em"
      }, {
        style: "font-style=italic"
      }],
      toDOM: function toDOM() {
        return emDOM;
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/code.js
var require_code = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/code.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.code = void 0;
    var _markTypes = require_markTypes();
    var code = exports2.code = (0, _markTypes.code)({
      parseDOM: [{
        tag: "span.code",
        preserveWhitespace: true
      }, {
        tag: "code",
        preserveWhitespace: true
      }, {
        tag: "tt",
        preserveWhitespace: true
      }, {
        tag: "span",
        preserveWhitespace: true,
        getAttrs: function getAttrs(domNode) {
          var dom = domNode;
          if (dom.style.whiteSpace === "pre") {
            return {};
          }
          if (dom.style.fontFamily && dom.style.fontFamily.toLowerCase().indexOf("monospace") >= 0) {
            return {};
          }
          return false;
        }
      }],
      toDOM: function toDOM() {
        return ["span", {
          class: "code",
          spellcheck: "false"
        }];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/strike.js
var require_strike = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/strike.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.strike = void 0;
    var _markTypes = require_markTypes();
    var strike = exports2.strike = (0, _markTypes.strike)({
      parseDOM: [{
        tag: "strike"
      }, {
        tag: "s"
      }, {
        tag: "del"
      }, {
        style: "text-decoration",
        getAttrs: function getAttrs(value) {
          return value === "line-through" && null;
        }
      }],
      toDOM: function toDOM() {
        return ["s"];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/strong.js
var require_strong = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/strong.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.strong = void 0;
    var _markTypes = require_markTypes();
    var strongDOM = ["strong"];
    var strong = exports2.strong = (0, _markTypes.strong)({
      parseDOM: [
        {
          tag: "strong"
        },
        // This works around a Google Docs misbehavior where
        // pasted content will be inexplicably wrapped in `<b>`
        // tags with a font-weight normal.
        {
          tag: "b",
          getAttrs: function getAttrs(node) {
            var element = node;
            return element.style.fontWeight !== "normal" && null;
          }
        },
        {
          tag: "span",
          getAttrs: function getAttrs(node) {
            var element = node;
            var fontWeight = element.style.fontWeight;
            return typeof fontWeight === "string" && (fontWeight === "bold" || fontWeight === "bolder" || /^(bold(er)?|[5-9]\d{2,})$/.test(fontWeight)) && null;
          }
        }
      ],
      toDOM: function toDOM() {
        return strongDOM;
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/underline.js
var require_underline = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/underline.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.underline = void 0;
    var _markTypes = require_markTypes();
    var underline = exports2.underline = (0, _markTypes.underline)({
      parseDOM: [{
        tag: "u"
      }, {
        style: "text-decoration",
        getAttrs: function getAttrs(value) {
          return value === "underline" && null;
        }
      }],
      toDOM: function toDOM() {
        return ["u"];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/link.js
var require_link = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/link.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.toJSON = exports2.link = exports2.getLinkAttrs = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _markTypes = require_markTypes();
    var _url = require_url();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var getLinkAttrs = exports2.getLinkAttrs = function getLinkAttrs2(attribute) {
      return function(domNode) {
        var dom = domNode;
        var href = dom.getAttribute(attribute) || "";
        var attrs = {
          __confluenceMetadata: dom.hasAttribute("__confluenceMetadata") ? JSON.parse(dom.getAttribute("__confluenceMetadata") || "") : void 0
        };
        if (!(0, _url.isSafeUrl)(href)) {
          return false;
        }
        if ((0, _url.isRootRelative)(href)) {
          attrs.href = href;
          return attrs;
        }
        attrs.href = (0, _url.normalizeUrl)(href);
        return attrs;
      };
    };
    var link = exports2.link = (0, _markTypes.link)({
      parseDOM: [{
        tag: "[data-block-link]",
        getAttrs: getLinkAttrs("data-block-link"),
        contentElement: function contentElement(node) {
          var clone = node.cloneNode(true);
          clone.removeAttribute("data-block-link");
          clone.setAttribute("data-skip-paste", "true");
          var wrapper = document.createElement("div");
          wrapper.appendChild(clone);
          return wrapper;
        }
      }, {
        tag: "a[href]",
        getAttrs: getLinkAttrs("href")
      }],
      toDOM: function toDOM(node, isInline) {
        var attrs = Object.keys(node.attrs).reduce(function(attrs2, key) {
          if (key === "__confluenceMetadata") {
            if (node.attrs[key] !== null) {
              attrs2[key] = JSON.stringify(node.attrs[key]);
            }
          } else if (key === "href") {
            attrs2[key] = (0, _url.isSafeUrl)(node.attrs[key]) ? node.attrs[key] : void 0;
          } else {
            attrs2[key] = node.attrs[key];
          }
          return attrs2;
        }, {});
        if (isInline) {
          return ["a", attrs];
        }
        return ["a", _objectSpread(_objectSpread({}, attrs), {}, (0, _defineProperty2.default)((0, _defineProperty2.default)({}, "data-block-link", "true"), "class", "blockLink")), 0];
      }
    });
    var OPTIONAL_ATTRS = ["title", "id", "collection", "occurrenceKey", "__confluenceMetadata"];
    var toJSON = exports2.toJSON = function toJSON2(mark) {
      return {
        type: mark.type.name,
        attrs: Object.keys(mark.attrs).reduce(function(attrs, key) {
          if (OPTIONAL_ATTRS.indexOf(key) === -1 || mark.attrs[key] !== null) {
            attrs[key] = mark.attrs[key];
          }
          return attrs;
        }, {})
      };
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/type-ahead-query.js
var require_type_ahead_query = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/type-ahead-query.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.typeAheadQuery = void 0;
    var _markTypes = require_markTypes();
    var _colors = require_colors();
    var typeAheadQuery = exports2.typeAheadQuery = (0, _markTypes.typeAheadQuery)({
      parseDOM: [{
        tag: "span[data-type-ahead-query]"
      }],
      toDOM: function toDOM(node) {
        return ["span", {
          "data-type-ahead-query": "true",
          "data-trigger": node.attrs.trigger,
          style: "color: ".concat(_colors.B400)
        }];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/subsup.js
var require_subsup = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/subsup.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.subsup = void 0;
    var _markTypes = require_markTypes();
    function getAttrFromVerticalAlign(node) {
      if (node === "sub") {
        return {
          type: "sub"
        };
      }
      if (node === "super") {
        return {
          type: "sup"
        };
      }
      return false;
    }
    var subsup = exports2.subsup = (0, _markTypes.subsup)({
      parseDOM: [{
        tag: "sub",
        attrs: {
          type: "sub"
        }
      }, {
        tag: "sup",
        attrs: {
          type: "sup"
        }
      }, {
        // Special case for pasting from Google Docs
        // Google Docs uses vertical align to denote subscript and super script
        style: "vertical-align=super",
        getAttrs: function getAttrs(node) {
          return getAttrFromVerticalAlign(node);
        }
      }, {
        style: "vertical-align=sub",
        getAttrs: function getAttrs(node) {
          return getAttrFromVerticalAlign(node);
        }
      }],
      toDOM: function toDOM(mark) {
        return [mark.attrs.type];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/text-color.js
var require_text_color = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/text-color.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.textColor = exports2.setGlobalTheme = exports2.getGlobalTheme = exports2.colorPaletteExtended = exports2.colorPalette = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _markTypes = require_markTypes();
    var _editorPalette = require_editor_palette();
    var _colors = require_colors();
    var _lchColorInversion = require_lch_color_inversion();
    var colorArrayPalette = [
      // default row - first color is added programatically
      // [N800, 'Squid ink'], // default dark gray
      [_colors.B500, "Dark blue"],
      // Chore coat
      [_colors.T500, "Dark teal"],
      // Shabby chic
      [_colors.G500, "Dark green"],
      // Keen green
      [_colors.Y400, "Orange"],
      // Cheezy blasters
      [_colors.R500, "Dark red"],
      // Dragon's blood
      [_colors.P500, "Dark purple"],
      // Prince
      // row 2
      [_colors.N80, "Light gray"],
      // Spooky ghost
      [_colors.B100, "Blue"],
      // Arvo breeze
      [_colors.T300, "Teal"],
      // Tamarama
      [_colors.G300, "Green"],
      // Fine pine
      [_colors.Y200, "Yellow"],
      // Pub mix
      [_colors.R300, "Red"],
      // Poppy surprise
      [_colors.P300, "Purple"],
      // Da' juice
      // row 3
      [_colors.N0, "White"],
      [_colors.B75, "Light blue"],
      // Schwag
      [_colors.T75, "Light teal"],
      // Arctic chill
      [_colors.G75, "Light green"],
      // Mintie
      [_colors.Y75, "Light yellow"],
      // Dandelion whisper
      [_colors.R75, "Light red"],
      // Bondi sunburn
      [_colors.P50, "Light purple"]
      // Lavender secret
    ];
    var colorPalette = exports2.colorPalette = /* @__PURE__ */ new Map();
    var colorPaletteExtended = exports2.colorPaletteExtended = colorPalette;
    colorArrayPalette.forEach(function(_ref) {
      var _ref2 = (0, _slicedToArray2.default)(_ref, 2), color = _ref2[0], label = _ref2[1];
      return colorPalette.set(color.toLowerCase(), label);
    });
    var testGlobalTheme;
    var setGlobalTheme = exports2.setGlobalTheme = function setGlobalTheme2(theme) {
      testGlobalTheme = theme;
    };
    var getGlobalTheme = exports2.getGlobalTheme = function getGlobalTheme2() {
      if (testGlobalTheme) {
        return {
          colorMode: testGlobalTheme
        };
      }
      var element = document.documentElement;
      var colorMode = element.getAttribute("data-color-mode") || "";
      return {
        colorMode
      };
    };
    var textColor = exports2.textColor = (0, _markTypes.textColor)({
      parseDOM: [
        {
          style: "color",
          getAttrs: function getAttrs(maybeValue) {
            var value = maybeValue;
            var hexColor;
            if (value.match(/^rgb/i)) {
              hexColor = (0, _colors.rgbToHex)(value);
            } else if (value[0] === "#") {
              hexColor = value.toLowerCase();
            }
            return hexColor && colorPalette.has(hexColor) ? {
              color: hexColor
            } : false;
          }
        },
        // This rule ensures when loading from a renderer or editor where the
        // presented text color does not match the stored hex color -- that the
        // text color is preserved.
        //
        // This was initially introduced to ensure text-color marks were not lost
        // when text-color was used inside a link, and is now also used to support
        // where the hex color stored in ADF is used as an ID for a design system
        // token (and based on theme mode -- the presented color will change).
        {
          tag: ".fabric-text-color-mark",
          getAttrs: function getAttrs(maybeElement) {
            if (!(maybeElement instanceof HTMLElement)) {
              return false;
            }
            var hexColor = maybeElement.dataset.textCustomColor;
            return hexColor && colorPalette.has(hexColor) ? {
              color: hexColor
            } : false;
          }
        }
      ],
      toDOM: function toDOM(mark) {
        var paletteColorValue;
        var tokenColor = (0, _editorPalette.hexToEditorTextPaletteColor)(mark.attrs.color);
        if (tokenColor) {
          paletteColorValue = tokenColor;
        } else {
          if (getGlobalTheme().colorMode === "dark") {
            paletteColorValue = (0, _lchColorInversion.getDarkModeLCHColor)(mark.attrs.color);
          } else {
            paletteColorValue = mark.attrs.color;
          }
        }
        return ["span", (0, _defineProperty2.default)({
          class: "fabric-text-color-mark",
          // Editor common has a common style which uses this css variable as the value for
          // the color property using the `fabric-text-color-mark` selector applied above.
          style: "--custom-palette-color: ".concat(paletteColorValue)
        }, "data-text-custom-color", mark.attrs.color)];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/confluence-inline-comment.js
var require_confluence_inline_comment = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/confluence-inline-comment.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.confluenceInlineComment = void 0;
    var _markTypes = require_markTypes();
    var confluenceInlineComment = exports2.confluenceInlineComment = (0, _markTypes.confluenceInlineComment)({
      parseDOM: [{
        tag: 'span[data-mark-type="confluenceInlineComment"]'
      }],
      toDOM: function toDOM(node) {
        return ["span", {
          "data-mark-type": "confluenceInlineComment",
          "data-reference": node.attrs.reference
        }];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/breakout.js
var require_breakout = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/breakout.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.breakout = void 0;
    var _markTypes = require_markTypes();
    var allowedTypes = ["wide", "full-width"];
    var breakout = exports2.breakout = (0, _markTypes.breakout)({
      parseDOM: [{
        tag: "div.fabric-editor-breakout-mark",
        getAttrs: function getAttrs(dom) {
          var mode = dom.getAttribute("data-mode");
          var width = dom.getAttribute("data-width");
          return {
            mode: allowedTypes.indexOf(mode || "") === -1 ? "wide" : mode,
            width: width ? parseInt(width) : null
          };
        }
      }],
      toDOM: function toDOM(mark) {
        var _mark$attrs;
        return ["div", {
          class: "fabric-editor-breakout-mark",
          "data-mode": mark.attrs.mode,
          "data-width": (_mark$attrs = mark.attrs) === null || _mark$attrs === void 0 ? void 0 : _mark$attrs.width
        }, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/alignment.js
var require_alignment = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/alignment.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.alignmentPositionMap = exports2.alignment = void 0;
    var _markTypes = require_markTypes();
    var alignmentPositionMap = exports2.alignmentPositionMap = {
      end: "right",
      right: "end",
      center: "center"
    };
    var alignment = exports2.alignment = (0, _markTypes.alignment)({
      parseDOM: [{
        tag: "div.fabric-editor-block-mark",
        getAttrs: function getAttrs(dom) {
          var align = dom.getAttribute("data-align");
          return align ? {
            align
          } : false;
        }
      }],
      toDOM: function toDOM(mark) {
        return ["div", {
          class: "fabric-editor-block-mark fabric-editor-alignment fabric-editor-align-".concat(mark.attrs.align),
          "data-align": mark.attrs.align
        }, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/indentation.js
var require_indentation = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/indentation.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.indentation = void 0;
    var _markTypes = require_markTypes();
    var indentation = exports2.indentation = (0, _markTypes.indentation)({
      parseDOM: [{
        tag: "div.fabric-editor-indentation-mark",
        getAttrs: function getAttrs(dom) {
          var level = +(dom.getAttribute("data-level") || "0");
          return {
            level: level > 6 ? 6 : level < 1 ? false : level
          };
        }
      }],
      toDOM: function toDOM(mark) {
        return ["div", {
          class: "fabric-editor-block-mark fabric-editor-indentation-mark",
          "data-level": mark.attrs.level
        }, 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/annotation.js
var require_annotation = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/annotation.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.annotation = exports2.AnnotationTypes = exports2.AnnotationMarkStates = void 0;
    exports2.buildDataAttributes = buildDataAttributes;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _markTypes = require_markTypes();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var AnnotationTypes = exports2.AnnotationTypes = /* @__PURE__ */ (function(AnnotationTypes2) {
      AnnotationTypes2["INLINE_COMMENT"] = "inlineComment";
      return AnnotationTypes2;
    })({});
    var AnnotationMarkStates = exports2.AnnotationMarkStates = /* @__PURE__ */ (function(AnnotationMarkStates2) {
      AnnotationMarkStates2["RESOLVED"] = "resolved";
      AnnotationMarkStates2["ACTIVE"] = "active";
      return AnnotationMarkStates2;
    })({});
    function buildDataAttributes(_ref) {
      var id = _ref.id, annotationType = _ref.annotationType, state = _ref.state;
      var data = {
        "data-mark-type": "annotation",
        "data-mark-annotation-type": annotationType,
        "data-id": id
      };
      if (state) {
        return _objectSpread(_objectSpread({}, data), {}, {
          "data-mark-annotation-state": state
        });
      }
      return data;
    }
    var annotation = exports2.annotation = (0, _markTypes.annotation)({
      parseDOM: [{
        tag: 'span[data-mark-type="annotation"]',
        mark: "annotation",
        getAttrs: function getAttrs(domNode) {
          var dom = domNode;
          var attrs = {
            id: dom.getAttribute("data-id"),
            annotationType: dom.getAttribute("data-mark-annotation-type")
          };
          return attrs;
        }
      }],
      toDOM: function toDOM(node) {
        return ["span", _objectSpread({
          // Prettier will remove the quotes around class. This would cause some browsers
          // to not add this attribute properly, as its a reserved word.
          // prettier-ignore
          "class": "fabric-editor-annotation"
        }, buildDataAttributes({
          id: node.attrs.id,
          annotationType: node.attrs.annotationType
        })), 0];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/unsupported-mark.js
var require_unsupported_mark = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/unsupported-mark.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.unsupportedMark = void 0;
    var _markTypes = require_markTypes();
    var unsupportedMark = exports2.unsupportedMark = (0, _markTypes.unsupportedMark)({
      toDOM: function toDOM() {
        return ["span"];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/unsupported-node-attributes.js
var require_unsupported_node_attributes = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/unsupported-node-attributes.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.unsupportedNodeAttribute = void 0;
    var _markTypes = require_markTypes();
    var unsupportedNodeAttribute = exports2.unsupportedNodeAttribute = (0, _markTypes.unsupportedNodeAttribute)({
      toDOM: function toDOM() {
        return ["span"];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/data-consumer.js
var require_data_consumer = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/data-consumer.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.toJSON = exports2.dataConsumer = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _markTypes = require_markTypes();
    var _parseDOM = require_parseDOM();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var parseDataConsumer = function parseDataConsumer2(maybeValue) {
      var sources = (0, _parseDOM.isDOMElement)(maybeValue) && maybeValue.getAttribute("data-sources");
      try {
        return sources ? {
          sources: JSON.parse(sources)
        } : false;
      } catch (_unused) {
        return false;
      }
    };
    var dataConsumer = exports2.dataConsumer = (0, _markTypes.dataConsumer)({
      parseDOM: [{
        tag: '[data-mark-type="dataConsumer"]',
        getAttrs: function getAttrs(maybeValue) {
          return parseDataConsumer(maybeValue);
        }
      }],
      toDOM: function toDOM(mark, inline) {
        var wrapperStyle = inline ? "span" : "div";
        return [wrapperStyle, {
          "data-mark-type": "dataConsumer",
          "data-sources": JSON.stringify(mark.attrs.sources)
        }];
      }
    });
    var toJSON = exports2.toJSON = function toJSON2(mark) {
      return {
        type: mark.type.name,
        attrs: Object.keys(mark.attrs).filter(function(key) {
          return key === "sources" && mark.attrs[key].length > 0 && mark.attrs[key] !== null;
        }).reduce(function(acc, key) {
          return _objectSpread(_objectSpread({}, acc), {}, (0, _defineProperty2.default)({}, key, mark.attrs[key]));
        }, {})
      };
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/fragment.js
var require_fragment = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/fragment.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.toJSON = exports2.fragment = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _markTypes = require_markTypes();
    var _parseDOM = require_parseDOM();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var parseFragment = function parseFragment2(maybeValue) {
      var _maybeValue$getAttrib;
      if (!(0, _parseDOM.isDOMElement)(maybeValue)) {
        return false;
      }
      var name = (_maybeValue$getAttrib = maybeValue.getAttribute("data-name")) !== null && _maybeValue$getAttrib !== void 0 ? _maybeValue$getAttrib : void 0;
      var localId = maybeValue.getAttribute("data-localId");
      if (!localId) {
        return false;
      }
      return {
        localId,
        name
      };
    };
    var fragment = exports2.fragment = (0, _markTypes.fragment)({
      parseDOM: [{
        tag: '[data-mark-type="fragment"]',
        getAttrs: function getAttrs(maybeValue) {
          return parseFragment(maybeValue);
        }
      }],
      toDOM: function toDOM(mark, inline) {
        var wrapperStyle = inline ? "span" : "div";
        return [wrapperStyle, {
          "data-mark-type": "fragment",
          "data-name": mark.attrs.name,
          "data-localId": mark.attrs.localId
        }];
      }
    });
    var toJSON = exports2.toJSON = function toJSON2(mark) {
      return {
        type: mark.type.name,
        attrs: _objectSpread({
          localId: mark.attrs.localId
        }, mark.attrs.name ? {
          name: mark.attrs.name
        } : {})
      };
    };
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/border.js
var require_border = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/border.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.borderColorPalette = exports2.border = void 0;
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _markTypes = require_markTypes();
    var _editorPalette = require_editor_palette();
    var _colors = require_colors();
    var borderColorArrayPalette = [[_colors.N300A, "Subtle gray"], [_colors.N600, "Gray"], [_colors.N1000, "Bold gray"]];
    var borderColorPalette = exports2.borderColorPalette = /* @__PURE__ */ new Map();
    borderColorArrayPalette.forEach(function(_ref) {
      var _ref2 = (0, _slicedToArray2.default)(_ref, 2), color = _ref2[0], label = _ref2[1];
      return borderColorPalette.set(color.toLowerCase(), label);
    });
    var border = exports2.border = (0, _markTypes.border)({
      parseDOM: [{
        tag: '[data-mark-type="border"]',
        getAttrs: function getAttrs(domNode) {
          var _dom$getAttribute, _dom$getAttribute2;
          var dom = domNode;
          var color = ((_dom$getAttribute = dom.getAttribute("data-color")) !== null && _dom$getAttribute !== void 0 ? _dom$getAttribute : "").toLowerCase();
          var size = +((_dom$getAttribute2 = dom.getAttribute("data-size")) !== null && _dom$getAttribute2 !== void 0 ? _dom$getAttribute2 : "0");
          return {
            size: size > 3 ? 3 : size < 1 ? false : size,
            color: borderColorPalette.has(color) ? color : false
          };
        }
      }],
      toDOM: function toDOM(mark, isInline) {
        var wrapperStyle = isInline ? "span" : "div";
        var paletteColorValue = (0, _editorPalette.hexToEditorBorderPaletteColor)(mark.attrs.color) || mark.attrs.color;
        return [wrapperStyle, {
          "data-mark-type": "border",
          "data-color": mark.attrs.color,
          "data-size": mark.attrs.size,
          style: "--custom-palette-color: ".concat(paletteColorValue)
        }];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/background-color.js
var require_background_color = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/background-color.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.backgroundColorPaletteNext = exports2.backgroundColorPalette = exports2.backgroundColor = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _markTypes = require_markTypes();
    var _editorPalette = require_editor_palette();
    var _colors = require_colors();
    var _textColor = require_text_color();
    var _lchColorInversion = require_lch_color_inversion();
    var colorArrayPalette = [
      [_colors.Neutral300, "Gray"],
      // token: color.background.accent.gray.subtler
      [_colors.T200, "Teal"],
      // token: color.background.accent.teal.subtler
      [_colors.L200, "Lime"],
      // token: color.background.accent.lime.subtler
      [_colors.O200, "Orange"],
      // token: color.background.accent.orange.subtler
      [_colors.M200, "Magenta"],
      // token: color.background.accent.magenta.subtler
      [_colors.P200, "Purple"]
      // token: color.background.accent.purple.subtler
    ];
    var colorArrayPaletteNext = [
      [_colors.Neutral300, "Gray"],
      // token: color.background.accent.gray.subtler
      [_colors.P200, "Purple"],
      // token: color.background.accent.purple.subtler
      [_colors.M200, "Magenta"],
      // token: color.background.accent.magenta.subtler
      [_colors.O200, "Orange"],
      // token: color.background.accent.orange.subtler
      [_colors.Yellow200, "Yellow"],
      // token: color.background.accent.yellow.subtler
      [_colors.L200, "Lime"],
      // token: color.background.accent.lime.subtler
      [_colors.T200, "Teal"]
      // token: color.background.accent.teal.subtler
    ];
    var backgroundColorPalette = exports2.backgroundColorPalette = /* @__PURE__ */ new Map();
    colorArrayPalette.forEach(function(_ref) {
      var _ref2 = (0, _slicedToArray2.default)(_ref, 2), color = _ref2[0], label = _ref2[1];
      return backgroundColorPalette.set(color.toLowerCase(), label);
    });
    var backgroundColorPaletteNext = exports2.backgroundColorPaletteNext = /* @__PURE__ */ new Map();
    colorArrayPaletteNext.forEach(function(_ref3) {
      var _ref4 = (0, _slicedToArray2.default)(_ref3, 2), color = _ref4[0], label = _ref4[1];
      return backgroundColorPaletteNext.set(color.toLowerCase(), label);
    });
    var backgroundColor = exports2.backgroundColor = (0, _markTypes.backgroundColor)({
      parseDOM: [
        {
          style: "background-color",
          getAttrs: function getAttrs(maybeValue) {
            var value = maybeValue;
            var hexColor;
            if (value.match(/^rgb/i)) {
              hexColor = (0, _colors.rgbToHex)(value);
            } else if (value[0] === "#") {
              hexColor = value.toLowerCase();
            }
            return hexColor && backgroundColorPalette.has(hexColor) ? {
              color: hexColor
            } : false;
          }
        },
        // This rule ensures when loading from a renderer or editor where the
        // presented text color does not match the stored hex color -- that the
        // text color is preserved.
        //
        // This is used to support the work-around that converts the hex color to
        // a design system token to enable light / dark mode (through a CSS variable --custom-palette-color)
        {
          tag: ".fabric-background-color-mark",
          getAttrs: function getAttrs(maybeElement) {
            if (!(maybeElement instanceof HTMLElement)) {
              return false;
            }
            var hexColor = maybeElement.dataset.backgroundCustomColor;
            return hexColor && backgroundColorPalette.has(hexColor) ? {
              color: hexColor
            } : false;
          }
        }
      ],
      toDOM: function toDOM(mark) {
        var paletteColorValue;
        var tokenColor = (0, _editorPalette.hexToEditorTextBackgroundPaletteColor)(mark.attrs.color);
        if (tokenColor) {
          paletteColorValue = tokenColor;
        } else {
          if ((0, _textColor.getGlobalTheme)().colorMode === "dark") {
            paletteColorValue = (0, _lchColorInversion.getDarkModeLCHColor)(mark.attrs.color);
          } else {
            paletteColorValue = mark.attrs.color;
          }
        }
        return ["span", (0, _defineProperty2.default)({
          class: "fabric-background-color-mark",
          // Editor common has a common style which uses this css variable as the value for
          // the color property using the `fabric-text-background-color-mark` selector applied above.
          style: "--custom-palette-color: ".concat(paletteColorValue)
        }, "data-background-custom-color", mark.attrs.color)];
      }
    });
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/index.js
var require_marks = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/marks/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "AnnotationMarkStates", {
      enumerable: true,
      get: function get() {
        return _annotation.AnnotationMarkStates;
      }
    });
    Object.defineProperty(exports2, "AnnotationTypes", {
      enumerable: true,
      get: function get() {
        return _annotation.AnnotationTypes;
      }
    });
    Object.defineProperty(exports2, "alignment", {
      enumerable: true,
      get: function get() {
        return _alignment.alignment;
      }
    });
    Object.defineProperty(exports2, "alignmentPositionMap", {
      enumerable: true,
      get: function get() {
        return _alignment.alignmentPositionMap;
      }
    });
    Object.defineProperty(exports2, "annotation", {
      enumerable: true,
      get: function get() {
        return _annotation.annotation;
      }
    });
    Object.defineProperty(exports2, "backgroundColor", {
      enumerable: true,
      get: function get() {
        return _backgroundColor.backgroundColor;
      }
    });
    Object.defineProperty(exports2, "backgroundColorPalette", {
      enumerable: true,
      get: function get() {
        return _backgroundColor.backgroundColorPalette;
      }
    });
    Object.defineProperty(exports2, "backgroundColorPaletteNext", {
      enumerable: true,
      get: function get() {
        return _backgroundColor.backgroundColorPaletteNext;
      }
    });
    Object.defineProperty(exports2, "border", {
      enumerable: true,
      get: function get() {
        return _border.border;
      }
    });
    Object.defineProperty(exports2, "borderColorPalette", {
      enumerable: true,
      get: function get() {
        return _border.borderColorPalette;
      }
    });
    Object.defineProperty(exports2, "breakout", {
      enumerable: true,
      get: function get() {
        return _breakout.breakout;
      }
    });
    Object.defineProperty(exports2, "buildAnnotationMarkDataAttributes", {
      enumerable: true,
      get: function get() {
        return _annotation.buildDataAttributes;
      }
    });
    Object.defineProperty(exports2, "code", {
      enumerable: true,
      get: function get() {
        return _code.code;
      }
    });
    Object.defineProperty(exports2, "colorPalette", {
      enumerable: true,
      get: function get() {
        return _textColor.colorPalette;
      }
    });
    Object.defineProperty(exports2, "colorPaletteExtended", {
      enumerable: true,
      get: function get() {
        return _textColor.colorPaletteExtended;
      }
    });
    Object.defineProperty(exports2, "confluenceInlineComment", {
      enumerable: true,
      get: function get() {
        return _confluenceInlineComment.confluenceInlineComment;
      }
    });
    Object.defineProperty(exports2, "dataConsumer", {
      enumerable: true,
      get: function get() {
        return _dataConsumer.dataConsumer;
      }
    });
    Object.defineProperty(exports2, "dataConsumerToJSON", {
      enumerable: true,
      get: function get() {
        return _dataConsumer.toJSON;
      }
    });
    Object.defineProperty(exports2, "em", {
      enumerable: true,
      get: function get() {
        return _em.em;
      }
    });
    Object.defineProperty(exports2, "fragment", {
      enumerable: true,
      get: function get() {
        return _fragment.fragment;
      }
    });
    Object.defineProperty(exports2, "fragmentToJSON", {
      enumerable: true,
      get: function get() {
        return _fragment.toJSON;
      }
    });
    Object.defineProperty(exports2, "indentation", {
      enumerable: true,
      get: function get() {
        return _indentation.indentation;
      }
    });
    Object.defineProperty(exports2, "link", {
      enumerable: true,
      get: function get() {
        return _link.link;
      }
    });
    Object.defineProperty(exports2, "linkToJSON", {
      enumerable: true,
      get: function get() {
        return _link.toJSON;
      }
    });
    Object.defineProperty(exports2, "strike", {
      enumerable: true,
      get: function get() {
        return _strike.strike;
      }
    });
    Object.defineProperty(exports2, "strong", {
      enumerable: true,
      get: function get() {
        return _strong.strong;
      }
    });
    Object.defineProperty(exports2, "subsup", {
      enumerable: true,
      get: function get() {
        return _subsup.subsup;
      }
    });
    Object.defineProperty(exports2, "textColor", {
      enumerable: true,
      get: function get() {
        return _textColor.textColor;
      }
    });
    Object.defineProperty(exports2, "typeAheadQuery", {
      enumerable: true,
      get: function get() {
        return _typeAheadQuery.typeAheadQuery;
      }
    });
    Object.defineProperty(exports2, "underline", {
      enumerable: true,
      get: function get() {
        return _underline.underline;
      }
    });
    Object.defineProperty(exports2, "unsupportedMark", {
      enumerable: true,
      get: function get() {
        return _unsupportedMark.unsupportedMark;
      }
    });
    Object.defineProperty(exports2, "unsupportedNodeAttribute", {
      enumerable: true,
      get: function get() {
        return _unsupportedNodeAttributes.unsupportedNodeAttribute;
      }
    });
    var _em = require_em();
    var _code = require_code();
    var _strike = require_strike();
    var _strong = require_strong();
    var _underline = require_underline();
    var _link = require_link();
    var _typeAheadQuery = require_type_ahead_query();
    var _subsup = require_subsup();
    var _textColor = require_text_color();
    var _confluenceInlineComment = require_confluence_inline_comment();
    var _breakout = require_breakout();
    var _alignment = require_alignment();
    var _indentation = require_indentation();
    var _annotation = require_annotation();
    var _unsupportedMark = require_unsupported_mark();
    var _unsupportedNodeAttributes = require_unsupported_node_attributes();
    var _dataConsumer = require_data_consumer();
    var _fragment = require_fragment();
    var _border = require_border();
    var _backgroundColor = require_background_color();
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/create-schema.js
var require_create_schema = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/create-schema.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.allowCustomPanel = void 0;
    exports2.createSchema = createSchema;
    exports2.getNodesAndMarksMap = getNodesAndMarksMap;
    var _model = require_model();
    var _groups = require_groups();
    var _sanitizeNodes = require_sanitizeNodes();
    var _marks = require_marks();
    var _nodes = require_nodes();
    function addItems(builtInItems, config) {
      var customSpecs = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
      if (!config) {
        return {};
      }
      var items = builtInItems.reduce(function(items2, _ref) {
        var name = _ref.name, spec = _ref.spec;
        if (config.indexOf(name) !== -1) {
          items2[name] = customSpecs[name] || spec;
        }
        return items2;
      }, {});
      return Object.keys(customSpecs).reduce(function(items2, name) {
        if (items2[name]) {
          return items2;
        }
        items2[name] = customSpecs[name];
        return items2;
      }, items);
    }
    function groupDeclaration(name) {
      return {
        name: "__".concat(name, "GroupDeclaration"),
        spec: {
          group: name
        }
      };
    }
    var markGroupDeclarations = [groupDeclaration(_groups.COLOR), groupDeclaration(_groups.FONT_STYLE), groupDeclaration(_groups.SEARCH_QUERY), groupDeclaration(_groups.LINK)];
    var markGroupDeclarationsNames = markGroupDeclarations.map(function(groupMark) {
      return groupMark.name;
    });
    var nodesInOrder = [{
      name: "doc",
      spec: _nodes.doc
    }, {
      name: "paragraph",
      spec: _nodes.paragraph
    }, {
      name: "text",
      spec: _nodes.text
    }, {
      name: "bulletList",
      spec: _nodes.bulletList
    }, {
      name: "orderedList",
      spec: _nodes.orderedListWithOrder
    }, {
      name: "listItem",
      spec: _nodes.listItem
    }, {
      name: "heading",
      spec: _nodes.heading
    }, {
      name: "blockquote",
      spec: _nodes.extendedBlockquote
    }, {
      name: "codeBlock",
      spec: _nodes.codeBlock
    }, {
      name: "panel",
      spec: (0, _nodes.extendedPanel)(true)
    }, {
      name: "rule",
      spec: _nodes.rule
    }, {
      name: "image",
      spec: _nodes.image
    }, {
      name: "mention",
      spec: _nodes.mention
    }, {
      name: "caption",
      spec: _nodes.caption
    }, {
      name: "media",
      spec: _nodes.media
    }, {
      name: "mediaGroup",
      spec: _nodes.mediaGroup
    }, {
      name: "mediaSingle",
      spec: _nodes.mediaSingleFull
    }, {
      name: "mediaInline",
      spec: _nodes.mediaInline
    }, {
      name: "placeholder",
      spec: _nodes.placeholder
    }, {
      name: "layoutSection",
      spec: _nodes.layoutSection
    }, {
      name: "layoutColumn",
      spec: _nodes.layoutColumn
    }, {
      name: "hardBreak",
      spec: _nodes.hardBreak
    }, {
      name: "emoji",
      spec: _nodes.emoji
    }, {
      name: "table",
      spec: _nodes.table
    }, {
      name: "tableCell",
      spec: _nodes.tableCell
    }, {
      name: "tableRow",
      spec: _nodes.tableRow
    }, {
      name: "tableHeader",
      spec: _nodes.tableHeader
    }, {
      name: "confluenceJiraIssue",
      spec: _nodes.confluenceJiraIssue
    }, {
      name: "confluenceUnsupportedInline",
      spec: _nodes.confluenceUnsupportedInline
    }, {
      name: "confluenceUnsupportedBlock",
      spec: _nodes.confluenceUnsupportedBlock
    }, {
      name: "decisionList",
      spec: _nodes.decisionList
    }, {
      name: "decisionItem",
      spec: _nodes.decisionItem
    }, {
      name: "taskList",
      spec: _nodes.taskList
    }, {
      name: "taskItem",
      spec: _nodes.taskItem
    }, {
      name: "blockTaskItem",
      spec: _nodes.blockTaskItem
    }, {
      name: "date",
      spec: _nodes.date
    }, {
      name: "status",
      spec: _nodes.status
    }, {
      name: "expand",
      spec: _nodes.expandWithNestedExpand
    }, {
      name: "nestedExpand",
      spec: _nodes.nestedExpand
    }, {
      name: "extension",
      spec: _nodes.extension
    }, {
      name: "inlineExtension",
      spec: _nodes.inlineExtension
    }, {
      name: "bodiedExtension",
      spec: _nodes.bodiedExtension
    }, {
      name: "multiBodiedExtension",
      spec: _nodes.multiBodiedExtension
    }, {
      name: "extensionFrame",
      spec: _nodes.extensionFrame
    }, {
      name: "inlineCard",
      spec: _nodes.inlineCard
    }, {
      name: "blockCard",
      spec: _nodes.blockCard
    }, {
      name: "embedCard",
      spec: _nodes.embedCard
    }, {
      name: "syncBlock",
      spec: _nodes.syncBlock
    }, {
      name: "unknownBlock",
      spec: _nodes.unknownBlock
    }, {
      name: "unsupportedBlock",
      spec: _nodes.unsupportedBlock
    }, {
      name: "unsupportedInline",
      spec: _nodes.unsupportedInline
    }];
    var marksInOrder = [{
      name: "link",
      spec: _marks.link
    }, {
      name: "em",
      spec: _marks.em
    }, {
      name: "strong",
      spec: _marks.strong
    }, {
      name: "textColor",
      spec: _marks.textColor
    }, {
      name: "backgroundColor",
      spec: _marks.backgroundColor
    }, {
      name: "strike",
      spec: _marks.strike
    }, {
      name: "subsup",
      spec: _marks.subsup
    }, {
      name: "underline",
      spec: _marks.underline
    }, {
      name: "code",
      spec: _marks.code
    }, {
      name: "typeAheadQuery",
      spec: _marks.typeAheadQuery
    }, {
      name: "alignment",
      spec: _marks.alignment
    }, {
      name: "annotation",
      spec: _marks.annotation
    }, {
      name: "confluenceInlineComment",
      spec: _marks.confluenceInlineComment
    }].concat(markGroupDeclarations, [{
      name: "breakout",
      spec: _marks.breakout
    }, {
      name: "dataConsumer",
      spec: _marks.dataConsumer
    }, {
      name: "fragment",
      spec: _marks.fragment
    }, {
      name: "indentation",
      spec: _marks.indentation
    }, {
      name: "border",
      spec: _marks.border
    }, {
      name: "unsupportedMark",
      spec: _marks.unsupportedMark
    }, {
      name: "unsupportedNodeAttribute",
      spec: _marks.unsupportedNodeAttribute
    }]);
    function getNodesAndMarksMap() {
      var nodes = nodesInOrder.reduce(function(acc, _ref2) {
        var name = _ref2.name, spec = _ref2.spec;
        acc[name] = spec;
        return acc;
      }, {});
      var marks = marksInOrder.reduce(function(acc, _ref3) {
        var name = _ref3.name, spec = _ref3.spec;
        acc[name] = spec;
        return acc;
      }, {});
      return {
        nodes,
        marks
      };
    }
    function createSchema(config) {
      var customNodeSpecs = config.customNodeSpecs, customMarkSpecs = config.customMarkSpecs;
      var nodesConfig = Object.keys(customNodeSpecs || {}).concat(config.nodes);
      var marksConfig = Object.keys(customMarkSpecs || {}).concat(config.marks || []).concat(markGroupDeclarationsNames);
      var nodes = addItems(nodesInOrder, nodesConfig, customNodeSpecs);
      var marks = addItems(marksInOrder, marksConfig, customMarkSpecs);
      nodes = (0, _sanitizeNodes.sanitizeNodes)(nodes, marks);
      return new _model.Schema({
        nodes,
        marks
      });
    }
    var allowCustomPanel = exports2.allowCustomPanel = true;
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/default-schema.js
var require_default_schema = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/default-schema.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.getSchemaBasedOnStage = exports2.defaultSchemaConfig = exports2.defaultSchema = void 0;
    var _memoizeOne = _interopRequireDefault(require_memoize_one_cjs());
    var _nodes = require_nodes();
    var _createSchema = require_create_schema();
    var getDefaultSchemaConfig = function getDefaultSchemaConfig2() {
      var defaultSchemaConfig2 = {
        nodes: ["doc", "paragraph", "text", "bulletList", "orderedList", "listItem", "heading", "blockquote", "codeBlock", "panel", "rule", "image", "caption", "mention", "media", "mediaGroup", "mediaSingle", "mediaInline", "confluenceUnsupportedBlock", "confluenceUnsupportedInline", "confluenceJiraIssue", "expand", "nestedExpand", "extension", "inlineExtension", "bodiedExtension", "hardBreak", "emoji", "table", "tableCell", "tableHeader", "tableRow", "decisionList", "decisionItem", "taskList", "taskItem", "blockTaskItem", "unknownBlock", "date", "status", "placeholder", "layoutSection", "layoutColumn", "inlineCard", "blockCard", "embedCard", "unsupportedBlock", "unsupportedInline"],
        marks: [
          "link",
          "em",
          "strong",
          "strike",
          "subsup",
          "underline",
          "code",
          "textColor",
          "backgroundColor",
          "confluenceInlineComment",
          "breakout",
          "alignment",
          "indentation",
          "annotation",
          "dataConsumer",
          "border",
          "unsupportedMark",
          "unsupportedNodeAttribute",
          "typeAheadQuery",
          // https://product-fabric.atlassian.net/browse/ED-10214,
          "fragment"
        ]
      };
      return defaultSchemaConfig2;
    };
    var defaultSchemaConfig = exports2.defaultSchemaConfig = getDefaultSchemaConfig();
    var getSchemaBasedOnStage = exports2.getSchemaBasedOnStage = (0, _memoizeOne.default)(function() {
      var stage = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "final";
      var defaultSchemaConfig2 = getDefaultSchemaConfig();
      if (stage === "stage0") {
        defaultSchemaConfig2.customNodeSpecs = {
          layoutSection: _nodes.layoutSectionWithSingleColumn,
          multiBodiedExtension: _nodes.multiBodiedExtension,
          extensionFrame: _nodes.extensionFrame,
          expand: _nodes.expandWithNestedExpand,
          listItem: _nodes.listItemWithDecisionStage0,
          table: _nodes.tableWithNestedTable,
          tableRow: _nodes.tableRowWithNestedTable,
          tableCell: _nodes.tableCellWithNestedTable,
          tableHeader: _nodes.tableHeaderWithNestedTable
        };
      }
      return (0, _createSchema.createSchema)(defaultSchemaConfig2);
    });
    var defaultSchema = exports2.defaultSchema = getSchemaBasedOnStage();
  }
});

// node_modules/entities/lib/maps/entities.json
var require_entities = __commonJS({
  "node_modules/entities/lib/maps/entities.json"(exports2, module2) {
    module2.exports = { Aacute: "\xC1", aacute: "\xE1", Abreve: "\u0102", abreve: "\u0103", ac: "\u223E", acd: "\u223F", acE: "\u223E\u0333", Acirc: "\xC2", acirc: "\xE2", acute: "\xB4", Acy: "\u0410", acy: "\u0430", AElig: "\xC6", aelig: "\xE6", af: "\u2061", Afr: "\u{1D504}", afr: "\u{1D51E}", Agrave: "\xC0", agrave: "\xE0", alefsym: "\u2135", aleph: "\u2135", Alpha: "\u0391", alpha: "\u03B1", Amacr: "\u0100", amacr: "\u0101", amalg: "\u2A3F", amp: "&", AMP: "&", andand: "\u2A55", And: "\u2A53", and: "\u2227", andd: "\u2A5C", andslope: "\u2A58", andv: "\u2A5A", ang: "\u2220", ange: "\u29A4", angle: "\u2220", angmsdaa: "\u29A8", angmsdab: "\u29A9", angmsdac: "\u29AA", angmsdad: "\u29AB", angmsdae: "\u29AC", angmsdaf: "\u29AD", angmsdag: "\u29AE", angmsdah: "\u29AF", angmsd: "\u2221", angrt: "\u221F", angrtvb: "\u22BE", angrtvbd: "\u299D", angsph: "\u2222", angst: "\xC5", angzarr: "\u237C", Aogon: "\u0104", aogon: "\u0105", Aopf: "\u{1D538}", aopf: "\u{1D552}", apacir: "\u2A6F", ap: "\u2248", apE: "\u2A70", ape: "\u224A", apid: "\u224B", apos: "'", ApplyFunction: "\u2061", approx: "\u2248", approxeq: "\u224A", Aring: "\xC5", aring: "\xE5", Ascr: "\u{1D49C}", ascr: "\u{1D4B6}", Assign: "\u2254", ast: "*", asymp: "\u2248", asympeq: "\u224D", Atilde: "\xC3", atilde: "\xE3", Auml: "\xC4", auml: "\xE4", awconint: "\u2233", awint: "\u2A11", backcong: "\u224C", backepsilon: "\u03F6", backprime: "\u2035", backsim: "\u223D", backsimeq: "\u22CD", Backslash: "\u2216", Barv: "\u2AE7", barvee: "\u22BD", barwed: "\u2305", Barwed: "\u2306", barwedge: "\u2305", bbrk: "\u23B5", bbrktbrk: "\u23B6", bcong: "\u224C", Bcy: "\u0411", bcy: "\u0431", bdquo: "\u201E", becaus: "\u2235", because: "\u2235", Because: "\u2235", bemptyv: "\u29B0", bepsi: "\u03F6", bernou: "\u212C", Bernoullis: "\u212C", Beta: "\u0392", beta: "\u03B2", beth: "\u2136", between: "\u226C", Bfr: "\u{1D505}", bfr: "\u{1D51F}", bigcap: "\u22C2", bigcirc: "\u25EF", bigcup: "\u22C3", bigodot: "\u2A00", bigoplus: "\u2A01", bigotimes: "\u2A02", bigsqcup: "\u2A06", bigstar: "\u2605", bigtriangledown: "\u25BD", bigtriangleup: "\u25B3", biguplus: "\u2A04", bigvee: "\u22C1", bigwedge: "\u22C0", bkarow: "\u290D", blacklozenge: "\u29EB", blacksquare: "\u25AA", blacktriangle: "\u25B4", blacktriangledown: "\u25BE", blacktriangleleft: "\u25C2", blacktriangleright: "\u25B8", blank: "\u2423", blk12: "\u2592", blk14: "\u2591", blk34: "\u2593", block: "\u2588", bne: "=\u20E5", bnequiv: "\u2261\u20E5", bNot: "\u2AED", bnot: "\u2310", Bopf: "\u{1D539}", bopf: "\u{1D553}", bot: "\u22A5", bottom: "\u22A5", bowtie: "\u22C8", boxbox: "\u29C9", boxdl: "\u2510", boxdL: "\u2555", boxDl: "\u2556", boxDL: "\u2557", boxdr: "\u250C", boxdR: "\u2552", boxDr: "\u2553", boxDR: "\u2554", boxh: "\u2500", boxH: "\u2550", boxhd: "\u252C", boxHd: "\u2564", boxhD: "\u2565", boxHD: "\u2566", boxhu: "\u2534", boxHu: "\u2567", boxhU: "\u2568", boxHU: "\u2569", boxminus: "\u229F", boxplus: "\u229E", boxtimes: "\u22A0", boxul: "\u2518", boxuL: "\u255B", boxUl: "\u255C", boxUL: "\u255D", boxur: "\u2514", boxuR: "\u2558", boxUr: "\u2559", boxUR: "\u255A", boxv: "\u2502", boxV: "\u2551", boxvh: "\u253C", boxvH: "\u256A", boxVh: "\u256B", boxVH: "\u256C", boxvl: "\u2524", boxvL: "\u2561", boxVl: "\u2562", boxVL: "\u2563", boxvr: "\u251C", boxvR: "\u255E", boxVr: "\u255F", boxVR: "\u2560", bprime: "\u2035", breve: "\u02D8", Breve: "\u02D8", brvbar: "\xA6", bscr: "\u{1D4B7}", Bscr: "\u212C", bsemi: "\u204F", bsim: "\u223D", bsime: "\u22CD", bsolb: "\u29C5", bsol: "\\", bsolhsub: "\u27C8", bull: "\u2022", bullet: "\u2022", bump: "\u224E", bumpE: "\u2AAE", bumpe: "\u224F", Bumpeq: "\u224E", bumpeq: "\u224F", Cacute: "\u0106", cacute: "\u0107", capand: "\u2A44", capbrcup: "\u2A49", capcap: "\u2A4B", cap: "\u2229", Cap: "\u22D2", capcup: "\u2A47", capdot: "\u2A40", CapitalDifferentialD: "\u2145", caps: "\u2229\uFE00", caret: "\u2041", caron: "\u02C7", Cayleys: "\u212D", ccaps: "\u2A4D", Ccaron: "\u010C", ccaron: "\u010D", Ccedil: "\xC7", ccedil: "\xE7", Ccirc: "\u0108", ccirc: "\u0109", Cconint: "\u2230", ccups: "\u2A4C", ccupssm: "\u2A50", Cdot: "\u010A", cdot: "\u010B", cedil: "\xB8", Cedilla: "\xB8", cemptyv: "\u29B2", cent: "\xA2", centerdot: "\xB7", CenterDot: "\xB7", cfr: "\u{1D520}", Cfr: "\u212D", CHcy: "\u0427", chcy: "\u0447", check: "\u2713", checkmark: "\u2713", Chi: "\u03A7", chi: "\u03C7", circ: "\u02C6", circeq: "\u2257", circlearrowleft: "\u21BA", circlearrowright: "\u21BB", circledast: "\u229B", circledcirc: "\u229A", circleddash: "\u229D", CircleDot: "\u2299", circledR: "\xAE", circledS: "\u24C8", CircleMinus: "\u2296", CirclePlus: "\u2295", CircleTimes: "\u2297", cir: "\u25CB", cirE: "\u29C3", cire: "\u2257", cirfnint: "\u2A10", cirmid: "\u2AEF", cirscir: "\u29C2", ClockwiseContourIntegral: "\u2232", CloseCurlyDoubleQuote: "\u201D", CloseCurlyQuote: "\u2019", clubs: "\u2663", clubsuit: "\u2663", colon: ":", Colon: "\u2237", Colone: "\u2A74", colone: "\u2254", coloneq: "\u2254", comma: ",", commat: "@", comp: "\u2201", compfn: "\u2218", complement: "\u2201", complexes: "\u2102", cong: "\u2245", congdot: "\u2A6D", Congruent: "\u2261", conint: "\u222E", Conint: "\u222F", ContourIntegral: "\u222E", copf: "\u{1D554}", Copf: "\u2102", coprod: "\u2210", Coproduct: "\u2210", copy: "\xA9", COPY: "\xA9", copysr: "\u2117", CounterClockwiseContourIntegral: "\u2233", crarr: "\u21B5", cross: "\u2717", Cross: "\u2A2F", Cscr: "\u{1D49E}", cscr: "\u{1D4B8}", csub: "\u2ACF", csube: "\u2AD1", csup: "\u2AD0", csupe: "\u2AD2", ctdot: "\u22EF", cudarrl: "\u2938", cudarrr: "\u2935", cuepr: "\u22DE", cuesc: "\u22DF", cularr: "\u21B6", cularrp: "\u293D", cupbrcap: "\u2A48", cupcap: "\u2A46", CupCap: "\u224D", cup: "\u222A", Cup: "\u22D3", cupcup: "\u2A4A", cupdot: "\u228D", cupor: "\u2A45", cups: "\u222A\uFE00", curarr: "\u21B7", curarrm: "\u293C", curlyeqprec: "\u22DE", curlyeqsucc: "\u22DF", curlyvee: "\u22CE", curlywedge: "\u22CF", curren: "\xA4", curvearrowleft: "\u21B6", curvearrowright: "\u21B7", cuvee: "\u22CE", cuwed: "\u22CF", cwconint: "\u2232", cwint: "\u2231", cylcty: "\u232D", dagger: "\u2020", Dagger: "\u2021", daleth: "\u2138", darr: "\u2193", Darr: "\u21A1", dArr: "\u21D3", dash: "\u2010", Dashv: "\u2AE4", dashv: "\u22A3", dbkarow: "\u290F", dblac: "\u02DD", Dcaron: "\u010E", dcaron: "\u010F", Dcy: "\u0414", dcy: "\u0434", ddagger: "\u2021", ddarr: "\u21CA", DD: "\u2145", dd: "\u2146", DDotrahd: "\u2911", ddotseq: "\u2A77", deg: "\xB0", Del: "\u2207", Delta: "\u0394", delta: "\u03B4", demptyv: "\u29B1", dfisht: "\u297F", Dfr: "\u{1D507}", dfr: "\u{1D521}", dHar: "\u2965", dharl: "\u21C3", dharr: "\u21C2", DiacriticalAcute: "\xB4", DiacriticalDot: "\u02D9", DiacriticalDoubleAcute: "\u02DD", DiacriticalGrave: "`", DiacriticalTilde: "\u02DC", diam: "\u22C4", diamond: "\u22C4", Diamond: "\u22C4", diamondsuit: "\u2666", diams: "\u2666", die: "\xA8", DifferentialD: "\u2146", digamma: "\u03DD", disin: "\u22F2", div: "\xF7", divide: "\xF7", divideontimes: "\u22C7", divonx: "\u22C7", DJcy: "\u0402", djcy: "\u0452", dlcorn: "\u231E", dlcrop: "\u230D", dollar: "$", Dopf: "\u{1D53B}", dopf: "\u{1D555}", Dot: "\xA8", dot: "\u02D9", DotDot: "\u20DC", doteq: "\u2250", doteqdot: "\u2251", DotEqual: "\u2250", dotminus: "\u2238", dotplus: "\u2214", dotsquare: "\u22A1", doublebarwedge: "\u2306", DoubleContourIntegral: "\u222F", DoubleDot: "\xA8", DoubleDownArrow: "\u21D3", DoubleLeftArrow: "\u21D0", DoubleLeftRightArrow: "\u21D4", DoubleLeftTee: "\u2AE4", DoubleLongLeftArrow: "\u27F8", DoubleLongLeftRightArrow: "\u27FA", DoubleLongRightArrow: "\u27F9", DoubleRightArrow: "\u21D2", DoubleRightTee: "\u22A8", DoubleUpArrow: "\u21D1", DoubleUpDownArrow: "\u21D5", DoubleVerticalBar: "\u2225", DownArrowBar: "\u2913", downarrow: "\u2193", DownArrow: "\u2193", Downarrow: "\u21D3", DownArrowUpArrow: "\u21F5", DownBreve: "\u0311", downdownarrows: "\u21CA", downharpoonleft: "\u21C3", downharpoonright: "\u21C2", DownLeftRightVector: "\u2950", DownLeftTeeVector: "\u295E", DownLeftVectorBar: "\u2956", DownLeftVector: "\u21BD", DownRightTeeVector: "\u295F", DownRightVectorBar: "\u2957", DownRightVector: "\u21C1", DownTeeArrow: "\u21A7", DownTee: "\u22A4", drbkarow: "\u2910", drcorn: "\u231F", drcrop: "\u230C", Dscr: "\u{1D49F}", dscr: "\u{1D4B9}", DScy: "\u0405", dscy: "\u0455", dsol: "\u29F6", Dstrok: "\u0110", dstrok: "\u0111", dtdot: "\u22F1", dtri: "\u25BF", dtrif: "\u25BE", duarr: "\u21F5", duhar: "\u296F", dwangle: "\u29A6", DZcy: "\u040F", dzcy: "\u045F", dzigrarr: "\u27FF", Eacute: "\xC9", eacute: "\xE9", easter: "\u2A6E", Ecaron: "\u011A", ecaron: "\u011B", Ecirc: "\xCA", ecirc: "\xEA", ecir: "\u2256", ecolon: "\u2255", Ecy: "\u042D", ecy: "\u044D", eDDot: "\u2A77", Edot: "\u0116", edot: "\u0117", eDot: "\u2251", ee: "\u2147", efDot: "\u2252", Efr: "\u{1D508}", efr: "\u{1D522}", eg: "\u2A9A", Egrave: "\xC8", egrave: "\xE8", egs: "\u2A96", egsdot: "\u2A98", el: "\u2A99", Element: "\u2208", elinters: "\u23E7", ell: "\u2113", els: "\u2A95", elsdot: "\u2A97", Emacr: "\u0112", emacr: "\u0113", empty: "\u2205", emptyset: "\u2205", EmptySmallSquare: "\u25FB", emptyv: "\u2205", EmptyVerySmallSquare: "\u25AB", emsp13: "\u2004", emsp14: "\u2005", emsp: "\u2003", ENG: "\u014A", eng: "\u014B", ensp: "\u2002", Eogon: "\u0118", eogon: "\u0119", Eopf: "\u{1D53C}", eopf: "\u{1D556}", epar: "\u22D5", eparsl: "\u29E3", eplus: "\u2A71", epsi: "\u03B5", Epsilon: "\u0395", epsilon: "\u03B5", epsiv: "\u03F5", eqcirc: "\u2256", eqcolon: "\u2255", eqsim: "\u2242", eqslantgtr: "\u2A96", eqslantless: "\u2A95", Equal: "\u2A75", equals: "=", EqualTilde: "\u2242", equest: "\u225F", Equilibrium: "\u21CC", equiv: "\u2261", equivDD: "\u2A78", eqvparsl: "\u29E5", erarr: "\u2971", erDot: "\u2253", escr: "\u212F", Escr: "\u2130", esdot: "\u2250", Esim: "\u2A73", esim: "\u2242", Eta: "\u0397", eta: "\u03B7", ETH: "\xD0", eth: "\xF0", Euml: "\xCB", euml: "\xEB", euro: "\u20AC", excl: "!", exist: "\u2203", Exists: "\u2203", expectation: "\u2130", exponentiale: "\u2147", ExponentialE: "\u2147", fallingdotseq: "\u2252", Fcy: "\u0424", fcy: "\u0444", female: "\u2640", ffilig: "\uFB03", fflig: "\uFB00", ffllig: "\uFB04", Ffr: "\u{1D509}", ffr: "\u{1D523}", filig: "\uFB01", FilledSmallSquare: "\u25FC", FilledVerySmallSquare: "\u25AA", fjlig: "fj", flat: "\u266D", fllig: "\uFB02", fltns: "\u25B1", fnof: "\u0192", Fopf: "\u{1D53D}", fopf: "\u{1D557}", forall: "\u2200", ForAll: "\u2200", fork: "\u22D4", forkv: "\u2AD9", Fouriertrf: "\u2131", fpartint: "\u2A0D", frac12: "\xBD", frac13: "\u2153", frac14: "\xBC", frac15: "\u2155", frac16: "\u2159", frac18: "\u215B", frac23: "\u2154", frac25: "\u2156", frac34: "\xBE", frac35: "\u2157", frac38: "\u215C", frac45: "\u2158", frac56: "\u215A", frac58: "\u215D", frac78: "\u215E", frasl: "\u2044", frown: "\u2322", fscr: "\u{1D4BB}", Fscr: "\u2131", gacute: "\u01F5", Gamma: "\u0393", gamma: "\u03B3", Gammad: "\u03DC", gammad: "\u03DD", gap: "\u2A86", Gbreve: "\u011E", gbreve: "\u011F", Gcedil: "\u0122", Gcirc: "\u011C", gcirc: "\u011D", Gcy: "\u0413", gcy: "\u0433", Gdot: "\u0120", gdot: "\u0121", ge: "\u2265", gE: "\u2267", gEl: "\u2A8C", gel: "\u22DB", geq: "\u2265", geqq: "\u2267", geqslant: "\u2A7E", gescc: "\u2AA9", ges: "\u2A7E", gesdot: "\u2A80", gesdoto: "\u2A82", gesdotol: "\u2A84", gesl: "\u22DB\uFE00", gesles: "\u2A94", Gfr: "\u{1D50A}", gfr: "\u{1D524}", gg: "\u226B", Gg: "\u22D9", ggg: "\u22D9", gimel: "\u2137", GJcy: "\u0403", gjcy: "\u0453", gla: "\u2AA5", gl: "\u2277", glE: "\u2A92", glj: "\u2AA4", gnap: "\u2A8A", gnapprox: "\u2A8A", gne: "\u2A88", gnE: "\u2269", gneq: "\u2A88", gneqq: "\u2269", gnsim: "\u22E7", Gopf: "\u{1D53E}", gopf: "\u{1D558}", grave: "`", GreaterEqual: "\u2265", GreaterEqualLess: "\u22DB", GreaterFullEqual: "\u2267", GreaterGreater: "\u2AA2", GreaterLess: "\u2277", GreaterSlantEqual: "\u2A7E", GreaterTilde: "\u2273", Gscr: "\u{1D4A2}", gscr: "\u210A", gsim: "\u2273", gsime: "\u2A8E", gsiml: "\u2A90", gtcc: "\u2AA7", gtcir: "\u2A7A", gt: ">", GT: ">", Gt: "\u226B", gtdot: "\u22D7", gtlPar: "\u2995", gtquest: "\u2A7C", gtrapprox: "\u2A86", gtrarr: "\u2978", gtrdot: "\u22D7", gtreqless: "\u22DB", gtreqqless: "\u2A8C", gtrless: "\u2277", gtrsim: "\u2273", gvertneqq: "\u2269\uFE00", gvnE: "\u2269\uFE00", Hacek: "\u02C7", hairsp: "\u200A", half: "\xBD", hamilt: "\u210B", HARDcy: "\u042A", hardcy: "\u044A", harrcir: "\u2948", harr: "\u2194", hArr: "\u21D4", harrw: "\u21AD", Hat: "^", hbar: "\u210F", Hcirc: "\u0124", hcirc: "\u0125", hearts: "\u2665", heartsuit: "\u2665", hellip: "\u2026", hercon: "\u22B9", hfr: "\u{1D525}", Hfr: "\u210C", HilbertSpace: "\u210B", hksearow: "\u2925", hkswarow: "\u2926", hoarr: "\u21FF", homtht: "\u223B", hookleftarrow: "\u21A9", hookrightarrow: "\u21AA", hopf: "\u{1D559}", Hopf: "\u210D", horbar: "\u2015", HorizontalLine: "\u2500", hscr: "\u{1D4BD}", Hscr: "\u210B", hslash: "\u210F", Hstrok: "\u0126", hstrok: "\u0127", HumpDownHump: "\u224E", HumpEqual: "\u224F", hybull: "\u2043", hyphen: "\u2010", Iacute: "\xCD", iacute: "\xED", ic: "\u2063", Icirc: "\xCE", icirc: "\xEE", Icy: "\u0418", icy: "\u0438", Idot: "\u0130", IEcy: "\u0415", iecy: "\u0435", iexcl: "\xA1", iff: "\u21D4", ifr: "\u{1D526}", Ifr: "\u2111", Igrave: "\xCC", igrave: "\xEC", ii: "\u2148", iiiint: "\u2A0C", iiint: "\u222D", iinfin: "\u29DC", iiota: "\u2129", IJlig: "\u0132", ijlig: "\u0133", Imacr: "\u012A", imacr: "\u012B", image: "\u2111", ImaginaryI: "\u2148", imagline: "\u2110", imagpart: "\u2111", imath: "\u0131", Im: "\u2111", imof: "\u22B7", imped: "\u01B5", Implies: "\u21D2", incare: "\u2105", in: "\u2208", infin: "\u221E", infintie: "\u29DD", inodot: "\u0131", intcal: "\u22BA", int: "\u222B", Int: "\u222C", integers: "\u2124", Integral: "\u222B", intercal: "\u22BA", Intersection: "\u22C2", intlarhk: "\u2A17", intprod: "\u2A3C", InvisibleComma: "\u2063", InvisibleTimes: "\u2062", IOcy: "\u0401", iocy: "\u0451", Iogon: "\u012E", iogon: "\u012F", Iopf: "\u{1D540}", iopf: "\u{1D55A}", Iota: "\u0399", iota: "\u03B9", iprod: "\u2A3C", iquest: "\xBF", iscr: "\u{1D4BE}", Iscr: "\u2110", isin: "\u2208", isindot: "\u22F5", isinE: "\u22F9", isins: "\u22F4", isinsv: "\u22F3", isinv: "\u2208", it: "\u2062", Itilde: "\u0128", itilde: "\u0129", Iukcy: "\u0406", iukcy: "\u0456", Iuml: "\xCF", iuml: "\xEF", Jcirc: "\u0134", jcirc: "\u0135", Jcy: "\u0419", jcy: "\u0439", Jfr: "\u{1D50D}", jfr: "\u{1D527}", jmath: "\u0237", Jopf: "\u{1D541}", jopf: "\u{1D55B}", Jscr: "\u{1D4A5}", jscr: "\u{1D4BF}", Jsercy: "\u0408", jsercy: "\u0458", Jukcy: "\u0404", jukcy: "\u0454", Kappa: "\u039A", kappa: "\u03BA", kappav: "\u03F0", Kcedil: "\u0136", kcedil: "\u0137", Kcy: "\u041A", kcy: "\u043A", Kfr: "\u{1D50E}", kfr: "\u{1D528}", kgreen: "\u0138", KHcy: "\u0425", khcy: "\u0445", KJcy: "\u040C", kjcy: "\u045C", Kopf: "\u{1D542}", kopf: "\u{1D55C}", Kscr: "\u{1D4A6}", kscr: "\u{1D4C0}", lAarr: "\u21DA", Lacute: "\u0139", lacute: "\u013A", laemptyv: "\u29B4", lagran: "\u2112", Lambda: "\u039B", lambda: "\u03BB", lang: "\u27E8", Lang: "\u27EA", langd: "\u2991", langle: "\u27E8", lap: "\u2A85", Laplacetrf: "\u2112", laquo: "\xAB", larrb: "\u21E4", larrbfs: "\u291F", larr: "\u2190", Larr: "\u219E", lArr: "\u21D0", larrfs: "\u291D", larrhk: "\u21A9", larrlp: "\u21AB", larrpl: "\u2939", larrsim: "\u2973", larrtl: "\u21A2", latail: "\u2919", lAtail: "\u291B", lat: "\u2AAB", late: "\u2AAD", lates: "\u2AAD\uFE00", lbarr: "\u290C", lBarr: "\u290E", lbbrk: "\u2772", lbrace: "{", lbrack: "[", lbrke: "\u298B", lbrksld: "\u298F", lbrkslu: "\u298D", Lcaron: "\u013D", lcaron: "\u013E", Lcedil: "\u013B", lcedil: "\u013C", lceil: "\u2308", lcub: "{", Lcy: "\u041B", lcy: "\u043B", ldca: "\u2936", ldquo: "\u201C", ldquor: "\u201E", ldrdhar: "\u2967", ldrushar: "\u294B", ldsh: "\u21B2", le: "\u2264", lE: "\u2266", LeftAngleBracket: "\u27E8", LeftArrowBar: "\u21E4", leftarrow: "\u2190", LeftArrow: "\u2190", Leftarrow: "\u21D0", LeftArrowRightArrow: "\u21C6", leftarrowtail: "\u21A2", LeftCeiling: "\u2308", LeftDoubleBracket: "\u27E6", LeftDownTeeVector: "\u2961", LeftDownVectorBar: "\u2959", LeftDownVector: "\u21C3", LeftFloor: "\u230A", leftharpoondown: "\u21BD", leftharpoonup: "\u21BC", leftleftarrows: "\u21C7", leftrightarrow: "\u2194", LeftRightArrow: "\u2194", Leftrightarrow: "\u21D4", leftrightarrows: "\u21C6", leftrightharpoons: "\u21CB", leftrightsquigarrow: "\u21AD", LeftRightVector: "\u294E", LeftTeeArrow: "\u21A4", LeftTee: "\u22A3", LeftTeeVector: "\u295A", leftthreetimes: "\u22CB", LeftTriangleBar: "\u29CF", LeftTriangle: "\u22B2", LeftTriangleEqual: "\u22B4", LeftUpDownVector: "\u2951", LeftUpTeeVector: "\u2960", LeftUpVectorBar: "\u2958", LeftUpVector: "\u21BF", LeftVectorBar: "\u2952", LeftVector: "\u21BC", lEg: "\u2A8B", leg: "\u22DA", leq: "\u2264", leqq: "\u2266", leqslant: "\u2A7D", lescc: "\u2AA8", les: "\u2A7D", lesdot: "\u2A7F", lesdoto: "\u2A81", lesdotor: "\u2A83", lesg: "\u22DA\uFE00", lesges: "\u2A93", lessapprox: "\u2A85", lessdot: "\u22D6", lesseqgtr: "\u22DA", lesseqqgtr: "\u2A8B", LessEqualGreater: "\u22DA", LessFullEqual: "\u2266", LessGreater: "\u2276", lessgtr: "\u2276", LessLess: "\u2AA1", lesssim: "\u2272", LessSlantEqual: "\u2A7D", LessTilde: "\u2272", lfisht: "\u297C", lfloor: "\u230A", Lfr: "\u{1D50F}", lfr: "\u{1D529}", lg: "\u2276", lgE: "\u2A91", lHar: "\u2962", lhard: "\u21BD", lharu: "\u21BC", lharul: "\u296A", lhblk: "\u2584", LJcy: "\u0409", ljcy: "\u0459", llarr: "\u21C7", ll: "\u226A", Ll: "\u22D8", llcorner: "\u231E", Lleftarrow: "\u21DA", llhard: "\u296B", lltri: "\u25FA", Lmidot: "\u013F", lmidot: "\u0140", lmoustache: "\u23B0", lmoust: "\u23B0", lnap: "\u2A89", lnapprox: "\u2A89", lne: "\u2A87", lnE: "\u2268", lneq: "\u2A87", lneqq: "\u2268", lnsim: "\u22E6", loang: "\u27EC", loarr: "\u21FD", lobrk: "\u27E6", longleftarrow: "\u27F5", LongLeftArrow: "\u27F5", Longleftarrow: "\u27F8", longleftrightarrow: "\u27F7", LongLeftRightArrow: "\u27F7", Longleftrightarrow: "\u27FA", longmapsto: "\u27FC", longrightarrow: "\u27F6", LongRightArrow: "\u27F6", Longrightarrow: "\u27F9", looparrowleft: "\u21AB", looparrowright: "\u21AC", lopar: "\u2985", Lopf: "\u{1D543}", lopf: "\u{1D55D}", loplus: "\u2A2D", lotimes: "\u2A34", lowast: "\u2217", lowbar: "_", LowerLeftArrow: "\u2199", LowerRightArrow: "\u2198", loz: "\u25CA", lozenge: "\u25CA", lozf: "\u29EB", lpar: "(", lparlt: "\u2993", lrarr: "\u21C6", lrcorner: "\u231F", lrhar: "\u21CB", lrhard: "\u296D", lrm: "\u200E", lrtri: "\u22BF", lsaquo: "\u2039", lscr: "\u{1D4C1}", Lscr: "\u2112", lsh: "\u21B0", Lsh: "\u21B0", lsim: "\u2272", lsime: "\u2A8D", lsimg: "\u2A8F", lsqb: "[", lsquo: "\u2018", lsquor: "\u201A", Lstrok: "\u0141", lstrok: "\u0142", ltcc: "\u2AA6", ltcir: "\u2A79", lt: "<", LT: "<", Lt: "\u226A", ltdot: "\u22D6", lthree: "\u22CB", ltimes: "\u22C9", ltlarr: "\u2976", ltquest: "\u2A7B", ltri: "\u25C3", ltrie: "\u22B4", ltrif: "\u25C2", ltrPar: "\u2996", lurdshar: "\u294A", luruhar: "\u2966", lvertneqq: "\u2268\uFE00", lvnE: "\u2268\uFE00", macr: "\xAF", male: "\u2642", malt: "\u2720", maltese: "\u2720", Map: "\u2905", map: "\u21A6", mapsto: "\u21A6", mapstodown: "\u21A7", mapstoleft: "\u21A4", mapstoup: "\u21A5", marker: "\u25AE", mcomma: "\u2A29", Mcy: "\u041C", mcy: "\u043C", mdash: "\u2014", mDDot: "\u223A", measuredangle: "\u2221", MediumSpace: "\u205F", Mellintrf: "\u2133", Mfr: "\u{1D510}", mfr: "\u{1D52A}", mho: "\u2127", micro: "\xB5", midast: "*", midcir: "\u2AF0", mid: "\u2223", middot: "\xB7", minusb: "\u229F", minus: "\u2212", minusd: "\u2238", minusdu: "\u2A2A", MinusPlus: "\u2213", mlcp: "\u2ADB", mldr: "\u2026", mnplus: "\u2213", models: "\u22A7", Mopf: "\u{1D544}", mopf: "\u{1D55E}", mp: "\u2213", mscr: "\u{1D4C2}", Mscr: "\u2133", mstpos: "\u223E", Mu: "\u039C", mu: "\u03BC", multimap: "\u22B8", mumap: "\u22B8", nabla: "\u2207", Nacute: "\u0143", nacute: "\u0144", nang: "\u2220\u20D2", nap: "\u2249", napE: "\u2A70\u0338", napid: "\u224B\u0338", napos: "\u0149", napprox: "\u2249", natural: "\u266E", naturals: "\u2115", natur: "\u266E", nbsp: "\xA0", nbump: "\u224E\u0338", nbumpe: "\u224F\u0338", ncap: "\u2A43", Ncaron: "\u0147", ncaron: "\u0148", Ncedil: "\u0145", ncedil: "\u0146", ncong: "\u2247", ncongdot: "\u2A6D\u0338", ncup: "\u2A42", Ncy: "\u041D", ncy: "\u043D", ndash: "\u2013", nearhk: "\u2924", nearr: "\u2197", neArr: "\u21D7", nearrow: "\u2197", ne: "\u2260", nedot: "\u2250\u0338", NegativeMediumSpace: "\u200B", NegativeThickSpace: "\u200B", NegativeThinSpace: "\u200B", NegativeVeryThinSpace: "\u200B", nequiv: "\u2262", nesear: "\u2928", nesim: "\u2242\u0338", NestedGreaterGreater: "\u226B", NestedLessLess: "\u226A", NewLine: "\n", nexist: "\u2204", nexists: "\u2204", Nfr: "\u{1D511}", nfr: "\u{1D52B}", ngE: "\u2267\u0338", nge: "\u2271", ngeq: "\u2271", ngeqq: "\u2267\u0338", ngeqslant: "\u2A7E\u0338", nges: "\u2A7E\u0338", nGg: "\u22D9\u0338", ngsim: "\u2275", nGt: "\u226B\u20D2", ngt: "\u226F", ngtr: "\u226F", nGtv: "\u226B\u0338", nharr: "\u21AE", nhArr: "\u21CE", nhpar: "\u2AF2", ni: "\u220B", nis: "\u22FC", nisd: "\u22FA", niv: "\u220B", NJcy: "\u040A", njcy: "\u045A", nlarr: "\u219A", nlArr: "\u21CD", nldr: "\u2025", nlE: "\u2266\u0338", nle: "\u2270", nleftarrow: "\u219A", nLeftarrow: "\u21CD", nleftrightarrow: "\u21AE", nLeftrightarrow: "\u21CE", nleq: "\u2270", nleqq: "\u2266\u0338", nleqslant: "\u2A7D\u0338", nles: "\u2A7D\u0338", nless: "\u226E", nLl: "\u22D8\u0338", nlsim: "\u2274", nLt: "\u226A\u20D2", nlt: "\u226E", nltri: "\u22EA", nltrie: "\u22EC", nLtv: "\u226A\u0338", nmid: "\u2224", NoBreak: "\u2060", NonBreakingSpace: "\xA0", nopf: "\u{1D55F}", Nopf: "\u2115", Not: "\u2AEC", not: "\xAC", NotCongruent: "\u2262", NotCupCap: "\u226D", NotDoubleVerticalBar: "\u2226", NotElement: "\u2209", NotEqual: "\u2260", NotEqualTilde: "\u2242\u0338", NotExists: "\u2204", NotGreater: "\u226F", NotGreaterEqual: "\u2271", NotGreaterFullEqual: "\u2267\u0338", NotGreaterGreater: "\u226B\u0338", NotGreaterLess: "\u2279", NotGreaterSlantEqual: "\u2A7E\u0338", NotGreaterTilde: "\u2275", NotHumpDownHump: "\u224E\u0338", NotHumpEqual: "\u224F\u0338", notin: "\u2209", notindot: "\u22F5\u0338", notinE: "\u22F9\u0338", notinva: "\u2209", notinvb: "\u22F7", notinvc: "\u22F6", NotLeftTriangleBar: "\u29CF\u0338", NotLeftTriangle: "\u22EA", NotLeftTriangleEqual: "\u22EC", NotLess: "\u226E", NotLessEqual: "\u2270", NotLessGreater: "\u2278", NotLessLess: "\u226A\u0338", NotLessSlantEqual: "\u2A7D\u0338", NotLessTilde: "\u2274", NotNestedGreaterGreater: "\u2AA2\u0338", NotNestedLessLess: "\u2AA1\u0338", notni: "\u220C", notniva: "\u220C", notnivb: "\u22FE", notnivc: "\u22FD", NotPrecedes: "\u2280", NotPrecedesEqual: "\u2AAF\u0338", NotPrecedesSlantEqual: "\u22E0", NotReverseElement: "\u220C", NotRightTriangleBar: "\u29D0\u0338", NotRightTriangle: "\u22EB", NotRightTriangleEqual: "\u22ED", NotSquareSubset: "\u228F\u0338", NotSquareSubsetEqual: "\u22E2", NotSquareSuperset: "\u2290\u0338", NotSquareSupersetEqual: "\u22E3", NotSubset: "\u2282\u20D2", NotSubsetEqual: "\u2288", NotSucceeds: "\u2281", NotSucceedsEqual: "\u2AB0\u0338", NotSucceedsSlantEqual: "\u22E1", NotSucceedsTilde: "\u227F\u0338", NotSuperset: "\u2283\u20D2", NotSupersetEqual: "\u2289", NotTilde: "\u2241", NotTildeEqual: "\u2244", NotTildeFullEqual: "\u2247", NotTildeTilde: "\u2249", NotVerticalBar: "\u2224", nparallel: "\u2226", npar: "\u2226", nparsl: "\u2AFD\u20E5", npart: "\u2202\u0338", npolint: "\u2A14", npr: "\u2280", nprcue: "\u22E0", nprec: "\u2280", npreceq: "\u2AAF\u0338", npre: "\u2AAF\u0338", nrarrc: "\u2933\u0338", nrarr: "\u219B", nrArr: "\u21CF", nrarrw: "\u219D\u0338", nrightarrow: "\u219B", nRightarrow: "\u21CF", nrtri: "\u22EB", nrtrie: "\u22ED", nsc: "\u2281", nsccue: "\u22E1", nsce: "\u2AB0\u0338", Nscr: "\u{1D4A9}", nscr: "\u{1D4C3}", nshortmid: "\u2224", nshortparallel: "\u2226", nsim: "\u2241", nsime: "\u2244", nsimeq: "\u2244", nsmid: "\u2224", nspar: "\u2226", nsqsube: "\u22E2", nsqsupe: "\u22E3", nsub: "\u2284", nsubE: "\u2AC5\u0338", nsube: "\u2288", nsubset: "\u2282\u20D2", nsubseteq: "\u2288", nsubseteqq: "\u2AC5\u0338", nsucc: "\u2281", nsucceq: "\u2AB0\u0338", nsup: "\u2285", nsupE: "\u2AC6\u0338", nsupe: "\u2289", nsupset: "\u2283\u20D2", nsupseteq: "\u2289", nsupseteqq: "\u2AC6\u0338", ntgl: "\u2279", Ntilde: "\xD1", ntilde: "\xF1", ntlg: "\u2278", ntriangleleft: "\u22EA", ntrianglelefteq: "\u22EC", ntriangleright: "\u22EB", ntrianglerighteq: "\u22ED", Nu: "\u039D", nu: "\u03BD", num: "#", numero: "\u2116", numsp: "\u2007", nvap: "\u224D\u20D2", nvdash: "\u22AC", nvDash: "\u22AD", nVdash: "\u22AE", nVDash: "\u22AF", nvge: "\u2265\u20D2", nvgt: ">\u20D2", nvHarr: "\u2904", nvinfin: "\u29DE", nvlArr: "\u2902", nvle: "\u2264\u20D2", nvlt: "<\u20D2", nvltrie: "\u22B4\u20D2", nvrArr: "\u2903", nvrtrie: "\u22B5\u20D2", nvsim: "\u223C\u20D2", nwarhk: "\u2923", nwarr: "\u2196", nwArr: "\u21D6", nwarrow: "\u2196", nwnear: "\u2927", Oacute: "\xD3", oacute: "\xF3", oast: "\u229B", Ocirc: "\xD4", ocirc: "\xF4", ocir: "\u229A", Ocy: "\u041E", ocy: "\u043E", odash: "\u229D", Odblac: "\u0150", odblac: "\u0151", odiv: "\u2A38", odot: "\u2299", odsold: "\u29BC", OElig: "\u0152", oelig: "\u0153", ofcir: "\u29BF", Ofr: "\u{1D512}", ofr: "\u{1D52C}", ogon: "\u02DB", Ograve: "\xD2", ograve: "\xF2", ogt: "\u29C1", ohbar: "\u29B5", ohm: "\u03A9", oint: "\u222E", olarr: "\u21BA", olcir: "\u29BE", olcross: "\u29BB", oline: "\u203E", olt: "\u29C0", Omacr: "\u014C", omacr: "\u014D", Omega: "\u03A9", omega: "\u03C9", Omicron: "\u039F", omicron: "\u03BF", omid: "\u29B6", ominus: "\u2296", Oopf: "\u{1D546}", oopf: "\u{1D560}", opar: "\u29B7", OpenCurlyDoubleQuote: "\u201C", OpenCurlyQuote: "\u2018", operp: "\u29B9", oplus: "\u2295", orarr: "\u21BB", Or: "\u2A54", or: "\u2228", ord: "\u2A5D", order: "\u2134", orderof: "\u2134", ordf: "\xAA", ordm: "\xBA", origof: "\u22B6", oror: "\u2A56", orslope: "\u2A57", orv: "\u2A5B", oS: "\u24C8", Oscr: "\u{1D4AA}", oscr: "\u2134", Oslash: "\xD8", oslash: "\xF8", osol: "\u2298", Otilde: "\xD5", otilde: "\xF5", otimesas: "\u2A36", Otimes: "\u2A37", otimes: "\u2297", Ouml: "\xD6", ouml: "\xF6", ovbar: "\u233D", OverBar: "\u203E", OverBrace: "\u23DE", OverBracket: "\u23B4", OverParenthesis: "\u23DC", para: "\xB6", parallel: "\u2225", par: "\u2225", parsim: "\u2AF3", parsl: "\u2AFD", part: "\u2202", PartialD: "\u2202", Pcy: "\u041F", pcy: "\u043F", percnt: "%", period: ".", permil: "\u2030", perp: "\u22A5", pertenk: "\u2031", Pfr: "\u{1D513}", pfr: "\u{1D52D}", Phi: "\u03A6", phi: "\u03C6", phiv: "\u03D5", phmmat: "\u2133", phone: "\u260E", Pi: "\u03A0", pi: "\u03C0", pitchfork: "\u22D4", piv: "\u03D6", planck: "\u210F", planckh: "\u210E", plankv: "\u210F", plusacir: "\u2A23", plusb: "\u229E", pluscir: "\u2A22", plus: "+", plusdo: "\u2214", plusdu: "\u2A25", pluse: "\u2A72", PlusMinus: "\xB1", plusmn: "\xB1", plussim: "\u2A26", plustwo: "\u2A27", pm: "\xB1", Poincareplane: "\u210C", pointint: "\u2A15", popf: "\u{1D561}", Popf: "\u2119", pound: "\xA3", prap: "\u2AB7", Pr: "\u2ABB", pr: "\u227A", prcue: "\u227C", precapprox: "\u2AB7", prec: "\u227A", preccurlyeq: "\u227C", Precedes: "\u227A", PrecedesEqual: "\u2AAF", PrecedesSlantEqual: "\u227C", PrecedesTilde: "\u227E", preceq: "\u2AAF", precnapprox: "\u2AB9", precneqq: "\u2AB5", precnsim: "\u22E8", pre: "\u2AAF", prE: "\u2AB3", precsim: "\u227E", prime: "\u2032", Prime: "\u2033", primes: "\u2119", prnap: "\u2AB9", prnE: "\u2AB5", prnsim: "\u22E8", prod: "\u220F", Product: "\u220F", profalar: "\u232E", profline: "\u2312", profsurf: "\u2313", prop: "\u221D", Proportional: "\u221D", Proportion: "\u2237", propto: "\u221D", prsim: "\u227E", prurel: "\u22B0", Pscr: "\u{1D4AB}", pscr: "\u{1D4C5}", Psi: "\u03A8", psi: "\u03C8", puncsp: "\u2008", Qfr: "\u{1D514}", qfr: "\u{1D52E}", qint: "\u2A0C", qopf: "\u{1D562}", Qopf: "\u211A", qprime: "\u2057", Qscr: "\u{1D4AC}", qscr: "\u{1D4C6}", quaternions: "\u210D", quatint: "\u2A16", quest: "?", questeq: "\u225F", quot: '"', QUOT: '"', rAarr: "\u21DB", race: "\u223D\u0331", Racute: "\u0154", racute: "\u0155", radic: "\u221A", raemptyv: "\u29B3", rang: "\u27E9", Rang: "\u27EB", rangd: "\u2992", range: "\u29A5", rangle: "\u27E9", raquo: "\xBB", rarrap: "\u2975", rarrb: "\u21E5", rarrbfs: "\u2920", rarrc: "\u2933", rarr: "\u2192", Rarr: "\u21A0", rArr: "\u21D2", rarrfs: "\u291E", rarrhk: "\u21AA", rarrlp: "\u21AC", rarrpl: "\u2945", rarrsim: "\u2974", Rarrtl: "\u2916", rarrtl: "\u21A3", rarrw: "\u219D", ratail: "\u291A", rAtail: "\u291C", ratio: "\u2236", rationals: "\u211A", rbarr: "\u290D", rBarr: "\u290F", RBarr: "\u2910", rbbrk: "\u2773", rbrace: "}", rbrack: "]", rbrke: "\u298C", rbrksld: "\u298E", rbrkslu: "\u2990", Rcaron: "\u0158", rcaron: "\u0159", Rcedil: "\u0156", rcedil: "\u0157", rceil: "\u2309", rcub: "}", Rcy: "\u0420", rcy: "\u0440", rdca: "\u2937", rdldhar: "\u2969", rdquo: "\u201D", rdquor: "\u201D", rdsh: "\u21B3", real: "\u211C", realine: "\u211B", realpart: "\u211C", reals: "\u211D", Re: "\u211C", rect: "\u25AD", reg: "\xAE", REG: "\xAE", ReverseElement: "\u220B", ReverseEquilibrium: "\u21CB", ReverseUpEquilibrium: "\u296F", rfisht: "\u297D", rfloor: "\u230B", rfr: "\u{1D52F}", Rfr: "\u211C", rHar: "\u2964", rhard: "\u21C1", rharu: "\u21C0", rharul: "\u296C", Rho: "\u03A1", rho: "\u03C1", rhov: "\u03F1", RightAngleBracket: "\u27E9", RightArrowBar: "\u21E5", rightarrow: "\u2192", RightArrow: "\u2192", Rightarrow: "\u21D2", RightArrowLeftArrow: "\u21C4", rightarrowtail: "\u21A3", RightCeiling: "\u2309", RightDoubleBracket: "\u27E7", RightDownTeeVector: "\u295D", RightDownVectorBar: "\u2955", RightDownVector: "\u21C2", RightFloor: "\u230B", rightharpoondown: "\u21C1", rightharpoonup: "\u21C0", rightleftarrows: "\u21C4", rightleftharpoons: "\u21CC", rightrightarrows: "\u21C9", rightsquigarrow: "\u219D", RightTeeArrow: "\u21A6", RightTee: "\u22A2", RightTeeVector: "\u295B", rightthreetimes: "\u22CC", RightTriangleBar: "\u29D0", RightTriangle: "\u22B3", RightTriangleEqual: "\u22B5", RightUpDownVector: "\u294F", RightUpTeeVector: "\u295C", RightUpVectorBar: "\u2954", RightUpVector: "\u21BE", RightVectorBar: "\u2953", RightVector: "\u21C0", ring: "\u02DA", risingdotseq: "\u2253", rlarr: "\u21C4", rlhar: "\u21CC", rlm: "\u200F", rmoustache: "\u23B1", rmoust: "\u23B1", rnmid: "\u2AEE", roang: "\u27ED", roarr: "\u21FE", robrk: "\u27E7", ropar: "\u2986", ropf: "\u{1D563}", Ropf: "\u211D", roplus: "\u2A2E", rotimes: "\u2A35", RoundImplies: "\u2970", rpar: ")", rpargt: "\u2994", rppolint: "\u2A12", rrarr: "\u21C9", Rrightarrow: "\u21DB", rsaquo: "\u203A", rscr: "\u{1D4C7}", Rscr: "\u211B", rsh: "\u21B1", Rsh: "\u21B1", rsqb: "]", rsquo: "\u2019", rsquor: "\u2019", rthree: "\u22CC", rtimes: "\u22CA", rtri: "\u25B9", rtrie: "\u22B5", rtrif: "\u25B8", rtriltri: "\u29CE", RuleDelayed: "\u29F4", ruluhar: "\u2968", rx: "\u211E", Sacute: "\u015A", sacute: "\u015B", sbquo: "\u201A", scap: "\u2AB8", Scaron: "\u0160", scaron: "\u0161", Sc: "\u2ABC", sc: "\u227B", sccue: "\u227D", sce: "\u2AB0", scE: "\u2AB4", Scedil: "\u015E", scedil: "\u015F", Scirc: "\u015C", scirc: "\u015D", scnap: "\u2ABA", scnE: "\u2AB6", scnsim: "\u22E9", scpolint: "\u2A13", scsim: "\u227F", Scy: "\u0421", scy: "\u0441", sdotb: "\u22A1", sdot: "\u22C5", sdote: "\u2A66", searhk: "\u2925", searr: "\u2198", seArr: "\u21D8", searrow: "\u2198", sect: "\xA7", semi: ";", seswar: "\u2929", setminus: "\u2216", setmn: "\u2216", sext: "\u2736", Sfr: "\u{1D516}", sfr: "\u{1D530}", sfrown: "\u2322", sharp: "\u266F", SHCHcy: "\u0429", shchcy: "\u0449", SHcy: "\u0428", shcy: "\u0448", ShortDownArrow: "\u2193", ShortLeftArrow: "\u2190", shortmid: "\u2223", shortparallel: "\u2225", ShortRightArrow: "\u2192", ShortUpArrow: "\u2191", shy: "\xAD", Sigma: "\u03A3", sigma: "\u03C3", sigmaf: "\u03C2", sigmav: "\u03C2", sim: "\u223C", simdot: "\u2A6A", sime: "\u2243", simeq: "\u2243", simg: "\u2A9E", simgE: "\u2AA0", siml: "\u2A9D", simlE: "\u2A9F", simne: "\u2246", simplus: "\u2A24", simrarr: "\u2972", slarr: "\u2190", SmallCircle: "\u2218", smallsetminus: "\u2216", smashp: "\u2A33", smeparsl: "\u29E4", smid: "\u2223", smile: "\u2323", smt: "\u2AAA", smte: "\u2AAC", smtes: "\u2AAC\uFE00", SOFTcy: "\u042C", softcy: "\u044C", solbar: "\u233F", solb: "\u29C4", sol: "/", Sopf: "\u{1D54A}", sopf: "\u{1D564}", spades: "\u2660", spadesuit: "\u2660", spar: "\u2225", sqcap: "\u2293", sqcaps: "\u2293\uFE00", sqcup: "\u2294", sqcups: "\u2294\uFE00", Sqrt: "\u221A", sqsub: "\u228F", sqsube: "\u2291", sqsubset: "\u228F", sqsubseteq: "\u2291", sqsup: "\u2290", sqsupe: "\u2292", sqsupset: "\u2290", sqsupseteq: "\u2292", square: "\u25A1", Square: "\u25A1", SquareIntersection: "\u2293", SquareSubset: "\u228F", SquareSubsetEqual: "\u2291", SquareSuperset: "\u2290", SquareSupersetEqual: "\u2292", SquareUnion: "\u2294", squarf: "\u25AA", squ: "\u25A1", squf: "\u25AA", srarr: "\u2192", Sscr: "\u{1D4AE}", sscr: "\u{1D4C8}", ssetmn: "\u2216", ssmile: "\u2323", sstarf: "\u22C6", Star: "\u22C6", star: "\u2606", starf: "\u2605", straightepsilon: "\u03F5", straightphi: "\u03D5", strns: "\xAF", sub: "\u2282", Sub: "\u22D0", subdot: "\u2ABD", subE: "\u2AC5", sube: "\u2286", subedot: "\u2AC3", submult: "\u2AC1", subnE: "\u2ACB", subne: "\u228A", subplus: "\u2ABF", subrarr: "\u2979", subset: "\u2282", Subset: "\u22D0", subseteq: "\u2286", subseteqq: "\u2AC5", SubsetEqual: "\u2286", subsetneq: "\u228A", subsetneqq: "\u2ACB", subsim: "\u2AC7", subsub: "\u2AD5", subsup: "\u2AD3", succapprox: "\u2AB8", succ: "\u227B", succcurlyeq: "\u227D", Succeeds: "\u227B", SucceedsEqual: "\u2AB0", SucceedsSlantEqual: "\u227D", SucceedsTilde: "\u227F", succeq: "\u2AB0", succnapprox: "\u2ABA", succneqq: "\u2AB6", succnsim: "\u22E9", succsim: "\u227F", SuchThat: "\u220B", sum: "\u2211", Sum: "\u2211", sung: "\u266A", sup1: "\xB9", sup2: "\xB2", sup3: "\xB3", sup: "\u2283", Sup: "\u22D1", supdot: "\u2ABE", supdsub: "\u2AD8", supE: "\u2AC6", supe: "\u2287", supedot: "\u2AC4", Superset: "\u2283", SupersetEqual: "\u2287", suphsol: "\u27C9", suphsub: "\u2AD7", suplarr: "\u297B", supmult: "\u2AC2", supnE: "\u2ACC", supne: "\u228B", supplus: "\u2AC0", supset: "\u2283", Supset: "\u22D1", supseteq: "\u2287", supseteqq: "\u2AC6", supsetneq: "\u228B", supsetneqq: "\u2ACC", supsim: "\u2AC8", supsub: "\u2AD4", supsup: "\u2AD6", swarhk: "\u2926", swarr: "\u2199", swArr: "\u21D9", swarrow: "\u2199", swnwar: "\u292A", szlig: "\xDF", Tab: "	", target: "\u2316", Tau: "\u03A4", tau: "\u03C4", tbrk: "\u23B4", Tcaron: "\u0164", tcaron: "\u0165", Tcedil: "\u0162", tcedil: "\u0163", Tcy: "\u0422", tcy: "\u0442", tdot: "\u20DB", telrec: "\u2315", Tfr: "\u{1D517}", tfr: "\u{1D531}", there4: "\u2234", therefore: "\u2234", Therefore: "\u2234", Theta: "\u0398", theta: "\u03B8", thetasym: "\u03D1", thetav: "\u03D1", thickapprox: "\u2248", thicksim: "\u223C", ThickSpace: "\u205F\u200A", ThinSpace: "\u2009", thinsp: "\u2009", thkap: "\u2248", thksim: "\u223C", THORN: "\xDE", thorn: "\xFE", tilde: "\u02DC", Tilde: "\u223C", TildeEqual: "\u2243", TildeFullEqual: "\u2245", TildeTilde: "\u2248", timesbar: "\u2A31", timesb: "\u22A0", times: "\xD7", timesd: "\u2A30", tint: "\u222D", toea: "\u2928", topbot: "\u2336", topcir: "\u2AF1", top: "\u22A4", Topf: "\u{1D54B}", topf: "\u{1D565}", topfork: "\u2ADA", tosa: "\u2929", tprime: "\u2034", trade: "\u2122", TRADE: "\u2122", triangle: "\u25B5", triangledown: "\u25BF", triangleleft: "\u25C3", trianglelefteq: "\u22B4", triangleq: "\u225C", triangleright: "\u25B9", trianglerighteq: "\u22B5", tridot: "\u25EC", trie: "\u225C", triminus: "\u2A3A", TripleDot: "\u20DB", triplus: "\u2A39", trisb: "\u29CD", tritime: "\u2A3B", trpezium: "\u23E2", Tscr: "\u{1D4AF}", tscr: "\u{1D4C9}", TScy: "\u0426", tscy: "\u0446", TSHcy: "\u040B", tshcy: "\u045B", Tstrok: "\u0166", tstrok: "\u0167", twixt: "\u226C", twoheadleftarrow: "\u219E", twoheadrightarrow: "\u21A0", Uacute: "\xDA", uacute: "\xFA", uarr: "\u2191", Uarr: "\u219F", uArr: "\u21D1", Uarrocir: "\u2949", Ubrcy: "\u040E", ubrcy: "\u045E", Ubreve: "\u016C", ubreve: "\u016D", Ucirc: "\xDB", ucirc: "\xFB", Ucy: "\u0423", ucy: "\u0443", udarr: "\u21C5", Udblac: "\u0170", udblac: "\u0171", udhar: "\u296E", ufisht: "\u297E", Ufr: "\u{1D518}", ufr: "\u{1D532}", Ugrave: "\xD9", ugrave: "\xF9", uHar: "\u2963", uharl: "\u21BF", uharr: "\u21BE", uhblk: "\u2580", ulcorn: "\u231C", ulcorner: "\u231C", ulcrop: "\u230F", ultri: "\u25F8", Umacr: "\u016A", umacr: "\u016B", uml: "\xA8", UnderBar: "_", UnderBrace: "\u23DF", UnderBracket: "\u23B5", UnderParenthesis: "\u23DD", Union: "\u22C3", UnionPlus: "\u228E", Uogon: "\u0172", uogon: "\u0173", Uopf: "\u{1D54C}", uopf: "\u{1D566}", UpArrowBar: "\u2912", uparrow: "\u2191", UpArrow: "\u2191", Uparrow: "\u21D1", UpArrowDownArrow: "\u21C5", updownarrow: "\u2195", UpDownArrow: "\u2195", Updownarrow: "\u21D5", UpEquilibrium: "\u296E", upharpoonleft: "\u21BF", upharpoonright: "\u21BE", uplus: "\u228E", UpperLeftArrow: "\u2196", UpperRightArrow: "\u2197", upsi: "\u03C5", Upsi: "\u03D2", upsih: "\u03D2", Upsilon: "\u03A5", upsilon: "\u03C5", UpTeeArrow: "\u21A5", UpTee: "\u22A5", upuparrows: "\u21C8", urcorn: "\u231D", urcorner: "\u231D", urcrop: "\u230E", Uring: "\u016E", uring: "\u016F", urtri: "\u25F9", Uscr: "\u{1D4B0}", uscr: "\u{1D4CA}", utdot: "\u22F0", Utilde: "\u0168", utilde: "\u0169", utri: "\u25B5", utrif: "\u25B4", uuarr: "\u21C8", Uuml: "\xDC", uuml: "\xFC", uwangle: "\u29A7", vangrt: "\u299C", varepsilon: "\u03F5", varkappa: "\u03F0", varnothing: "\u2205", varphi: "\u03D5", varpi: "\u03D6", varpropto: "\u221D", varr: "\u2195", vArr: "\u21D5", varrho: "\u03F1", varsigma: "\u03C2", varsubsetneq: "\u228A\uFE00", varsubsetneqq: "\u2ACB\uFE00", varsupsetneq: "\u228B\uFE00", varsupsetneqq: "\u2ACC\uFE00", vartheta: "\u03D1", vartriangleleft: "\u22B2", vartriangleright: "\u22B3", vBar: "\u2AE8", Vbar: "\u2AEB", vBarv: "\u2AE9", Vcy: "\u0412", vcy: "\u0432", vdash: "\u22A2", vDash: "\u22A8", Vdash: "\u22A9", VDash: "\u22AB", Vdashl: "\u2AE6", veebar: "\u22BB", vee: "\u2228", Vee: "\u22C1", veeeq: "\u225A", vellip: "\u22EE", verbar: "|", Verbar: "\u2016", vert: "|", Vert: "\u2016", VerticalBar: "\u2223", VerticalLine: "|", VerticalSeparator: "\u2758", VerticalTilde: "\u2240", VeryThinSpace: "\u200A", Vfr: "\u{1D519}", vfr: "\u{1D533}", vltri: "\u22B2", vnsub: "\u2282\u20D2", vnsup: "\u2283\u20D2", Vopf: "\u{1D54D}", vopf: "\u{1D567}", vprop: "\u221D", vrtri: "\u22B3", Vscr: "\u{1D4B1}", vscr: "\u{1D4CB}", vsubnE: "\u2ACB\uFE00", vsubne: "\u228A\uFE00", vsupnE: "\u2ACC\uFE00", vsupne: "\u228B\uFE00", Vvdash: "\u22AA", vzigzag: "\u299A", Wcirc: "\u0174", wcirc: "\u0175", wedbar: "\u2A5F", wedge: "\u2227", Wedge: "\u22C0", wedgeq: "\u2259", weierp: "\u2118", Wfr: "\u{1D51A}", wfr: "\u{1D534}", Wopf: "\u{1D54E}", wopf: "\u{1D568}", wp: "\u2118", wr: "\u2240", wreath: "\u2240", Wscr: "\u{1D4B2}", wscr: "\u{1D4CC}", xcap: "\u22C2", xcirc: "\u25EF", xcup: "\u22C3", xdtri: "\u25BD", Xfr: "\u{1D51B}", xfr: "\u{1D535}", xharr: "\u27F7", xhArr: "\u27FA", Xi: "\u039E", xi: "\u03BE", xlarr: "\u27F5", xlArr: "\u27F8", xmap: "\u27FC", xnis: "\u22FB", xodot: "\u2A00", Xopf: "\u{1D54F}", xopf: "\u{1D569}", xoplus: "\u2A01", xotime: "\u2A02", xrarr: "\u27F6", xrArr: "\u27F9", Xscr: "\u{1D4B3}", xscr: "\u{1D4CD}", xsqcup: "\u2A06", xuplus: "\u2A04", xutri: "\u25B3", xvee: "\u22C1", xwedge: "\u22C0", Yacute: "\xDD", yacute: "\xFD", YAcy: "\u042F", yacy: "\u044F", Ycirc: "\u0176", ycirc: "\u0177", Ycy: "\u042B", ycy: "\u044B", yen: "\xA5", Yfr: "\u{1D51C}", yfr: "\u{1D536}", YIcy: "\u0407", yicy: "\u0457", Yopf: "\u{1D550}", yopf: "\u{1D56A}", Yscr: "\u{1D4B4}", yscr: "\u{1D4CE}", YUcy: "\u042E", yucy: "\u044E", yuml: "\xFF", Yuml: "\u0178", Zacute: "\u0179", zacute: "\u017A", Zcaron: "\u017D", zcaron: "\u017E", Zcy: "\u0417", zcy: "\u0437", Zdot: "\u017B", zdot: "\u017C", zeetrf: "\u2128", ZeroWidthSpace: "\u200B", Zeta: "\u0396", zeta: "\u03B6", zfr: "\u{1D537}", Zfr: "\u2128", ZHcy: "\u0416", zhcy: "\u0436", zigrarr: "\u21DD", zopf: "\u{1D56B}", Zopf: "\u2124", Zscr: "\u{1D4B5}", zscr: "\u{1D4CF}", zwj: "\u200D", zwnj: "\u200C" };
  }
});

// node_modules/markdown-it/lib/common/entities.js
var require_entities2 = __commonJS({
  "node_modules/markdown-it/lib/common/entities.js"(exports2, module2) {
    "use strict";
    module2.exports = require_entities();
  }
});

// node_modules/mdurl/encode.js
var require_encode = __commonJS({
  "node_modules/mdurl/encode.js"(exports2, module2) {
    "use strict";
    var encodeCache = {};
    function getEncodeCache(exclude) {
      var i, ch, cache = encodeCache[exclude];
      if (cache) {
        return cache;
      }
      cache = encodeCache[exclude] = [];
      for (i = 0; i < 128; i++) {
        ch = String.fromCharCode(i);
        if (/^[0-9a-z]$/i.test(ch)) {
          cache.push(ch);
        } else {
          cache.push("%" + ("0" + i.toString(16).toUpperCase()).slice(-2));
        }
      }
      for (i = 0; i < exclude.length; i++) {
        cache[exclude.charCodeAt(i)] = exclude[i];
      }
      return cache;
    }
    function encode(string, exclude, keepEscaped) {
      var i, l, code, nextCode, cache, result = "";
      if (typeof exclude !== "string") {
        keepEscaped = exclude;
        exclude = encode.defaultChars;
      }
      if (typeof keepEscaped === "undefined") {
        keepEscaped = true;
      }
      cache = getEncodeCache(exclude);
      for (i = 0, l = string.length; i < l; i++) {
        code = string.charCodeAt(i);
        if (keepEscaped && code === 37 && i + 2 < l) {
          if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
            result += string.slice(i, i + 3);
            i += 2;
            continue;
          }
        }
        if (code < 128) {
          result += cache[code];
          continue;
        }
        if (code >= 55296 && code <= 57343) {
          if (code >= 55296 && code <= 56319 && i + 1 < l) {
            nextCode = string.charCodeAt(i + 1);
            if (nextCode >= 56320 && nextCode <= 57343) {
              result += encodeURIComponent(string[i] + string[i + 1]);
              i++;
              continue;
            }
          }
          result += "%EF%BF%BD";
          continue;
        }
        result += encodeURIComponent(string[i]);
      }
      return result;
    }
    encode.defaultChars = ";/?:@&=+$,-_.!~*'()#";
    encode.componentChars = "-_.!~*'()";
    module2.exports = encode;
  }
});

// node_modules/mdurl/decode.js
var require_decode = __commonJS({
  "node_modules/mdurl/decode.js"(exports2, module2) {
    "use strict";
    var decodeCache = {};
    function getDecodeCache(exclude) {
      var i, ch, cache = decodeCache[exclude];
      if (cache) {
        return cache;
      }
      cache = decodeCache[exclude] = [];
      for (i = 0; i < 128; i++) {
        ch = String.fromCharCode(i);
        cache.push(ch);
      }
      for (i = 0; i < exclude.length; i++) {
        ch = exclude.charCodeAt(i);
        cache[ch] = "%" + ("0" + ch.toString(16).toUpperCase()).slice(-2);
      }
      return cache;
    }
    function decode(string, exclude) {
      var cache;
      if (typeof exclude !== "string") {
        exclude = decode.defaultChars;
      }
      cache = getDecodeCache(exclude);
      return string.replace(/(%[a-f0-9]{2})+/gi, function(seq) {
        var i, l, b1, b2, b3, b4, chr, result = "";
        for (i = 0, l = seq.length; i < l; i += 3) {
          b1 = parseInt(seq.slice(i + 1, i + 3), 16);
          if (b1 < 128) {
            result += cache[b1];
            continue;
          }
          if ((b1 & 224) === 192 && i + 3 < l) {
            b2 = parseInt(seq.slice(i + 4, i + 6), 16);
            if ((b2 & 192) === 128) {
              chr = b1 << 6 & 1984 | b2 & 63;
              if (chr < 128) {
                result += "\uFFFD\uFFFD";
              } else {
                result += String.fromCharCode(chr);
              }
              i += 3;
              continue;
            }
          }
          if ((b1 & 240) === 224 && i + 6 < l) {
            b2 = parseInt(seq.slice(i + 4, i + 6), 16);
            b3 = parseInt(seq.slice(i + 7, i + 9), 16);
            if ((b2 & 192) === 128 && (b3 & 192) === 128) {
              chr = b1 << 12 & 61440 | b2 << 6 & 4032 | b3 & 63;
              if (chr < 2048 || chr >= 55296 && chr <= 57343) {
                result += "\uFFFD\uFFFD\uFFFD";
              } else {
                result += String.fromCharCode(chr);
              }
              i += 6;
              continue;
            }
          }
          if ((b1 & 248) === 240 && i + 9 < l) {
            b2 = parseInt(seq.slice(i + 4, i + 6), 16);
            b3 = parseInt(seq.slice(i + 7, i + 9), 16);
            b4 = parseInt(seq.slice(i + 10, i + 12), 16);
            if ((b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128) {
              chr = b1 << 18 & 1835008 | b2 << 12 & 258048 | b3 << 6 & 4032 | b4 & 63;
              if (chr < 65536 || chr > 1114111) {
                result += "\uFFFD\uFFFD\uFFFD\uFFFD";
              } else {
                chr -= 65536;
                result += String.fromCharCode(55296 + (chr >> 10), 56320 + (chr & 1023));
              }
              i += 9;
              continue;
            }
          }
          result += "\uFFFD";
        }
        return result;
      });
    }
    decode.defaultChars = ";/?:@&=+$,#";
    decode.componentChars = "";
    module2.exports = decode;
  }
});

// node_modules/mdurl/format.js
var require_format = __commonJS({
  "node_modules/mdurl/format.js"(exports2, module2) {
    "use strict";
    module2.exports = function format(url) {
      var result = "";
      result += url.protocol || "";
      result += url.slashes ? "//" : "";
      result += url.auth ? url.auth + "@" : "";
      if (url.hostname && url.hostname.indexOf(":") !== -1) {
        result += "[" + url.hostname + "]";
      } else {
        result += url.hostname || "";
      }
      result += url.port ? ":" + url.port : "";
      result += url.pathname || "";
      result += url.search || "";
      result += url.hash || "";
      return result;
    };
  }
});

// node_modules/mdurl/parse.js
var require_parse = __commonJS({
  "node_modules/mdurl/parse.js"(exports2, module2) {
    "use strict";
    function Url() {
      this.protocol = null;
      this.slashes = null;
      this.auth = null;
      this.port = null;
      this.hostname = null;
      this.hash = null;
      this.search = null;
      this.pathname = null;
    }
    var protocolPattern = /^([a-z0-9.+-]+:)/i;
    var portPattern = /:[0-9]*$/;
    var simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
    var delims = ["<", ">", '"', "`", " ", "\r", "\n", "	"];
    var unwise = ["{", "}", "|", "\\", "^", "`"].concat(delims);
    var autoEscape = ["'"].concat(unwise);
    var nonHostChars = ["%", "/", "?", ";", "#"].concat(autoEscape);
    var hostEndingChars = ["/", "?", "#"];
    var hostnameMaxLen = 255;
    var hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
    var hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
    var hostlessProtocol = {
      "javascript": true,
      "javascript:": true
    };
    var slashedProtocol = {
      "http": true,
      "https": true,
      "ftp": true,
      "gopher": true,
      "file": true,
      "http:": true,
      "https:": true,
      "ftp:": true,
      "gopher:": true,
      "file:": true
    };
    function urlParse(url, slashesDenoteHost) {
      if (url && url instanceof Url) {
        return url;
      }
      var u = new Url();
      u.parse(url, slashesDenoteHost);
      return u;
    }
    Url.prototype.parse = function(url, slashesDenoteHost) {
      var i, l, lowerProto, hec, slashes, rest = url;
      rest = rest.trim();
      if (!slashesDenoteHost && url.split("#").length === 1) {
        var simplePath = simplePathPattern.exec(rest);
        if (simplePath) {
          this.pathname = simplePath[1];
          if (simplePath[2]) {
            this.search = simplePath[2];
          }
          return this;
        }
      }
      var proto = protocolPattern.exec(rest);
      if (proto) {
        proto = proto[0];
        lowerProto = proto.toLowerCase();
        this.protocol = proto;
        rest = rest.substr(proto.length);
      }
      if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
        slashes = rest.substr(0, 2) === "//";
        if (slashes && !(proto && hostlessProtocol[proto])) {
          rest = rest.substr(2);
          this.slashes = true;
        }
      }
      if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
        var hostEnd = -1;
        for (i = 0; i < hostEndingChars.length; i++) {
          hec = rest.indexOf(hostEndingChars[i]);
          if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
            hostEnd = hec;
          }
        }
        var auth, atSign;
        if (hostEnd === -1) {
          atSign = rest.lastIndexOf("@");
        } else {
          atSign = rest.lastIndexOf("@", hostEnd);
        }
        if (atSign !== -1) {
          auth = rest.slice(0, atSign);
          rest = rest.slice(atSign + 1);
          this.auth = auth;
        }
        hostEnd = -1;
        for (i = 0; i < nonHostChars.length; i++) {
          hec = rest.indexOf(nonHostChars[i]);
          if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
            hostEnd = hec;
          }
        }
        if (hostEnd === -1) {
          hostEnd = rest.length;
        }
        if (rest[hostEnd - 1] === ":") {
          hostEnd--;
        }
        var host = rest.slice(0, hostEnd);
        rest = rest.slice(hostEnd);
        this.parseHost(host);
        this.hostname = this.hostname || "";
        var ipv6Hostname = this.hostname[0] === "[" && this.hostname[this.hostname.length - 1] === "]";
        if (!ipv6Hostname) {
          var hostparts = this.hostname.split(/\./);
          for (i = 0, l = hostparts.length; i < l; i++) {
            var part = hostparts[i];
            if (!part) {
              continue;
            }
            if (!part.match(hostnamePartPattern)) {
              var newpart = "";
              for (var j = 0, k = part.length; j < k; j++) {
                if (part.charCodeAt(j) > 127) {
                  newpart += "x";
                } else {
                  newpart += part[j];
                }
              }
              if (!newpart.match(hostnamePartPattern)) {
                var validParts = hostparts.slice(0, i);
                var notHost = hostparts.slice(i + 1);
                var bit = part.match(hostnamePartStart);
                if (bit) {
                  validParts.push(bit[1]);
                  notHost.unshift(bit[2]);
                }
                if (notHost.length) {
                  rest = notHost.join(".") + rest;
                }
                this.hostname = validParts.join(".");
                break;
              }
            }
          }
        }
        if (this.hostname.length > hostnameMaxLen) {
          this.hostname = "";
        }
        if (ipv6Hostname) {
          this.hostname = this.hostname.substr(1, this.hostname.length - 2);
        }
      }
      var hash = rest.indexOf("#");
      if (hash !== -1) {
        this.hash = rest.substr(hash);
        rest = rest.slice(0, hash);
      }
      var qm = rest.indexOf("?");
      if (qm !== -1) {
        this.search = rest.substr(qm);
        rest = rest.slice(0, qm);
      }
      if (rest) {
        this.pathname = rest;
      }
      if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
        this.pathname = "";
      }
      return this;
    };
    Url.prototype.parseHost = function(host) {
      var port = portPattern.exec(host);
      if (port) {
        port = port[0];
        if (port !== ":") {
          this.port = port.substr(1);
        }
        host = host.substr(0, host.length - port.length);
      }
      if (host) {
        this.hostname = host;
      }
    };
    module2.exports = urlParse;
  }
});

// node_modules/mdurl/index.js
var require_mdurl = __commonJS({
  "node_modules/mdurl/index.js"(exports2, module2) {
    "use strict";
    module2.exports.encode = require_encode();
    module2.exports.decode = require_decode();
    module2.exports.format = require_format();
    module2.exports.parse = require_parse();
  }
});

// node_modules/uc.micro/categories/Cf/regex.js
var require_regex5 = __commonJS({
  "node_modules/uc.micro/categories/Cf/regex.js"(exports2, module2) {
    module2.exports = /[\xAD\u0600-\u0605\u061C\u06DD\u070F\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB]|\uD804[\uDCBD\uDCCD]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]/;
  }
});

// node_modules/uc.micro/index.js
var require_uc = __commonJS({
  "node_modules/uc.micro/index.js"(exports2) {
    "use strict";
    exports2.Any = require_regex();
    exports2.Cc = require_regex2();
    exports2.Cf = require_regex5();
    exports2.P = require_regex4();
    exports2.Z = require_regex3();
  }
});

// node_modules/markdown-it/lib/common/utils.js
var require_utils3 = __commonJS({
  "node_modules/markdown-it/lib/common/utils.js"(exports2) {
    "use strict";
    function _class(obj) {
      return Object.prototype.toString.call(obj);
    }
    function isString(obj) {
      return _class(obj) === "[object String]";
    }
    var _hasOwnProperty = Object.prototype.hasOwnProperty;
    function has(object, key) {
      return _hasOwnProperty.call(object, key);
    }
    function assign(obj) {
      var sources = Array.prototype.slice.call(arguments, 1);
      sources.forEach(function(source) {
        if (!source) {
          return;
        }
        if (typeof source !== "object") {
          throw new TypeError(source + "must be object");
        }
        Object.keys(source).forEach(function(key) {
          obj[key] = source[key];
        });
      });
      return obj;
    }
    function arrayReplaceAt(src, pos, newElements) {
      return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));
    }
    function isValidEntityCode(c) {
      if (c >= 55296 && c <= 57343) {
        return false;
      }
      if (c >= 64976 && c <= 65007) {
        return false;
      }
      if ((c & 65535) === 65535 || (c & 65535) === 65534) {
        return false;
      }
      if (c >= 0 && c <= 8) {
        return false;
      }
      if (c === 11) {
        return false;
      }
      if (c >= 14 && c <= 31) {
        return false;
      }
      if (c >= 127 && c <= 159) {
        return false;
      }
      if (c > 1114111) {
        return false;
      }
      return true;
    }
    function fromCodePoint(c) {
      if (c > 65535) {
        c -= 65536;
        var surrogate1 = 55296 + (c >> 10), surrogate2 = 56320 + (c & 1023);
        return String.fromCharCode(surrogate1, surrogate2);
      }
      return String.fromCharCode(c);
    }
    var UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~])/g;
    var ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;
    var UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + "|" + ENTITY_RE.source, "gi");
    var DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i;
    var entities = require_entities2();
    function replaceEntityPattern(match, name) {
      var code;
      if (has(entities, name)) {
        return entities[name];
      }
      if (name.charCodeAt(0) === 35 && DIGITAL_ENTITY_TEST_RE.test(name)) {
        code = name[1].toLowerCase() === "x" ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
        if (isValidEntityCode(code)) {
          return fromCodePoint(code);
        }
      }
      return match;
    }
    function unescapeMd(str) {
      if (str.indexOf("\\") < 0) {
        return str;
      }
      return str.replace(UNESCAPE_MD_RE, "$1");
    }
    function unescapeAll(str) {
      if (str.indexOf("\\") < 0 && str.indexOf("&") < 0) {
        return str;
      }
      return str.replace(UNESCAPE_ALL_RE, function(match, escaped, entity) {
        if (escaped) {
          return escaped;
        }
        return replaceEntityPattern(match, entity);
      });
    }
    var HTML_ESCAPE_TEST_RE = /[&<>"]/;
    var HTML_ESCAPE_REPLACE_RE = /[&<>"]/g;
    var HTML_REPLACEMENTS = {
      "&": "&amp;",
      "<": "&lt;",
      ">": "&gt;",
      '"': "&quot;"
    };
    function replaceUnsafeChar(ch) {
      return HTML_REPLACEMENTS[ch];
    }
    function escapeHtml(str) {
      if (HTML_ESCAPE_TEST_RE.test(str)) {
        return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
      }
      return str;
    }
    var REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g;
    function escapeRE(str) {
      return str.replace(REGEXP_ESCAPE_RE, "\\$&");
    }
    function isSpace(code) {
      switch (code) {
        case 9:
        case 32:
          return true;
      }
      return false;
    }
    function isWhiteSpace(code) {
      if (code >= 8192 && code <= 8202) {
        return true;
      }
      switch (code) {
        case 9:
        // \t
        case 10:
        // \n
        case 11:
        // \v
        case 12:
        // \f
        case 13:
        // \r
        case 32:
        case 160:
        case 5760:
        case 8239:
        case 8287:
        case 12288:
          return true;
      }
      return false;
    }
    var UNICODE_PUNCT_RE = require_regex4();
    function isPunctChar(ch) {
      return UNICODE_PUNCT_RE.test(ch);
    }
    function isMdAsciiPunct(ch) {
      switch (ch) {
        case 33:
        case 34:
        case 35:
        case 36:
        case 37:
        case 38:
        case 39:
        case 40:
        case 41:
        case 42:
        case 43:
        case 44:
        case 45:
        case 46:
        case 47:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 91:
        case 92:
        case 93:
        case 94:
        case 95:
        case 96:
        case 123:
        case 124:
        case 125:
        case 126:
          return true;
        default:
          return false;
      }
    }
    function normalizeReference(str) {
      str = str.trim().replace(/\s+/g, " ");
      if ("\u1E9E".toLowerCase() === "\u1E7E") {
        str = str.replace(/ẞ/g, "\xDF");
      }
      return str.toLowerCase().toUpperCase();
    }
    exports2.lib = {};
    exports2.lib.mdurl = require_mdurl();
    exports2.lib.ucmicro = require_uc();
    exports2.assign = assign;
    exports2.isString = isString;
    exports2.has = has;
    exports2.unescapeMd = unescapeMd;
    exports2.unescapeAll = unescapeAll;
    exports2.isValidEntityCode = isValidEntityCode;
    exports2.fromCodePoint = fromCodePoint;
    exports2.escapeHtml = escapeHtml;
    exports2.arrayReplaceAt = arrayReplaceAt;
    exports2.isSpace = isSpace;
    exports2.isWhiteSpace = isWhiteSpace;
    exports2.isMdAsciiPunct = isMdAsciiPunct;
    exports2.isPunctChar = isPunctChar;
    exports2.escapeRE = escapeRE;
    exports2.normalizeReference = normalizeReference;
  }
});

// node_modules/markdown-it/lib/helpers/parse_link_label.js
var require_parse_link_label = __commonJS({
  "node_modules/markdown-it/lib/helpers/parse_link_label.js"(exports2, module2) {
    "use strict";
    module2.exports = function parseLinkLabel(state, start, disableNested) {
      var level, found, marker, prevPos, labelEnd = -1, max = state.posMax, oldPos = state.pos;
      state.pos = start + 1;
      level = 1;
      while (state.pos < max) {
        marker = state.src.charCodeAt(state.pos);
        if (marker === 93) {
          level--;
          if (level === 0) {
            found = true;
            break;
          }
        }
        prevPos = state.pos;
        state.md.inline.skipToken(state);
        if (marker === 91) {
          if (prevPos === state.pos - 1) {
            level++;
          } else if (disableNested) {
            state.pos = oldPos;
            return -1;
          }
        }
      }
      if (found) {
        labelEnd = state.pos;
      }
      state.pos = oldPos;
      return labelEnd;
    };
  }
});

// node_modules/markdown-it/lib/helpers/parse_link_destination.js
var require_parse_link_destination = __commonJS({
  "node_modules/markdown-it/lib/helpers/parse_link_destination.js"(exports2, module2) {
    "use strict";
    var unescapeAll = require_utils3().unescapeAll;
    module2.exports = function parseLinkDestination(str, start, max) {
      var code, level, pos = start, result = {
        ok: false,
        pos: 0,
        lines: 0,
        str: ""
      };
      if (str.charCodeAt(pos) === 60) {
        pos++;
        while (pos < max) {
          code = str.charCodeAt(pos);
          if (code === 10) {
            return result;
          }
          if (code === 60) {
            return result;
          }
          if (code === 62) {
            result.pos = pos + 1;
            result.str = unescapeAll(str.slice(start + 1, pos));
            result.ok = true;
            return result;
          }
          if (code === 92 && pos + 1 < max) {
            pos += 2;
            continue;
          }
          pos++;
        }
        return result;
      }
      level = 0;
      while (pos < max) {
        code = str.charCodeAt(pos);
        if (code === 32) {
          break;
        }
        if (code < 32 || code === 127) {
          break;
        }
        if (code === 92 && pos + 1 < max) {
          if (str.charCodeAt(pos + 1) === 32) {
            break;
          }
          pos += 2;
          continue;
        }
        if (code === 40) {
          level++;
          if (level > 32) {
            return result;
          }
        }
        if (code === 41) {
          if (level === 0) {
            break;
          }
          level--;
        }
        pos++;
      }
      if (start === pos) {
        return result;
      }
      if (level !== 0) {
        return result;
      }
      result.str = unescapeAll(str.slice(start, pos));
      result.pos = pos;
      result.ok = true;
      return result;
    };
  }
});

// node_modules/markdown-it/lib/helpers/parse_link_title.js
var require_parse_link_title = __commonJS({
  "node_modules/markdown-it/lib/helpers/parse_link_title.js"(exports2, module2) {
    "use strict";
    var unescapeAll = require_utils3().unescapeAll;
    module2.exports = function parseLinkTitle(str, start, max) {
      var code, marker, lines = 0, pos = start, result = {
        ok: false,
        pos: 0,
        lines: 0,
        str: ""
      };
      if (pos >= max) {
        return result;
      }
      marker = str.charCodeAt(pos);
      if (marker !== 34 && marker !== 39 && marker !== 40) {
        return result;
      }
      pos++;
      if (marker === 40) {
        marker = 41;
      }
      while (pos < max) {
        code = str.charCodeAt(pos);
        if (code === marker) {
          result.pos = pos + 1;
          result.lines = lines;
          result.str = unescapeAll(str.slice(start + 1, pos));
          result.ok = true;
          return result;
        } else if (code === 40 && marker === 41) {
          return result;
        } else if (code === 10) {
          lines++;
        } else if (code === 92 && pos + 1 < max) {
          pos++;
          if (str.charCodeAt(pos) === 10) {
            lines++;
          }
        }
        pos++;
      }
      return result;
    };
  }
});

// node_modules/markdown-it/lib/helpers/index.js
var require_helpers = __commonJS({
  "node_modules/markdown-it/lib/helpers/index.js"(exports2) {
    "use strict";
    exports2.parseLinkLabel = require_parse_link_label();
    exports2.parseLinkDestination = require_parse_link_destination();
    exports2.parseLinkTitle = require_parse_link_title();
  }
});

// node_modules/markdown-it/lib/renderer.js
var require_renderer = __commonJS({
  "node_modules/markdown-it/lib/renderer.js"(exports2, module2) {
    "use strict";
    var assign = require_utils3().assign;
    var unescapeAll = require_utils3().unescapeAll;
    var escapeHtml = require_utils3().escapeHtml;
    var default_rules = {};
    default_rules.code_inline = function(tokens, idx, options, env, slf) {
      var token = tokens[idx];
      return "<code" + slf.renderAttrs(token) + ">" + escapeHtml(token.content) + "</code>";
    };
    default_rules.code_block = function(tokens, idx, options, env, slf) {
      var token = tokens[idx];
      return "<pre" + slf.renderAttrs(token) + "><code>" + escapeHtml(tokens[idx].content) + "</code></pre>\n";
    };
    default_rules.fence = function(tokens, idx, options, env, slf) {
      var token = tokens[idx], info = token.info ? unescapeAll(token.info).trim() : "", langName = "", langAttrs = "", highlighted, i, arr, tmpAttrs, tmpToken;
      if (info) {
        arr = info.split(/(\s+)/g);
        langName = arr[0];
        langAttrs = arr.slice(2).join("");
      }
      if (options.highlight) {
        highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content);
      } else {
        highlighted = escapeHtml(token.content);
      }
      if (highlighted.indexOf("<pre") === 0) {
        return highlighted + "\n";
      }
      if (info) {
        i = token.attrIndex("class");
        tmpAttrs = token.attrs ? token.attrs.slice() : [];
        if (i < 0) {
          tmpAttrs.push(["class", options.langPrefix + langName]);
        } else {
          tmpAttrs[i] = tmpAttrs[i].slice();
          tmpAttrs[i][1] += " " + options.langPrefix + langName;
        }
        tmpToken = {
          attrs: tmpAttrs
        };
        return "<pre><code" + slf.renderAttrs(tmpToken) + ">" + highlighted + "</code></pre>\n";
      }
      return "<pre><code" + slf.renderAttrs(token) + ">" + highlighted + "</code></pre>\n";
    };
    default_rules.image = function(tokens, idx, options, env, slf) {
      var token = tokens[idx];
      token.attrs[token.attrIndex("alt")][1] = slf.renderInlineAsText(token.children, options, env);
      return slf.renderToken(tokens, idx, options);
    };
    default_rules.hardbreak = function(tokens, idx, options) {
      return options.xhtmlOut ? "<br />\n" : "<br>\n";
    };
    default_rules.softbreak = function(tokens, idx, options) {
      return options.breaks ? options.xhtmlOut ? "<br />\n" : "<br>\n" : "\n";
    };
    default_rules.text = function(tokens, idx) {
      return escapeHtml(tokens[idx].content);
    };
    default_rules.html_block = function(tokens, idx) {
      return tokens[idx].content;
    };
    default_rules.html_inline = function(tokens, idx) {
      return tokens[idx].content;
    };
    function Renderer() {
      this.rules = assign({}, default_rules);
    }
    Renderer.prototype.renderAttrs = function renderAttrs(token) {
      var i, l, result;
      if (!token.attrs) {
        return "";
      }
      result = "";
      for (i = 0, l = token.attrs.length; i < l; i++) {
        result += " " + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"';
      }
      return result;
    };
    Renderer.prototype.renderToken = function renderToken(tokens, idx, options) {
      var nextToken, result = "", needLf = false, token = tokens[idx];
      if (token.hidden) {
        return "";
      }
      if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
        result += "\n";
      }
      result += (token.nesting === -1 ? "</" : "<") + token.tag;
      result += this.renderAttrs(token);
      if (token.nesting === 0 && options.xhtmlOut) {
        result += " /";
      }
      if (token.block) {
        needLf = true;
        if (token.nesting === 1) {
          if (idx + 1 < tokens.length) {
            nextToken = tokens[idx + 1];
            if (nextToken.type === "inline" || nextToken.hidden) {
              needLf = false;
            } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
              needLf = false;
            }
          }
        }
      }
      result += needLf ? ">\n" : ">";
      return result;
    };
    Renderer.prototype.renderInline = function(tokens, options, env) {
      var type, result = "", rules = this.rules;
      for (var i = 0, len = tokens.length; i < len; i++) {
        type = tokens[i].type;
        if (typeof rules[type] !== "undefined") {
          result += rules[type](tokens, i, options, env, this);
        } else {
          result += this.renderToken(tokens, i, options);
        }
      }
      return result;
    };
    Renderer.prototype.renderInlineAsText = function(tokens, options, env) {
      var result = "";
      for (var i = 0, len = tokens.length; i < len; i++) {
        if (tokens[i].type === "text") {
          result += tokens[i].content;
        } else if (tokens[i].type === "image") {
          result += this.renderInlineAsText(tokens[i].children, options, env);
        } else if (tokens[i].type === "softbreak") {
          result += "\n";
        }
      }
      return result;
    };
    Renderer.prototype.render = function(tokens, options, env) {
      var i, len, type, result = "", rules = this.rules;
      for (i = 0, len = tokens.length; i < len; i++) {
        type = tokens[i].type;
        if (type === "inline") {
          result += this.renderInline(tokens[i].children, options, env);
        } else if (typeof rules[type] !== "undefined") {
          result += rules[type](tokens, i, options, env, this);
        } else {
          result += this.renderToken(tokens, i, options, env);
        }
      }
      return result;
    };
    module2.exports = Renderer;
  }
});

// node_modules/markdown-it/lib/ruler.js
var require_ruler = __commonJS({
  "node_modules/markdown-it/lib/ruler.js"(exports2, module2) {
    "use strict";
    function Ruler() {
      this.__rules__ = [];
      this.__cache__ = null;
    }
    Ruler.prototype.__find__ = function(name) {
      for (var i = 0; i < this.__rules__.length; i++) {
        if (this.__rules__[i].name === name) {
          return i;
        }
      }
      return -1;
    };
    Ruler.prototype.__compile__ = function() {
      var self2 = this;
      var chains = [""];
      self2.__rules__.forEach(function(rule) {
        if (!rule.enabled) {
          return;
        }
        rule.alt.forEach(function(altName) {
          if (chains.indexOf(altName) < 0) {
            chains.push(altName);
          }
        });
      });
      self2.__cache__ = {};
      chains.forEach(function(chain) {
        self2.__cache__[chain] = [];
        self2.__rules__.forEach(function(rule) {
          if (!rule.enabled) {
            return;
          }
          if (chain && rule.alt.indexOf(chain) < 0) {
            return;
          }
          self2.__cache__[chain].push(rule.fn);
        });
      });
    };
    Ruler.prototype.at = function(name, fn, options) {
      var index = this.__find__(name);
      var opt = options || {};
      if (index === -1) {
        throw new Error("Parser rule not found: " + name);
      }
      this.__rules__[index].fn = fn;
      this.__rules__[index].alt = opt.alt || [];
      this.__cache__ = null;
    };
    Ruler.prototype.before = function(beforeName, ruleName, fn, options) {
      var index = this.__find__(beforeName);
      var opt = options || {};
      if (index === -1) {
        throw new Error("Parser rule not found: " + beforeName);
      }
      this.__rules__.splice(index, 0, {
        name: ruleName,
        enabled: true,
        fn,
        alt: opt.alt || []
      });
      this.__cache__ = null;
    };
    Ruler.prototype.after = function(afterName, ruleName, fn, options) {
      var index = this.__find__(afterName);
      var opt = options || {};
      if (index === -1) {
        throw new Error("Parser rule not found: " + afterName);
      }
      this.__rules__.splice(index + 1, 0, {
        name: ruleName,
        enabled: true,
        fn,
        alt: opt.alt || []
      });
      this.__cache__ = null;
    };
    Ruler.prototype.push = function(ruleName, fn, options) {
      var opt = options || {};
      this.__rules__.push({
        name: ruleName,
        enabled: true,
        fn,
        alt: opt.alt || []
      });
      this.__cache__ = null;
    };
    Ruler.prototype.enable = function(list, ignoreInvalid) {
      if (!Array.isArray(list)) {
        list = [list];
      }
      var result = [];
      list.forEach(function(name) {
        var idx = this.__find__(name);
        if (idx < 0) {
          if (ignoreInvalid) {
            return;
          }
          throw new Error("Rules manager: invalid rule name " + name);
        }
        this.__rules__[idx].enabled = true;
        result.push(name);
      }, this);
      this.__cache__ = null;
      return result;
    };
    Ruler.prototype.enableOnly = function(list, ignoreInvalid) {
      if (!Array.isArray(list)) {
        list = [list];
      }
      this.__rules__.forEach(function(rule) {
        rule.enabled = false;
      });
      this.enable(list, ignoreInvalid);
    };
    Ruler.prototype.disable = function(list, ignoreInvalid) {
      if (!Array.isArray(list)) {
        list = [list];
      }
      var result = [];
      list.forEach(function(name) {
        var idx = this.__find__(name);
        if (idx < 0) {
          if (ignoreInvalid) {
            return;
          }
          throw new Error("Rules manager: invalid rule name " + name);
        }
        this.__rules__[idx].enabled = false;
        result.push(name);
      }, this);
      this.__cache__ = null;
      return result;
    };
    Ruler.prototype.getRules = function(chainName) {
      if (this.__cache__ === null) {
        this.__compile__();
      }
      return this.__cache__[chainName] || [];
    };
    module2.exports = Ruler;
  }
});

// node_modules/markdown-it/lib/rules_core/normalize.js
var require_normalize = __commonJS({
  "node_modules/markdown-it/lib/rules_core/normalize.js"(exports2, module2) {
    "use strict";
    var NEWLINES_RE = /\r\n?|\n/g;
    var NULL_RE = /\0/g;
    module2.exports = function normalize(state) {
      var str;
      str = state.src.replace(NEWLINES_RE, "\n");
      str = str.replace(NULL_RE, "\uFFFD");
      state.src = str;
    };
  }
});

// node_modules/markdown-it/lib/rules_core/block.js
var require_block = __commonJS({
  "node_modules/markdown-it/lib/rules_core/block.js"(exports2, module2) {
    "use strict";
    module2.exports = function block(state) {
      var token;
      if (state.inlineMode) {
        token = new state.Token("inline", "", 0);
        token.content = state.src;
        token.map = [0, 1];
        token.children = [];
        state.tokens.push(token);
      } else {
        state.md.block.parse(state.src, state.md, state.env, state.tokens);
      }
    };
  }
});

// node_modules/markdown-it/lib/rules_core/inline.js
var require_inline = __commonJS({
  "node_modules/markdown-it/lib/rules_core/inline.js"(exports2, module2) {
    "use strict";
    module2.exports = function inline(state) {
      var tokens = state.tokens, tok, i, l;
      for (i = 0, l = tokens.length; i < l; i++) {
        tok = tokens[i];
        if (tok.type === "inline") {
          state.md.inline.parse(tok.content, state.md, state.env, tok.children);
        }
      }
    };
  }
});

// node_modules/markdown-it/lib/rules_core/linkify.js
var require_linkify = __commonJS({
  "node_modules/markdown-it/lib/rules_core/linkify.js"(exports2, module2) {
    "use strict";
    var arrayReplaceAt = require_utils3().arrayReplaceAt;
    function isLinkOpen(str) {
      return /^<a[>\s]/i.test(str);
    }
    function isLinkClose(str) {
      return /^<\/a\s*>/i.test(str);
    }
    module2.exports = function linkify(state) {
      var i, j, l, tokens, token, currentToken, nodes, ln, text, pos, lastPos, level, htmlLinkLevel, url, fullUrl, urlText, blockTokens = state.tokens, links;
      if (!state.md.options.linkify) {
        return;
      }
      for (j = 0, l = blockTokens.length; j < l; j++) {
        if (blockTokens[j].type !== "inline" || !state.md.linkify.pretest(blockTokens[j].content)) {
          continue;
        }
        tokens = blockTokens[j].children;
        htmlLinkLevel = 0;
        for (i = tokens.length - 1; i >= 0; i--) {
          currentToken = tokens[i];
          if (currentToken.type === "link_close") {
            i--;
            while (tokens[i].level !== currentToken.level && tokens[i].type !== "link_open") {
              i--;
            }
            continue;
          }
          if (currentToken.type === "html_inline") {
            if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {
              htmlLinkLevel--;
            }
            if (isLinkClose(currentToken.content)) {
              htmlLinkLevel++;
            }
          }
          if (htmlLinkLevel > 0) {
            continue;
          }
          if (currentToken.type === "text" && state.md.linkify.test(currentToken.content)) {
            text = currentToken.content;
            links = state.md.linkify.match(text);
            nodes = [];
            level = currentToken.level;
            lastPos = 0;
            if (links.length > 0 && links[0].index === 0 && i > 0 && tokens[i - 1].type === "text_special") {
              links = links.slice(1);
            }
            for (ln = 0; ln < links.length; ln++) {
              url = links[ln].url;
              fullUrl = state.md.normalizeLink(url);
              if (!state.md.validateLink(fullUrl)) {
                continue;
              }
              urlText = links[ln].text;
              if (!links[ln].schema) {
                urlText = state.md.normalizeLinkText("http://" + urlText).replace(/^http:\/\//, "");
              } else if (links[ln].schema === "mailto:" && !/^mailto:/i.test(urlText)) {
                urlText = state.md.normalizeLinkText("mailto:" + urlText).replace(/^mailto:/, "");
              } else {
                urlText = state.md.normalizeLinkText(urlText);
              }
              pos = links[ln].index;
              if (pos > lastPos) {
                token = new state.Token("text", "", 0);
                token.content = text.slice(lastPos, pos);
                token.level = level;
                nodes.push(token);
              }
              token = new state.Token("link_open", "a", 1);
              token.attrs = [["href", fullUrl]];
              token.level = level++;
              token.markup = "linkify";
              token.info = "auto";
              nodes.push(token);
              token = new state.Token("text", "", 0);
              token.content = urlText;
              token.level = level;
              nodes.push(token);
              token = new state.Token("link_close", "a", -1);
              token.level = --level;
              token.markup = "linkify";
              token.info = "auto";
              nodes.push(token);
              lastPos = links[ln].lastIndex;
            }
            if (lastPos < text.length) {
              token = new state.Token("text", "", 0);
              token.content = text.slice(lastPos);
              token.level = level;
              nodes.push(token);
            }
            blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
          }
        }
      }
    };
  }
});

// node_modules/markdown-it/lib/rules_core/replacements.js
var require_replacements = __commonJS({
  "node_modules/markdown-it/lib/rules_core/replacements.js"(exports2, module2) {
    "use strict";
    var RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/;
    var SCOPED_ABBR_TEST_RE = /\((c|tm|r)\)/i;
    var SCOPED_ABBR_RE = /\((c|tm|r)\)/ig;
    var SCOPED_ABBR = {
      c: "\xA9",
      r: "\xAE",
      tm: "\u2122"
    };
    function replaceFn(match, name) {
      return SCOPED_ABBR[name.toLowerCase()];
    }
    function replace_scoped(inlineTokens) {
      var i, token, inside_autolink = 0;
      for (i = inlineTokens.length - 1; i >= 0; i--) {
        token = inlineTokens[i];
        if (token.type === "text" && !inside_autolink) {
          token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);
        }
        if (token.type === "link_open" && token.info === "auto") {
          inside_autolink--;
        }
        if (token.type === "link_close" && token.info === "auto") {
          inside_autolink++;
        }
      }
    }
    function replace_rare(inlineTokens) {
      var i, token, inside_autolink = 0;
      for (i = inlineTokens.length - 1; i >= 0; i--) {
        token = inlineTokens[i];
        if (token.type === "text" && !inside_autolink) {
          if (RARE_RE.test(token.content)) {
            token.content = token.content.replace(/\+-/g, "\xB1").replace(/\.{2,}/g, "\u2026").replace(/([?!])…/g, "$1..").replace(/([?!]){4,}/g, "$1$1$1").replace(/,{2,}/g, ",").replace(/(^|[^-])---(?=[^-]|$)/mg, "$1\u2014").replace(/(^|\s)--(?=\s|$)/mg, "$1\u2013").replace(/(^|[^-\s])--(?=[^-\s]|$)/mg, "$1\u2013");
          }
        }
        if (token.type === "link_open" && token.info === "auto") {
          inside_autolink--;
        }
        if (token.type === "link_close" && token.info === "auto") {
          inside_autolink++;
        }
      }
    }
    module2.exports = function replace(state) {
      var blkIdx;
      if (!state.md.options.typographer) {
        return;
      }
      for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
        if (state.tokens[blkIdx].type !== "inline") {
          continue;
        }
        if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
          replace_scoped(state.tokens[blkIdx].children);
        }
        if (RARE_RE.test(state.tokens[blkIdx].content)) {
          replace_rare(state.tokens[blkIdx].children);
        }
      }
    };
  }
});

// node_modules/markdown-it/lib/rules_core/smartquotes.js
var require_smartquotes = __commonJS({
  "node_modules/markdown-it/lib/rules_core/smartquotes.js"(exports2, module2) {
    "use strict";
    var isWhiteSpace = require_utils3().isWhiteSpace;
    var isPunctChar = require_utils3().isPunctChar;
    var isMdAsciiPunct = require_utils3().isMdAsciiPunct;
    var QUOTE_TEST_RE = /['"]/;
    var QUOTE_RE = /['"]/g;
    var APOSTROPHE = "\u2019";
    function replaceAt(str, index, ch) {
      return str.slice(0, index) + ch + str.slice(index + 1);
    }
    function process_inlines(tokens, state) {
      var i, token, text, t, pos, max, thisLevel, item, lastChar, nextChar, isLastPunctChar, isNextPunctChar, isLastWhiteSpace, isNextWhiteSpace, canOpen, canClose, j, isSingle, stack, openQuote, closeQuote;
      stack = [];
      for (i = 0; i < tokens.length; i++) {
        token = tokens[i];
        thisLevel = tokens[i].level;
        for (j = stack.length - 1; j >= 0; j--) {
          if (stack[j].level <= thisLevel) {
            break;
          }
        }
        stack.length = j + 1;
        if (token.type !== "text") {
          continue;
        }
        text = token.content;
        pos = 0;
        max = text.length;
        OUTER:
          while (pos < max) {
            QUOTE_RE.lastIndex = pos;
            t = QUOTE_RE.exec(text);
            if (!t) {
              break;
            }
            canOpen = canClose = true;
            pos = t.index + 1;
            isSingle = t[0] === "'";
            lastChar = 32;
            if (t.index - 1 >= 0) {
              lastChar = text.charCodeAt(t.index - 1);
            } else {
              for (j = i - 1; j >= 0; j--) {
                if (tokens[j].type === "softbreak" || tokens[j].type === "hardbreak") break;
                if (!tokens[j].content) continue;
                lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);
                break;
              }
            }
            nextChar = 32;
            if (pos < max) {
              nextChar = text.charCodeAt(pos);
            } else {
              for (j = i + 1; j < tokens.length; j++) {
                if (tokens[j].type === "softbreak" || tokens[j].type === "hardbreak") break;
                if (!tokens[j].content) continue;
                nextChar = tokens[j].content.charCodeAt(0);
                break;
              }
            }
            isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
            isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
            isLastWhiteSpace = isWhiteSpace(lastChar);
            isNextWhiteSpace = isWhiteSpace(nextChar);
            if (isNextWhiteSpace) {
              canOpen = false;
            } else if (isNextPunctChar) {
              if (!(isLastWhiteSpace || isLastPunctChar)) {
                canOpen = false;
              }
            }
            if (isLastWhiteSpace) {
              canClose = false;
            } else if (isLastPunctChar) {
              if (!(isNextWhiteSpace || isNextPunctChar)) {
                canClose = false;
              }
            }
            if (nextChar === 34 && t[0] === '"') {
              if (lastChar >= 48 && lastChar <= 57) {
                canClose = canOpen = false;
              }
            }
            if (canOpen && canClose) {
              canOpen = isLastPunctChar;
              canClose = isNextPunctChar;
            }
            if (!canOpen && !canClose) {
              if (isSingle) {
                token.content = replaceAt(token.content, t.index, APOSTROPHE);
              }
              continue;
            }
            if (canClose) {
              for (j = stack.length - 1; j >= 0; j--) {
                item = stack[j];
                if (stack[j].level < thisLevel) {
                  break;
                }
                if (item.single === isSingle && stack[j].level === thisLevel) {
                  item = stack[j];
                  if (isSingle) {
                    openQuote = state.md.options.quotes[2];
                    closeQuote = state.md.options.quotes[3];
                  } else {
                    openQuote = state.md.options.quotes[0];
                    closeQuote = state.md.options.quotes[1];
                  }
                  token.content = replaceAt(token.content, t.index, closeQuote);
                  tokens[item.token].content = replaceAt(
                    tokens[item.token].content,
                    item.pos,
                    openQuote
                  );
                  pos += closeQuote.length - 1;
                  if (item.token === i) {
                    pos += openQuote.length - 1;
                  }
                  text = token.content;
                  max = text.length;
                  stack.length = j;
                  continue OUTER;
                }
              }
            }
            if (canOpen) {
              stack.push({
                token: i,
                pos: t.index,
                single: isSingle,
                level: thisLevel
              });
            } else if (canClose && isSingle) {
              token.content = replaceAt(token.content, t.index, APOSTROPHE);
            }
          }
      }
    }
    module2.exports = function smartquotes(state) {
      var blkIdx;
      if (!state.md.options.typographer) {
        return;
      }
      for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
        if (state.tokens[blkIdx].type !== "inline" || !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {
          continue;
        }
        process_inlines(state.tokens[blkIdx].children, state);
      }
    };
  }
});

// node_modules/markdown-it/lib/rules_core/text_join.js
var require_text_join = __commonJS({
  "node_modules/markdown-it/lib/rules_core/text_join.js"(exports2, module2) {
    "use strict";
    module2.exports = function text_join(state) {
      var j, l, tokens, curr, max, last, blockTokens = state.tokens;
      for (j = 0, l = blockTokens.length; j < l; j++) {
        if (blockTokens[j].type !== "inline") continue;
        tokens = blockTokens[j].children;
        max = tokens.length;
        for (curr = 0; curr < max; curr++) {
          if (tokens[curr].type === "text_special") {
            tokens[curr].type = "text";
          }
        }
        for (curr = last = 0; curr < max; curr++) {
          if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") {
            tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
          } else {
            if (curr !== last) {
              tokens[last] = tokens[curr];
            }
            last++;
          }
        }
        if (curr !== last) {
          tokens.length = last;
        }
      }
    };
  }
});

// node_modules/markdown-it/lib/token.js
var require_token = __commonJS({
  "node_modules/markdown-it/lib/token.js"(exports2, module2) {
    "use strict";
    function Token(type, tag, nesting) {
      this.type = type;
      this.tag = tag;
      this.attrs = null;
      this.map = null;
      this.nesting = nesting;
      this.level = 0;
      this.children = null;
      this.content = "";
      this.markup = "";
      this.info = "";
      this.meta = null;
      this.block = false;
      this.hidden = false;
    }
    Token.prototype.attrIndex = function attrIndex(name) {
      var attrs, i, len;
      if (!this.attrs) {
        return -1;
      }
      attrs = this.attrs;
      for (i = 0, len = attrs.length; i < len; i++) {
        if (attrs[i][0] === name) {
          return i;
        }
      }
      return -1;
    };
    Token.prototype.attrPush = function attrPush(attrData) {
      if (this.attrs) {
        this.attrs.push(attrData);
      } else {
        this.attrs = [attrData];
      }
    };
    Token.prototype.attrSet = function attrSet(name, value) {
      var idx = this.attrIndex(name), attrData = [name, value];
      if (idx < 0) {
        this.attrPush(attrData);
      } else {
        this.attrs[idx] = attrData;
      }
    };
    Token.prototype.attrGet = function attrGet(name) {
      var idx = this.attrIndex(name), value = null;
      if (idx >= 0) {
        value = this.attrs[idx][1];
      }
      return value;
    };
    Token.prototype.attrJoin = function attrJoin(name, value) {
      var idx = this.attrIndex(name);
      if (idx < 0) {
        this.attrPush([name, value]);
      } else {
        this.attrs[idx][1] = this.attrs[idx][1] + " " + value;
      }
    };
    module2.exports = Token;
  }
});

// node_modules/markdown-it/lib/rules_core/state_core.js
var require_state_core = __commonJS({
  "node_modules/markdown-it/lib/rules_core/state_core.js"(exports2, module2) {
    "use strict";
    var Token = require_token();
    function StateCore(src, md, env) {
      this.src = src;
      this.env = env;
      this.tokens = [];
      this.inlineMode = false;
      this.md = md;
    }
    StateCore.prototype.Token = Token;
    module2.exports = StateCore;
  }
});

// node_modules/markdown-it/lib/parser_core.js
var require_parser_core = __commonJS({
  "node_modules/markdown-it/lib/parser_core.js"(exports2, module2) {
    "use strict";
    var Ruler = require_ruler();
    var _rules = [
      ["normalize", require_normalize()],
      ["block", require_block()],
      ["inline", require_inline()],
      ["linkify", require_linkify()],
      ["replacements", require_replacements()],
      ["smartquotes", require_smartquotes()],
      // `text_join` finds `text_special` tokens (for escape sequences)
      // and joins them with the rest of the text
      ["text_join", require_text_join()]
    ];
    function Core() {
      this.ruler = new Ruler();
      for (var i = 0; i < _rules.length; i++) {
        this.ruler.push(_rules[i][0], _rules[i][1]);
      }
    }
    Core.prototype.process = function(state) {
      var i, l, rules;
      rules = this.ruler.getRules("");
      for (i = 0, l = rules.length; i < l; i++) {
        rules[i](state);
      }
    };
    Core.prototype.State = require_state_core();
    module2.exports = Core;
  }
});

// node_modules/markdown-it/lib/rules_block/table.js
var require_table = __commonJS({
  "node_modules/markdown-it/lib/rules_block/table.js"(exports2, module2) {
    "use strict";
    var isSpace = require_utils3().isSpace;
    function getLine(state, line) {
      var pos = state.bMarks[line] + state.tShift[line], max = state.eMarks[line];
      return state.src.slice(pos, max);
    }
    function escapedSplit(str) {
      var result = [], pos = 0, max = str.length, ch, isEscaped = false, lastPos = 0, current = "";
      ch = str.charCodeAt(pos);
      while (pos < max) {
        if (ch === 124) {
          if (!isEscaped) {
            result.push(current + str.substring(lastPos, pos));
            current = "";
            lastPos = pos + 1;
          } else {
            current += str.substring(lastPos, pos - 1);
            lastPos = pos;
          }
        }
        isEscaped = ch === 92;
        pos++;
        ch = str.charCodeAt(pos);
      }
      result.push(current + str.substring(lastPos));
      return result;
    }
    module2.exports = function table(state, startLine, endLine, silent) {
      var ch, lineText, pos, i, l, nextLine, columns, columnCount, token, aligns, t, tableLines, tbodyLines, oldParentType, terminate, terminatorRules, firstCh, secondCh;
      if (startLine + 2 > endLine) {
        return false;
      }
      nextLine = startLine + 1;
      if (state.sCount[nextLine] < state.blkIndent) {
        return false;
      }
      if (state.sCount[nextLine] - state.blkIndent >= 4) {
        return false;
      }
      pos = state.bMarks[nextLine] + state.tShift[nextLine];
      if (pos >= state.eMarks[nextLine]) {
        return false;
      }
      firstCh = state.src.charCodeAt(pos++);
      if (firstCh !== 124 && firstCh !== 45 && firstCh !== 58) {
        return false;
      }
      if (pos >= state.eMarks[nextLine]) {
        return false;
      }
      secondCh = state.src.charCodeAt(pos++);
      if (secondCh !== 124 && secondCh !== 45 && secondCh !== 58 && !isSpace(secondCh)) {
        return false;
      }
      if (firstCh === 45 && isSpace(secondCh)) {
        return false;
      }
      while (pos < state.eMarks[nextLine]) {
        ch = state.src.charCodeAt(pos);
        if (ch !== 124 && ch !== 45 && ch !== 58 && !isSpace(ch)) {
          return false;
        }
        pos++;
      }
      lineText = getLine(state, startLine + 1);
      columns = lineText.split("|");
      aligns = [];
      for (i = 0; i < columns.length; i++) {
        t = columns[i].trim();
        if (!t) {
          if (i === 0 || i === columns.length - 1) {
            continue;
          } else {
            return false;
          }
        }
        if (!/^:?-+:?$/.test(t)) {
          return false;
        }
        if (t.charCodeAt(t.length - 1) === 58) {
          aligns.push(t.charCodeAt(0) === 58 ? "center" : "right");
        } else if (t.charCodeAt(0) === 58) {
          aligns.push("left");
        } else {
          aligns.push("");
        }
      }
      lineText = getLine(state, startLine).trim();
      if (lineText.indexOf("|") === -1) {
        return false;
      }
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      columns = escapedSplit(lineText);
      if (columns.length && columns[0] === "") columns.shift();
      if (columns.length && columns[columns.length - 1] === "") columns.pop();
      columnCount = columns.length;
      if (columnCount === 0 || columnCount !== aligns.length) {
        return false;
      }
      if (silent) {
        return true;
      }
      oldParentType = state.parentType;
      state.parentType = "table";
      terminatorRules = state.md.block.ruler.getRules("blockquote");
      token = state.push("table_open", "table", 1);
      token.map = tableLines = [startLine, 0];
      token = state.push("thead_open", "thead", 1);
      token.map = [startLine, startLine + 1];
      token = state.push("tr_open", "tr", 1);
      token.map = [startLine, startLine + 1];
      for (i = 0; i < columns.length; i++) {
        token = state.push("th_open", "th", 1);
        if (aligns[i]) {
          token.attrs = [["style", "text-align:" + aligns[i]]];
        }
        token = state.push("inline", "", 0);
        token.content = columns[i].trim();
        token.children = [];
        token = state.push("th_close", "th", -1);
      }
      token = state.push("tr_close", "tr", -1);
      token = state.push("thead_close", "thead", -1);
      for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
        if (state.sCount[nextLine] < state.blkIndent) {
          break;
        }
        terminate = false;
        for (i = 0, l = terminatorRules.length; i < l; i++) {
          if (terminatorRules[i](state, nextLine, endLine, true)) {
            terminate = true;
            break;
          }
        }
        if (terminate) {
          break;
        }
        lineText = getLine(state, nextLine).trim();
        if (!lineText) {
          break;
        }
        if (state.sCount[nextLine] - state.blkIndent >= 4) {
          break;
        }
        columns = escapedSplit(lineText);
        if (columns.length && columns[0] === "") columns.shift();
        if (columns.length && columns[columns.length - 1] === "") columns.pop();
        if (nextLine === startLine + 2) {
          token = state.push("tbody_open", "tbody", 1);
          token.map = tbodyLines = [startLine + 2, 0];
        }
        token = state.push("tr_open", "tr", 1);
        token.map = [nextLine, nextLine + 1];
        for (i = 0; i < columnCount; i++) {
          token = state.push("td_open", "td", 1);
          if (aligns[i]) {
            token.attrs = [["style", "text-align:" + aligns[i]]];
          }
          token = state.push("inline", "", 0);
          token.content = columns[i] ? columns[i].trim() : "";
          token.children = [];
          token = state.push("td_close", "td", -1);
        }
        token = state.push("tr_close", "tr", -1);
      }
      if (tbodyLines) {
        token = state.push("tbody_close", "tbody", -1);
        tbodyLines[1] = nextLine;
      }
      token = state.push("table_close", "table", -1);
      tableLines[1] = nextLine;
      state.parentType = oldParentType;
      state.line = nextLine;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_block/code.js
var require_code2 = __commonJS({
  "node_modules/markdown-it/lib/rules_block/code.js"(exports2, module2) {
    "use strict";
    module2.exports = function code(state, startLine, endLine) {
      var nextLine, last, token;
      if (state.sCount[startLine] - state.blkIndent < 4) {
        return false;
      }
      last = nextLine = startLine + 1;
      while (nextLine < endLine) {
        if (state.isEmpty(nextLine)) {
          nextLine++;
          continue;
        }
        if (state.sCount[nextLine] - state.blkIndent >= 4) {
          nextLine++;
          last = nextLine;
          continue;
        }
        break;
      }
      state.line = last;
      token = state.push("code_block", "code", 0);
      token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + "\n";
      token.map = [startLine, state.line];
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_block/fence.js
var require_fence = __commonJS({
  "node_modules/markdown-it/lib/rules_block/fence.js"(exports2, module2) {
    "use strict";
    module2.exports = function fence(state, startLine, endLine, silent) {
      var marker, len, params, nextLine, mem, token, markup, haveEndMarker = false, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      if (pos + 3 > max) {
        return false;
      }
      marker = state.src.charCodeAt(pos);
      if (marker !== 126 && marker !== 96) {
        return false;
      }
      mem = pos;
      pos = state.skipChars(pos, marker);
      len = pos - mem;
      if (len < 3) {
        return false;
      }
      markup = state.src.slice(mem, pos);
      params = state.src.slice(pos, max);
      if (marker === 96) {
        if (params.indexOf(String.fromCharCode(marker)) >= 0) {
          return false;
        }
      }
      if (silent) {
        return true;
      }
      nextLine = startLine;
      for (; ; ) {
        nextLine++;
        if (nextLine >= endLine) {
          break;
        }
        pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];
        max = state.eMarks[nextLine];
        if (pos < max && state.sCount[nextLine] < state.blkIndent) {
          break;
        }
        if (state.src.charCodeAt(pos) !== marker) {
          continue;
        }
        if (state.sCount[nextLine] - state.blkIndent >= 4) {
          continue;
        }
        pos = state.skipChars(pos, marker);
        if (pos - mem < len) {
          continue;
        }
        pos = state.skipSpaces(pos);
        if (pos < max) {
          continue;
        }
        haveEndMarker = true;
        break;
      }
      len = state.sCount[startLine];
      state.line = nextLine + (haveEndMarker ? 1 : 0);
      token = state.push("fence", "code", 0);
      token.info = params;
      token.content = state.getLines(startLine + 1, nextLine, len, true);
      token.markup = markup;
      token.map = [startLine, state.line];
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_block/blockquote.js
var require_blockquote2 = __commonJS({
  "node_modules/markdown-it/lib/rules_block/blockquote.js"(exports2, module2) {
    "use strict";
    var isSpace = require_utils3().isSpace;
    module2.exports = function blockquote(state, startLine, endLine, silent) {
      var adjustTab, ch, i, initial, l, lastLineEmpty, lines, nextLine, offset, oldBMarks, oldBSCount, oldIndent, oldParentType, oldSCount, oldTShift, spaceAfterMarker, terminate, terminatorRules, token, isOutdented, oldLineMax = state.lineMax, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      if (state.src.charCodeAt(pos) !== 62) {
        return false;
      }
      if (silent) {
        return true;
      }
      oldBMarks = [];
      oldBSCount = [];
      oldSCount = [];
      oldTShift = [];
      terminatorRules = state.md.block.ruler.getRules("blockquote");
      oldParentType = state.parentType;
      state.parentType = "blockquote";
      for (nextLine = startLine; nextLine < endLine; nextLine++) {
        isOutdented = state.sCount[nextLine] < state.blkIndent;
        pos = state.bMarks[nextLine] + state.tShift[nextLine];
        max = state.eMarks[nextLine];
        if (pos >= max) {
          break;
        }
        if (state.src.charCodeAt(pos++) === 62 && !isOutdented) {
          initial = state.sCount[nextLine] + 1;
          if (state.src.charCodeAt(pos) === 32) {
            pos++;
            initial++;
            adjustTab = false;
            spaceAfterMarker = true;
          } else if (state.src.charCodeAt(pos) === 9) {
            spaceAfterMarker = true;
            if ((state.bsCount[nextLine] + initial) % 4 === 3) {
              pos++;
              initial++;
              adjustTab = false;
            } else {
              adjustTab = true;
            }
          } else {
            spaceAfterMarker = false;
          }
          offset = initial;
          oldBMarks.push(state.bMarks[nextLine]);
          state.bMarks[nextLine] = pos;
          while (pos < max) {
            ch = state.src.charCodeAt(pos);
            if (isSpace(ch)) {
              if (ch === 9) {
                offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;
              } else {
                offset++;
              }
            } else {
              break;
            }
            pos++;
          }
          lastLineEmpty = pos >= max;
          oldBSCount.push(state.bsCount[nextLine]);
          state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);
          oldSCount.push(state.sCount[nextLine]);
          state.sCount[nextLine] = offset - initial;
          oldTShift.push(state.tShift[nextLine]);
          state.tShift[nextLine] = pos - state.bMarks[nextLine];
          continue;
        }
        if (lastLineEmpty) {
          break;
        }
        terminate = false;
        for (i = 0, l = terminatorRules.length; i < l; i++) {
          if (terminatorRules[i](state, nextLine, endLine, true)) {
            terminate = true;
            break;
          }
        }
        if (terminate) {
          state.lineMax = nextLine;
          if (state.blkIndent !== 0) {
            oldBMarks.push(state.bMarks[nextLine]);
            oldBSCount.push(state.bsCount[nextLine]);
            oldTShift.push(state.tShift[nextLine]);
            oldSCount.push(state.sCount[nextLine]);
            state.sCount[nextLine] -= state.blkIndent;
          }
          break;
        }
        oldBMarks.push(state.bMarks[nextLine]);
        oldBSCount.push(state.bsCount[nextLine]);
        oldTShift.push(state.tShift[nextLine]);
        oldSCount.push(state.sCount[nextLine]);
        state.sCount[nextLine] = -1;
      }
      oldIndent = state.blkIndent;
      state.blkIndent = 0;
      token = state.push("blockquote_open", "blockquote", 1);
      token.markup = ">";
      token.map = lines = [startLine, 0];
      state.md.block.tokenize(state, startLine, nextLine);
      token = state.push("blockquote_close", "blockquote", -1);
      token.markup = ">";
      state.lineMax = oldLineMax;
      state.parentType = oldParentType;
      lines[1] = state.line;
      for (i = 0; i < oldTShift.length; i++) {
        state.bMarks[i + startLine] = oldBMarks[i];
        state.tShift[i + startLine] = oldTShift[i];
        state.sCount[i + startLine] = oldSCount[i];
        state.bsCount[i + startLine] = oldBSCount[i];
      }
      state.blkIndent = oldIndent;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_block/hr.js
var require_hr = __commonJS({
  "node_modules/markdown-it/lib/rules_block/hr.js"(exports2, module2) {
    "use strict";
    var isSpace = require_utils3().isSpace;
    module2.exports = function hr(state, startLine, endLine, silent) {
      var marker, cnt, ch, token, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      marker = state.src.charCodeAt(pos++);
      if (marker !== 42 && marker !== 45 && marker !== 95) {
        return false;
      }
      cnt = 1;
      while (pos < max) {
        ch = state.src.charCodeAt(pos++);
        if (ch !== marker && !isSpace(ch)) {
          return false;
        }
        if (ch === marker) {
          cnt++;
        }
      }
      if (cnt < 3) {
        return false;
      }
      if (silent) {
        return true;
      }
      state.line = startLine + 1;
      token = state.push("hr", "hr", 0);
      token.map = [startLine, state.line];
      token.markup = Array(cnt + 1).join(String.fromCharCode(marker));
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_block/list.js
var require_list = __commonJS({
  "node_modules/markdown-it/lib/rules_block/list.js"(exports2, module2) {
    "use strict";
    var isSpace = require_utils3().isSpace;
    function skipBulletListMarker(state, startLine) {
      var marker, pos, max, ch;
      pos = state.bMarks[startLine] + state.tShift[startLine];
      max = state.eMarks[startLine];
      marker = state.src.charCodeAt(pos++);
      if (marker !== 42 && marker !== 45 && marker !== 43) {
        return -1;
      }
      if (pos < max) {
        ch = state.src.charCodeAt(pos);
        if (!isSpace(ch)) {
          return -1;
        }
      }
      return pos;
    }
    function skipOrderedListMarker(state, startLine) {
      var ch, start = state.bMarks[startLine] + state.tShift[startLine], pos = start, max = state.eMarks[startLine];
      if (pos + 1 >= max) {
        return -1;
      }
      ch = state.src.charCodeAt(pos++);
      if (ch < 48 || ch > 57) {
        return -1;
      }
      for (; ; ) {
        if (pos >= max) {
          return -1;
        }
        ch = state.src.charCodeAt(pos++);
        if (ch >= 48 && ch <= 57) {
          if (pos - start >= 10) {
            return -1;
          }
          continue;
        }
        if (ch === 41 || ch === 46) {
          break;
        }
        return -1;
      }
      if (pos < max) {
        ch = state.src.charCodeAt(pos);
        if (!isSpace(ch)) {
          return -1;
        }
      }
      return pos;
    }
    function markTightParagraphs(state, idx) {
      var i, l, level = state.level + 2;
      for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
        if (state.tokens[i].level === level && state.tokens[i].type === "paragraph_open") {
          state.tokens[i + 2].hidden = true;
          state.tokens[i].hidden = true;
          i += 2;
        }
      }
    }
    module2.exports = function list(state, startLine, endLine, silent) {
      var ch, contentStart, i, indent, indentAfterMarker, initial, isOrdered, itemLines, l, listLines, listTokIdx, markerCharCode, markerValue, max, offset, oldListIndent, oldParentType, oldSCount, oldTShift, oldTight, pos, posAfterMarker, prevEmptyEnd, start, terminate, terminatorRules, token, nextLine = startLine, isTerminatingParagraph = false, tight = true;
      if (state.sCount[nextLine] - state.blkIndent >= 4) {
        return false;
      }
      if (state.listIndent >= 0 && state.sCount[nextLine] - state.listIndent >= 4 && state.sCount[nextLine] < state.blkIndent) {
        return false;
      }
      if (silent && state.parentType === "paragraph") {
        if (state.sCount[nextLine] >= state.blkIndent) {
          isTerminatingParagraph = true;
        }
      }
      if ((posAfterMarker = skipOrderedListMarker(state, nextLine)) >= 0) {
        isOrdered = true;
        start = state.bMarks[nextLine] + state.tShift[nextLine];
        markerValue = Number(state.src.slice(start, posAfterMarker - 1));
        if (isTerminatingParagraph && markerValue !== 1) return false;
      } else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) >= 0) {
        isOrdered = false;
      } else {
        return false;
      }
      if (isTerminatingParagraph) {
        if (state.skipSpaces(posAfterMarker) >= state.eMarks[nextLine]) return false;
      }
      if (silent) {
        return true;
      }
      markerCharCode = state.src.charCodeAt(posAfterMarker - 1);
      listTokIdx = state.tokens.length;
      if (isOrdered) {
        token = state.push("ordered_list_open", "ol", 1);
        if (markerValue !== 1) {
          token.attrs = [["start", markerValue]];
        }
      } else {
        token = state.push("bullet_list_open", "ul", 1);
      }
      token.map = listLines = [nextLine, 0];
      token.markup = String.fromCharCode(markerCharCode);
      prevEmptyEnd = false;
      terminatorRules = state.md.block.ruler.getRules("list");
      oldParentType = state.parentType;
      state.parentType = "list";
      while (nextLine < endLine) {
        pos = posAfterMarker;
        max = state.eMarks[nextLine];
        initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[nextLine] + state.tShift[nextLine]);
        while (pos < max) {
          ch = state.src.charCodeAt(pos);
          if (ch === 9) {
            offset += 4 - (offset + state.bsCount[nextLine]) % 4;
          } else if (ch === 32) {
            offset++;
          } else {
            break;
          }
          pos++;
        }
        contentStart = pos;
        if (contentStart >= max) {
          indentAfterMarker = 1;
        } else {
          indentAfterMarker = offset - initial;
        }
        if (indentAfterMarker > 4) {
          indentAfterMarker = 1;
        }
        indent = initial + indentAfterMarker;
        token = state.push("list_item_open", "li", 1);
        token.markup = String.fromCharCode(markerCharCode);
        token.map = itemLines = [nextLine, 0];
        if (isOrdered) {
          token.info = state.src.slice(start, posAfterMarker - 1);
        }
        oldTight = state.tight;
        oldTShift = state.tShift[nextLine];
        oldSCount = state.sCount[nextLine];
        oldListIndent = state.listIndent;
        state.listIndent = state.blkIndent;
        state.blkIndent = indent;
        state.tight = true;
        state.tShift[nextLine] = contentStart - state.bMarks[nextLine];
        state.sCount[nextLine] = offset;
        if (contentStart >= max && state.isEmpty(nextLine + 1)) {
          state.line = Math.min(state.line + 2, endLine);
        } else {
          state.md.block.tokenize(state, nextLine, endLine, true);
        }
        if (!state.tight || prevEmptyEnd) {
          tight = false;
        }
        prevEmptyEnd = state.line - nextLine > 1 && state.isEmpty(state.line - 1);
        state.blkIndent = state.listIndent;
        state.listIndent = oldListIndent;
        state.tShift[nextLine] = oldTShift;
        state.sCount[nextLine] = oldSCount;
        state.tight = oldTight;
        token = state.push("list_item_close", "li", -1);
        token.markup = String.fromCharCode(markerCharCode);
        nextLine = state.line;
        itemLines[1] = nextLine;
        if (nextLine >= endLine) {
          break;
        }
        if (state.sCount[nextLine] < state.blkIndent) {
          break;
        }
        if (state.sCount[nextLine] - state.blkIndent >= 4) {
          break;
        }
        terminate = false;
        for (i = 0, l = terminatorRules.length; i < l; i++) {
          if (terminatorRules[i](state, nextLine, endLine, true)) {
            terminate = true;
            break;
          }
        }
        if (terminate) {
          break;
        }
        if (isOrdered) {
          posAfterMarker = skipOrderedListMarker(state, nextLine);
          if (posAfterMarker < 0) {
            break;
          }
          start = state.bMarks[nextLine] + state.tShift[nextLine];
        } else {
          posAfterMarker = skipBulletListMarker(state, nextLine);
          if (posAfterMarker < 0) {
            break;
          }
        }
        if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) {
          break;
        }
      }
      if (isOrdered) {
        token = state.push("ordered_list_close", "ol", -1);
      } else {
        token = state.push("bullet_list_close", "ul", -1);
      }
      token.markup = String.fromCharCode(markerCharCode);
      listLines[1] = nextLine;
      state.line = nextLine;
      state.parentType = oldParentType;
      if (tight) {
        markTightParagraphs(state, listTokIdx);
      }
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_block/reference.js
var require_reference = __commonJS({
  "node_modules/markdown-it/lib/rules_block/reference.js"(exports2, module2) {
    "use strict";
    var normalizeReference = require_utils3().normalizeReference;
    var isSpace = require_utils3().isSpace;
    module2.exports = function reference(state, startLine, _endLine, silent) {
      var ch, destEndPos, destEndLineNo, endLine, href, i, l, label, labelEnd, oldParentType, res, start, str, terminate, terminatorRules, title, lines = 0, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine], nextLine = startLine + 1;
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      if (state.src.charCodeAt(pos) !== 91) {
        return false;
      }
      while (++pos < max) {
        if (state.src.charCodeAt(pos) === 93 && state.src.charCodeAt(pos - 1) !== 92) {
          if (pos + 1 === max) {
            return false;
          }
          if (state.src.charCodeAt(pos + 1) !== 58) {
            return false;
          }
          break;
        }
      }
      endLine = state.lineMax;
      terminatorRules = state.md.block.ruler.getRules("reference");
      oldParentType = state.parentType;
      state.parentType = "reference";
      for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
        if (state.sCount[nextLine] - state.blkIndent > 3) {
          continue;
        }
        if (state.sCount[nextLine] < 0) {
          continue;
        }
        terminate = false;
        for (i = 0, l = terminatorRules.length; i < l; i++) {
          if (terminatorRules[i](state, nextLine, endLine, true)) {
            terminate = true;
            break;
          }
        }
        if (terminate) {
          break;
        }
      }
      str = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
      max = str.length;
      for (pos = 1; pos < max; pos++) {
        ch = str.charCodeAt(pos);
        if (ch === 91) {
          return false;
        } else if (ch === 93) {
          labelEnd = pos;
          break;
        } else if (ch === 10) {
          lines++;
        } else if (ch === 92) {
          pos++;
          if (pos < max && str.charCodeAt(pos) === 10) {
            lines++;
          }
        }
      }
      if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 58) {
        return false;
      }
      for (pos = labelEnd + 2; pos < max; pos++) {
        ch = str.charCodeAt(pos);
        if (ch === 10) {
          lines++;
        } else if (isSpace(ch)) {
        } else {
          break;
        }
      }
      res = state.md.helpers.parseLinkDestination(str, pos, max);
      if (!res.ok) {
        return false;
      }
      href = state.md.normalizeLink(res.str);
      if (!state.md.validateLink(href)) {
        return false;
      }
      pos = res.pos;
      lines += res.lines;
      destEndPos = pos;
      destEndLineNo = lines;
      start = pos;
      for (; pos < max; pos++) {
        ch = str.charCodeAt(pos);
        if (ch === 10) {
          lines++;
        } else if (isSpace(ch)) {
        } else {
          break;
        }
      }
      res = state.md.helpers.parseLinkTitle(str, pos, max);
      if (pos < max && start !== pos && res.ok) {
        title = res.str;
        pos = res.pos;
        lines += res.lines;
      } else {
        title = "";
        pos = destEndPos;
        lines = destEndLineNo;
      }
      while (pos < max) {
        ch = str.charCodeAt(pos);
        if (!isSpace(ch)) {
          break;
        }
        pos++;
      }
      if (pos < max && str.charCodeAt(pos) !== 10) {
        if (title) {
          title = "";
          pos = destEndPos;
          lines = destEndLineNo;
          while (pos < max) {
            ch = str.charCodeAt(pos);
            if (!isSpace(ch)) {
              break;
            }
            pos++;
          }
        }
      }
      if (pos < max && str.charCodeAt(pos) !== 10) {
        return false;
      }
      label = normalizeReference(str.slice(1, labelEnd));
      if (!label) {
        return false;
      }
      if (silent) {
        return true;
      }
      if (typeof state.env.references === "undefined") {
        state.env.references = {};
      }
      if (typeof state.env.references[label] === "undefined") {
        state.env.references[label] = { title, href };
      }
      state.parentType = oldParentType;
      state.line = startLine + lines + 1;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/common/html_blocks.js
var require_html_blocks = __commonJS({
  "node_modules/markdown-it/lib/common/html_blocks.js"(exports2, module2) {
    "use strict";
    module2.exports = [
      "address",
      "article",
      "aside",
      "base",
      "basefont",
      "blockquote",
      "body",
      "caption",
      "center",
      "col",
      "colgroup",
      "dd",
      "details",
      "dialog",
      "dir",
      "div",
      "dl",
      "dt",
      "fieldset",
      "figcaption",
      "figure",
      "footer",
      "form",
      "frame",
      "frameset",
      "h1",
      "h2",
      "h3",
      "h4",
      "h5",
      "h6",
      "head",
      "header",
      "hr",
      "html",
      "iframe",
      "legend",
      "li",
      "link",
      "main",
      "menu",
      "menuitem",
      "nav",
      "noframes",
      "ol",
      "optgroup",
      "option",
      "p",
      "param",
      "section",
      "source",
      "summary",
      "table",
      "tbody",
      "td",
      "tfoot",
      "th",
      "thead",
      "title",
      "tr",
      "track",
      "ul"
    ];
  }
});

// node_modules/markdown-it/lib/common/html_re.js
var require_html_re = __commonJS({
  "node_modules/markdown-it/lib/common/html_re.js"(exports2, module2) {
    "use strict";
    var attr_name = "[a-zA-Z_:][a-zA-Z0-9:._-]*";
    var unquoted = "[^\"'=<>`\\x00-\\x20]+";
    var single_quoted = "'[^']*'";
    var double_quoted = '"[^"]*"';
    var attr_value = "(?:" + unquoted + "|" + single_quoted + "|" + double_quoted + ")";
    var attribute = "(?:\\s+" + attr_name + "(?:\\s*=\\s*" + attr_value + ")?)";
    var open_tag = "<[A-Za-z][A-Za-z0-9\\-]*" + attribute + "*\\s*\\/?>";
    var close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>";
    var comment = "<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->";
    var processing = "<[?][\\s\\S]*?[?]>";
    var declaration = "<![A-Z]+\\s+[^>]*>";
    var cdata = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>";
    var HTML_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + "|" + comment + "|" + processing + "|" + declaration + "|" + cdata + ")");
    var HTML_OPEN_CLOSE_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + ")");
    module2.exports.HTML_TAG_RE = HTML_TAG_RE;
    module2.exports.HTML_OPEN_CLOSE_TAG_RE = HTML_OPEN_CLOSE_TAG_RE;
  }
});

// node_modules/markdown-it/lib/rules_block/html_block.js
var require_html_block = __commonJS({
  "node_modules/markdown-it/lib/rules_block/html_block.js"(exports2, module2) {
    "use strict";
    var block_names = require_html_blocks();
    var HTML_OPEN_CLOSE_TAG_RE = require_html_re().HTML_OPEN_CLOSE_TAG_RE;
    var HTML_SEQUENCES = [
      [/^<(script|pre|style|textarea)(?=(\s|>|$))/i, /<\/(script|pre|style|textarea)>/i, true],
      [/^<!--/, /-->/, true],
      [/^<\?/, /\?>/, true],
      [/^<![A-Z]/, />/, true],
      [/^<!\[CDATA\[/, /\]\]>/, true],
      [new RegExp("^</?(" + block_names.join("|") + ")(?=(\\s|/?>|$))", "i"), /^$/, true],
      [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + "\\s*$"), /^$/, false]
    ];
    module2.exports = function html_block(state, startLine, endLine, silent) {
      var i, nextLine, token, lineText, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      if (!state.md.options.html) {
        return false;
      }
      if (state.src.charCodeAt(pos) !== 60) {
        return false;
      }
      lineText = state.src.slice(pos, max);
      for (i = 0; i < HTML_SEQUENCES.length; i++) {
        if (HTML_SEQUENCES[i][0].test(lineText)) {
          break;
        }
      }
      if (i === HTML_SEQUENCES.length) {
        return false;
      }
      if (silent) {
        return HTML_SEQUENCES[i][2];
      }
      nextLine = startLine + 1;
      if (!HTML_SEQUENCES[i][1].test(lineText)) {
        for (; nextLine < endLine; nextLine++) {
          if (state.sCount[nextLine] < state.blkIndent) {
            break;
          }
          pos = state.bMarks[nextLine] + state.tShift[nextLine];
          max = state.eMarks[nextLine];
          lineText = state.src.slice(pos, max);
          if (HTML_SEQUENCES[i][1].test(lineText)) {
            if (lineText.length !== 0) {
              nextLine++;
            }
            break;
          }
        }
      }
      state.line = nextLine;
      token = state.push("html_block", "", 0);
      token.map = [startLine, nextLine];
      token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_block/heading.js
var require_heading2 = __commonJS({
  "node_modules/markdown-it/lib/rules_block/heading.js"(exports2, module2) {
    "use strict";
    var isSpace = require_utils3().isSpace;
    module2.exports = function heading(state, startLine, endLine, silent) {
      var ch, level, tmp, token, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      ch = state.src.charCodeAt(pos);
      if (ch !== 35 || pos >= max) {
        return false;
      }
      level = 1;
      ch = state.src.charCodeAt(++pos);
      while (ch === 35 && pos < max && level <= 6) {
        level++;
        ch = state.src.charCodeAt(++pos);
      }
      if (level > 6 || pos < max && !isSpace(ch)) {
        return false;
      }
      if (silent) {
        return true;
      }
      max = state.skipSpacesBack(max, pos);
      tmp = state.skipCharsBack(max, 35, pos);
      if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {
        max = tmp;
      }
      state.line = startLine + 1;
      token = state.push("heading_open", "h" + String(level), 1);
      token.markup = "########".slice(0, level);
      token.map = [startLine, state.line];
      token = state.push("inline", "", 0);
      token.content = state.src.slice(pos, max).trim();
      token.map = [startLine, state.line];
      token.children = [];
      token = state.push("heading_close", "h" + String(level), -1);
      token.markup = "########".slice(0, level);
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_block/lheading.js
var require_lheading = __commonJS({
  "node_modules/markdown-it/lib/rules_block/lheading.js"(exports2, module2) {
    "use strict";
    module2.exports = function lheading(state, startLine, endLine) {
      var content, terminate, i, l, token, pos, max, level, marker, nextLine = startLine + 1, oldParentType, terminatorRules = state.md.block.ruler.getRules("paragraph");
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      oldParentType = state.parentType;
      state.parentType = "paragraph";
      for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
        if (state.sCount[nextLine] - state.blkIndent > 3) {
          continue;
        }
        if (state.sCount[nextLine] >= state.blkIndent) {
          pos = state.bMarks[nextLine] + state.tShift[nextLine];
          max = state.eMarks[nextLine];
          if (pos < max) {
            marker = state.src.charCodeAt(pos);
            if (marker === 45 || marker === 61) {
              pos = state.skipChars(pos, marker);
              pos = state.skipSpaces(pos);
              if (pos >= max) {
                level = marker === 61 ? 1 : 2;
                break;
              }
            }
          }
        }
        if (state.sCount[nextLine] < 0) {
          continue;
        }
        terminate = false;
        for (i = 0, l = terminatorRules.length; i < l; i++) {
          if (terminatorRules[i](state, nextLine, endLine, true)) {
            terminate = true;
            break;
          }
        }
        if (terminate) {
          break;
        }
      }
      if (!level) {
        return false;
      }
      content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
      state.line = nextLine + 1;
      token = state.push("heading_open", "h" + String(level), 1);
      token.markup = String.fromCharCode(marker);
      token.map = [startLine, state.line];
      token = state.push("inline", "", 0);
      token.content = content;
      token.map = [startLine, state.line - 1];
      token.children = [];
      token = state.push("heading_close", "h" + String(level), -1);
      token.markup = String.fromCharCode(marker);
      state.parentType = oldParentType;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_block/paragraph.js
var require_paragraph2 = __commonJS({
  "node_modules/markdown-it/lib/rules_block/paragraph.js"(exports2, module2) {
    "use strict";
    module2.exports = function paragraph(state, startLine, endLine) {
      var content, terminate, i, l, token, oldParentType, nextLine = startLine + 1, terminatorRules = state.md.block.ruler.getRules("paragraph");
      oldParentType = state.parentType;
      state.parentType = "paragraph";
      for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
        if (state.sCount[nextLine] - state.blkIndent > 3) {
          continue;
        }
        if (state.sCount[nextLine] < 0) {
          continue;
        }
        terminate = false;
        for (i = 0, l = terminatorRules.length; i < l; i++) {
          if (terminatorRules[i](state, nextLine, endLine, true)) {
            terminate = true;
            break;
          }
        }
        if (terminate) {
          break;
        }
      }
      content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
      state.line = nextLine;
      token = state.push("paragraph_open", "p", 1);
      token.map = [startLine, state.line];
      token = state.push("inline", "", 0);
      token.content = content;
      token.map = [startLine, state.line];
      token.children = [];
      token = state.push("paragraph_close", "p", -1);
      state.parentType = oldParentType;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_block/state_block.js
var require_state_block = __commonJS({
  "node_modules/markdown-it/lib/rules_block/state_block.js"(exports2, module2) {
    "use strict";
    var Token = require_token();
    var isSpace = require_utils3().isSpace;
    function StateBlock(src, md, env, tokens) {
      var ch, s, start, pos, len, indent, offset, indent_found;
      this.src = src;
      this.md = md;
      this.env = env;
      this.tokens = tokens;
      this.bMarks = [];
      this.eMarks = [];
      this.tShift = [];
      this.sCount = [];
      this.bsCount = [];
      this.blkIndent = 0;
      this.line = 0;
      this.lineMax = 0;
      this.tight = false;
      this.ddIndent = -1;
      this.listIndent = -1;
      this.parentType = "root";
      this.level = 0;
      this.result = "";
      s = this.src;
      indent_found = false;
      for (start = pos = indent = offset = 0, len = s.length; pos < len; pos++) {
        ch = s.charCodeAt(pos);
        if (!indent_found) {
          if (isSpace(ch)) {
            indent++;
            if (ch === 9) {
              offset += 4 - offset % 4;
            } else {
              offset++;
            }
            continue;
          } else {
            indent_found = true;
          }
        }
        if (ch === 10 || pos === len - 1) {
          if (ch !== 10) {
            pos++;
          }
          this.bMarks.push(start);
          this.eMarks.push(pos);
          this.tShift.push(indent);
          this.sCount.push(offset);
          this.bsCount.push(0);
          indent_found = false;
          indent = 0;
          offset = 0;
          start = pos + 1;
        }
      }
      this.bMarks.push(s.length);
      this.eMarks.push(s.length);
      this.tShift.push(0);
      this.sCount.push(0);
      this.bsCount.push(0);
      this.lineMax = this.bMarks.length - 1;
    }
    StateBlock.prototype.push = function(type, tag, nesting) {
      var token = new Token(type, tag, nesting);
      token.block = true;
      if (nesting < 0) this.level--;
      token.level = this.level;
      if (nesting > 0) this.level++;
      this.tokens.push(token);
      return token;
    };
    StateBlock.prototype.isEmpty = function isEmpty(line) {
      return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];
    };
    StateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {
      for (var max = this.lineMax; from < max; from++) {
        if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {
          break;
        }
      }
      return from;
    };
    StateBlock.prototype.skipSpaces = function skipSpaces(pos) {
      var ch;
      for (var max = this.src.length; pos < max; pos++) {
        ch = this.src.charCodeAt(pos);
        if (!isSpace(ch)) {
          break;
        }
      }
      return pos;
    };
    StateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {
      if (pos <= min) {
        return pos;
      }
      while (pos > min) {
        if (!isSpace(this.src.charCodeAt(--pos))) {
          return pos + 1;
        }
      }
      return pos;
    };
    StateBlock.prototype.skipChars = function skipChars(pos, code) {
      for (var max = this.src.length; pos < max; pos++) {
        if (this.src.charCodeAt(pos) !== code) {
          break;
        }
      }
      return pos;
    };
    StateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {
      if (pos <= min) {
        return pos;
      }
      while (pos > min) {
        if (code !== this.src.charCodeAt(--pos)) {
          return pos + 1;
        }
      }
      return pos;
    };
    StateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {
      var i, lineIndent, ch, first, last, queue, lineStart, line = begin;
      if (begin >= end) {
        return "";
      }
      queue = new Array(end - begin);
      for (i = 0; line < end; line++, i++) {
        lineIndent = 0;
        lineStart = first = this.bMarks[line];
        if (line + 1 < end || keepLastLF) {
          last = this.eMarks[line] + 1;
        } else {
          last = this.eMarks[line];
        }
        while (first < last && lineIndent < indent) {
          ch = this.src.charCodeAt(first);
          if (isSpace(ch)) {
            if (ch === 9) {
              lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
            } else {
              lineIndent++;
            }
          } else if (first - lineStart < this.tShift[line]) {
            lineIndent++;
          } else {
            break;
          }
          first++;
        }
        if (lineIndent > indent) {
          queue[i] = new Array(lineIndent - indent + 1).join(" ") + this.src.slice(first, last);
        } else {
          queue[i] = this.src.slice(first, last);
        }
      }
      return queue.join("");
    };
    StateBlock.prototype.Token = Token;
    module2.exports = StateBlock;
  }
});

// node_modules/markdown-it/lib/parser_block.js
var require_parser_block = __commonJS({
  "node_modules/markdown-it/lib/parser_block.js"(exports2, module2) {
    "use strict";
    var Ruler = require_ruler();
    var _rules = [
      // First 2 params - rule name & source. Secondary array - list of rules,
      // which can be terminated by this one.
      ["table", require_table(), ["paragraph", "reference"]],
      ["code", require_code2()],
      ["fence", require_fence(), ["paragraph", "reference", "blockquote", "list"]],
      ["blockquote", require_blockquote2(), ["paragraph", "reference", "blockquote", "list"]],
      ["hr", require_hr(), ["paragraph", "reference", "blockquote", "list"]],
      ["list", require_list(), ["paragraph", "reference", "blockquote"]],
      ["reference", require_reference()],
      ["html_block", require_html_block(), ["paragraph", "reference", "blockquote"]],
      ["heading", require_heading2(), ["paragraph", "reference", "blockquote"]],
      ["lheading", require_lheading()],
      ["paragraph", require_paragraph2()]
    ];
    function ParserBlock() {
      this.ruler = new Ruler();
      for (var i = 0; i < _rules.length; i++) {
        this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() });
      }
    }
    ParserBlock.prototype.tokenize = function(state, startLine, endLine) {
      var ok, i, prevLine, rules = this.ruler.getRules(""), len = rules.length, line = startLine, hasEmptyLines = false, maxNesting = state.md.options.maxNesting;
      while (line < endLine) {
        state.line = line = state.skipEmptyLines(line);
        if (line >= endLine) {
          break;
        }
        if (state.sCount[line] < state.blkIndent) {
          break;
        }
        if (state.level >= maxNesting) {
          state.line = endLine;
          break;
        }
        prevLine = state.line;
        for (i = 0; i < len; i++) {
          ok = rules[i](state, line, endLine, false);
          if (ok) {
            if (prevLine >= state.line) {
              throw new Error("block rule didn't increment state.line");
            }
            break;
          }
        }
        if (!ok) throw new Error("none of the block rules matched");
        state.tight = !hasEmptyLines;
        if (state.isEmpty(state.line - 1)) {
          hasEmptyLines = true;
        }
        line = state.line;
        if (line < endLine && state.isEmpty(line)) {
          hasEmptyLines = true;
          line++;
          state.line = line;
        }
      }
    };
    ParserBlock.prototype.parse = function(src, md, env, outTokens) {
      var state;
      if (!src) {
        return;
      }
      state = new this.State(src, md, env, outTokens);
      this.tokenize(state, state.line, state.lineMax);
    };
    ParserBlock.prototype.State = require_state_block();
    module2.exports = ParserBlock;
  }
});

// node_modules/markdown-it/lib/rules_inline/text.js
var require_text2 = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/text.js"(exports2, module2) {
    "use strict";
    function isTerminatorChar(ch) {
      switch (ch) {
        case 10:
        case 33:
        case 35:
        case 36:
        case 37:
        case 38:
        case 42:
        case 43:
        case 45:
        case 58:
        case 60:
        case 61:
        case 62:
        case 64:
        case 91:
        case 92:
        case 93:
        case 94:
        case 95:
        case 96:
        case 123:
        case 125:
        case 126:
          return true;
        default:
          return false;
      }
    }
    module2.exports = function text(state, silent) {
      var pos = state.pos;
      while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {
        pos++;
      }
      if (pos === state.pos) {
        return false;
      }
      if (!silent) {
        state.pending += state.src.slice(state.pos, pos);
      }
      state.pos = pos;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/linkify.js
var require_linkify2 = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/linkify.js"(exports2, module2) {
    "use strict";
    var SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;
    module2.exports = function linkify(state, silent) {
      var pos, max, match, proto, link, url, fullUrl, token;
      if (!state.md.options.linkify) return false;
      if (state.linkLevel > 0) return false;
      pos = state.pos;
      max = state.posMax;
      if (pos + 3 > max) return false;
      if (state.src.charCodeAt(pos) !== 58) return false;
      if (state.src.charCodeAt(pos + 1) !== 47) return false;
      if (state.src.charCodeAt(pos + 2) !== 47) return false;
      match = state.pending.match(SCHEME_RE);
      if (!match) return false;
      proto = match[1];
      link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));
      if (!link) return false;
      url = link.url;
      if (url.length <= proto.length) return false;
      url = url.replace(/\*+$/, "");
      fullUrl = state.md.normalizeLink(url);
      if (!state.md.validateLink(fullUrl)) return false;
      if (!silent) {
        state.pending = state.pending.slice(0, -proto.length);
        token = state.push("link_open", "a", 1);
        token.attrs = [["href", fullUrl]];
        token.markup = "linkify";
        token.info = "auto";
        token = state.push("text", "", 0);
        token.content = state.md.normalizeLinkText(url);
        token = state.push("link_close", "a", -1);
        token.markup = "linkify";
        token.info = "auto";
      }
      state.pos += url.length - proto.length;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/newline.js
var require_newline = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/newline.js"(exports2, module2) {
    "use strict";
    var isSpace = require_utils3().isSpace;
    module2.exports = function newline(state, silent) {
      var pmax, max, ws, pos = state.pos;
      if (state.src.charCodeAt(pos) !== 10) {
        return false;
      }
      pmax = state.pending.length - 1;
      max = state.posMax;
      if (!silent) {
        if (pmax >= 0 && state.pending.charCodeAt(pmax) === 32) {
          if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 32) {
            ws = pmax - 1;
            while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 32) ws--;
            state.pending = state.pending.slice(0, ws);
            state.push("hardbreak", "br", 0);
          } else {
            state.pending = state.pending.slice(0, -1);
            state.push("softbreak", "br", 0);
          }
        } else {
          state.push("softbreak", "br", 0);
        }
      }
      pos++;
      while (pos < max && isSpace(state.src.charCodeAt(pos))) {
        pos++;
      }
      state.pos = pos;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/escape.js
var require_escape = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/escape.js"(exports2, module2) {
    "use strict";
    var isSpace = require_utils3().isSpace;
    var ESCAPED = [];
    for (i = 0; i < 256; i++) {
      ESCAPED.push(0);
    }
    var i;
    "\\!\"#$%&'()*+,./:;<=>?@[]^_`{|}~-".split("").forEach(function(ch) {
      ESCAPED[ch.charCodeAt(0)] = 1;
    });
    module2.exports = function escape(state, silent) {
      var ch1, ch2, origStr, escapedStr, token, pos = state.pos, max = state.posMax;
      if (state.src.charCodeAt(pos) !== 92) return false;
      pos++;
      if (pos >= max) return false;
      ch1 = state.src.charCodeAt(pos);
      if (ch1 === 10) {
        if (!silent) {
          state.push("hardbreak", "br", 0);
        }
        pos++;
        while (pos < max) {
          ch1 = state.src.charCodeAt(pos);
          if (!isSpace(ch1)) break;
          pos++;
        }
        state.pos = pos;
        return true;
      }
      escapedStr = state.src[pos];
      if (ch1 >= 55296 && ch1 <= 56319 && pos + 1 < max) {
        ch2 = state.src.charCodeAt(pos + 1);
        if (ch2 >= 56320 && ch2 <= 57343) {
          escapedStr += state.src[pos + 1];
          pos++;
        }
      }
      origStr = "\\" + escapedStr;
      if (!silent) {
        token = state.push("text_special", "", 0);
        if (ch1 < 256 && ESCAPED[ch1] !== 0) {
          token.content = escapedStr;
        } else {
          token.content = origStr;
        }
        token.markup = origStr;
        token.info = "escape";
      }
      state.pos = pos + 1;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/backticks.js
var require_backticks = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/backticks.js"(exports2, module2) {
    "use strict";
    module2.exports = function backtick(state, silent) {
      var start, max, marker, token, matchStart, matchEnd, openerLength, closerLength, pos = state.pos, ch = state.src.charCodeAt(pos);
      if (ch !== 96) {
        return false;
      }
      start = pos;
      pos++;
      max = state.posMax;
      while (pos < max && state.src.charCodeAt(pos) === 96) {
        pos++;
      }
      marker = state.src.slice(start, pos);
      openerLength = marker.length;
      if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {
        if (!silent) state.pending += marker;
        state.pos += openerLength;
        return true;
      }
      matchEnd = pos;
      while ((matchStart = state.src.indexOf("`", matchEnd)) !== -1) {
        matchEnd = matchStart + 1;
        while (matchEnd < max && state.src.charCodeAt(matchEnd) === 96) {
          matchEnd++;
        }
        closerLength = matchEnd - matchStart;
        if (closerLength === openerLength) {
          if (!silent) {
            token = state.push("code_inline", "code", 0);
            token.markup = marker;
            token.content = state.src.slice(pos, matchStart).replace(/\n/g, " ").replace(/^ (.+) $/, "$1");
          }
          state.pos = matchEnd;
          return true;
        }
        state.backticks[closerLength] = matchStart;
      }
      state.backticksScanned = true;
      if (!silent) state.pending += marker;
      state.pos += openerLength;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/strikethrough.js
var require_strikethrough = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/strikethrough.js"(exports2, module2) {
    "use strict";
    module2.exports.tokenize = function strikethrough(state, silent) {
      var i, scanned, token, len, ch, start = state.pos, marker = state.src.charCodeAt(start);
      if (silent) {
        return false;
      }
      if (marker !== 126) {
        return false;
      }
      scanned = state.scanDelims(state.pos, true);
      len = scanned.length;
      ch = String.fromCharCode(marker);
      if (len < 2) {
        return false;
      }
      if (len % 2) {
        token = state.push("text", "", 0);
        token.content = ch;
        len--;
      }
      for (i = 0; i < len; i += 2) {
        token = state.push("text", "", 0);
        token.content = ch + ch;
        state.delimiters.push({
          marker,
          length: 0,
          // disable "rule of 3" length checks meant for emphasis
          token: state.tokens.length - 1,
          end: -1,
          open: scanned.can_open,
          close: scanned.can_close
        });
      }
      state.pos += scanned.length;
      return true;
    };
    function postProcess(state, delimiters) {
      var i, j, startDelim, endDelim, token, loneMarkers = [], max = delimiters.length;
      for (i = 0; i < max; i++) {
        startDelim = delimiters[i];
        if (startDelim.marker !== 126) {
          continue;
        }
        if (startDelim.end === -1) {
          continue;
        }
        endDelim = delimiters[startDelim.end];
        token = state.tokens[startDelim.token];
        token.type = "s_open";
        token.tag = "s";
        token.nesting = 1;
        token.markup = "~~";
        token.content = "";
        token = state.tokens[endDelim.token];
        token.type = "s_close";
        token.tag = "s";
        token.nesting = -1;
        token.markup = "~~";
        token.content = "";
        if (state.tokens[endDelim.token - 1].type === "text" && state.tokens[endDelim.token - 1].content === "~") {
          loneMarkers.push(endDelim.token - 1);
        }
      }
      while (loneMarkers.length) {
        i = loneMarkers.pop();
        j = i + 1;
        while (j < state.tokens.length && state.tokens[j].type === "s_close") {
          j++;
        }
        j--;
        if (i !== j) {
          token = state.tokens[j];
          state.tokens[j] = state.tokens[i];
          state.tokens[i] = token;
        }
      }
    }
    module2.exports.postProcess = function strikethrough(state) {
      var curr, tokens_meta = state.tokens_meta, max = state.tokens_meta.length;
      postProcess(state, state.delimiters);
      for (curr = 0; curr < max; curr++) {
        if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
          postProcess(state, tokens_meta[curr].delimiters);
        }
      }
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/emphasis.js
var require_emphasis = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/emphasis.js"(exports2, module2) {
    "use strict";
    module2.exports.tokenize = function emphasis(state, silent) {
      var i, scanned, token, start = state.pos, marker = state.src.charCodeAt(start);
      if (silent) {
        return false;
      }
      if (marker !== 95 && marker !== 42) {
        return false;
      }
      scanned = state.scanDelims(state.pos, marker === 42);
      for (i = 0; i < scanned.length; i++) {
        token = state.push("text", "", 0);
        token.content = String.fromCharCode(marker);
        state.delimiters.push({
          // Char code of the starting marker (number).
          //
          marker,
          // Total length of these series of delimiters.
          //
          length: scanned.length,
          // A position of the token this delimiter corresponds to.
          //
          token: state.tokens.length - 1,
          // If this delimiter is matched as a valid opener, `end` will be
          // equal to its position, otherwise it's `-1`.
          //
          end: -1,
          // Boolean flags that determine if this delimiter could open or close
          // an emphasis.
          //
          open: scanned.can_open,
          close: scanned.can_close
        });
      }
      state.pos += scanned.length;
      return true;
    };
    function postProcess(state, delimiters) {
      var i, startDelim, endDelim, token, ch, isStrong, max = delimiters.length;
      for (i = max - 1; i >= 0; i--) {
        startDelim = delimiters[i];
        if (startDelim.marker !== 95 && startDelim.marker !== 42) {
          continue;
        }
        if (startDelim.end === -1) {
          continue;
        }
        endDelim = delimiters[startDelim.end];
        isStrong = i > 0 && delimiters[i - 1].end === startDelim.end + 1 && // check that first two markers match and adjacent
        delimiters[i - 1].marker === startDelim.marker && delimiters[i - 1].token === startDelim.token - 1 && // check that last two markers are adjacent (we can safely assume they match)
        delimiters[startDelim.end + 1].token === endDelim.token + 1;
        ch = String.fromCharCode(startDelim.marker);
        token = state.tokens[startDelim.token];
        token.type = isStrong ? "strong_open" : "em_open";
        token.tag = isStrong ? "strong" : "em";
        token.nesting = 1;
        token.markup = isStrong ? ch + ch : ch;
        token.content = "";
        token = state.tokens[endDelim.token];
        token.type = isStrong ? "strong_close" : "em_close";
        token.tag = isStrong ? "strong" : "em";
        token.nesting = -1;
        token.markup = isStrong ? ch + ch : ch;
        token.content = "";
        if (isStrong) {
          state.tokens[delimiters[i - 1].token].content = "";
          state.tokens[delimiters[startDelim.end + 1].token].content = "";
          i--;
        }
      }
    }
    module2.exports.postProcess = function emphasis(state) {
      var curr, tokens_meta = state.tokens_meta, max = state.tokens_meta.length;
      postProcess(state, state.delimiters);
      for (curr = 0; curr < max; curr++) {
        if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
          postProcess(state, tokens_meta[curr].delimiters);
        }
      }
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/link.js
var require_link2 = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/link.js"(exports2, module2) {
    "use strict";
    var normalizeReference = require_utils3().normalizeReference;
    var isSpace = require_utils3().isSpace;
    module2.exports = function link(state, silent) {
      var attrs, code, label, labelEnd, labelStart, pos, res, ref, token, href = "", title = "", oldPos = state.pos, max = state.posMax, start = state.pos, parseReference = true;
      if (state.src.charCodeAt(state.pos) !== 91) {
        return false;
      }
      labelStart = state.pos + 1;
      labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);
      if (labelEnd < 0) {
        return false;
      }
      pos = labelEnd + 1;
      if (pos < max && state.src.charCodeAt(pos) === 40) {
        parseReference = false;
        pos++;
        for (; pos < max; pos++) {
          code = state.src.charCodeAt(pos);
          if (!isSpace(code) && code !== 10) {
            break;
          }
        }
        if (pos >= max) {
          return false;
        }
        start = pos;
        res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
        if (res.ok) {
          href = state.md.normalizeLink(res.str);
          if (state.md.validateLink(href)) {
            pos = res.pos;
          } else {
            href = "";
          }
          start = pos;
          for (; pos < max; pos++) {
            code = state.src.charCodeAt(pos);
            if (!isSpace(code) && code !== 10) {
              break;
            }
          }
          res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
          if (pos < max && start !== pos && res.ok) {
            title = res.str;
            pos = res.pos;
            for (; pos < max; pos++) {
              code = state.src.charCodeAt(pos);
              if (!isSpace(code) && code !== 10) {
                break;
              }
            }
          }
        }
        if (pos >= max || state.src.charCodeAt(pos) !== 41) {
          parseReference = true;
        }
        pos++;
      }
      if (parseReference) {
        if (typeof state.env.references === "undefined") {
          return false;
        }
        if (pos < max && state.src.charCodeAt(pos) === 91) {
          start = pos + 1;
          pos = state.md.helpers.parseLinkLabel(state, pos);
          if (pos >= 0) {
            label = state.src.slice(start, pos++);
          } else {
            pos = labelEnd + 1;
          }
        } else {
          pos = labelEnd + 1;
        }
        if (!label) {
          label = state.src.slice(labelStart, labelEnd);
        }
        ref = state.env.references[normalizeReference(label)];
        if (!ref) {
          state.pos = oldPos;
          return false;
        }
        href = ref.href;
        title = ref.title;
      }
      if (!silent) {
        state.pos = labelStart;
        state.posMax = labelEnd;
        token = state.push("link_open", "a", 1);
        token.attrs = attrs = [["href", href]];
        if (title) {
          attrs.push(["title", title]);
        }
        state.linkLevel++;
        state.md.inline.tokenize(state);
        state.linkLevel--;
        token = state.push("link_close", "a", -1);
      }
      state.pos = pos;
      state.posMax = max;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/image.js
var require_image2 = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/image.js"(exports2, module2) {
    "use strict";
    var normalizeReference = require_utils3().normalizeReference;
    var isSpace = require_utils3().isSpace;
    module2.exports = function image(state, silent) {
      var attrs, code, content, label, labelEnd, labelStart, pos, ref, res, title, token, tokens, start, href = "", oldPos = state.pos, max = state.posMax;
      if (state.src.charCodeAt(state.pos) !== 33) {
        return false;
      }
      if (state.src.charCodeAt(state.pos + 1) !== 91) {
        return false;
      }
      labelStart = state.pos + 2;
      labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);
      if (labelEnd < 0) {
        return false;
      }
      pos = labelEnd + 1;
      if (pos < max && state.src.charCodeAt(pos) === 40) {
        pos++;
        for (; pos < max; pos++) {
          code = state.src.charCodeAt(pos);
          if (!isSpace(code) && code !== 10) {
            break;
          }
        }
        if (pos >= max) {
          return false;
        }
        start = pos;
        res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
        if (res.ok) {
          href = state.md.normalizeLink(res.str);
          if (state.md.validateLink(href)) {
            pos = res.pos;
          } else {
            href = "";
          }
        }
        start = pos;
        for (; pos < max; pos++) {
          code = state.src.charCodeAt(pos);
          if (!isSpace(code) && code !== 10) {
            break;
          }
        }
        res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
        if (pos < max && start !== pos && res.ok) {
          title = res.str;
          pos = res.pos;
          for (; pos < max; pos++) {
            code = state.src.charCodeAt(pos);
            if (!isSpace(code) && code !== 10) {
              break;
            }
          }
        } else {
          title = "";
        }
        if (pos >= max || state.src.charCodeAt(pos) !== 41) {
          state.pos = oldPos;
          return false;
        }
        pos++;
      } else {
        if (typeof state.env.references === "undefined") {
          return false;
        }
        if (pos < max && state.src.charCodeAt(pos) === 91) {
          start = pos + 1;
          pos = state.md.helpers.parseLinkLabel(state, pos);
          if (pos >= 0) {
            label = state.src.slice(start, pos++);
          } else {
            pos = labelEnd + 1;
          }
        } else {
          pos = labelEnd + 1;
        }
        if (!label) {
          label = state.src.slice(labelStart, labelEnd);
        }
        ref = state.env.references[normalizeReference(label)];
        if (!ref) {
          state.pos = oldPos;
          return false;
        }
        href = ref.href;
        title = ref.title;
      }
      if (!silent) {
        content = state.src.slice(labelStart, labelEnd);
        state.md.inline.parse(
          content,
          state.md,
          state.env,
          tokens = []
        );
        token = state.push("image", "img", 0);
        token.attrs = attrs = [["src", href], ["alt", ""]];
        token.children = tokens;
        token.content = content;
        if (title) {
          attrs.push(["title", title]);
        }
      }
      state.pos = pos;
      state.posMax = max;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/autolink.js
var require_autolink = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/autolink.js"(exports2, module2) {
    "use strict";
    var EMAIL_RE = /^([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;
    var AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.\-]{1,31}):([^<>\x00-\x20]*)$/;
    module2.exports = function autolink(state, silent) {
      var url, fullUrl, token, ch, start, max, pos = state.pos;
      if (state.src.charCodeAt(pos) !== 60) {
        return false;
      }
      start = state.pos;
      max = state.posMax;
      for (; ; ) {
        if (++pos >= max) return false;
        ch = state.src.charCodeAt(pos);
        if (ch === 60) return false;
        if (ch === 62) break;
      }
      url = state.src.slice(start + 1, pos);
      if (AUTOLINK_RE.test(url)) {
        fullUrl = state.md.normalizeLink(url);
        if (!state.md.validateLink(fullUrl)) {
          return false;
        }
        if (!silent) {
          token = state.push("link_open", "a", 1);
          token.attrs = [["href", fullUrl]];
          token.markup = "autolink";
          token.info = "auto";
          token = state.push("text", "", 0);
          token.content = state.md.normalizeLinkText(url);
          token = state.push("link_close", "a", -1);
          token.markup = "autolink";
          token.info = "auto";
        }
        state.pos += url.length + 2;
        return true;
      }
      if (EMAIL_RE.test(url)) {
        fullUrl = state.md.normalizeLink("mailto:" + url);
        if (!state.md.validateLink(fullUrl)) {
          return false;
        }
        if (!silent) {
          token = state.push("link_open", "a", 1);
          token.attrs = [["href", fullUrl]];
          token.markup = "autolink";
          token.info = "auto";
          token = state.push("text", "", 0);
          token.content = state.md.normalizeLinkText(url);
          token = state.push("link_close", "a", -1);
          token.markup = "autolink";
          token.info = "auto";
        }
        state.pos += url.length + 2;
        return true;
      }
      return false;
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/html_inline.js
var require_html_inline = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/html_inline.js"(exports2, module2) {
    "use strict";
    var HTML_TAG_RE = require_html_re().HTML_TAG_RE;
    function isLinkOpen(str) {
      return /^<a[>\s]/i.test(str);
    }
    function isLinkClose(str) {
      return /^<\/a\s*>/i.test(str);
    }
    function isLetter(ch) {
      var lc = ch | 32;
      return lc >= 97 && lc <= 122;
    }
    module2.exports = function html_inline(state, silent) {
      var ch, match, max, token, pos = state.pos;
      if (!state.md.options.html) {
        return false;
      }
      max = state.posMax;
      if (state.src.charCodeAt(pos) !== 60 || pos + 2 >= max) {
        return false;
      }
      ch = state.src.charCodeAt(pos + 1);
      if (ch !== 33 && ch !== 63 && ch !== 47 && !isLetter(ch)) {
        return false;
      }
      match = state.src.slice(pos).match(HTML_TAG_RE);
      if (!match) {
        return false;
      }
      if (!silent) {
        token = state.push("html_inline", "", 0);
        token.content = match[0];
        if (isLinkOpen(token.content)) state.linkLevel++;
        if (isLinkClose(token.content)) state.linkLevel--;
      }
      state.pos += match[0].length;
      return true;
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/entity.js
var require_entity = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/entity.js"(exports2, module2) {
    "use strict";
    var entities = require_entities2();
    var has = require_utils3().has;
    var isValidEntityCode = require_utils3().isValidEntityCode;
    var fromCodePoint = require_utils3().fromCodePoint;
    var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
    var NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;
    module2.exports = function entity(state, silent) {
      var ch, code, match, token, pos = state.pos, max = state.posMax;
      if (state.src.charCodeAt(pos) !== 38) return false;
      if (pos + 1 >= max) return false;
      ch = state.src.charCodeAt(pos + 1);
      if (ch === 35) {
        match = state.src.slice(pos).match(DIGITAL_RE);
        if (match) {
          if (!silent) {
            code = match[1][0].toLowerCase() === "x" ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);
            token = state.push("text_special", "", 0);
            token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(65533);
            token.markup = match[0];
            token.info = "entity";
          }
          state.pos += match[0].length;
          return true;
        }
      } else {
        match = state.src.slice(pos).match(NAMED_RE);
        if (match) {
          if (has(entities, match[1])) {
            if (!silent) {
              token = state.push("text_special", "", 0);
              token.content = entities[match[1]];
              token.markup = match[0];
              token.info = "entity";
            }
            state.pos += match[0].length;
            return true;
          }
        }
      }
      return false;
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/balance_pairs.js
var require_balance_pairs = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/balance_pairs.js"(exports2, module2) {
    "use strict";
    function processDelimiters(delimiters) {
      var closerIdx, openerIdx, closer, opener, minOpenerIdx, newMinOpenerIdx, isOddMatch, lastJump, openersBottom = {}, max = delimiters.length;
      if (!max) return;
      var headerIdx = 0;
      var lastTokenIdx = -2;
      var jumps = [];
      for (closerIdx = 0; closerIdx < max; closerIdx++) {
        closer = delimiters[closerIdx];
        jumps.push(0);
        if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {
          headerIdx = closerIdx;
        }
        lastTokenIdx = closer.token;
        closer.length = closer.length || 0;
        if (!closer.close) continue;
        if (!openersBottom.hasOwnProperty(closer.marker)) {
          openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1];
        }
        minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + closer.length % 3];
        openerIdx = headerIdx - jumps[headerIdx] - 1;
        newMinOpenerIdx = openerIdx;
        for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {
          opener = delimiters[openerIdx];
          if (opener.marker !== closer.marker) continue;
          if (opener.open && opener.end < 0) {
            isOddMatch = false;
            if (opener.close || closer.open) {
              if ((opener.length + closer.length) % 3 === 0) {
                if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {
                  isOddMatch = true;
                }
              }
            }
            if (!isOddMatch) {
              lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open ? jumps[openerIdx - 1] + 1 : 0;
              jumps[closerIdx] = closerIdx - openerIdx + lastJump;
              jumps[openerIdx] = lastJump;
              closer.open = false;
              opener.end = closerIdx;
              opener.close = false;
              newMinOpenerIdx = -1;
              lastTokenIdx = -2;
              break;
            }
          }
        }
        if (newMinOpenerIdx !== -1) {
          openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length || 0) % 3] = newMinOpenerIdx;
        }
      }
    }
    module2.exports = function link_pairs(state) {
      var curr, tokens_meta = state.tokens_meta, max = state.tokens_meta.length;
      processDelimiters(state.delimiters);
      for (curr = 0; curr < max; curr++) {
        if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
          processDelimiters(tokens_meta[curr].delimiters);
        }
      }
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/fragments_join.js
var require_fragments_join = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/fragments_join.js"(exports2, module2) {
    "use strict";
    module2.exports = function fragments_join(state) {
      var curr, last, level = 0, tokens = state.tokens, max = state.tokens.length;
      for (curr = last = 0; curr < max; curr++) {
        if (tokens[curr].nesting < 0) level--;
        tokens[curr].level = level;
        if (tokens[curr].nesting > 0) level++;
        if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") {
          tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
        } else {
          if (curr !== last) {
            tokens[last] = tokens[curr];
          }
          last++;
        }
      }
      if (curr !== last) {
        tokens.length = last;
      }
    };
  }
});

// node_modules/markdown-it/lib/rules_inline/state_inline.js
var require_state_inline = __commonJS({
  "node_modules/markdown-it/lib/rules_inline/state_inline.js"(exports2, module2) {
    "use strict";
    var Token = require_token();
    var isWhiteSpace = require_utils3().isWhiteSpace;
    var isPunctChar = require_utils3().isPunctChar;
    var isMdAsciiPunct = require_utils3().isMdAsciiPunct;
    function StateInline(src, md, env, outTokens) {
      this.src = src;
      this.env = env;
      this.md = md;
      this.tokens = outTokens;
      this.tokens_meta = Array(outTokens.length);
      this.pos = 0;
      this.posMax = this.src.length;
      this.level = 0;
      this.pending = "";
      this.pendingLevel = 0;
      this.cache = {};
      this.delimiters = [];
      this._prev_delimiters = [];
      this.backticks = {};
      this.backticksScanned = false;
      this.linkLevel = 0;
    }
    StateInline.prototype.pushPending = function() {
      var token = new Token("text", "", 0);
      token.content = this.pending;
      token.level = this.pendingLevel;
      this.tokens.push(token);
      this.pending = "";
      return token;
    };
    StateInline.prototype.push = function(type, tag, nesting) {
      if (this.pending) {
        this.pushPending();
      }
      var token = new Token(type, tag, nesting);
      var token_meta = null;
      if (nesting < 0) {
        this.level--;
        this.delimiters = this._prev_delimiters.pop();
      }
      token.level = this.level;
      if (nesting > 0) {
        this.level++;
        this._prev_delimiters.push(this.delimiters);
        this.delimiters = [];
        token_meta = { delimiters: this.delimiters };
      }
      this.pendingLevel = this.level;
      this.tokens.push(token);
      this.tokens_meta.push(token_meta);
      return token;
    };
    StateInline.prototype.scanDelims = function(start, canSplitWord) {
      var pos = start, lastChar, nextChar, count, can_open, can_close, isLastWhiteSpace, isLastPunctChar, isNextWhiteSpace, isNextPunctChar, left_flanking = true, right_flanking = true, max = this.posMax, marker = this.src.charCodeAt(start);
      lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 32;
      while (pos < max && this.src.charCodeAt(pos) === marker) {
        pos++;
      }
      count = pos - start;
      nextChar = pos < max ? this.src.charCodeAt(pos) : 32;
      isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
      isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
      isLastWhiteSpace = isWhiteSpace(lastChar);
      isNextWhiteSpace = isWhiteSpace(nextChar);
      if (isNextWhiteSpace) {
        left_flanking = false;
      } else if (isNextPunctChar) {
        if (!(isLastWhiteSpace || isLastPunctChar)) {
          left_flanking = false;
        }
      }
      if (isLastWhiteSpace) {
        right_flanking = false;
      } else if (isLastPunctChar) {
        if (!(isNextWhiteSpace || isNextPunctChar)) {
          right_flanking = false;
        }
      }
      if (!canSplitWord) {
        can_open = left_flanking && (!right_flanking || isLastPunctChar);
        can_close = right_flanking && (!left_flanking || isNextPunctChar);
      } else {
        can_open = left_flanking;
        can_close = right_flanking;
      }
      return {
        can_open,
        can_close,
        length: count
      };
    };
    StateInline.prototype.Token = Token;
    module2.exports = StateInline;
  }
});

// node_modules/markdown-it/lib/parser_inline.js
var require_parser_inline = __commonJS({
  "node_modules/markdown-it/lib/parser_inline.js"(exports2, module2) {
    "use strict";
    var Ruler = require_ruler();
    var _rules = [
      ["text", require_text2()],
      ["linkify", require_linkify2()],
      ["newline", require_newline()],
      ["escape", require_escape()],
      ["backticks", require_backticks()],
      ["strikethrough", require_strikethrough().tokenize],
      ["emphasis", require_emphasis().tokenize],
      ["link", require_link2()],
      ["image", require_image2()],
      ["autolink", require_autolink()],
      ["html_inline", require_html_inline()],
      ["entity", require_entity()]
    ];
    var _rules2 = [
      ["balance_pairs", require_balance_pairs()],
      ["strikethrough", require_strikethrough().postProcess],
      ["emphasis", require_emphasis().postProcess],
      // rules for pairs separate '**' into its own text tokens, which may be left unused,
      // rule below merges unused segments back with the rest of the text
      ["fragments_join", require_fragments_join()]
    ];
    function ParserInline() {
      var i;
      this.ruler = new Ruler();
      for (i = 0; i < _rules.length; i++) {
        this.ruler.push(_rules[i][0], _rules[i][1]);
      }
      this.ruler2 = new Ruler();
      for (i = 0; i < _rules2.length; i++) {
        this.ruler2.push(_rules2[i][0], _rules2[i][1]);
      }
    }
    ParserInline.prototype.skipToken = function(state) {
      var ok, i, pos = state.pos, rules = this.ruler.getRules(""), len = rules.length, maxNesting = state.md.options.maxNesting, cache = state.cache;
      if (typeof cache[pos] !== "undefined") {
        state.pos = cache[pos];
        return;
      }
      if (state.level < maxNesting) {
        for (i = 0; i < len; i++) {
          state.level++;
          ok = rules[i](state, true);
          state.level--;
          if (ok) {
            if (pos >= state.pos) {
              throw new Error("inline rule didn't increment state.pos");
            }
            break;
          }
        }
      } else {
        state.pos = state.posMax;
      }
      if (!ok) {
        state.pos++;
      }
      cache[pos] = state.pos;
    };
    ParserInline.prototype.tokenize = function(state) {
      var ok, i, prevPos, rules = this.ruler.getRules(""), len = rules.length, end = state.posMax, maxNesting = state.md.options.maxNesting;
      while (state.pos < end) {
        prevPos = state.pos;
        if (state.level < maxNesting) {
          for (i = 0; i < len; i++) {
            ok = rules[i](state, false);
            if (ok) {
              if (prevPos >= state.pos) {
                throw new Error("inline rule didn't increment state.pos");
              }
              break;
            }
          }
        }
        if (ok) {
          if (state.pos >= end) {
            break;
          }
          continue;
        }
        state.pending += state.src[state.pos++];
      }
      if (state.pending) {
        state.pushPending();
      }
    };
    ParserInline.prototype.parse = function(str, md, env, outTokens) {
      var i, rules, len;
      var state = new this.State(str, md, env, outTokens);
      this.tokenize(state);
      rules = this.ruler2.getRules("");
      len = rules.length;
      for (i = 0; i < len; i++) {
        rules[i](state);
      }
    };
    ParserInline.prototype.State = require_state_inline();
    module2.exports = ParserInline;
  }
});

// node_modules/markdown-it/node_modules/linkify-it/lib/re.js
var require_re2 = __commonJS({
  "node_modules/markdown-it/node_modules/linkify-it/lib/re.js"(exports2, module2) {
    "use strict";
    module2.exports = function(opts) {
      var re = {};
      opts = opts || {};
      re.src_Any = require_regex().source;
      re.src_Cc = require_regex2().source;
      re.src_Z = require_regex3().source;
      re.src_P = require_regex4().source;
      re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join("|");
      re.src_ZCc = [re.src_Z, re.src_Cc].join("|");
      var text_separators = "[><\uFF5C]";
      re.src_pseudo_letter = "(?:(?!" + text_separators + "|" + re.src_ZPCc + ")" + re.src_Any + ")";
      re.src_ip4 = "(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)";
      re.src_auth = "(?:(?:(?!" + re.src_ZCc + "|[@/\\[\\]()]).)+@)?";
      re.src_port = "(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?";
      re.src_host_terminator = "(?=$|" + text_separators + "|" + re.src_ZPCc + ")(?!" + (opts["---"] ? "-(?!--)|" : "-|") + "_|:\\d|\\.-|\\.(?!$|" + re.src_ZPCc + "))";
      re.src_path = "(?:[/?#](?:(?!" + re.src_ZCc + "|" + text_separators + `|[()[\\]{}.,"'?!\\-;]).|\\[(?:(?!` + re.src_ZCc + "|\\]).)*\\]|\\((?:(?!" + re.src_ZCc + "|[)]).)*\\)|\\{(?:(?!" + re.src_ZCc + '|[}]).)*\\}|\\"(?:(?!' + re.src_ZCc + `|["]).)+\\"|\\'(?:(?!` + re.src_ZCc + "|[']).)+\\'|\\'(?=" + re.src_pseudo_letter + "|[-])|\\.{2,}[a-zA-Z0-9%/&]|\\.(?!" + re.src_ZCc + "|[.]|$)|" + (opts["---"] ? "\\-(?!--(?:[^-]|$))(?:-*)|" : "\\-+|") + ",(?!" + re.src_ZCc + "|$)|;(?!" + re.src_ZCc + "|$)|\\!+(?!" + re.src_ZCc + "|[!]|$)|\\?(?!" + re.src_ZCc + "|[?]|$))+|\\/)?";
      re.src_email_name = '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
      re.src_xn = "xn--[a-z0-9\\-]{1,59}";
      re.src_domain_root = // Allow letters & digits (http://test1)
      "(?:" + re.src_xn + "|" + re.src_pseudo_letter + "{1,63})";
      re.src_domain = "(?:" + re.src_xn + "|(?:" + re.src_pseudo_letter + ")|(?:" + re.src_pseudo_letter + "(?:-|" + re.src_pseudo_letter + "){0,61}" + re.src_pseudo_letter + "))";
      re.src_host = "(?:(?:(?:(?:" + re.src_domain + ")\\.)*" + re.src_domain + "))";
      re.tpl_host_fuzzy = "(?:" + re.src_ip4 + "|(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%)))";
      re.tpl_host_no_ip_fuzzy = "(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%))";
      re.src_host_strict = re.src_host + re.src_host_terminator;
      re.tpl_host_fuzzy_strict = re.tpl_host_fuzzy + re.src_host_terminator;
      re.src_host_port_strict = re.src_host + re.src_port + re.src_host_terminator;
      re.tpl_host_port_fuzzy_strict = re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
      re.tpl_host_port_no_ip_fuzzy_strict = re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;
      re.tpl_host_fuzzy_test = "localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:" + re.src_ZPCc + "|>|$))";
      re.tpl_email_fuzzy = "(^|" + text_separators + '|"|\\(|' + re.src_ZCc + ")(" + re.src_email_name + "@" + re.tpl_host_fuzzy_strict + ")";
      re.tpl_link_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
      // but can start with > (markdown blockquote)
      "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_fuzzy_strict + re.src_path + ")";
      re.tpl_link_no_ip_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
      // but can start with > (markdown blockquote)
      "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ")";
      return re;
    };
  }
});

// node_modules/markdown-it/node_modules/linkify-it/index.js
var require_linkify_it2 = __commonJS({
  "node_modules/markdown-it/node_modules/linkify-it/index.js"(exports2, module2) {
    "use strict";
    function assign(obj) {
      var sources = Array.prototype.slice.call(arguments, 1);
      sources.forEach(function(source) {
        if (!source) {
          return;
        }
        Object.keys(source).forEach(function(key) {
          obj[key] = source[key];
        });
      });
      return obj;
    }
    function _class(obj) {
      return Object.prototype.toString.call(obj);
    }
    function isString(obj) {
      return _class(obj) === "[object String]";
    }
    function isObject(obj) {
      return _class(obj) === "[object Object]";
    }
    function isRegExp(obj) {
      return _class(obj) === "[object RegExp]";
    }
    function isFunction(obj) {
      return _class(obj) === "[object Function]";
    }
    function escapeRE(str) {
      return str.replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&");
    }
    var defaultOptions = {
      fuzzyLink: true,
      fuzzyEmail: true,
      fuzzyIP: false
    };
    function isOptionsObj(obj) {
      return Object.keys(obj || {}).reduce(function(acc, k) {
        return acc || defaultOptions.hasOwnProperty(k);
      }, false);
    }
    var defaultSchemas = {
      "http:": {
        validate: function(text, pos, self2) {
          var tail = text.slice(pos);
          if (!self2.re.http) {
            self2.re.http = new RegExp(
              "^\\/\\/" + self2.re.src_auth + self2.re.src_host_port_strict + self2.re.src_path,
              "i"
            );
          }
          if (self2.re.http.test(tail)) {
            return tail.match(self2.re.http)[0].length;
          }
          return 0;
        }
      },
      "https:": "http:",
      "ftp:": "http:",
      "//": {
        validate: function(text, pos, self2) {
          var tail = text.slice(pos);
          if (!self2.re.no_http) {
            self2.re.no_http = new RegExp(
              "^" + self2.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'
              // with code comments
              "(?:localhost|(?:(?:" + self2.re.src_domain + ")\\.)+" + self2.re.src_domain_root + ")" + self2.re.src_port + self2.re.src_host_terminator + self2.re.src_path,
              "i"
            );
          }
          if (self2.re.no_http.test(tail)) {
            if (pos >= 3 && text[pos - 3] === ":") {
              return 0;
            }
            if (pos >= 3 && text[pos - 3] === "/") {
              return 0;
            }
            return tail.match(self2.re.no_http)[0].length;
          }
          return 0;
        }
      },
      "mailto:": {
        validate: function(text, pos, self2) {
          var tail = text.slice(pos);
          if (!self2.re.mailto) {
            self2.re.mailto = new RegExp(
              "^" + self2.re.src_email_name + "@" + self2.re.src_host_strict,
              "i"
            );
          }
          if (self2.re.mailto.test(tail)) {
            return tail.match(self2.re.mailto)[0].length;
          }
          return 0;
        }
      }
    };
    var tlds_2ch_src_re = "a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]";
    var tlds_default = "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|\u0440\u0444".split("|");
    function resetScanCache(self2) {
      self2.__index__ = -1;
      self2.__text_cache__ = "";
    }
    function createValidator(re) {
      return function(text, pos) {
        var tail = text.slice(pos);
        if (re.test(tail)) {
          return tail.match(re)[0].length;
        }
        return 0;
      };
    }
    function createNormalizer() {
      return function(match, self2) {
        self2.normalize(match);
      };
    }
    function compile(self2) {
      var re = self2.re = require_re2()(self2.__opts__);
      var tlds = self2.__tlds__.slice();
      self2.onCompile();
      if (!self2.__tlds_replaced__) {
        tlds.push(tlds_2ch_src_re);
      }
      tlds.push(re.src_xn);
      re.src_tlds = tlds.join("|");
      function untpl(tpl) {
        return tpl.replace("%TLDS%", re.src_tlds);
      }
      re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), "i");
      re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), "i");
      re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "i");
      re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), "i");
      var aliases = [];
      self2.__compiled__ = {};
      function schemaError(name, val) {
        throw new Error('(LinkifyIt) Invalid schema "' + name + '": ' + val);
      }
      Object.keys(self2.__schemas__).forEach(function(name) {
        var val = self2.__schemas__[name];
        if (val === null) {
          return;
        }
        var compiled = { validate: null, link: null };
        self2.__compiled__[name] = compiled;
        if (isObject(val)) {
          if (isRegExp(val.validate)) {
            compiled.validate = createValidator(val.validate);
          } else if (isFunction(val.validate)) {
            compiled.validate = val.validate;
          } else {
            schemaError(name, val);
          }
          if (isFunction(val.normalize)) {
            compiled.normalize = val.normalize;
          } else if (!val.normalize) {
            compiled.normalize = createNormalizer();
          } else {
            schemaError(name, val);
          }
          return;
        }
        if (isString(val)) {
          aliases.push(name);
          return;
        }
        schemaError(name, val);
      });
      aliases.forEach(function(alias) {
        if (!self2.__compiled__[self2.__schemas__[alias]]) {
          return;
        }
        self2.__compiled__[alias].validate = self2.__compiled__[self2.__schemas__[alias]].validate;
        self2.__compiled__[alias].normalize = self2.__compiled__[self2.__schemas__[alias]].normalize;
      });
      self2.__compiled__[""] = { validate: null, normalize: createNormalizer() };
      var slist = Object.keys(self2.__compiled__).filter(function(name) {
        return name.length > 0 && self2.__compiled__[name];
      }).map(escapeRE).join("|");
      self2.re.schema_test = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "i");
      self2.re.schema_search = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "ig");
      self2.re.schema_at_start = RegExp("^" + self2.re.schema_search.source, "i");
      self2.re.pretest = RegExp(
        "(" + self2.re.schema_test.source + ")|(" + self2.re.host_fuzzy_test.source + ")|@",
        "i"
      );
      resetScanCache(self2);
    }
    function Match(self2, shift) {
      var start = self2.__index__, end = self2.__last_index__, text = self2.__text_cache__.slice(start, end);
      this.schema = self2.__schema__.toLowerCase();
      this.index = start + shift;
      this.lastIndex = end + shift;
      this.raw = text;
      this.text = text;
      this.url = text;
    }
    function createMatch(self2, shift) {
      var match = new Match(self2, shift);
      self2.__compiled__[match.schema].normalize(match, self2);
      return match;
    }
    function LinkifyIt(schemas, options) {
      if (!(this instanceof LinkifyIt)) {
        return new LinkifyIt(schemas, options);
      }
      if (!options) {
        if (isOptionsObj(schemas)) {
          options = schemas;
          schemas = {};
        }
      }
      this.__opts__ = assign({}, defaultOptions, options);
      this.__index__ = -1;
      this.__last_index__ = -1;
      this.__schema__ = "";
      this.__text_cache__ = "";
      this.__schemas__ = assign({}, defaultSchemas, schemas);
      this.__compiled__ = {};
      this.__tlds__ = tlds_default;
      this.__tlds_replaced__ = false;
      this.re = {};
      compile(this);
    }
    LinkifyIt.prototype.add = function add(schema, definition) {
      this.__schemas__[schema] = definition;
      compile(this);
      return this;
    };
    LinkifyIt.prototype.set = function set(options) {
      this.__opts__ = assign(this.__opts__, options);
      return this;
    };
    LinkifyIt.prototype.test = function test(text) {
      this.__text_cache__ = text;
      this.__index__ = -1;
      if (!text.length) {
        return false;
      }
      var m, ml, me, len, shift, next, re, tld_pos, at_pos;
      if (this.re.schema_test.test(text)) {
        re = this.re.schema_search;
        re.lastIndex = 0;
        while ((m = re.exec(text)) !== null) {
          len = this.testSchemaAt(text, m[2], re.lastIndex);
          if (len) {
            this.__schema__ = m[2];
            this.__index__ = m.index + m[1].length;
            this.__last_index__ = m.index + m[0].length + len;
            break;
          }
        }
      }
      if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
        tld_pos = text.search(this.re.host_fuzzy_test);
        if (tld_pos >= 0) {
          if (this.__index__ < 0 || tld_pos < this.__index__) {
            if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {
              shift = ml.index + ml[1].length;
              if (this.__index__ < 0 || shift < this.__index__) {
                this.__schema__ = "";
                this.__index__ = shift;
                this.__last_index__ = ml.index + ml[0].length;
              }
            }
          }
        }
      }
      if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
        at_pos = text.indexOf("@");
        if (at_pos >= 0) {
          if ((me = text.match(this.re.email_fuzzy)) !== null) {
            shift = me.index + me[1].length;
            next = me.index + me[0].length;
            if (this.__index__ < 0 || shift < this.__index__ || shift === this.__index__ && next > this.__last_index__) {
              this.__schema__ = "mailto:";
              this.__index__ = shift;
              this.__last_index__ = next;
            }
          }
        }
      }
      return this.__index__ >= 0;
    };
    LinkifyIt.prototype.pretest = function pretest(text) {
      return this.re.pretest.test(text);
    };
    LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {
      if (!this.__compiled__[schema.toLowerCase()]) {
        return 0;
      }
      return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);
    };
    LinkifyIt.prototype.match = function match(text) {
      var shift = 0, result = [];
      if (this.__index__ >= 0 && this.__text_cache__ === text) {
        result.push(createMatch(this, shift));
        shift = this.__last_index__;
      }
      var tail = shift ? text.slice(shift) : text;
      while (this.test(tail)) {
        result.push(createMatch(this, shift));
        tail = tail.slice(this.__last_index__);
        shift += this.__last_index__;
      }
      if (result.length) {
        return result;
      }
      return null;
    };
    LinkifyIt.prototype.matchAtStart = function matchAtStart(text) {
      this.__text_cache__ = text;
      this.__index__ = -1;
      if (!text.length) return null;
      var m = this.re.schema_at_start.exec(text);
      if (!m) return null;
      var len = this.testSchemaAt(text, m[2], m[0].length);
      if (!len) return null;
      this.__schema__ = m[2];
      this.__index__ = m.index + m[1].length;
      this.__last_index__ = m.index + m[0].length + len;
      return createMatch(this, 0);
    };
    LinkifyIt.prototype.tlds = function tlds(list, keepOld) {
      list = Array.isArray(list) ? list : [list];
      if (!keepOld) {
        this.__tlds__ = list.slice();
        this.__tlds_replaced__ = true;
        compile(this);
        return this;
      }
      this.__tlds__ = this.__tlds__.concat(list).sort().filter(function(el, idx, arr) {
        return el !== arr[idx - 1];
      }).reverse();
      compile(this);
      return this;
    };
    LinkifyIt.prototype.normalize = function normalize(match) {
      if (!match.schema) {
        match.url = "http://" + match.url;
      }
      if (match.schema === "mailto:" && !/^mailto:/i.test(match.url)) {
        match.url = "mailto:" + match.url;
      }
    };
    LinkifyIt.prototype.onCompile = function onCompile() {
    };
    module2.exports = LinkifyIt;
  }
});

// node_modules/markdown-it/lib/presets/default.js
var require_default = __commonJS({
  "node_modules/markdown-it/lib/presets/default.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      options: {
        html: false,
        // Enable HTML tags in source
        xhtmlOut: false,
        // Use '/' to close single tags (<br />)
        breaks: false,
        // Convert '\n' in paragraphs into <br>
        langPrefix: "language-",
        // CSS language prefix for fenced blocks
        linkify: false,
        // autoconvert URL-like texts to links
        // Enable some language-neutral replacements + quotes beautification
        typographer: false,
        // Double + single quotes replacement pairs, when typographer enabled,
        // and smartquotes on. Could be either a String or an Array.
        //
        // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
        // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
        quotes: "\u201C\u201D\u2018\u2019",
        /* “”‘’ */
        // Highlighter function. Should return escaped HTML,
        // or '' if the source string is not changed and should be escaped externaly.
        // If result starts with <pre... internal wrapper is skipped.
        //
        // function (/*str, lang*/) { return ''; }
        //
        highlight: null,
        maxNesting: 100
        // Internal protection, recursion limit
      },
      components: {
        core: {},
        block: {},
        inline: {}
      }
    };
  }
});

// node_modules/markdown-it/lib/presets/zero.js
var require_zero = __commonJS({
  "node_modules/markdown-it/lib/presets/zero.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      options: {
        html: false,
        // Enable HTML tags in source
        xhtmlOut: false,
        // Use '/' to close single tags (<br />)
        breaks: false,
        // Convert '\n' in paragraphs into <br>
        langPrefix: "language-",
        // CSS language prefix for fenced blocks
        linkify: false,
        // autoconvert URL-like texts to links
        // Enable some language-neutral replacements + quotes beautification
        typographer: false,
        // Double + single quotes replacement pairs, when typographer enabled,
        // and smartquotes on. Could be either a String or an Array.
        //
        // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
        // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
        quotes: "\u201C\u201D\u2018\u2019",
        /* “”‘’ */
        // Highlighter function. Should return escaped HTML,
        // or '' if the source string is not changed and should be escaped externaly.
        // If result starts with <pre... internal wrapper is skipped.
        //
        // function (/*str, lang*/) { return ''; }
        //
        highlight: null,
        maxNesting: 20
        // Internal protection, recursion limit
      },
      components: {
        core: {
          rules: [
            "normalize",
            "block",
            "inline",
            "text_join"
          ]
        },
        block: {
          rules: [
            "paragraph"
          ]
        },
        inline: {
          rules: [
            "text"
          ],
          rules2: [
            "balance_pairs",
            "fragments_join"
          ]
        }
      }
    };
  }
});

// node_modules/markdown-it/lib/presets/commonmark.js
var require_commonmark = __commonJS({
  "node_modules/markdown-it/lib/presets/commonmark.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      options: {
        html: true,
        // Enable HTML tags in source
        xhtmlOut: true,
        // Use '/' to close single tags (<br />)
        breaks: false,
        // Convert '\n' in paragraphs into <br>
        langPrefix: "language-",
        // CSS language prefix for fenced blocks
        linkify: false,
        // autoconvert URL-like texts to links
        // Enable some language-neutral replacements + quotes beautification
        typographer: false,
        // Double + single quotes replacement pairs, when typographer enabled,
        // and smartquotes on. Could be either a String or an Array.
        //
        // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
        // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
        quotes: "\u201C\u201D\u2018\u2019",
        /* “”‘’ */
        // Highlighter function. Should return escaped HTML,
        // or '' if the source string is not changed and should be escaped externaly.
        // If result starts with <pre... internal wrapper is skipped.
        //
        // function (/*str, lang*/) { return ''; }
        //
        highlight: null,
        maxNesting: 20
        // Internal protection, recursion limit
      },
      components: {
        core: {
          rules: [
            "normalize",
            "block",
            "inline",
            "text_join"
          ]
        },
        block: {
          rules: [
            "blockquote",
            "code",
            "fence",
            "heading",
            "hr",
            "html_block",
            "lheading",
            "list",
            "reference",
            "paragraph"
          ]
        },
        inline: {
          rules: [
            "autolink",
            "backticks",
            "emphasis",
            "entity",
            "escape",
            "html_inline",
            "image",
            "link",
            "newline",
            "text"
          ],
          rules2: [
            "balance_pairs",
            "emphasis",
            "fragments_join"
          ]
        }
      }
    };
  }
});

// node_modules/markdown-it/lib/index.js
var require_lib = __commonJS({
  "node_modules/markdown-it/lib/index.js"(exports2, module2) {
    "use strict";
    var utils = require_utils3();
    var helpers = require_helpers();
    var Renderer = require_renderer();
    var ParserCore = require_parser_core();
    var ParserBlock = require_parser_block();
    var ParserInline = require_parser_inline();
    var LinkifyIt = require_linkify_it2();
    var mdurl = require_mdurl();
    var punycode = require("punycode");
    var config = {
      default: require_default(),
      zero: require_zero(),
      commonmark: require_commonmark()
    };
    var BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
    var GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/;
    function validateLink(url) {
      var str = url.trim().toLowerCase();
      return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) ? true : false : true;
    }
    var RECODE_HOSTNAME_FOR = ["http:", "https:", "mailto:"];
    function normalizeLink(url) {
      var parsed = mdurl.parse(url, true);
      if (parsed.hostname) {
        if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
          try {
            parsed.hostname = punycode.toASCII(parsed.hostname);
          } catch (er) {
          }
        }
      }
      return mdurl.encode(mdurl.format(parsed));
    }
    function normalizeLinkText(url) {
      var parsed = mdurl.parse(url, true);
      if (parsed.hostname) {
        if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
          try {
            parsed.hostname = punycode.toUnicode(parsed.hostname);
          } catch (er) {
          }
        }
      }
      return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + "%");
    }
    function MarkdownIt(presetName, options) {
      if (!(this instanceof MarkdownIt)) {
        return new MarkdownIt(presetName, options);
      }
      if (!options) {
        if (!utils.isString(presetName)) {
          options = presetName || {};
          presetName = "default";
        }
      }
      this.inline = new ParserInline();
      this.block = new ParserBlock();
      this.core = new ParserCore();
      this.renderer = new Renderer();
      this.linkify = new LinkifyIt();
      this.validateLink = validateLink;
      this.normalizeLink = normalizeLink;
      this.normalizeLinkText = normalizeLinkText;
      this.utils = utils;
      this.helpers = utils.assign({}, helpers);
      this.options = {};
      this.configure(presetName);
      if (options) {
        this.set(options);
      }
    }
    MarkdownIt.prototype.set = function(options) {
      utils.assign(this.options, options);
      return this;
    };
    MarkdownIt.prototype.configure = function(presets) {
      var self2 = this, presetName;
      if (utils.isString(presets)) {
        presetName = presets;
        presets = config[presetName];
        if (!presets) {
          throw new Error('Wrong `markdown-it` preset "' + presetName + '", check name');
        }
      }
      if (!presets) {
        throw new Error("Wrong `markdown-it` preset, can't be empty");
      }
      if (presets.options) {
        self2.set(presets.options);
      }
      if (presets.components) {
        Object.keys(presets.components).forEach(function(name) {
          if (presets.components[name].rules) {
            self2[name].ruler.enableOnly(presets.components[name].rules);
          }
          if (presets.components[name].rules2) {
            self2[name].ruler2.enableOnly(presets.components[name].rules2);
          }
        });
      }
      return this;
    };
    MarkdownIt.prototype.enable = function(list, ignoreInvalid) {
      var result = [];
      if (!Array.isArray(list)) {
        list = [list];
      }
      ["core", "block", "inline"].forEach(function(chain) {
        result = result.concat(this[chain].ruler.enable(list, true));
      }, this);
      result = result.concat(this.inline.ruler2.enable(list, true));
      var missed = list.filter(function(name) {
        return result.indexOf(name) < 0;
      });
      if (missed.length && !ignoreInvalid) {
        throw new Error("MarkdownIt. Failed to enable unknown rule(s): " + missed);
      }
      return this;
    };
    MarkdownIt.prototype.disable = function(list, ignoreInvalid) {
      var result = [];
      if (!Array.isArray(list)) {
        list = [list];
      }
      ["core", "block", "inline"].forEach(function(chain) {
        result = result.concat(this[chain].ruler.disable(list, true));
      }, this);
      result = result.concat(this.inline.ruler2.disable(list, true));
      var missed = list.filter(function(name) {
        return result.indexOf(name) < 0;
      });
      if (missed.length && !ignoreInvalid) {
        throw new Error("MarkdownIt. Failed to disable unknown rule(s): " + missed);
      }
      return this;
    };
    MarkdownIt.prototype.use = function(plugin) {
      var args2 = [this].concat(Array.prototype.slice.call(arguments, 1));
      plugin.apply(plugin, args2);
      return this;
    };
    MarkdownIt.prototype.parse = function(src, env) {
      if (typeof src !== "string") {
        throw new Error("Input data should be a String");
      }
      var state = new this.core.State(src, this, env);
      this.core.process(state);
      return state.tokens;
    };
    MarkdownIt.prototype.render = function(src, env) {
      env = env || {};
      return this.renderer.render(this.parse(src, env), this.options, env);
    };
    MarkdownIt.prototype.parseInline = function(src, env) {
      var state = new this.core.State(src, this, env);
      state.inlineMode = true;
      this.core.process(state);
      return state.tokens;
    };
    MarkdownIt.prototype.renderInline = function(src, env) {
      env = env || {};
      return this.renderer.render(this.parseInline(src, env), this.options, env);
    };
    module2.exports = MarkdownIt;
  }
});

// node_modules/markdown-it/index.js
var require_markdown_it = __commonJS({
  "node_modules/markdown-it/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_lib();
  }
});

// node_modules/markdown-it-table/dist/cjs/table.js
var require_table2 = __commonJS({
  "node_modules/markdown-it-table/dist/cjs/table.js"(exports2, module2) {
    "use strict";
    function isSpace(code) {
      switch (code) {
        case 9:
        case 32:
          return true;
      }
      return false;
    }
    function getLine(state, line) {
      var pos = state.bMarks[line] + state.blkIndent, max = state.eMarks[line];
      return state.src.substr(pos, max - pos);
    }
    function escapedSplit(str) {
      var result = [], pos = 0, max = str.length, ch, escapes = 0, lastPos = 0, backTicked = false, lastBackTick = 0;
      ch = str.charCodeAt(pos);
      while (pos < max) {
        if (ch === 96) {
          if (backTicked) {
            backTicked = false;
            lastBackTick = pos;
          } else if (escapes % 2 === 0) {
            backTicked = true;
            lastBackTick = pos;
          }
        } else if (ch === 124 && escapes % 2 === 0 && !backTicked) {
          result.push(str.substring(lastPos, pos));
          lastPos = pos + 1;
        }
        if (ch === 92) {
          escapes++;
        } else {
          escapes = 0;
        }
        pos++;
        if (pos === max && backTicked) {
          backTicked = false;
          pos = lastBackTick + 1;
        }
        ch = str.charCodeAt(pos);
      }
      result.push(str.substring(lastPos));
      return result;
    }
    module2.exports = function table(state, startLine, endLine, silent) {
      var ch, lineText, pos, i, nextLine, columns, columnCount, token, aligns, t, tableLines, tbodyLines;
      if (startLine + 2 > endLine) {
        return false;
      }
      nextLine = startLine + 1;
      if (state.sCount[nextLine] < state.blkIndent) {
        return false;
      }
      if (state.sCount[nextLine] - state.blkIndent >= 4) {
        return false;
      }
      pos = state.bMarks[nextLine] + state.tShift[nextLine];
      if (pos >= state.eMarks[nextLine]) {
        return false;
      }
      ch = state.src.charCodeAt(pos++);
      if (ch !== 124 && ch !== 45 && ch !== 58) {
        return false;
      }
      while (pos < state.eMarks[nextLine]) {
        ch = state.src.charCodeAt(pos);
        if (ch !== 124 && ch !== 45 && ch !== 58 && !isSpace(ch)) {
          return false;
        }
        pos++;
      }
      lineText = getLine(state, startLine + 1);
      columns = lineText.split("|");
      aligns = [];
      for (i = 0; i < columns.length; i++) {
        t = columns[i].trim();
        if (!t) {
          if (i === 0 || i === columns.length - 1) {
            continue;
          } else {
            return false;
          }
        }
        if (!/^:?-+:?$/.test(t)) {
          return false;
        }
        if (t.charCodeAt(t.length - 1) === 58) {
          aligns.push(t.charCodeAt(0) === 58 ? "center" : "right");
        } else if (t.charCodeAt(0) === 58) {
          aligns.push("left");
        } else {
          aligns.push("");
        }
      }
      lineText = getLine(state, startLine).trim();
      if (lineText.indexOf("|") === -1) {
        return false;
      }
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      columns = escapedSplit(lineText.replace(/^\||\|$/g, ""));
      columnCount = columns.length;
      if (columnCount > aligns.length) {
        return false;
      }
      if (silent) {
        return true;
      }
      token = state.push("table_open", "table", 1);
      token.map = tableLines = [startLine, 0];
      token = state.push("tr_open", "tr", 1);
      token.map = [startLine, startLine + 1];
      for (i = 0; i < columns.length; i++) {
        token = state.push("th_open", "th", 1);
        token.map = [startLine, startLine + 1];
        if (aligns[i]) {
          token.attrs = [["style", "text-align:" + aligns[i]]];
        }
        token = state.push("paragraph_open", "p", 1);
        token = state.push("inline", "", 0);
        token.content = columns[i].trim();
        token.map = [startLine, startLine + 1];
        token.children = [];
        token = state.push("paragraph_close", "p", -1);
        token = state.push("th_close", "th", -1);
      }
      token = state.push("tr_close", "tr", -1);
      token.map = tbodyLines = [startLine + 2, 0];
      var oldLineMax = state.lineMax;
      for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
        if (state.sCount[nextLine] < state.blkIndent) {
          break;
        }
        lineText = getLine(state, nextLine).trim();
        if (lineText.indexOf("|") === -1) {
          break;
        }
        if (state.sCount[nextLine] - state.blkIndent >= 4) {
          break;
        }
        columns = escapedSplit(lineText.replace(/^\||\|$/g, ""));
        token = state.push("tr_open", "tr", 1);
        for (var _i = 0, offset = 1; _i < columns.length; _i++) {
          token = state.push("td_open", "td", 1);
          if (aligns[_i]) {
            token.attrs = [["style", "text-align:" + aligns[_i]]];
          }
          var shift = columns[_i][0] === " " || /^(\d+\.|\*|-)$/.test(columns[_i].trim()) ? 1 : 0;
          state.bMarks[nextLine] += offset + shift;
          offset = (columns[_i] || "").length + (shift ? 0 : 1);
          state.eMarks[nextLine] = state.bMarks[nextLine] + offset - 1;
          state.lineMax = 1;
          state.md.block.tokenize(state, nextLine, nextLine + 1);
          token = state.push("td_close", "td", -1);
        }
        token = state.push("tr_close", "tr", -1);
      }
      state.lineMax = oldLineMax;
      token = state.push("table_close", "table", -1);
      tableLines[1] = tbodyLines[1] = nextLine;
      state.line = nextLine;
      return true;
    };
  }
});

// node_modules/markdown-it-table/dist/cjs/index.js
var require_cjs3 = __commonJS({
  "node_modules/markdown-it-table/dist/cjs/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.markdownItTable = void 0;
    var _table = require_table2();
    var _table2 = _interopRequireDefault(_table);
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    var markdownItTable = exports2.markdownItTable = function markdownItTable2(md, options) {
      md.block.ruler.before("paragraph", "table", _table2.default, {
        alt: ["paragraph", "reference"]
      });
    };
  }
});

// node_modules/prosemirror-markdown/node_modules/mdurl/build/index.cjs.js
var require_index_cjs = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/mdurl/build/index.cjs.js"(exports2) {
    "use strict";
    var decodeCache = {};
    function getDecodeCache(exclude) {
      let cache = decodeCache[exclude];
      if (cache) {
        return cache;
      }
      cache = decodeCache[exclude] = [];
      for (let i = 0; i < 128; i++) {
        const ch = String.fromCharCode(i);
        cache.push(ch);
      }
      for (let i = 0; i < exclude.length; i++) {
        const ch = exclude.charCodeAt(i);
        cache[ch] = "%" + ("0" + ch.toString(16).toUpperCase()).slice(-2);
      }
      return cache;
    }
    function decode(string, exclude) {
      if (typeof exclude !== "string") {
        exclude = decode.defaultChars;
      }
      const cache = getDecodeCache(exclude);
      return string.replace(/(%[a-f0-9]{2})+/gi, function(seq) {
        let result = "";
        for (let i = 0, l = seq.length; i < l; i += 3) {
          const b1 = parseInt(seq.slice(i + 1, i + 3), 16);
          if (b1 < 128) {
            result += cache[b1];
            continue;
          }
          if ((b1 & 224) === 192 && i + 3 < l) {
            const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
            if ((b2 & 192) === 128) {
              const chr = b1 << 6 & 1984 | b2 & 63;
              if (chr < 128) {
                result += "\uFFFD\uFFFD";
              } else {
                result += String.fromCharCode(chr);
              }
              i += 3;
              continue;
            }
          }
          if ((b1 & 240) === 224 && i + 6 < l) {
            const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
            const b3 = parseInt(seq.slice(i + 7, i + 9), 16);
            if ((b2 & 192) === 128 && (b3 & 192) === 128) {
              const chr = b1 << 12 & 61440 | b2 << 6 & 4032 | b3 & 63;
              if (chr < 2048 || chr >= 55296 && chr <= 57343) {
                result += "\uFFFD\uFFFD\uFFFD";
              } else {
                result += String.fromCharCode(chr);
              }
              i += 6;
              continue;
            }
          }
          if ((b1 & 248) === 240 && i + 9 < l) {
            const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
            const b3 = parseInt(seq.slice(i + 7, i + 9), 16);
            const b4 = parseInt(seq.slice(i + 10, i + 12), 16);
            if ((b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128) {
              let chr = b1 << 18 & 1835008 | b2 << 12 & 258048 | b3 << 6 & 4032 | b4 & 63;
              if (chr < 65536 || chr > 1114111) {
                result += "\uFFFD\uFFFD\uFFFD\uFFFD";
              } else {
                chr -= 65536;
                result += String.fromCharCode(55296 + (chr >> 10), 56320 + (chr & 1023));
              }
              i += 9;
              continue;
            }
          }
          result += "\uFFFD";
        }
        return result;
      });
    }
    decode.defaultChars = ";/?:@&=+$,#";
    decode.componentChars = "";
    var encodeCache = {};
    function getEncodeCache(exclude) {
      let cache = encodeCache[exclude];
      if (cache) {
        return cache;
      }
      cache = encodeCache[exclude] = [];
      for (let i = 0; i < 128; i++) {
        const ch = String.fromCharCode(i);
        if (/^[0-9a-z]$/i.test(ch)) {
          cache.push(ch);
        } else {
          cache.push("%" + ("0" + i.toString(16).toUpperCase()).slice(-2));
        }
      }
      for (let i = 0; i < exclude.length; i++) {
        cache[exclude.charCodeAt(i)] = exclude[i];
      }
      return cache;
    }
    function encode(string, exclude, keepEscaped) {
      if (typeof exclude !== "string") {
        keepEscaped = exclude;
        exclude = encode.defaultChars;
      }
      if (typeof keepEscaped === "undefined") {
        keepEscaped = true;
      }
      const cache = getEncodeCache(exclude);
      let result = "";
      for (let i = 0, l = string.length; i < l; i++) {
        const code = string.charCodeAt(i);
        if (keepEscaped && code === 37 && i + 2 < l) {
          if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
            result += string.slice(i, i + 3);
            i += 2;
            continue;
          }
        }
        if (code < 128) {
          result += cache[code];
          continue;
        }
        if (code >= 55296 && code <= 57343) {
          if (code >= 55296 && code <= 56319 && i + 1 < l) {
            const nextCode = string.charCodeAt(i + 1);
            if (nextCode >= 56320 && nextCode <= 57343) {
              result += encodeURIComponent(string[i] + string[i + 1]);
              i++;
              continue;
            }
          }
          result += "%EF%BF%BD";
          continue;
        }
        result += encodeURIComponent(string[i]);
      }
      return result;
    }
    encode.defaultChars = ";/?:@&=+$,-_.!~*'()#";
    encode.componentChars = "-_.!~*'()";
    function format(url) {
      let result = "";
      result += url.protocol || "";
      result += url.slashes ? "//" : "";
      result += url.auth ? url.auth + "@" : "";
      if (url.hostname && url.hostname.indexOf(":") !== -1) {
        result += "[" + url.hostname + "]";
      } else {
        result += url.hostname || "";
      }
      result += url.port ? ":" + url.port : "";
      result += url.pathname || "";
      result += url.search || "";
      result += url.hash || "";
      return result;
    }
    function Url() {
      this.protocol = null;
      this.slashes = null;
      this.auth = null;
      this.port = null;
      this.hostname = null;
      this.hash = null;
      this.search = null;
      this.pathname = null;
    }
    var protocolPattern = /^([a-z0-9.+-]+:)/i;
    var portPattern = /:[0-9]*$/;
    var simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
    var delims = ["<", ">", '"', "`", " ", "\r", "\n", "	"];
    var unwise = ["{", "}", "|", "\\", "^", "`"].concat(delims);
    var autoEscape = ["'"].concat(unwise);
    var nonHostChars = ["%", "/", "?", ";", "#"].concat(autoEscape);
    var hostEndingChars = ["/", "?", "#"];
    var hostnameMaxLen = 255;
    var hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
    var hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
    var hostlessProtocol = {
      javascript: true,
      "javascript:": true
    };
    var slashedProtocol = {
      http: true,
      https: true,
      ftp: true,
      gopher: true,
      file: true,
      "http:": true,
      "https:": true,
      "ftp:": true,
      "gopher:": true,
      "file:": true
    };
    function urlParse(url, slashesDenoteHost) {
      if (url && url instanceof Url) return url;
      const u = new Url();
      u.parse(url, slashesDenoteHost);
      return u;
    }
    Url.prototype.parse = function(url, slashesDenoteHost) {
      let lowerProto, hec, slashes;
      let rest = url;
      rest = rest.trim();
      if (!slashesDenoteHost && url.split("#").length === 1) {
        const simplePath = simplePathPattern.exec(rest);
        if (simplePath) {
          this.pathname = simplePath[1];
          if (simplePath[2]) {
            this.search = simplePath[2];
          }
          return this;
        }
      }
      let proto = protocolPattern.exec(rest);
      if (proto) {
        proto = proto[0];
        lowerProto = proto.toLowerCase();
        this.protocol = proto;
        rest = rest.substr(proto.length);
      }
      if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
        slashes = rest.substr(0, 2) === "//";
        if (slashes && !(proto && hostlessProtocol[proto])) {
          rest = rest.substr(2);
          this.slashes = true;
        }
      }
      if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
        let hostEnd = -1;
        for (let i = 0; i < hostEndingChars.length; i++) {
          hec = rest.indexOf(hostEndingChars[i]);
          if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
            hostEnd = hec;
          }
        }
        let auth, atSign;
        if (hostEnd === -1) {
          atSign = rest.lastIndexOf("@");
        } else {
          atSign = rest.lastIndexOf("@", hostEnd);
        }
        if (atSign !== -1) {
          auth = rest.slice(0, atSign);
          rest = rest.slice(atSign + 1);
          this.auth = auth;
        }
        hostEnd = -1;
        for (let i = 0; i < nonHostChars.length; i++) {
          hec = rest.indexOf(nonHostChars[i]);
          if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
            hostEnd = hec;
          }
        }
        if (hostEnd === -1) {
          hostEnd = rest.length;
        }
        if (rest[hostEnd - 1] === ":") {
          hostEnd--;
        }
        const host = rest.slice(0, hostEnd);
        rest = rest.slice(hostEnd);
        this.parseHost(host);
        this.hostname = this.hostname || "";
        const ipv6Hostname = this.hostname[0] === "[" && this.hostname[this.hostname.length - 1] === "]";
        if (!ipv6Hostname) {
          const hostparts = this.hostname.split(/\./);
          for (let i = 0, l = hostparts.length; i < l; i++) {
            const part = hostparts[i];
            if (!part) {
              continue;
            }
            if (!part.match(hostnamePartPattern)) {
              let newpart = "";
              for (let j = 0, k = part.length; j < k; j++) {
                if (part.charCodeAt(j) > 127) {
                  newpart += "x";
                } else {
                  newpart += part[j];
                }
              }
              if (!newpart.match(hostnamePartPattern)) {
                const validParts = hostparts.slice(0, i);
                const notHost = hostparts.slice(i + 1);
                const bit = part.match(hostnamePartStart);
                if (bit) {
                  validParts.push(bit[1]);
                  notHost.unshift(bit[2]);
                }
                if (notHost.length) {
                  rest = notHost.join(".") + rest;
                }
                this.hostname = validParts.join(".");
                break;
              }
            }
          }
        }
        if (this.hostname.length > hostnameMaxLen) {
          this.hostname = "";
        }
        if (ipv6Hostname) {
          this.hostname = this.hostname.substr(1, this.hostname.length - 2);
        }
      }
      const hash = rest.indexOf("#");
      if (hash !== -1) {
        this.hash = rest.substr(hash);
        rest = rest.slice(0, hash);
      }
      const qm = rest.indexOf("?");
      if (qm !== -1) {
        this.search = rest.substr(qm);
        rest = rest.slice(0, qm);
      }
      if (rest) {
        this.pathname = rest;
      }
      if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
        this.pathname = "";
      }
      return this;
    };
    Url.prototype.parseHost = function(host) {
      let port = portPattern.exec(host);
      if (port) {
        port = port[0];
        if (port !== ":") {
          this.port = port.substr(1);
        }
        host = host.substr(0, host.length - port.length);
      }
      if (host) {
        this.hostname = host;
      }
    };
    exports2.decode = decode;
    exports2.encode = encode;
    exports2.format = format;
    exports2.parse = urlParse;
  }
});

// node_modules/prosemirror-markdown/node_modules/uc.micro/build/index.cjs.js
var require_index_cjs2 = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/uc.micro/build/index.cjs.js"(exports2) {
    "use strict";
    var regex$5 = /[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
    var regex$4 = /[\0-\x1F\x7F-\x9F]/;
    var regex$3 = /[\xAD\u0600-\u0605\u061C\u06DD\u070F\u0890\u0891\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB]|\uD804[\uDCBD\uDCCD]|\uD80D[\uDC30-\uDC3F]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]/;
    var regex$2 = /[!-#%-\*,-\/:;\?@\[-\]_\{\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061D-\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1B7D\u1B7E\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52-\u2E5D\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDEAD\uDF55-\uDF59\uDF86-\uDF89]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5A\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDEB9\uDF3C-\uDF3E]|\uD806[\uDC3B\uDD44-\uDD46\uDDE2\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2\uDF00-\uDF09]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8\uDF43-\uDF4F\uDFFF]|\uD809[\uDC70-\uDC74]|\uD80B[\uDFF1\uDFF2]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A\uDFE2]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]/;
    var regex$1 = /[\$\+<->\^`\|~\xA2-\xA6\xA8\xA9\xAC\xAE-\xB1\xB4\xB8\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0384\u0385\u03F6\u0482\u058D-\u058F\u0606-\u0608\u060B\u060E\u060F\u06DE\u06E9\u06FD\u06FE\u07F6\u07FE\u07FF\u0888\u09F2\u09F3\u09FA\u09FB\u0AF1\u0B70\u0BF3-\u0BFA\u0C7F\u0D4F\u0D79\u0E3F\u0F01-\u0F03\u0F13\u0F15-\u0F17\u0F1A-\u0F1F\u0F34\u0F36\u0F38\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE\u0FCF\u0FD5-\u0FD8\u109E\u109F\u1390-\u1399\u166D\u17DB\u1940\u19DE-\u19FF\u1B61-\u1B6A\u1B74-\u1B7C\u1FBD\u1FBF-\u1FC1\u1FCD-\u1FCF\u1FDD-\u1FDF\u1FED-\u1FEF\u1FFD\u1FFE\u2044\u2052\u207A-\u207C\u208A-\u208C\u20A0-\u20C0\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F\u218A\u218B\u2190-\u2307\u230C-\u2328\u232B-\u2426\u2440-\u244A\u249C-\u24E9\u2500-\u2767\u2794-\u27C4\u27C7-\u27E5\u27F0-\u2982\u2999-\u29D7\u29DC-\u29FB\u29FE-\u2B73\u2B76-\u2B95\u2B97-\u2BFF\u2CE5-\u2CEA\u2E50\u2E51\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFF\u3004\u3012\u3013\u3020\u3036\u3037\u303E\u303F\u309B\u309C\u3190\u3191\u3196-\u319F\u31C0-\u31E3\u31EF\u3200-\u321E\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA700-\uA716\uA720\uA721\uA789\uA78A\uA828-\uA82B\uA836-\uA839\uAA77-\uAA79\uAB5B\uAB6A\uAB6B\uFB29\uFBB2-\uFBC2\uFD40-\uFD4F\uFDCF\uFDFC-\uFDFF\uFE62\uFE64-\uFE66\uFE69\uFF04\uFF0B\uFF1C-\uFF1E\uFF3E\uFF40\uFF5C\uFF5E\uFFE0-\uFFE6\uFFE8-\uFFEE\uFFFC\uFFFD]|\uD800[\uDD37-\uDD3F\uDD79-\uDD89\uDD8C-\uDD8E\uDD90-\uDD9C\uDDA0\uDDD0-\uDDFC]|\uD802[\uDC77\uDC78\uDEC8]|\uD805\uDF3F|\uD807[\uDFD5-\uDFF1]|\uD81A[\uDF3C-\uDF3F\uDF45]|\uD82F\uDC9C|\uD833[\uDF50-\uDFC3]|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD64\uDD6A-\uDD6C\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDEA\uDE00-\uDE41\uDE45\uDF00-\uDF56]|\uD835[\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85\uDE86]|\uD838[\uDD4F\uDEFF]|\uD83B[\uDCAC\uDCB0\uDD2E\uDEF0\uDEF1]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD0D-\uDDAD\uDDE6-\uDE02\uDE10-\uDE3B\uDE40-\uDE48\uDE50\uDE51\uDE60-\uDE65\uDF00-\uDFFF]|\uD83D[\uDC00-\uDED7\uDEDC-\uDEEC\uDEF0-\uDEFC\uDF00-\uDF76\uDF7B-\uDFD9\uDFE0-\uDFEB\uDFF0]|\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDCB0\uDCB1\uDD00-\uDE53\uDE60-\uDE6D\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC5\uDECE-\uDEDB\uDEE0-\uDEE8\uDEF0-\uDEF8\uDF00-\uDF92\uDF94-\uDFCA]/;
    var regex = /[ \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/;
    exports2.Any = regex$5;
    exports2.Cc = regex$4;
    exports2.Cf = regex$3;
    exports2.P = regex$2;
    exports2.S = regex$1;
    exports2.Z = regex;
  }
});

// node_modules/prosemirror-markdown/node_modules/entities/lib/generated/decode-data-html.js
var require_decode_data_html = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/entities/lib/generated/decode-data-html.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = new Uint16Array(
      // prettier-ignore
      '\u1D41<\xD5\u0131\u028A\u049D\u057B\u05D0\u0675\u06DE\u07A2\u07D6\u080F\u0A4A\u0A91\u0DA1\u0E6D\u0F09\u0F26\u10CA\u1228\u12E1\u1415\u149D\u14C3\u14DF\u1525\0\0\0\0\0\0\u156B\u16CD\u198D\u1C12\u1DDD\u1F7E\u2060\u21B0\u228D\u23C0\u23FB\u2442\u2824\u2912\u2D08\u2E48\u2FCE\u3016\u32BA\u3639\u37AC\u38FE\u3A28\u3A71\u3AE0\u3B2E\u0800EMabcfglmnoprstu\\bfms\x7F\x84\x8B\x90\x95\x98\xA6\xB3\xB9\xC8\xCFlig\u803B\xC6\u40C6P\u803B&\u4026cute\u803B\xC1\u40C1reve;\u4102\u0100iyx}rc\u803B\xC2\u40C2;\u4410r;\uC000\u{1D504}rave\u803B\xC0\u40C0pha;\u4391acr;\u4100d;\u6A53\u0100gp\x9D\xA1on;\u4104f;\uC000\u{1D538}plyFunction;\u6061ing\u803B\xC5\u40C5\u0100cs\xBE\xC3r;\uC000\u{1D49C}ign;\u6254ilde\u803B\xC3\u40C3ml\u803B\xC4\u40C4\u0400aceforsu\xE5\xFB\xFE\u0117\u011C\u0122\u0127\u012A\u0100cr\xEA\xF2kslash;\u6216\u0176\xF6\xF8;\u6AE7ed;\u6306y;\u4411\u0180crt\u0105\u010B\u0114ause;\u6235noullis;\u612Ca;\u4392r;\uC000\u{1D505}pf;\uC000\u{1D539}eve;\u42D8c\xF2\u0113mpeq;\u624E\u0700HOacdefhilorsu\u014D\u0151\u0156\u0180\u019E\u01A2\u01B5\u01B7\u01BA\u01DC\u0215\u0273\u0278\u027Ecy;\u4427PY\u803B\xA9\u40A9\u0180cpy\u015D\u0162\u017Aute;\u4106\u0100;i\u0167\u0168\u62D2talDifferentialD;\u6145leys;\u612D\u0200aeio\u0189\u018E\u0194\u0198ron;\u410Cdil\u803B\xC7\u40C7rc;\u4108nint;\u6230ot;\u410A\u0100dn\u01A7\u01ADilla;\u40B8terDot;\u40B7\xF2\u017Fi;\u43A7rcle\u0200DMPT\u01C7\u01CB\u01D1\u01D6ot;\u6299inus;\u6296lus;\u6295imes;\u6297o\u0100cs\u01E2\u01F8kwiseContourIntegral;\u6232eCurly\u0100DQ\u0203\u020FoubleQuote;\u601Duote;\u6019\u0200lnpu\u021E\u0228\u0247\u0255on\u0100;e\u0225\u0226\u6237;\u6A74\u0180git\u022F\u0236\u023Aruent;\u6261nt;\u622FourIntegral;\u622E\u0100fr\u024C\u024E;\u6102oduct;\u6210nterClockwiseContourIntegral;\u6233oss;\u6A2Fcr;\uC000\u{1D49E}p\u0100;C\u0284\u0285\u62D3ap;\u624D\u0580DJSZacefios\u02A0\u02AC\u02B0\u02B4\u02B8\u02CB\u02D7\u02E1\u02E6\u0333\u048D\u0100;o\u0179\u02A5trahd;\u6911cy;\u4402cy;\u4405cy;\u440F\u0180grs\u02BF\u02C4\u02C7ger;\u6021r;\u61A1hv;\u6AE4\u0100ay\u02D0\u02D5ron;\u410E;\u4414l\u0100;t\u02DD\u02DE\u6207a;\u4394r;\uC000\u{1D507}\u0100af\u02EB\u0327\u0100cm\u02F0\u0322ritical\u0200ADGT\u0300\u0306\u0316\u031Ccute;\u40B4o\u0174\u030B\u030D;\u42D9bleAcute;\u42DDrave;\u4060ilde;\u42DCond;\u62C4ferentialD;\u6146\u0470\u033D\0\0\0\u0342\u0354\0\u0405f;\uC000\u{1D53B}\u0180;DE\u0348\u0349\u034D\u40A8ot;\u60DCqual;\u6250ble\u0300CDLRUV\u0363\u0372\u0382\u03CF\u03E2\u03F8ontourIntegra\xEC\u0239o\u0274\u0379\0\0\u037B\xBB\u0349nArrow;\u61D3\u0100eo\u0387\u03A4ft\u0180ART\u0390\u0396\u03A1rrow;\u61D0ightArrow;\u61D4e\xE5\u02CAng\u0100LR\u03AB\u03C4eft\u0100AR\u03B3\u03B9rrow;\u67F8ightArrow;\u67FAightArrow;\u67F9ight\u0100AT\u03D8\u03DErrow;\u61D2ee;\u62A8p\u0241\u03E9\0\0\u03EFrrow;\u61D1ownArrow;\u61D5erticalBar;\u6225n\u0300ABLRTa\u0412\u042A\u0430\u045E\u047F\u037Crrow\u0180;BU\u041D\u041E\u0422\u6193ar;\u6913pArrow;\u61F5reve;\u4311eft\u02D2\u043A\0\u0446\0\u0450ightVector;\u6950eeVector;\u695Eector\u0100;B\u0459\u045A\u61BDar;\u6956ight\u01D4\u0467\0\u0471eeVector;\u695Fector\u0100;B\u047A\u047B\u61C1ar;\u6957ee\u0100;A\u0486\u0487\u62A4rrow;\u61A7\u0100ct\u0492\u0497r;\uC000\u{1D49F}rok;\u4110\u0800NTacdfglmopqstux\u04BD\u04C0\u04C4\u04CB\u04DE\u04E2\u04E7\u04EE\u04F5\u0521\u052F\u0536\u0552\u055D\u0560\u0565G;\u414AH\u803B\xD0\u40D0cute\u803B\xC9\u40C9\u0180aiy\u04D2\u04D7\u04DCron;\u411Arc\u803B\xCA\u40CA;\u442Dot;\u4116r;\uC000\u{1D508}rave\u803B\xC8\u40C8ement;\u6208\u0100ap\u04FA\u04FEcr;\u4112ty\u0253\u0506\0\0\u0512mallSquare;\u65FBerySmallSquare;\u65AB\u0100gp\u0526\u052Aon;\u4118f;\uC000\u{1D53C}silon;\u4395u\u0100ai\u053C\u0549l\u0100;T\u0542\u0543\u6A75ilde;\u6242librium;\u61CC\u0100ci\u0557\u055Ar;\u6130m;\u6A73a;\u4397ml\u803B\xCB\u40CB\u0100ip\u056A\u056Fsts;\u6203onentialE;\u6147\u0280cfios\u0585\u0588\u058D\u05B2\u05CCy;\u4424r;\uC000\u{1D509}lled\u0253\u0597\0\0\u05A3mallSquare;\u65FCerySmallSquare;\u65AA\u0370\u05BA\0\u05BF\0\0\u05C4f;\uC000\u{1D53D}All;\u6200riertrf;\u6131c\xF2\u05CB\u0600JTabcdfgorst\u05E8\u05EC\u05EF\u05FA\u0600\u0612\u0616\u061B\u061D\u0623\u066C\u0672cy;\u4403\u803B>\u403Emma\u0100;d\u05F7\u05F8\u4393;\u43DCreve;\u411E\u0180eiy\u0607\u060C\u0610dil;\u4122rc;\u411C;\u4413ot;\u4120r;\uC000\u{1D50A};\u62D9pf;\uC000\u{1D53E}eater\u0300EFGLST\u0635\u0644\u064E\u0656\u065B\u0666qual\u0100;L\u063E\u063F\u6265ess;\u62DBullEqual;\u6267reater;\u6AA2ess;\u6277lantEqual;\u6A7Eilde;\u6273cr;\uC000\u{1D4A2};\u626B\u0400Aacfiosu\u0685\u068B\u0696\u069B\u069E\u06AA\u06BE\u06CARDcy;\u442A\u0100ct\u0690\u0694ek;\u42C7;\u405Eirc;\u4124r;\u610ClbertSpace;\u610B\u01F0\u06AF\0\u06B2f;\u610DizontalLine;\u6500\u0100ct\u06C3\u06C5\xF2\u06A9rok;\u4126mp\u0144\u06D0\u06D8ownHum\xF0\u012Fqual;\u624F\u0700EJOacdfgmnostu\u06FA\u06FE\u0703\u0707\u070E\u071A\u071E\u0721\u0728\u0744\u0778\u078B\u078F\u0795cy;\u4415lig;\u4132cy;\u4401cute\u803B\xCD\u40CD\u0100iy\u0713\u0718rc\u803B\xCE\u40CE;\u4418ot;\u4130r;\u6111rave\u803B\xCC\u40CC\u0180;ap\u0720\u072F\u073F\u0100cg\u0734\u0737r;\u412AinaryI;\u6148lie\xF3\u03DD\u01F4\u0749\0\u0762\u0100;e\u074D\u074E\u622C\u0100gr\u0753\u0758ral;\u622Bsection;\u62C2isible\u0100CT\u076C\u0772omma;\u6063imes;\u6062\u0180gpt\u077F\u0783\u0788on;\u412Ef;\uC000\u{1D540}a;\u4399cr;\u6110ilde;\u4128\u01EB\u079A\0\u079Ecy;\u4406l\u803B\xCF\u40CF\u0280cfosu\u07AC\u07B7\u07BC\u07C2\u07D0\u0100iy\u07B1\u07B5rc;\u4134;\u4419r;\uC000\u{1D50D}pf;\uC000\u{1D541}\u01E3\u07C7\0\u07CCr;\uC000\u{1D4A5}rcy;\u4408kcy;\u4404\u0380HJacfos\u07E4\u07E8\u07EC\u07F1\u07FD\u0802\u0808cy;\u4425cy;\u440Cppa;\u439A\u0100ey\u07F6\u07FBdil;\u4136;\u441Ar;\uC000\u{1D50E}pf;\uC000\u{1D542}cr;\uC000\u{1D4A6}\u0580JTaceflmost\u0825\u0829\u082C\u0850\u0863\u09B3\u09B8\u09C7\u09CD\u0A37\u0A47cy;\u4409\u803B<\u403C\u0280cmnpr\u0837\u083C\u0841\u0844\u084Dute;\u4139bda;\u439Bg;\u67EAlacetrf;\u6112r;\u619E\u0180aey\u0857\u085C\u0861ron;\u413Ddil;\u413B;\u441B\u0100fs\u0868\u0970t\u0500ACDFRTUVar\u087E\u08A9\u08B1\u08E0\u08E6\u08FC\u092F\u095B\u0390\u096A\u0100nr\u0883\u088FgleBracket;\u67E8row\u0180;BR\u0899\u089A\u089E\u6190ar;\u61E4ightArrow;\u61C6eiling;\u6308o\u01F5\u08B7\0\u08C3bleBracket;\u67E6n\u01D4\u08C8\0\u08D2eeVector;\u6961ector\u0100;B\u08DB\u08DC\u61C3ar;\u6959loor;\u630Aight\u0100AV\u08EF\u08F5rrow;\u6194ector;\u694E\u0100er\u0901\u0917e\u0180;AV\u0909\u090A\u0910\u62A3rrow;\u61A4ector;\u695Aiangle\u0180;BE\u0924\u0925\u0929\u62B2ar;\u69CFqual;\u62B4p\u0180DTV\u0937\u0942\u094CownVector;\u6951eeVector;\u6960ector\u0100;B\u0956\u0957\u61BFar;\u6958ector\u0100;B\u0965\u0966\u61BCar;\u6952ight\xE1\u039Cs\u0300EFGLST\u097E\u098B\u0995\u099D\u09A2\u09ADqualGreater;\u62DAullEqual;\u6266reater;\u6276ess;\u6AA1lantEqual;\u6A7Dilde;\u6272r;\uC000\u{1D50F}\u0100;e\u09BD\u09BE\u62D8ftarrow;\u61DAidot;\u413F\u0180npw\u09D4\u0A16\u0A1Bg\u0200LRlr\u09DE\u09F7\u0A02\u0A10eft\u0100AR\u09E6\u09ECrrow;\u67F5ightArrow;\u67F7ightArrow;\u67F6eft\u0100ar\u03B3\u0A0Aight\xE1\u03BFight\xE1\u03CAf;\uC000\u{1D543}er\u0100LR\u0A22\u0A2CeftArrow;\u6199ightArrow;\u6198\u0180cht\u0A3E\u0A40\u0A42\xF2\u084C;\u61B0rok;\u4141;\u626A\u0400acefiosu\u0A5A\u0A5D\u0A60\u0A77\u0A7C\u0A85\u0A8B\u0A8Ep;\u6905y;\u441C\u0100dl\u0A65\u0A6FiumSpace;\u605Flintrf;\u6133r;\uC000\u{1D510}nusPlus;\u6213pf;\uC000\u{1D544}c\xF2\u0A76;\u439C\u0480Jacefostu\u0AA3\u0AA7\u0AAD\u0AC0\u0B14\u0B19\u0D91\u0D97\u0D9Ecy;\u440Acute;\u4143\u0180aey\u0AB4\u0AB9\u0ABEron;\u4147dil;\u4145;\u441D\u0180gsw\u0AC7\u0AF0\u0B0Eative\u0180MTV\u0AD3\u0ADF\u0AE8ediumSpace;\u600Bhi\u0100cn\u0AE6\u0AD8\xEB\u0AD9eryThi\xEE\u0AD9ted\u0100GL\u0AF8\u0B06reaterGreate\xF2\u0673essLes\xF3\u0A48Line;\u400Ar;\uC000\u{1D511}\u0200Bnpt\u0B22\u0B28\u0B37\u0B3Areak;\u6060BreakingSpace;\u40A0f;\u6115\u0680;CDEGHLNPRSTV\u0B55\u0B56\u0B6A\u0B7C\u0BA1\u0BEB\u0C04\u0C5E\u0C84\u0CA6\u0CD8\u0D61\u0D85\u6AEC\u0100ou\u0B5B\u0B64ngruent;\u6262pCap;\u626DoubleVerticalBar;\u6226\u0180lqx\u0B83\u0B8A\u0B9Bement;\u6209ual\u0100;T\u0B92\u0B93\u6260ilde;\uC000\u2242\u0338ists;\u6204reater\u0380;EFGLST\u0BB6\u0BB7\u0BBD\u0BC9\u0BD3\u0BD8\u0BE5\u626Fqual;\u6271ullEqual;\uC000\u2267\u0338reater;\uC000\u226B\u0338ess;\u6279lantEqual;\uC000\u2A7E\u0338ilde;\u6275ump\u0144\u0BF2\u0BFDownHump;\uC000\u224E\u0338qual;\uC000\u224F\u0338e\u0100fs\u0C0A\u0C27tTriangle\u0180;BE\u0C1A\u0C1B\u0C21\u62EAar;\uC000\u29CF\u0338qual;\u62ECs\u0300;EGLST\u0C35\u0C36\u0C3C\u0C44\u0C4B\u0C58\u626Equal;\u6270reater;\u6278ess;\uC000\u226A\u0338lantEqual;\uC000\u2A7D\u0338ilde;\u6274ested\u0100GL\u0C68\u0C79reaterGreater;\uC000\u2AA2\u0338essLess;\uC000\u2AA1\u0338recedes\u0180;ES\u0C92\u0C93\u0C9B\u6280qual;\uC000\u2AAF\u0338lantEqual;\u62E0\u0100ei\u0CAB\u0CB9verseElement;\u620CghtTriangle\u0180;BE\u0CCB\u0CCC\u0CD2\u62EBar;\uC000\u29D0\u0338qual;\u62ED\u0100qu\u0CDD\u0D0CuareSu\u0100bp\u0CE8\u0CF9set\u0100;E\u0CF0\u0CF3\uC000\u228F\u0338qual;\u62E2erset\u0100;E\u0D03\u0D06\uC000\u2290\u0338qual;\u62E3\u0180bcp\u0D13\u0D24\u0D4Eset\u0100;E\u0D1B\u0D1E\uC000\u2282\u20D2qual;\u6288ceeds\u0200;EST\u0D32\u0D33\u0D3B\u0D46\u6281qual;\uC000\u2AB0\u0338lantEqual;\u62E1ilde;\uC000\u227F\u0338erset\u0100;E\u0D58\u0D5B\uC000\u2283\u20D2qual;\u6289ilde\u0200;EFT\u0D6E\u0D6F\u0D75\u0D7F\u6241qual;\u6244ullEqual;\u6247ilde;\u6249erticalBar;\u6224cr;\uC000\u{1D4A9}ilde\u803B\xD1\u40D1;\u439D\u0700Eacdfgmoprstuv\u0DBD\u0DC2\u0DC9\u0DD5\u0DDB\u0DE0\u0DE7\u0DFC\u0E02\u0E20\u0E22\u0E32\u0E3F\u0E44lig;\u4152cute\u803B\xD3\u40D3\u0100iy\u0DCE\u0DD3rc\u803B\xD4\u40D4;\u441Eblac;\u4150r;\uC000\u{1D512}rave\u803B\xD2\u40D2\u0180aei\u0DEE\u0DF2\u0DF6cr;\u414Cga;\u43A9cron;\u439Fpf;\uC000\u{1D546}enCurly\u0100DQ\u0E0E\u0E1AoubleQuote;\u601Cuote;\u6018;\u6A54\u0100cl\u0E27\u0E2Cr;\uC000\u{1D4AA}ash\u803B\xD8\u40D8i\u016C\u0E37\u0E3Cde\u803B\xD5\u40D5es;\u6A37ml\u803B\xD6\u40D6er\u0100BP\u0E4B\u0E60\u0100ar\u0E50\u0E53r;\u603Eac\u0100ek\u0E5A\u0E5C;\u63DEet;\u63B4arenthesis;\u63DC\u0480acfhilors\u0E7F\u0E87\u0E8A\u0E8F\u0E92\u0E94\u0E9D\u0EB0\u0EFCrtialD;\u6202y;\u441Fr;\uC000\u{1D513}i;\u43A6;\u43A0usMinus;\u40B1\u0100ip\u0EA2\u0EADncareplan\xE5\u069Df;\u6119\u0200;eio\u0EB9\u0EBA\u0EE0\u0EE4\u6ABBcedes\u0200;EST\u0EC8\u0EC9\u0ECF\u0EDA\u627Aqual;\u6AAFlantEqual;\u627Cilde;\u627Eme;\u6033\u0100dp\u0EE9\u0EEEuct;\u620Fortion\u0100;a\u0225\u0EF9l;\u621D\u0100ci\u0F01\u0F06r;\uC000\u{1D4AB};\u43A8\u0200Ufos\u0F11\u0F16\u0F1B\u0F1FOT\u803B"\u4022r;\uC000\u{1D514}pf;\u611Acr;\uC000\u{1D4AC}\u0600BEacefhiorsu\u0F3E\u0F43\u0F47\u0F60\u0F73\u0FA7\u0FAA\u0FAD\u1096\u10A9\u10B4\u10BEarr;\u6910G\u803B\xAE\u40AE\u0180cnr\u0F4E\u0F53\u0F56ute;\u4154g;\u67EBr\u0100;t\u0F5C\u0F5D\u61A0l;\u6916\u0180aey\u0F67\u0F6C\u0F71ron;\u4158dil;\u4156;\u4420\u0100;v\u0F78\u0F79\u611Cerse\u0100EU\u0F82\u0F99\u0100lq\u0F87\u0F8Eement;\u620Builibrium;\u61CBpEquilibrium;\u696Fr\xBB\u0F79o;\u43A1ght\u0400ACDFTUVa\u0FC1\u0FEB\u0FF3\u1022\u1028\u105B\u1087\u03D8\u0100nr\u0FC6\u0FD2gleBracket;\u67E9row\u0180;BL\u0FDC\u0FDD\u0FE1\u6192ar;\u61E5eftArrow;\u61C4eiling;\u6309o\u01F5\u0FF9\0\u1005bleBracket;\u67E7n\u01D4\u100A\0\u1014eeVector;\u695Dector\u0100;B\u101D\u101E\u61C2ar;\u6955loor;\u630B\u0100er\u102D\u1043e\u0180;AV\u1035\u1036\u103C\u62A2rrow;\u61A6ector;\u695Biangle\u0180;BE\u1050\u1051\u1055\u62B3ar;\u69D0qual;\u62B5p\u0180DTV\u1063\u106E\u1078ownVector;\u694FeeVector;\u695Cector\u0100;B\u1082\u1083\u61BEar;\u6954ector\u0100;B\u1091\u1092\u61C0ar;\u6953\u0100pu\u109B\u109Ef;\u611DndImplies;\u6970ightarrow;\u61DB\u0100ch\u10B9\u10BCr;\u611B;\u61B1leDelayed;\u69F4\u0680HOacfhimoqstu\u10E4\u10F1\u10F7\u10FD\u1119\u111E\u1151\u1156\u1161\u1167\u11B5\u11BB\u11BF\u0100Cc\u10E9\u10EEHcy;\u4429y;\u4428FTcy;\u442Ccute;\u415A\u0280;aeiy\u1108\u1109\u110E\u1113\u1117\u6ABCron;\u4160dil;\u415Erc;\u415C;\u4421r;\uC000\u{1D516}ort\u0200DLRU\u112A\u1134\u113E\u1149ownArrow\xBB\u041EeftArrow\xBB\u089AightArrow\xBB\u0FDDpArrow;\u6191gma;\u43A3allCircle;\u6218pf;\uC000\u{1D54A}\u0272\u116D\0\0\u1170t;\u621Aare\u0200;ISU\u117B\u117C\u1189\u11AF\u65A1ntersection;\u6293u\u0100bp\u118F\u119Eset\u0100;E\u1197\u1198\u628Fqual;\u6291erset\u0100;E\u11A8\u11A9\u6290qual;\u6292nion;\u6294cr;\uC000\u{1D4AE}ar;\u62C6\u0200bcmp\u11C8\u11DB\u1209\u120B\u0100;s\u11CD\u11CE\u62D0et\u0100;E\u11CD\u11D5qual;\u6286\u0100ch\u11E0\u1205eeds\u0200;EST\u11ED\u11EE\u11F4\u11FF\u627Bqual;\u6AB0lantEqual;\u627Dilde;\u627FTh\xE1\u0F8C;\u6211\u0180;es\u1212\u1213\u1223\u62D1rset\u0100;E\u121C\u121D\u6283qual;\u6287et\xBB\u1213\u0580HRSacfhiors\u123E\u1244\u1249\u1255\u125E\u1271\u1276\u129F\u12C2\u12C8\u12D1ORN\u803B\xDE\u40DEADE;\u6122\u0100Hc\u124E\u1252cy;\u440By;\u4426\u0100bu\u125A\u125C;\u4009;\u43A4\u0180aey\u1265\u126A\u126Fron;\u4164dil;\u4162;\u4422r;\uC000\u{1D517}\u0100ei\u127B\u1289\u01F2\u1280\0\u1287efore;\u6234a;\u4398\u0100cn\u128E\u1298kSpace;\uC000\u205F\u200ASpace;\u6009lde\u0200;EFT\u12AB\u12AC\u12B2\u12BC\u623Cqual;\u6243ullEqual;\u6245ilde;\u6248pf;\uC000\u{1D54B}ipleDot;\u60DB\u0100ct\u12D6\u12DBr;\uC000\u{1D4AF}rok;\u4166\u0AE1\u12F7\u130E\u131A\u1326\0\u132C\u1331\0\0\0\0\0\u1338\u133D\u1377\u1385\0\u13FF\u1404\u140A\u1410\u0100cr\u12FB\u1301ute\u803B\xDA\u40DAr\u0100;o\u1307\u1308\u619Fcir;\u6949r\u01E3\u1313\0\u1316y;\u440Eve;\u416C\u0100iy\u131E\u1323rc\u803B\xDB\u40DB;\u4423blac;\u4170r;\uC000\u{1D518}rave\u803B\xD9\u40D9acr;\u416A\u0100di\u1341\u1369er\u0100BP\u1348\u135D\u0100ar\u134D\u1350r;\u405Fac\u0100ek\u1357\u1359;\u63DFet;\u63B5arenthesis;\u63DDon\u0100;P\u1370\u1371\u62C3lus;\u628E\u0100gp\u137B\u137Fon;\u4172f;\uC000\u{1D54C}\u0400ADETadps\u1395\u13AE\u13B8\u13C4\u03E8\u13D2\u13D7\u13F3rrow\u0180;BD\u1150\u13A0\u13A4ar;\u6912ownArrow;\u61C5ownArrow;\u6195quilibrium;\u696Eee\u0100;A\u13CB\u13CC\u62A5rrow;\u61A5own\xE1\u03F3er\u0100LR\u13DE\u13E8eftArrow;\u6196ightArrow;\u6197i\u0100;l\u13F9\u13FA\u43D2on;\u43A5ing;\u416Ecr;\uC000\u{1D4B0}ilde;\u4168ml\u803B\xDC\u40DC\u0480Dbcdefosv\u1427\u142C\u1430\u1433\u143E\u1485\u148A\u1490\u1496ash;\u62ABar;\u6AEBy;\u4412ash\u0100;l\u143B\u143C\u62A9;\u6AE6\u0100er\u1443\u1445;\u62C1\u0180bty\u144C\u1450\u147Aar;\u6016\u0100;i\u144F\u1455cal\u0200BLST\u1461\u1465\u146A\u1474ar;\u6223ine;\u407Ceparator;\u6758ilde;\u6240ThinSpace;\u600Ar;\uC000\u{1D519}pf;\uC000\u{1D54D}cr;\uC000\u{1D4B1}dash;\u62AA\u0280cefos\u14A7\u14AC\u14B1\u14B6\u14BCirc;\u4174dge;\u62C0r;\uC000\u{1D51A}pf;\uC000\u{1D54E}cr;\uC000\u{1D4B2}\u0200fios\u14CB\u14D0\u14D2\u14D8r;\uC000\u{1D51B};\u439Epf;\uC000\u{1D54F}cr;\uC000\u{1D4B3}\u0480AIUacfosu\u14F1\u14F5\u14F9\u14FD\u1504\u150F\u1514\u151A\u1520cy;\u442Fcy;\u4407cy;\u442Ecute\u803B\xDD\u40DD\u0100iy\u1509\u150Drc;\u4176;\u442Br;\uC000\u{1D51C}pf;\uC000\u{1D550}cr;\uC000\u{1D4B4}ml;\u4178\u0400Hacdefos\u1535\u1539\u153F\u154B\u154F\u155D\u1560\u1564cy;\u4416cute;\u4179\u0100ay\u1544\u1549ron;\u417D;\u4417ot;\u417B\u01F2\u1554\0\u155BoWidt\xE8\u0AD9a;\u4396r;\u6128pf;\u6124cr;\uC000\u{1D4B5}\u0BE1\u1583\u158A\u1590\0\u15B0\u15B6\u15BF\0\0\0\0\u15C6\u15DB\u15EB\u165F\u166D\0\u1695\u169B\u16B2\u16B9\0\u16BEcute\u803B\xE1\u40E1reve;\u4103\u0300;Ediuy\u159C\u159D\u15A1\u15A3\u15A8\u15AD\u623E;\uC000\u223E\u0333;\u623Frc\u803B\xE2\u40E2te\u80BB\xB4\u0306;\u4430lig\u803B\xE6\u40E6\u0100;r\xB2\u15BA;\uC000\u{1D51E}rave\u803B\xE0\u40E0\u0100ep\u15CA\u15D6\u0100fp\u15CF\u15D4sym;\u6135\xE8\u15D3ha;\u43B1\u0100ap\u15DFc\u0100cl\u15E4\u15E7r;\u4101g;\u6A3F\u0264\u15F0\0\0\u160A\u0280;adsv\u15FA\u15FB\u15FF\u1601\u1607\u6227nd;\u6A55;\u6A5Clope;\u6A58;\u6A5A\u0380;elmrsz\u1618\u1619\u161B\u161E\u163F\u164F\u1659\u6220;\u69A4e\xBB\u1619sd\u0100;a\u1625\u1626\u6221\u0461\u1630\u1632\u1634\u1636\u1638\u163A\u163C\u163E;\u69A8;\u69A9;\u69AA;\u69AB;\u69AC;\u69AD;\u69AE;\u69AFt\u0100;v\u1645\u1646\u621Fb\u0100;d\u164C\u164D\u62BE;\u699D\u0100pt\u1654\u1657h;\u6222\xBB\xB9arr;\u637C\u0100gp\u1663\u1667on;\u4105f;\uC000\u{1D552}\u0380;Eaeiop\u12C1\u167B\u167D\u1682\u1684\u1687\u168A;\u6A70cir;\u6A6F;\u624Ad;\u624Bs;\u4027rox\u0100;e\u12C1\u1692\xF1\u1683ing\u803B\xE5\u40E5\u0180cty\u16A1\u16A6\u16A8r;\uC000\u{1D4B6};\u402Amp\u0100;e\u12C1\u16AF\xF1\u0288ilde\u803B\xE3\u40E3ml\u803B\xE4\u40E4\u0100ci\u16C2\u16C8onin\xF4\u0272nt;\u6A11\u0800Nabcdefiklnoprsu\u16ED\u16F1\u1730\u173C\u1743\u1748\u1778\u177D\u17E0\u17E6\u1839\u1850\u170D\u193D\u1948\u1970ot;\u6AED\u0100cr\u16F6\u171Ek\u0200ceps\u1700\u1705\u170D\u1713ong;\u624Cpsilon;\u43F6rime;\u6035im\u0100;e\u171A\u171B\u623Dq;\u62CD\u0176\u1722\u1726ee;\u62BDed\u0100;g\u172C\u172D\u6305e\xBB\u172Drk\u0100;t\u135C\u1737brk;\u63B6\u0100oy\u1701\u1741;\u4431quo;\u601E\u0280cmprt\u1753\u175B\u1761\u1764\u1768aus\u0100;e\u010A\u0109ptyv;\u69B0s\xE9\u170Cno\xF5\u0113\u0180ahw\u176F\u1771\u1773;\u43B2;\u6136een;\u626Cr;\uC000\u{1D51F}g\u0380costuvw\u178D\u179D\u17B3\u17C1\u17D5\u17DB\u17DE\u0180aiu\u1794\u1796\u179A\xF0\u0760rc;\u65EFp\xBB\u1371\u0180dpt\u17A4\u17A8\u17ADot;\u6A00lus;\u6A01imes;\u6A02\u0271\u17B9\0\0\u17BEcup;\u6A06ar;\u6605riangle\u0100du\u17CD\u17D2own;\u65BDp;\u65B3plus;\u6A04e\xE5\u1444\xE5\u14ADarow;\u690D\u0180ako\u17ED\u1826\u1835\u0100cn\u17F2\u1823k\u0180lst\u17FA\u05AB\u1802ozenge;\u69EBriangle\u0200;dlr\u1812\u1813\u1818\u181D\u65B4own;\u65BEeft;\u65C2ight;\u65B8k;\u6423\u01B1\u182B\0\u1833\u01B2\u182F\0\u1831;\u6592;\u65914;\u6593ck;\u6588\u0100eo\u183E\u184D\u0100;q\u1843\u1846\uC000=\u20E5uiv;\uC000\u2261\u20E5t;\u6310\u0200ptwx\u1859\u185E\u1867\u186Cf;\uC000\u{1D553}\u0100;t\u13CB\u1863om\xBB\u13CCtie;\u62C8\u0600DHUVbdhmptuv\u1885\u1896\u18AA\u18BB\u18D7\u18DB\u18EC\u18FF\u1905\u190A\u1910\u1921\u0200LRlr\u188E\u1890\u1892\u1894;\u6557;\u6554;\u6556;\u6553\u0280;DUdu\u18A1\u18A2\u18A4\u18A6\u18A8\u6550;\u6566;\u6569;\u6564;\u6567\u0200LRlr\u18B3\u18B5\u18B7\u18B9;\u655D;\u655A;\u655C;\u6559\u0380;HLRhlr\u18CA\u18CB\u18CD\u18CF\u18D1\u18D3\u18D5\u6551;\u656C;\u6563;\u6560;\u656B;\u6562;\u655Fox;\u69C9\u0200LRlr\u18E4\u18E6\u18E8\u18EA;\u6555;\u6552;\u6510;\u650C\u0280;DUdu\u06BD\u18F7\u18F9\u18FB\u18FD;\u6565;\u6568;\u652C;\u6534inus;\u629Flus;\u629Eimes;\u62A0\u0200LRlr\u1919\u191B\u191D\u191F;\u655B;\u6558;\u6518;\u6514\u0380;HLRhlr\u1930\u1931\u1933\u1935\u1937\u1939\u193B\u6502;\u656A;\u6561;\u655E;\u653C;\u6524;\u651C\u0100ev\u0123\u1942bar\u803B\xA6\u40A6\u0200ceio\u1951\u1956\u195A\u1960r;\uC000\u{1D4B7}mi;\u604Fm\u0100;e\u171A\u171Cl\u0180;bh\u1968\u1969\u196B\u405C;\u69C5sub;\u67C8\u016C\u1974\u197El\u0100;e\u1979\u197A\u6022t\xBB\u197Ap\u0180;Ee\u012F\u1985\u1987;\u6AAE\u0100;q\u06DC\u06DB\u0CE1\u19A7\0\u19E8\u1A11\u1A15\u1A32\0\u1A37\u1A50\0\0\u1AB4\0\0\u1AC1\0\0\u1B21\u1B2E\u1B4D\u1B52\0\u1BFD\0\u1C0C\u0180cpr\u19AD\u19B2\u19DDute;\u4107\u0300;abcds\u19BF\u19C0\u19C4\u19CA\u19D5\u19D9\u6229nd;\u6A44rcup;\u6A49\u0100au\u19CF\u19D2p;\u6A4Bp;\u6A47ot;\u6A40;\uC000\u2229\uFE00\u0100eo\u19E2\u19E5t;\u6041\xEE\u0693\u0200aeiu\u19F0\u19FB\u1A01\u1A05\u01F0\u19F5\0\u19F8s;\u6A4Don;\u410Ddil\u803B\xE7\u40E7rc;\u4109ps\u0100;s\u1A0C\u1A0D\u6A4Cm;\u6A50ot;\u410B\u0180dmn\u1A1B\u1A20\u1A26il\u80BB\xB8\u01ADptyv;\u69B2t\u8100\xA2;e\u1A2D\u1A2E\u40A2r\xE4\u01B2r;\uC000\u{1D520}\u0180cei\u1A3D\u1A40\u1A4Dy;\u4447ck\u0100;m\u1A47\u1A48\u6713ark\xBB\u1A48;\u43C7r\u0380;Ecefms\u1A5F\u1A60\u1A62\u1A6B\u1AA4\u1AAA\u1AAE\u65CB;\u69C3\u0180;el\u1A69\u1A6A\u1A6D\u42C6q;\u6257e\u0261\u1A74\0\0\u1A88rrow\u0100lr\u1A7C\u1A81eft;\u61BAight;\u61BB\u0280RSacd\u1A92\u1A94\u1A96\u1A9A\u1A9F\xBB\u0F47;\u64C8st;\u629Birc;\u629Aash;\u629Dnint;\u6A10id;\u6AEFcir;\u69C2ubs\u0100;u\u1ABB\u1ABC\u6663it\xBB\u1ABC\u02EC\u1AC7\u1AD4\u1AFA\0\u1B0Aon\u0100;e\u1ACD\u1ACE\u403A\u0100;q\xC7\xC6\u026D\u1AD9\0\0\u1AE2a\u0100;t\u1ADE\u1ADF\u402C;\u4040\u0180;fl\u1AE8\u1AE9\u1AEB\u6201\xEE\u1160e\u0100mx\u1AF1\u1AF6ent\xBB\u1AE9e\xF3\u024D\u01E7\u1AFE\0\u1B07\u0100;d\u12BB\u1B02ot;\u6A6Dn\xF4\u0246\u0180fry\u1B10\u1B14\u1B17;\uC000\u{1D554}o\xE4\u0254\u8100\xA9;s\u0155\u1B1Dr;\u6117\u0100ao\u1B25\u1B29rr;\u61B5ss;\u6717\u0100cu\u1B32\u1B37r;\uC000\u{1D4B8}\u0100bp\u1B3C\u1B44\u0100;e\u1B41\u1B42\u6ACF;\u6AD1\u0100;e\u1B49\u1B4A\u6AD0;\u6AD2dot;\u62EF\u0380delprvw\u1B60\u1B6C\u1B77\u1B82\u1BAC\u1BD4\u1BF9arr\u0100lr\u1B68\u1B6A;\u6938;\u6935\u0270\u1B72\0\0\u1B75r;\u62DEc;\u62DFarr\u0100;p\u1B7F\u1B80\u61B6;\u693D\u0300;bcdos\u1B8F\u1B90\u1B96\u1BA1\u1BA5\u1BA8\u622Arcap;\u6A48\u0100au\u1B9B\u1B9Ep;\u6A46p;\u6A4Aot;\u628Dr;\u6A45;\uC000\u222A\uFE00\u0200alrv\u1BB5\u1BBF\u1BDE\u1BE3rr\u0100;m\u1BBC\u1BBD\u61B7;\u693Cy\u0180evw\u1BC7\u1BD4\u1BD8q\u0270\u1BCE\0\0\u1BD2re\xE3\u1B73u\xE3\u1B75ee;\u62CEedge;\u62CFen\u803B\xA4\u40A4earrow\u0100lr\u1BEE\u1BF3eft\xBB\u1B80ight\xBB\u1BBDe\xE4\u1BDD\u0100ci\u1C01\u1C07onin\xF4\u01F7nt;\u6231lcty;\u632D\u0980AHabcdefhijlorstuwz\u1C38\u1C3B\u1C3F\u1C5D\u1C69\u1C75\u1C8A\u1C9E\u1CAC\u1CB7\u1CFB\u1CFF\u1D0D\u1D7B\u1D91\u1DAB\u1DBB\u1DC6\u1DCDr\xF2\u0381ar;\u6965\u0200glrs\u1C48\u1C4D\u1C52\u1C54ger;\u6020eth;\u6138\xF2\u1133h\u0100;v\u1C5A\u1C5B\u6010\xBB\u090A\u016B\u1C61\u1C67arow;\u690Fa\xE3\u0315\u0100ay\u1C6E\u1C73ron;\u410F;\u4434\u0180;ao\u0332\u1C7C\u1C84\u0100gr\u02BF\u1C81r;\u61CAtseq;\u6A77\u0180glm\u1C91\u1C94\u1C98\u803B\xB0\u40B0ta;\u43B4ptyv;\u69B1\u0100ir\u1CA3\u1CA8sht;\u697F;\uC000\u{1D521}ar\u0100lr\u1CB3\u1CB5\xBB\u08DC\xBB\u101E\u0280aegsv\u1CC2\u0378\u1CD6\u1CDC\u1CE0m\u0180;os\u0326\u1CCA\u1CD4nd\u0100;s\u0326\u1CD1uit;\u6666amma;\u43DDin;\u62F2\u0180;io\u1CE7\u1CE8\u1CF8\u40F7de\u8100\xF7;o\u1CE7\u1CF0ntimes;\u62C7n\xF8\u1CF7cy;\u4452c\u026F\u1D06\0\0\u1D0Arn;\u631Eop;\u630D\u0280lptuw\u1D18\u1D1D\u1D22\u1D49\u1D55lar;\u4024f;\uC000\u{1D555}\u0280;emps\u030B\u1D2D\u1D37\u1D3D\u1D42q\u0100;d\u0352\u1D33ot;\u6251inus;\u6238lus;\u6214quare;\u62A1blebarwedg\xE5\xFAn\u0180adh\u112E\u1D5D\u1D67ownarrow\xF3\u1C83arpoon\u0100lr\u1D72\u1D76ef\xF4\u1CB4igh\xF4\u1CB6\u0162\u1D7F\u1D85karo\xF7\u0F42\u026F\u1D8A\0\0\u1D8Ern;\u631Fop;\u630C\u0180cot\u1D98\u1DA3\u1DA6\u0100ry\u1D9D\u1DA1;\uC000\u{1D4B9};\u4455l;\u69F6rok;\u4111\u0100dr\u1DB0\u1DB4ot;\u62F1i\u0100;f\u1DBA\u1816\u65BF\u0100ah\u1DC0\u1DC3r\xF2\u0429a\xF2\u0FA6angle;\u69A6\u0100ci\u1DD2\u1DD5y;\u445Fgrarr;\u67FF\u0900Dacdefglmnopqrstux\u1E01\u1E09\u1E19\u1E38\u0578\u1E3C\u1E49\u1E61\u1E7E\u1EA5\u1EAF\u1EBD\u1EE1\u1F2A\u1F37\u1F44\u1F4E\u1F5A\u0100Do\u1E06\u1D34o\xF4\u1C89\u0100cs\u1E0E\u1E14ute\u803B\xE9\u40E9ter;\u6A6E\u0200aioy\u1E22\u1E27\u1E31\u1E36ron;\u411Br\u0100;c\u1E2D\u1E2E\u6256\u803B\xEA\u40EAlon;\u6255;\u444Dot;\u4117\u0100Dr\u1E41\u1E45ot;\u6252;\uC000\u{1D522}\u0180;rs\u1E50\u1E51\u1E57\u6A9Aave\u803B\xE8\u40E8\u0100;d\u1E5C\u1E5D\u6A96ot;\u6A98\u0200;ils\u1E6A\u1E6B\u1E72\u1E74\u6A99nters;\u63E7;\u6113\u0100;d\u1E79\u1E7A\u6A95ot;\u6A97\u0180aps\u1E85\u1E89\u1E97cr;\u4113ty\u0180;sv\u1E92\u1E93\u1E95\u6205et\xBB\u1E93p\u01001;\u1E9D\u1EA4\u0133\u1EA1\u1EA3;\u6004;\u6005\u6003\u0100gs\u1EAA\u1EAC;\u414Bp;\u6002\u0100gp\u1EB4\u1EB8on;\u4119f;\uC000\u{1D556}\u0180als\u1EC4\u1ECE\u1ED2r\u0100;s\u1ECA\u1ECB\u62D5l;\u69E3us;\u6A71i\u0180;lv\u1EDA\u1EDB\u1EDF\u43B5on\xBB\u1EDB;\u43F5\u0200csuv\u1EEA\u1EF3\u1F0B\u1F23\u0100io\u1EEF\u1E31rc\xBB\u1E2E\u0269\u1EF9\0\0\u1EFB\xED\u0548ant\u0100gl\u1F02\u1F06tr\xBB\u1E5Dess\xBB\u1E7A\u0180aei\u1F12\u1F16\u1F1Als;\u403Dst;\u625Fv\u0100;D\u0235\u1F20D;\u6A78parsl;\u69E5\u0100Da\u1F2F\u1F33ot;\u6253rr;\u6971\u0180cdi\u1F3E\u1F41\u1EF8r;\u612Fo\xF4\u0352\u0100ah\u1F49\u1F4B;\u43B7\u803B\xF0\u40F0\u0100mr\u1F53\u1F57l\u803B\xEB\u40EBo;\u60AC\u0180cip\u1F61\u1F64\u1F67l;\u4021s\xF4\u056E\u0100eo\u1F6C\u1F74ctatio\xEE\u0559nential\xE5\u0579\u09E1\u1F92\0\u1F9E\0\u1FA1\u1FA7\0\0\u1FC6\u1FCC\0\u1FD3\0\u1FE6\u1FEA\u2000\0\u2008\u205Allingdotse\xF1\u1E44y;\u4444male;\u6640\u0180ilr\u1FAD\u1FB3\u1FC1lig;\u8000\uFB03\u0269\u1FB9\0\0\u1FBDg;\u8000\uFB00ig;\u8000\uFB04;\uC000\u{1D523}lig;\u8000\uFB01lig;\uC000fj\u0180alt\u1FD9\u1FDC\u1FE1t;\u666Dig;\u8000\uFB02ns;\u65B1of;\u4192\u01F0\u1FEE\0\u1FF3f;\uC000\u{1D557}\u0100ak\u05BF\u1FF7\u0100;v\u1FFC\u1FFD\u62D4;\u6AD9artint;\u6A0D\u0100ao\u200C\u2055\u0100cs\u2011\u2052\u03B1\u201A\u2030\u2038\u2045\u2048\0\u2050\u03B2\u2022\u2025\u2027\u202A\u202C\0\u202E\u803B\xBD\u40BD;\u6153\u803B\xBC\u40BC;\u6155;\u6159;\u615B\u01B3\u2034\0\u2036;\u6154;\u6156\u02B4\u203E\u2041\0\0\u2043\u803B\xBE\u40BE;\u6157;\u615C5;\u6158\u01B6\u204C\0\u204E;\u615A;\u615D8;\u615El;\u6044wn;\u6322cr;\uC000\u{1D4BB}\u0880Eabcdefgijlnorstv\u2082\u2089\u209F\u20A5\u20B0\u20B4\u20F0\u20F5\u20FA\u20FF\u2103\u2112\u2138\u0317\u213E\u2152\u219E\u0100;l\u064D\u2087;\u6A8C\u0180cmp\u2090\u2095\u209Dute;\u41F5ma\u0100;d\u209C\u1CDA\u43B3;\u6A86reve;\u411F\u0100iy\u20AA\u20AErc;\u411D;\u4433ot;\u4121\u0200;lqs\u063E\u0642\u20BD\u20C9\u0180;qs\u063E\u064C\u20C4lan\xF4\u0665\u0200;cdl\u0665\u20D2\u20D5\u20E5c;\u6AA9ot\u0100;o\u20DC\u20DD\u6A80\u0100;l\u20E2\u20E3\u6A82;\u6A84\u0100;e\u20EA\u20ED\uC000\u22DB\uFE00s;\u6A94r;\uC000\u{1D524}\u0100;g\u0673\u061Bmel;\u6137cy;\u4453\u0200;Eaj\u065A\u210C\u210E\u2110;\u6A92;\u6AA5;\u6AA4\u0200Eaes\u211B\u211D\u2129\u2134;\u6269p\u0100;p\u2123\u2124\u6A8Arox\xBB\u2124\u0100;q\u212E\u212F\u6A88\u0100;q\u212E\u211Bim;\u62E7pf;\uC000\u{1D558}\u0100ci\u2143\u2146r;\u610Am\u0180;el\u066B\u214E\u2150;\u6A8E;\u6A90\u8300>;cdlqr\u05EE\u2160\u216A\u216E\u2173\u2179\u0100ci\u2165\u2167;\u6AA7r;\u6A7Aot;\u62D7Par;\u6995uest;\u6A7C\u0280adels\u2184\u216A\u2190\u0656\u219B\u01F0\u2189\0\u218Epro\xF8\u209Er;\u6978q\u0100lq\u063F\u2196les\xF3\u2088i\xED\u066B\u0100en\u21A3\u21ADrtneqq;\uC000\u2269\uFE00\xC5\u21AA\u0500Aabcefkosy\u21C4\u21C7\u21F1\u21F5\u21FA\u2218\u221D\u222F\u2268\u227Dr\xF2\u03A0\u0200ilmr\u21D0\u21D4\u21D7\u21DBrs\xF0\u1484f\xBB\u2024il\xF4\u06A9\u0100dr\u21E0\u21E4cy;\u444A\u0180;cw\u08F4\u21EB\u21EFir;\u6948;\u61ADar;\u610Firc;\u4125\u0180alr\u2201\u220E\u2213rts\u0100;u\u2209\u220A\u6665it\xBB\u220Alip;\u6026con;\u62B9r;\uC000\u{1D525}s\u0100ew\u2223\u2229arow;\u6925arow;\u6926\u0280amopr\u223A\u223E\u2243\u225E\u2263rr;\u61FFtht;\u623Bk\u0100lr\u2249\u2253eftarrow;\u61A9ightarrow;\u61AAf;\uC000\u{1D559}bar;\u6015\u0180clt\u226F\u2274\u2278r;\uC000\u{1D4BD}as\xE8\u21F4rok;\u4127\u0100bp\u2282\u2287ull;\u6043hen\xBB\u1C5B\u0AE1\u22A3\0\u22AA\0\u22B8\u22C5\u22CE\0\u22D5\u22F3\0\0\u22F8\u2322\u2367\u2362\u237F\0\u2386\u23AA\u23B4cute\u803B\xED\u40ED\u0180;iy\u0771\u22B0\u22B5rc\u803B\xEE\u40EE;\u4438\u0100cx\u22BC\u22BFy;\u4435cl\u803B\xA1\u40A1\u0100fr\u039F\u22C9;\uC000\u{1D526}rave\u803B\xEC\u40EC\u0200;ino\u073E\u22DD\u22E9\u22EE\u0100in\u22E2\u22E6nt;\u6A0Ct;\u622Dfin;\u69DCta;\u6129lig;\u4133\u0180aop\u22FE\u231A\u231D\u0180cgt\u2305\u2308\u2317r;\u412B\u0180elp\u071F\u230F\u2313in\xE5\u078Ear\xF4\u0720h;\u4131f;\u62B7ed;\u41B5\u0280;cfot\u04F4\u232C\u2331\u233D\u2341are;\u6105in\u0100;t\u2338\u2339\u621Eie;\u69DDdo\xF4\u2319\u0280;celp\u0757\u234C\u2350\u235B\u2361al;\u62BA\u0100gr\u2355\u2359er\xF3\u1563\xE3\u234Darhk;\u6A17rod;\u6A3C\u0200cgpt\u236F\u2372\u2376\u237By;\u4451on;\u412Ff;\uC000\u{1D55A}a;\u43B9uest\u803B\xBF\u40BF\u0100ci\u238A\u238Fr;\uC000\u{1D4BE}n\u0280;Edsv\u04F4\u239B\u239D\u23A1\u04F3;\u62F9ot;\u62F5\u0100;v\u23A6\u23A7\u62F4;\u62F3\u0100;i\u0777\u23AElde;\u4129\u01EB\u23B8\0\u23BCcy;\u4456l\u803B\xEF\u40EF\u0300cfmosu\u23CC\u23D7\u23DC\u23E1\u23E7\u23F5\u0100iy\u23D1\u23D5rc;\u4135;\u4439r;\uC000\u{1D527}ath;\u4237pf;\uC000\u{1D55B}\u01E3\u23EC\0\u23F1r;\uC000\u{1D4BF}rcy;\u4458kcy;\u4454\u0400acfghjos\u240B\u2416\u2422\u2427\u242D\u2431\u2435\u243Bppa\u0100;v\u2413\u2414\u43BA;\u43F0\u0100ey\u241B\u2420dil;\u4137;\u443Ar;\uC000\u{1D528}reen;\u4138cy;\u4445cy;\u445Cpf;\uC000\u{1D55C}cr;\uC000\u{1D4C0}\u0B80ABEHabcdefghjlmnoprstuv\u2470\u2481\u2486\u248D\u2491\u250E\u253D\u255A\u2580\u264E\u265E\u2665\u2679\u267D\u269A\u26B2\u26D8\u275D\u2768\u278B\u27C0\u2801\u2812\u0180art\u2477\u247A\u247Cr\xF2\u09C6\xF2\u0395ail;\u691Barr;\u690E\u0100;g\u0994\u248B;\u6A8Bar;\u6962\u0963\u24A5\0\u24AA\0\u24B1\0\0\0\0\0\u24B5\u24BA\0\u24C6\u24C8\u24CD\0\u24F9ute;\u413Amptyv;\u69B4ra\xEE\u084Cbda;\u43BBg\u0180;dl\u088E\u24C1\u24C3;\u6991\xE5\u088E;\u6A85uo\u803B\xAB\u40ABr\u0400;bfhlpst\u0899\u24DE\u24E6\u24E9\u24EB\u24EE\u24F1\u24F5\u0100;f\u089D\u24E3s;\u691Fs;\u691D\xEB\u2252p;\u61ABl;\u6939im;\u6973l;\u61A2\u0180;ae\u24FF\u2500\u2504\u6AABil;\u6919\u0100;s\u2509\u250A\u6AAD;\uC000\u2AAD\uFE00\u0180abr\u2515\u2519\u251Drr;\u690Crk;\u6772\u0100ak\u2522\u252Cc\u0100ek\u2528\u252A;\u407B;\u405B\u0100es\u2531\u2533;\u698Bl\u0100du\u2539\u253B;\u698F;\u698D\u0200aeuy\u2546\u254B\u2556\u2558ron;\u413E\u0100di\u2550\u2554il;\u413C\xEC\u08B0\xE2\u2529;\u443B\u0200cqrs\u2563\u2566\u256D\u257Da;\u6936uo\u0100;r\u0E19\u1746\u0100du\u2572\u2577har;\u6967shar;\u694Bh;\u61B2\u0280;fgqs\u258B\u258C\u0989\u25F3\u25FF\u6264t\u0280ahlrt\u2598\u25A4\u25B7\u25C2\u25E8rrow\u0100;t\u0899\u25A1a\xE9\u24F6arpoon\u0100du\u25AF\u25B4own\xBB\u045Ap\xBB\u0966eftarrows;\u61C7ight\u0180ahs\u25CD\u25D6\u25DErrow\u0100;s\u08F4\u08A7arpoon\xF3\u0F98quigarro\xF7\u21F0hreetimes;\u62CB\u0180;qs\u258B\u0993\u25FAlan\xF4\u09AC\u0280;cdgs\u09AC\u260A\u260D\u261D\u2628c;\u6AA8ot\u0100;o\u2614\u2615\u6A7F\u0100;r\u261A\u261B\u6A81;\u6A83\u0100;e\u2622\u2625\uC000\u22DA\uFE00s;\u6A93\u0280adegs\u2633\u2639\u263D\u2649\u264Bppro\xF8\u24C6ot;\u62D6q\u0100gq\u2643\u2645\xF4\u0989gt\xF2\u248C\xF4\u099Bi\xED\u09B2\u0180ilr\u2655\u08E1\u265Asht;\u697C;\uC000\u{1D529}\u0100;E\u099C\u2663;\u6A91\u0161\u2669\u2676r\u0100du\u25B2\u266E\u0100;l\u0965\u2673;\u696Alk;\u6584cy;\u4459\u0280;acht\u0A48\u2688\u268B\u2691\u2696r\xF2\u25C1orne\xF2\u1D08ard;\u696Bri;\u65FA\u0100io\u269F\u26A4dot;\u4140ust\u0100;a\u26AC\u26AD\u63B0che\xBB\u26AD\u0200Eaes\u26BB\u26BD\u26C9\u26D4;\u6268p\u0100;p\u26C3\u26C4\u6A89rox\xBB\u26C4\u0100;q\u26CE\u26CF\u6A87\u0100;q\u26CE\u26BBim;\u62E6\u0400abnoptwz\u26E9\u26F4\u26F7\u271A\u272F\u2741\u2747\u2750\u0100nr\u26EE\u26F1g;\u67ECr;\u61FDr\xEB\u08C1g\u0180lmr\u26FF\u270D\u2714eft\u0100ar\u09E6\u2707ight\xE1\u09F2apsto;\u67FCight\xE1\u09FDparrow\u0100lr\u2725\u2729ef\xF4\u24EDight;\u61AC\u0180afl\u2736\u2739\u273Dr;\u6985;\uC000\u{1D55D}us;\u6A2Dimes;\u6A34\u0161\u274B\u274Fst;\u6217\xE1\u134E\u0180;ef\u2757\u2758\u1800\u65CAnge\xBB\u2758ar\u0100;l\u2764\u2765\u4028t;\u6993\u0280achmt\u2773\u2776\u277C\u2785\u2787r\xF2\u08A8orne\xF2\u1D8Car\u0100;d\u0F98\u2783;\u696D;\u600Eri;\u62BF\u0300achiqt\u2798\u279D\u0A40\u27A2\u27AE\u27BBquo;\u6039r;\uC000\u{1D4C1}m\u0180;eg\u09B2\u27AA\u27AC;\u6A8D;\u6A8F\u0100bu\u252A\u27B3o\u0100;r\u0E1F\u27B9;\u601Arok;\u4142\u8400<;cdhilqr\u082B\u27D2\u2639\u27DC\u27E0\u27E5\u27EA\u27F0\u0100ci\u27D7\u27D9;\u6AA6r;\u6A79re\xE5\u25F2mes;\u62C9arr;\u6976uest;\u6A7B\u0100Pi\u27F5\u27F9ar;\u6996\u0180;ef\u2800\u092D\u181B\u65C3r\u0100du\u2807\u280Dshar;\u694Ahar;\u6966\u0100en\u2817\u2821rtneqq;\uC000\u2268\uFE00\xC5\u281E\u0700Dacdefhilnopsu\u2840\u2845\u2882\u288E\u2893\u28A0\u28A5\u28A8\u28DA\u28E2\u28E4\u0A83\u28F3\u2902Dot;\u623A\u0200clpr\u284E\u2852\u2863\u287Dr\u803B\xAF\u40AF\u0100et\u2857\u2859;\u6642\u0100;e\u285E\u285F\u6720se\xBB\u285F\u0100;s\u103B\u2868to\u0200;dlu\u103B\u2873\u2877\u287Bow\xEE\u048Cef\xF4\u090F\xF0\u13D1ker;\u65AE\u0100oy\u2887\u288Cmma;\u6A29;\u443Cash;\u6014asuredangle\xBB\u1626r;\uC000\u{1D52A}o;\u6127\u0180cdn\u28AF\u28B4\u28C9ro\u803B\xB5\u40B5\u0200;acd\u1464\u28BD\u28C0\u28C4s\xF4\u16A7ir;\u6AF0ot\u80BB\xB7\u01B5us\u0180;bd\u28D2\u1903\u28D3\u6212\u0100;u\u1D3C\u28D8;\u6A2A\u0163\u28DE\u28E1p;\u6ADB\xF2\u2212\xF0\u0A81\u0100dp\u28E9\u28EEels;\u62A7f;\uC000\u{1D55E}\u0100ct\u28F8\u28FDr;\uC000\u{1D4C2}pos\xBB\u159D\u0180;lm\u2909\u290A\u290D\u43BCtimap;\u62B8\u0C00GLRVabcdefghijlmoprstuvw\u2942\u2953\u297E\u2989\u2998\u29DA\u29E9\u2A15\u2A1A\u2A58\u2A5D\u2A83\u2A95\u2AA4\u2AA8\u2B04\u2B07\u2B44\u2B7F\u2BAE\u2C34\u2C67\u2C7C\u2CE9\u0100gt\u2947\u294B;\uC000\u22D9\u0338\u0100;v\u2950\u0BCF\uC000\u226B\u20D2\u0180elt\u295A\u2972\u2976ft\u0100ar\u2961\u2967rrow;\u61CDightarrow;\u61CE;\uC000\u22D8\u0338\u0100;v\u297B\u0C47\uC000\u226A\u20D2ightarrow;\u61CF\u0100Dd\u298E\u2993ash;\u62AFash;\u62AE\u0280bcnpt\u29A3\u29A7\u29AC\u29B1\u29CCla\xBB\u02DEute;\u4144g;\uC000\u2220\u20D2\u0280;Eiop\u0D84\u29BC\u29C0\u29C5\u29C8;\uC000\u2A70\u0338d;\uC000\u224B\u0338s;\u4149ro\xF8\u0D84ur\u0100;a\u29D3\u29D4\u666El\u0100;s\u29D3\u0B38\u01F3\u29DF\0\u29E3p\u80BB\xA0\u0B37mp\u0100;e\u0BF9\u0C00\u0280aeouy\u29F4\u29FE\u2A03\u2A10\u2A13\u01F0\u29F9\0\u29FB;\u6A43on;\u4148dil;\u4146ng\u0100;d\u0D7E\u2A0Aot;\uC000\u2A6D\u0338p;\u6A42;\u443Dash;\u6013\u0380;Aadqsx\u0B92\u2A29\u2A2D\u2A3B\u2A41\u2A45\u2A50rr;\u61D7r\u0100hr\u2A33\u2A36k;\u6924\u0100;o\u13F2\u13F0ot;\uC000\u2250\u0338ui\xF6\u0B63\u0100ei\u2A4A\u2A4Ear;\u6928\xED\u0B98ist\u0100;s\u0BA0\u0B9Fr;\uC000\u{1D52B}\u0200Eest\u0BC5\u2A66\u2A79\u2A7C\u0180;qs\u0BBC\u2A6D\u0BE1\u0180;qs\u0BBC\u0BC5\u2A74lan\xF4\u0BE2i\xED\u0BEA\u0100;r\u0BB6\u2A81\xBB\u0BB7\u0180Aap\u2A8A\u2A8D\u2A91r\xF2\u2971rr;\u61AEar;\u6AF2\u0180;sv\u0F8D\u2A9C\u0F8C\u0100;d\u2AA1\u2AA2\u62FC;\u62FAcy;\u445A\u0380AEadest\u2AB7\u2ABA\u2ABE\u2AC2\u2AC5\u2AF6\u2AF9r\xF2\u2966;\uC000\u2266\u0338rr;\u619Ar;\u6025\u0200;fqs\u0C3B\u2ACE\u2AE3\u2AEFt\u0100ar\u2AD4\u2AD9rro\xF7\u2AC1ightarro\xF7\u2A90\u0180;qs\u0C3B\u2ABA\u2AEAlan\xF4\u0C55\u0100;s\u0C55\u2AF4\xBB\u0C36i\xED\u0C5D\u0100;r\u0C35\u2AFEi\u0100;e\u0C1A\u0C25i\xE4\u0D90\u0100pt\u2B0C\u2B11f;\uC000\u{1D55F}\u8180\xAC;in\u2B19\u2B1A\u2B36\u40ACn\u0200;Edv\u0B89\u2B24\u2B28\u2B2E;\uC000\u22F9\u0338ot;\uC000\u22F5\u0338\u01E1\u0B89\u2B33\u2B35;\u62F7;\u62F6i\u0100;v\u0CB8\u2B3C\u01E1\u0CB8\u2B41\u2B43;\u62FE;\u62FD\u0180aor\u2B4B\u2B63\u2B69r\u0200;ast\u0B7B\u2B55\u2B5A\u2B5Flle\xEC\u0B7Bl;\uC000\u2AFD\u20E5;\uC000\u2202\u0338lint;\u6A14\u0180;ce\u0C92\u2B70\u2B73u\xE5\u0CA5\u0100;c\u0C98\u2B78\u0100;e\u0C92\u2B7D\xF1\u0C98\u0200Aait\u2B88\u2B8B\u2B9D\u2BA7r\xF2\u2988rr\u0180;cw\u2B94\u2B95\u2B99\u619B;\uC000\u2933\u0338;\uC000\u219D\u0338ghtarrow\xBB\u2B95ri\u0100;e\u0CCB\u0CD6\u0380chimpqu\u2BBD\u2BCD\u2BD9\u2B04\u0B78\u2BE4\u2BEF\u0200;cer\u0D32\u2BC6\u0D37\u2BC9u\xE5\u0D45;\uC000\u{1D4C3}ort\u026D\u2B05\0\0\u2BD6ar\xE1\u2B56m\u0100;e\u0D6E\u2BDF\u0100;q\u0D74\u0D73su\u0100bp\u2BEB\u2BED\xE5\u0CF8\xE5\u0D0B\u0180bcp\u2BF6\u2C11\u2C19\u0200;Ees\u2BFF\u2C00\u0D22\u2C04\u6284;\uC000\u2AC5\u0338et\u0100;e\u0D1B\u2C0Bq\u0100;q\u0D23\u2C00c\u0100;e\u0D32\u2C17\xF1\u0D38\u0200;Ees\u2C22\u2C23\u0D5F\u2C27\u6285;\uC000\u2AC6\u0338et\u0100;e\u0D58\u2C2Eq\u0100;q\u0D60\u2C23\u0200gilr\u2C3D\u2C3F\u2C45\u2C47\xEC\u0BD7lde\u803B\xF1\u40F1\xE7\u0C43iangle\u0100lr\u2C52\u2C5Ceft\u0100;e\u0C1A\u2C5A\xF1\u0C26ight\u0100;e\u0CCB\u2C65\xF1\u0CD7\u0100;m\u2C6C\u2C6D\u43BD\u0180;es\u2C74\u2C75\u2C79\u4023ro;\u6116p;\u6007\u0480DHadgilrs\u2C8F\u2C94\u2C99\u2C9E\u2CA3\u2CB0\u2CB6\u2CD3\u2CE3ash;\u62ADarr;\u6904p;\uC000\u224D\u20D2ash;\u62AC\u0100et\u2CA8\u2CAC;\uC000\u2265\u20D2;\uC000>\u20D2nfin;\u69DE\u0180Aet\u2CBD\u2CC1\u2CC5rr;\u6902;\uC000\u2264\u20D2\u0100;r\u2CCA\u2CCD\uC000<\u20D2ie;\uC000\u22B4\u20D2\u0100At\u2CD8\u2CDCrr;\u6903rie;\uC000\u22B5\u20D2im;\uC000\u223C\u20D2\u0180Aan\u2CF0\u2CF4\u2D02rr;\u61D6r\u0100hr\u2CFA\u2CFDk;\u6923\u0100;o\u13E7\u13E5ear;\u6927\u1253\u1A95\0\0\0\0\0\0\0\0\0\0\0\0\0\u2D2D\0\u2D38\u2D48\u2D60\u2D65\u2D72\u2D84\u1B07\0\0\u2D8D\u2DAB\0\u2DC8\u2DCE\0\u2DDC\u2E19\u2E2B\u2E3E\u2E43\u0100cs\u2D31\u1A97ute\u803B\xF3\u40F3\u0100iy\u2D3C\u2D45r\u0100;c\u1A9E\u2D42\u803B\xF4\u40F4;\u443E\u0280abios\u1AA0\u2D52\u2D57\u01C8\u2D5Alac;\u4151v;\u6A38old;\u69BClig;\u4153\u0100cr\u2D69\u2D6Dir;\u69BF;\uC000\u{1D52C}\u036F\u2D79\0\0\u2D7C\0\u2D82n;\u42DBave\u803B\xF2\u40F2;\u69C1\u0100bm\u2D88\u0DF4ar;\u69B5\u0200acit\u2D95\u2D98\u2DA5\u2DA8r\xF2\u1A80\u0100ir\u2D9D\u2DA0r;\u69BEoss;\u69BBn\xE5\u0E52;\u69C0\u0180aei\u2DB1\u2DB5\u2DB9cr;\u414Dga;\u43C9\u0180cdn\u2DC0\u2DC5\u01CDron;\u43BF;\u69B6pf;\uC000\u{1D560}\u0180ael\u2DD4\u2DD7\u01D2r;\u69B7rp;\u69B9\u0380;adiosv\u2DEA\u2DEB\u2DEE\u2E08\u2E0D\u2E10\u2E16\u6228r\xF2\u1A86\u0200;efm\u2DF7\u2DF8\u2E02\u2E05\u6A5Dr\u0100;o\u2DFE\u2DFF\u6134f\xBB\u2DFF\u803B\xAA\u40AA\u803B\xBA\u40BAgof;\u62B6r;\u6A56lope;\u6A57;\u6A5B\u0180clo\u2E1F\u2E21\u2E27\xF2\u2E01ash\u803B\xF8\u40F8l;\u6298i\u016C\u2E2F\u2E34de\u803B\xF5\u40F5es\u0100;a\u01DB\u2E3As;\u6A36ml\u803B\xF6\u40F6bar;\u633D\u0AE1\u2E5E\0\u2E7D\0\u2E80\u2E9D\0\u2EA2\u2EB9\0\0\u2ECB\u0E9C\0\u2F13\0\0\u2F2B\u2FBC\0\u2FC8r\u0200;ast\u0403\u2E67\u2E72\u0E85\u8100\xB6;l\u2E6D\u2E6E\u40B6le\xEC\u0403\u0269\u2E78\0\0\u2E7Bm;\u6AF3;\u6AFDy;\u443Fr\u0280cimpt\u2E8B\u2E8F\u2E93\u1865\u2E97nt;\u4025od;\u402Eil;\u6030enk;\u6031r;\uC000\u{1D52D}\u0180imo\u2EA8\u2EB0\u2EB4\u0100;v\u2EAD\u2EAE\u43C6;\u43D5ma\xF4\u0A76ne;\u660E\u0180;tv\u2EBF\u2EC0\u2EC8\u43C0chfork\xBB\u1FFD;\u43D6\u0100au\u2ECF\u2EDFn\u0100ck\u2ED5\u2EDDk\u0100;h\u21F4\u2EDB;\u610E\xF6\u21F4s\u0480;abcdemst\u2EF3\u2EF4\u1908\u2EF9\u2EFD\u2F04\u2F06\u2F0A\u2F0E\u402Bcir;\u6A23ir;\u6A22\u0100ou\u1D40\u2F02;\u6A25;\u6A72n\u80BB\xB1\u0E9Dim;\u6A26wo;\u6A27\u0180ipu\u2F19\u2F20\u2F25ntint;\u6A15f;\uC000\u{1D561}nd\u803B\xA3\u40A3\u0500;Eaceinosu\u0EC8\u2F3F\u2F41\u2F44\u2F47\u2F81\u2F89\u2F92\u2F7E\u2FB6;\u6AB3p;\u6AB7u\xE5\u0ED9\u0100;c\u0ECE\u2F4C\u0300;acens\u0EC8\u2F59\u2F5F\u2F66\u2F68\u2F7Eppro\xF8\u2F43urlye\xF1\u0ED9\xF1\u0ECE\u0180aes\u2F6F\u2F76\u2F7Approx;\u6AB9qq;\u6AB5im;\u62E8i\xED\u0EDFme\u0100;s\u2F88\u0EAE\u6032\u0180Eas\u2F78\u2F90\u2F7A\xF0\u2F75\u0180dfp\u0EEC\u2F99\u2FAF\u0180als\u2FA0\u2FA5\u2FAAlar;\u632Eine;\u6312urf;\u6313\u0100;t\u0EFB\u2FB4\xEF\u0EFBrel;\u62B0\u0100ci\u2FC0\u2FC5r;\uC000\u{1D4C5};\u43C8ncsp;\u6008\u0300fiopsu\u2FDA\u22E2\u2FDF\u2FE5\u2FEB\u2FF1r;\uC000\u{1D52E}pf;\uC000\u{1D562}rime;\u6057cr;\uC000\u{1D4C6}\u0180aeo\u2FF8\u3009\u3013t\u0100ei\u2FFE\u3005rnion\xF3\u06B0nt;\u6A16st\u0100;e\u3010\u3011\u403F\xF1\u1F19\xF4\u0F14\u0A80ABHabcdefhilmnoprstux\u3040\u3051\u3055\u3059\u30E0\u310E\u312B\u3147\u3162\u3172\u318E\u3206\u3215\u3224\u3229\u3258\u326E\u3272\u3290\u32B0\u32B7\u0180art\u3047\u304A\u304Cr\xF2\u10B3\xF2\u03DDail;\u691Car\xF2\u1C65ar;\u6964\u0380cdenqrt\u3068\u3075\u3078\u307F\u308F\u3094\u30CC\u0100eu\u306D\u3071;\uC000\u223D\u0331te;\u4155i\xE3\u116Emptyv;\u69B3g\u0200;del\u0FD1\u3089\u308B\u308D;\u6992;\u69A5\xE5\u0FD1uo\u803B\xBB\u40BBr\u0580;abcfhlpstw\u0FDC\u30AC\u30AF\u30B7\u30B9\u30BC\u30BE\u30C0\u30C3\u30C7\u30CAp;\u6975\u0100;f\u0FE0\u30B4s;\u6920;\u6933s;\u691E\xEB\u225D\xF0\u272El;\u6945im;\u6974l;\u61A3;\u619D\u0100ai\u30D1\u30D5il;\u691Ao\u0100;n\u30DB\u30DC\u6236al\xF3\u0F1E\u0180abr\u30E7\u30EA\u30EEr\xF2\u17E5rk;\u6773\u0100ak\u30F3\u30FDc\u0100ek\u30F9\u30FB;\u407D;\u405D\u0100es\u3102\u3104;\u698Cl\u0100du\u310A\u310C;\u698E;\u6990\u0200aeuy\u3117\u311C\u3127\u3129ron;\u4159\u0100di\u3121\u3125il;\u4157\xEC\u0FF2\xE2\u30FA;\u4440\u0200clqs\u3134\u3137\u313D\u3144a;\u6937dhar;\u6969uo\u0100;r\u020E\u020Dh;\u61B3\u0180acg\u314E\u315F\u0F44l\u0200;ips\u0F78\u3158\u315B\u109Cn\xE5\u10BBar\xF4\u0FA9t;\u65AD\u0180ilr\u3169\u1023\u316Esht;\u697D;\uC000\u{1D52F}\u0100ao\u3177\u3186r\u0100du\u317D\u317F\xBB\u047B\u0100;l\u1091\u3184;\u696C\u0100;v\u318B\u318C\u43C1;\u43F1\u0180gns\u3195\u31F9\u31FCht\u0300ahlrst\u31A4\u31B0\u31C2\u31D8\u31E4\u31EErrow\u0100;t\u0FDC\u31ADa\xE9\u30C8arpoon\u0100du\u31BB\u31BFow\xEE\u317Ep\xBB\u1092eft\u0100ah\u31CA\u31D0rrow\xF3\u0FEAarpoon\xF3\u0551ightarrows;\u61C9quigarro\xF7\u30CBhreetimes;\u62CCg;\u42DAingdotse\xF1\u1F32\u0180ahm\u320D\u3210\u3213r\xF2\u0FEAa\xF2\u0551;\u600Foust\u0100;a\u321E\u321F\u63B1che\xBB\u321Fmid;\u6AEE\u0200abpt\u3232\u323D\u3240\u3252\u0100nr\u3237\u323Ag;\u67EDr;\u61FEr\xEB\u1003\u0180afl\u3247\u324A\u324Er;\u6986;\uC000\u{1D563}us;\u6A2Eimes;\u6A35\u0100ap\u325D\u3267r\u0100;g\u3263\u3264\u4029t;\u6994olint;\u6A12ar\xF2\u31E3\u0200achq\u327B\u3280\u10BC\u3285quo;\u603Ar;\uC000\u{1D4C7}\u0100bu\u30FB\u328Ao\u0100;r\u0214\u0213\u0180hir\u3297\u329B\u32A0re\xE5\u31F8mes;\u62CAi\u0200;efl\u32AA\u1059\u1821\u32AB\u65B9tri;\u69CEluhar;\u6968;\u611E\u0D61\u32D5\u32DB\u32DF\u332C\u3338\u3371\0\u337A\u33A4\0\0\u33EC\u33F0\0\u3428\u3448\u345A\u34AD\u34B1\u34CA\u34F1\0\u3616\0\0\u3633cute;\u415Bqu\xEF\u27BA\u0500;Eaceinpsy\u11ED\u32F3\u32F5\u32FF\u3302\u330B\u330F\u331F\u3326\u3329;\u6AB4\u01F0\u32FA\0\u32FC;\u6AB8on;\u4161u\xE5\u11FE\u0100;d\u11F3\u3307il;\u415Frc;\u415D\u0180Eas\u3316\u3318\u331B;\u6AB6p;\u6ABAim;\u62E9olint;\u6A13i\xED\u1204;\u4441ot\u0180;be\u3334\u1D47\u3335\u62C5;\u6A66\u0380Aacmstx\u3346\u334A\u3357\u335B\u335E\u3363\u336Drr;\u61D8r\u0100hr\u3350\u3352\xEB\u2228\u0100;o\u0A36\u0A34t\u803B\xA7\u40A7i;\u403Bwar;\u6929m\u0100in\u3369\xF0nu\xF3\xF1t;\u6736r\u0100;o\u3376\u2055\uC000\u{1D530}\u0200acoy\u3382\u3386\u3391\u33A0rp;\u666F\u0100hy\u338B\u338Fcy;\u4449;\u4448rt\u026D\u3399\0\0\u339Ci\xE4\u1464ara\xEC\u2E6F\u803B\xAD\u40AD\u0100gm\u33A8\u33B4ma\u0180;fv\u33B1\u33B2\u33B2\u43C3;\u43C2\u0400;deglnpr\u12AB\u33C5\u33C9\u33CE\u33D6\u33DE\u33E1\u33E6ot;\u6A6A\u0100;q\u12B1\u12B0\u0100;E\u33D3\u33D4\u6A9E;\u6AA0\u0100;E\u33DB\u33DC\u6A9D;\u6A9Fe;\u6246lus;\u6A24arr;\u6972ar\xF2\u113D\u0200aeit\u33F8\u3408\u340F\u3417\u0100ls\u33FD\u3404lsetm\xE9\u336Ahp;\u6A33parsl;\u69E4\u0100dl\u1463\u3414e;\u6323\u0100;e\u341C\u341D\u6AAA\u0100;s\u3422\u3423\u6AAC;\uC000\u2AAC\uFE00\u0180flp\u342E\u3433\u3442tcy;\u444C\u0100;b\u3438\u3439\u402F\u0100;a\u343E\u343F\u69C4r;\u633Ff;\uC000\u{1D564}a\u0100dr\u344D\u0402es\u0100;u\u3454\u3455\u6660it\xBB\u3455\u0180csu\u3460\u3479\u349F\u0100au\u3465\u346Fp\u0100;s\u1188\u346B;\uC000\u2293\uFE00p\u0100;s\u11B4\u3475;\uC000\u2294\uFE00u\u0100bp\u347F\u348F\u0180;es\u1197\u119C\u3486et\u0100;e\u1197\u348D\xF1\u119D\u0180;es\u11A8\u11AD\u3496et\u0100;e\u11A8\u349D\xF1\u11AE\u0180;af\u117B\u34A6\u05B0r\u0165\u34AB\u05B1\xBB\u117Car\xF2\u1148\u0200cemt\u34B9\u34BE\u34C2\u34C5r;\uC000\u{1D4C8}tm\xEE\xF1i\xEC\u3415ar\xE6\u11BE\u0100ar\u34CE\u34D5r\u0100;f\u34D4\u17BF\u6606\u0100an\u34DA\u34EDight\u0100ep\u34E3\u34EApsilo\xEE\u1EE0h\xE9\u2EAFs\xBB\u2852\u0280bcmnp\u34FB\u355E\u1209\u358B\u358E\u0480;Edemnprs\u350E\u350F\u3511\u3515\u351E\u3523\u352C\u3531\u3536\u6282;\u6AC5ot;\u6ABD\u0100;d\u11DA\u351Aot;\u6AC3ult;\u6AC1\u0100Ee\u3528\u352A;\u6ACB;\u628Alus;\u6ABFarr;\u6979\u0180eiu\u353D\u3552\u3555t\u0180;en\u350E\u3545\u354Bq\u0100;q\u11DA\u350Feq\u0100;q\u352B\u3528m;\u6AC7\u0100bp\u355A\u355C;\u6AD5;\u6AD3c\u0300;acens\u11ED\u356C\u3572\u3579\u357B\u3326ppro\xF8\u32FAurlye\xF1\u11FE\xF1\u11F3\u0180aes\u3582\u3588\u331Bppro\xF8\u331Aq\xF1\u3317g;\u666A\u0680123;Edehlmnps\u35A9\u35AC\u35AF\u121C\u35B2\u35B4\u35C0\u35C9\u35D5\u35DA\u35DF\u35E8\u35ED\u803B\xB9\u40B9\u803B\xB2\u40B2\u803B\xB3\u40B3;\u6AC6\u0100os\u35B9\u35BCt;\u6ABEub;\u6AD8\u0100;d\u1222\u35C5ot;\u6AC4s\u0100ou\u35CF\u35D2l;\u67C9b;\u6AD7arr;\u697Bult;\u6AC2\u0100Ee\u35E4\u35E6;\u6ACC;\u628Blus;\u6AC0\u0180eiu\u35F4\u3609\u360Ct\u0180;en\u121C\u35FC\u3602q\u0100;q\u1222\u35B2eq\u0100;q\u35E7\u35E4m;\u6AC8\u0100bp\u3611\u3613;\u6AD4;\u6AD6\u0180Aan\u361C\u3620\u362Drr;\u61D9r\u0100hr\u3626\u3628\xEB\u222E\u0100;o\u0A2B\u0A29war;\u692Alig\u803B\xDF\u40DF\u0BE1\u3651\u365D\u3660\u12CE\u3673\u3679\0\u367E\u36C2\0\0\0\0\0\u36DB\u3703\0\u3709\u376C\0\0\0\u3787\u0272\u3656\0\0\u365Bget;\u6316;\u43C4r\xEB\u0E5F\u0180aey\u3666\u366B\u3670ron;\u4165dil;\u4163;\u4442lrec;\u6315r;\uC000\u{1D531}\u0200eiko\u3686\u369D\u36B5\u36BC\u01F2\u368B\0\u3691e\u01004f\u1284\u1281a\u0180;sv\u3698\u3699\u369B\u43B8ym;\u43D1\u0100cn\u36A2\u36B2k\u0100as\u36A8\u36AEppro\xF8\u12C1im\xBB\u12ACs\xF0\u129E\u0100as\u36BA\u36AE\xF0\u12C1rn\u803B\xFE\u40FE\u01EC\u031F\u36C6\u22E7es\u8180\xD7;bd\u36CF\u36D0\u36D8\u40D7\u0100;a\u190F\u36D5r;\u6A31;\u6A30\u0180eps\u36E1\u36E3\u3700\xE1\u2A4D\u0200;bcf\u0486\u36EC\u36F0\u36F4ot;\u6336ir;\u6AF1\u0100;o\u36F9\u36FC\uC000\u{1D565}rk;\u6ADA\xE1\u3362rime;\u6034\u0180aip\u370F\u3712\u3764d\xE5\u1248\u0380adempst\u3721\u374D\u3740\u3751\u3757\u375C\u375Fngle\u0280;dlqr\u3730\u3731\u3736\u3740\u3742\u65B5own\xBB\u1DBBeft\u0100;e\u2800\u373E\xF1\u092E;\u625Cight\u0100;e\u32AA\u374B\xF1\u105Aot;\u65ECinus;\u6A3Alus;\u6A39b;\u69CDime;\u6A3Bezium;\u63E2\u0180cht\u3772\u377D\u3781\u0100ry\u3777\u377B;\uC000\u{1D4C9};\u4446cy;\u445Brok;\u4167\u0100io\u378B\u378Ex\xF4\u1777head\u0100lr\u3797\u37A0eftarro\xF7\u084Fightarrow\xBB\u0F5D\u0900AHabcdfghlmoprstuw\u37D0\u37D3\u37D7\u37E4\u37F0\u37FC\u380E\u381C\u3823\u3834\u3851\u385D\u386B\u38A9\u38CC\u38D2\u38EA\u38F6r\xF2\u03EDar;\u6963\u0100cr\u37DC\u37E2ute\u803B\xFA\u40FA\xF2\u1150r\u01E3\u37EA\0\u37EDy;\u445Eve;\u416D\u0100iy\u37F5\u37FArc\u803B\xFB\u40FB;\u4443\u0180abh\u3803\u3806\u380Br\xF2\u13ADlac;\u4171a\xF2\u13C3\u0100ir\u3813\u3818sht;\u697E;\uC000\u{1D532}rave\u803B\xF9\u40F9\u0161\u3827\u3831r\u0100lr\u382C\u382E\xBB\u0957\xBB\u1083lk;\u6580\u0100ct\u3839\u384D\u026F\u383F\0\0\u384Arn\u0100;e\u3845\u3846\u631Cr\xBB\u3846op;\u630Fri;\u65F8\u0100al\u3856\u385Acr;\u416B\u80BB\xA8\u0349\u0100gp\u3862\u3866on;\u4173f;\uC000\u{1D566}\u0300adhlsu\u114B\u3878\u387D\u1372\u3891\u38A0own\xE1\u13B3arpoon\u0100lr\u3888\u388Cef\xF4\u382Digh\xF4\u382Fi\u0180;hl\u3899\u389A\u389C\u43C5\xBB\u13FAon\xBB\u389Aparrows;\u61C8\u0180cit\u38B0\u38C4\u38C8\u026F\u38B6\0\0\u38C1rn\u0100;e\u38BC\u38BD\u631Dr\xBB\u38BDop;\u630Eng;\u416Fri;\u65F9cr;\uC000\u{1D4CA}\u0180dir\u38D9\u38DD\u38E2ot;\u62F0lde;\u4169i\u0100;f\u3730\u38E8\xBB\u1813\u0100am\u38EF\u38F2r\xF2\u38A8l\u803B\xFC\u40FCangle;\u69A7\u0780ABDacdeflnoprsz\u391C\u391F\u3929\u392D\u39B5\u39B8\u39BD\u39DF\u39E4\u39E8\u39F3\u39F9\u39FD\u3A01\u3A20r\xF2\u03F7ar\u0100;v\u3926\u3927\u6AE8;\u6AE9as\xE8\u03E1\u0100nr\u3932\u3937grt;\u699C\u0380eknprst\u34E3\u3946\u394B\u3952\u395D\u3964\u3996app\xE1\u2415othin\xE7\u1E96\u0180hir\u34EB\u2EC8\u3959op\xF4\u2FB5\u0100;h\u13B7\u3962\xEF\u318D\u0100iu\u3969\u396Dgm\xE1\u33B3\u0100bp\u3972\u3984setneq\u0100;q\u397D\u3980\uC000\u228A\uFE00;\uC000\u2ACB\uFE00setneq\u0100;q\u398F\u3992\uC000\u228B\uFE00;\uC000\u2ACC\uFE00\u0100hr\u399B\u399Fet\xE1\u369Ciangle\u0100lr\u39AA\u39AFeft\xBB\u0925ight\xBB\u1051y;\u4432ash\xBB\u1036\u0180elr\u39C4\u39D2\u39D7\u0180;be\u2DEA\u39CB\u39CFar;\u62BBq;\u625Alip;\u62EE\u0100bt\u39DC\u1468a\xF2\u1469r;\uC000\u{1D533}tr\xE9\u39AEsu\u0100bp\u39EF\u39F1\xBB\u0D1C\xBB\u0D59pf;\uC000\u{1D567}ro\xF0\u0EFBtr\xE9\u39B4\u0100cu\u3A06\u3A0Br;\uC000\u{1D4CB}\u0100bp\u3A10\u3A18n\u0100Ee\u3980\u3A16\xBB\u397En\u0100Ee\u3992\u3A1E\xBB\u3990igzag;\u699A\u0380cefoprs\u3A36\u3A3B\u3A56\u3A5B\u3A54\u3A61\u3A6Airc;\u4175\u0100di\u3A40\u3A51\u0100bg\u3A45\u3A49ar;\u6A5Fe\u0100;q\u15FA\u3A4F;\u6259erp;\u6118r;\uC000\u{1D534}pf;\uC000\u{1D568}\u0100;e\u1479\u3A66at\xE8\u1479cr;\uC000\u{1D4CC}\u0AE3\u178E\u3A87\0\u3A8B\0\u3A90\u3A9B\0\0\u3A9D\u3AA8\u3AAB\u3AAF\0\0\u3AC3\u3ACE\0\u3AD8\u17DC\u17DFtr\xE9\u17D1r;\uC000\u{1D535}\u0100Aa\u3A94\u3A97r\xF2\u03C3r\xF2\u09F6;\u43BE\u0100Aa\u3AA1\u3AA4r\xF2\u03B8r\xF2\u09EBa\xF0\u2713is;\u62FB\u0180dpt\u17A4\u3AB5\u3ABE\u0100fl\u3ABA\u17A9;\uC000\u{1D569}im\xE5\u17B2\u0100Aa\u3AC7\u3ACAr\xF2\u03CEr\xF2\u0A01\u0100cq\u3AD2\u17B8r;\uC000\u{1D4CD}\u0100pt\u17D6\u3ADCr\xE9\u17D4\u0400acefiosu\u3AF0\u3AFD\u3B08\u3B0C\u3B11\u3B15\u3B1B\u3B21c\u0100uy\u3AF6\u3AFBte\u803B\xFD\u40FD;\u444F\u0100iy\u3B02\u3B06rc;\u4177;\u444Bn\u803B\xA5\u40A5r;\uC000\u{1D536}cy;\u4457pf;\uC000\u{1D56A}cr;\uC000\u{1D4CE}\u0100cm\u3B26\u3B29y;\u444El\u803B\xFF\u40FF\u0500acdefhiosw\u3B42\u3B48\u3B54\u3B58\u3B64\u3B69\u3B6D\u3B74\u3B7A\u3B80cute;\u417A\u0100ay\u3B4D\u3B52ron;\u417E;\u4437ot;\u417C\u0100et\u3B5D\u3B61tr\xE6\u155Fa;\u43B6r;\uC000\u{1D537}cy;\u4436grarr;\u61DDpf;\uC000\u{1D56B}cr;\uC000\u{1D4CF}\u0100jn\u3B85\u3B87;\u600Dj;\u600C'.split("").map(function(c) {
        return c.charCodeAt(0);
      })
    );
  }
});

// node_modules/prosemirror-markdown/node_modules/entities/lib/generated/decode-data-xml.js
var require_decode_data_xml = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/entities/lib/generated/decode-data-xml.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = new Uint16Array(
      // prettier-ignore
      "\u0200aglq	\x1B\u026D\0\0p;\u4026os;\u4027t;\u403Et;\u403Cuot;\u4022".split("").map(function(c) {
        return c.charCodeAt(0);
      })
    );
  }
});

// node_modules/prosemirror-markdown/node_modules/entities/lib/decode_codepoint.js
var require_decode_codepoint = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/entities/lib/decode_codepoint.js"(exports2) {
    "use strict";
    var _a;
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.replaceCodePoint = exports2.fromCodePoint = void 0;
    var decodeMap = /* @__PURE__ */ new Map([
      [0, 65533],
      // C1 Unicode control character reference replacements
      [128, 8364],
      [130, 8218],
      [131, 402],
      [132, 8222],
      [133, 8230],
      [134, 8224],
      [135, 8225],
      [136, 710],
      [137, 8240],
      [138, 352],
      [139, 8249],
      [140, 338],
      [142, 381],
      [145, 8216],
      [146, 8217],
      [147, 8220],
      [148, 8221],
      [149, 8226],
      [150, 8211],
      [151, 8212],
      [152, 732],
      [153, 8482],
      [154, 353],
      [155, 8250],
      [156, 339],
      [158, 382],
      [159, 376]
    ]);
    exports2.fromCodePoint = // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins
    (_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function(codePoint) {
      var output = "";
      if (codePoint > 65535) {
        codePoint -= 65536;
        output += String.fromCharCode(codePoint >>> 10 & 1023 | 55296);
        codePoint = 56320 | codePoint & 1023;
      }
      output += String.fromCharCode(codePoint);
      return output;
    };
    function replaceCodePoint(codePoint) {
      var _a2;
      if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) {
        return 65533;
      }
      return (_a2 = decodeMap.get(codePoint)) !== null && _a2 !== void 0 ? _a2 : codePoint;
    }
    exports2.replaceCodePoint = replaceCodePoint;
    function decodeCodePoint(codePoint) {
      return (0, exports2.fromCodePoint)(replaceCodePoint(codePoint));
    }
    exports2.default = decodeCodePoint;
  }
});

// node_modules/prosemirror-markdown/node_modules/entities/lib/decode.js
var require_decode2 = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/entities/lib/decode.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    }) : (function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    }));
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.decodeXML = exports2.decodeHTMLStrict = exports2.decodeHTMLAttribute = exports2.decodeHTML = exports2.determineBranch = exports2.EntityDecoder = exports2.DecodingMode = exports2.BinTrieFlags = exports2.fromCodePoint = exports2.replaceCodePoint = exports2.decodeCodePoint = exports2.xmlDecodeTree = exports2.htmlDecodeTree = void 0;
    var decode_data_html_js_1 = __importDefault(require_decode_data_html());
    exports2.htmlDecodeTree = decode_data_html_js_1.default;
    var decode_data_xml_js_1 = __importDefault(require_decode_data_xml());
    exports2.xmlDecodeTree = decode_data_xml_js_1.default;
    var decode_codepoint_js_1 = __importStar(require_decode_codepoint());
    exports2.decodeCodePoint = decode_codepoint_js_1.default;
    var decode_codepoint_js_2 = require_decode_codepoint();
    Object.defineProperty(exports2, "replaceCodePoint", { enumerable: true, get: function() {
      return decode_codepoint_js_2.replaceCodePoint;
    } });
    Object.defineProperty(exports2, "fromCodePoint", { enumerable: true, get: function() {
      return decode_codepoint_js_2.fromCodePoint;
    } });
    var CharCodes;
    (function(CharCodes2) {
      CharCodes2[CharCodes2["NUM"] = 35] = "NUM";
      CharCodes2[CharCodes2["SEMI"] = 59] = "SEMI";
      CharCodes2[CharCodes2["EQUALS"] = 61] = "EQUALS";
      CharCodes2[CharCodes2["ZERO"] = 48] = "ZERO";
      CharCodes2[CharCodes2["NINE"] = 57] = "NINE";
      CharCodes2[CharCodes2["LOWER_A"] = 97] = "LOWER_A";
      CharCodes2[CharCodes2["LOWER_F"] = 102] = "LOWER_F";
      CharCodes2[CharCodes2["LOWER_X"] = 120] = "LOWER_X";
      CharCodes2[CharCodes2["LOWER_Z"] = 122] = "LOWER_Z";
      CharCodes2[CharCodes2["UPPER_A"] = 65] = "UPPER_A";
      CharCodes2[CharCodes2["UPPER_F"] = 70] = "UPPER_F";
      CharCodes2[CharCodes2["UPPER_Z"] = 90] = "UPPER_Z";
    })(CharCodes || (CharCodes = {}));
    var TO_LOWER_BIT = 32;
    var BinTrieFlags;
    (function(BinTrieFlags2) {
      BinTrieFlags2[BinTrieFlags2["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
      BinTrieFlags2[BinTrieFlags2["BRANCH_LENGTH"] = 16256] = "BRANCH_LENGTH";
      BinTrieFlags2[BinTrieFlags2["JUMP_TABLE"] = 127] = "JUMP_TABLE";
    })(BinTrieFlags = exports2.BinTrieFlags || (exports2.BinTrieFlags = {}));
    function isNumber(code) {
      return code >= CharCodes.ZERO && code <= CharCodes.NINE;
    }
    function isHexadecimalCharacter(code) {
      return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F;
    }
    function isAsciiAlphaNumeric(code) {
      return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z || isNumber(code);
    }
    function isEntityInAttributeInvalidEnd(code) {
      return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);
    }
    var EntityDecoderState;
    (function(EntityDecoderState2) {
      EntityDecoderState2[EntityDecoderState2["EntityStart"] = 0] = "EntityStart";
      EntityDecoderState2[EntityDecoderState2["NumericStart"] = 1] = "NumericStart";
      EntityDecoderState2[EntityDecoderState2["NumericDecimal"] = 2] = "NumericDecimal";
      EntityDecoderState2[EntityDecoderState2["NumericHex"] = 3] = "NumericHex";
      EntityDecoderState2[EntityDecoderState2["NamedEntity"] = 4] = "NamedEntity";
    })(EntityDecoderState || (EntityDecoderState = {}));
    var DecodingMode;
    (function(DecodingMode2) {
      DecodingMode2[DecodingMode2["Legacy"] = 0] = "Legacy";
      DecodingMode2[DecodingMode2["Strict"] = 1] = "Strict";
      DecodingMode2[DecodingMode2["Attribute"] = 2] = "Attribute";
    })(DecodingMode = exports2.DecodingMode || (exports2.DecodingMode = {}));
    var EntityDecoder = (
      /** @class */
      (function() {
        function EntityDecoder2(decodeTree, emitCodePoint, errors) {
          this.decodeTree = decodeTree;
          this.emitCodePoint = emitCodePoint;
          this.errors = errors;
          this.state = EntityDecoderState.EntityStart;
          this.consumed = 1;
          this.result = 0;
          this.treeIndex = 0;
          this.excess = 1;
          this.decodeMode = DecodingMode.Strict;
        }
        EntityDecoder2.prototype.startEntity = function(decodeMode) {
          this.decodeMode = decodeMode;
          this.state = EntityDecoderState.EntityStart;
          this.result = 0;
          this.treeIndex = 0;
          this.excess = 1;
          this.consumed = 1;
        };
        EntityDecoder2.prototype.write = function(str, offset) {
          switch (this.state) {
            case EntityDecoderState.EntityStart: {
              if (str.charCodeAt(offset) === CharCodes.NUM) {
                this.state = EntityDecoderState.NumericStart;
                this.consumed += 1;
                return this.stateNumericStart(str, offset + 1);
              }
              this.state = EntityDecoderState.NamedEntity;
              return this.stateNamedEntity(str, offset);
            }
            case EntityDecoderState.NumericStart: {
              return this.stateNumericStart(str, offset);
            }
            case EntityDecoderState.NumericDecimal: {
              return this.stateNumericDecimal(str, offset);
            }
            case EntityDecoderState.NumericHex: {
              return this.stateNumericHex(str, offset);
            }
            case EntityDecoderState.NamedEntity: {
              return this.stateNamedEntity(str, offset);
            }
          }
        };
        EntityDecoder2.prototype.stateNumericStart = function(str, offset) {
          if (offset >= str.length) {
            return -1;
          }
          if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
            this.state = EntityDecoderState.NumericHex;
            this.consumed += 1;
            return this.stateNumericHex(str, offset + 1);
          }
          this.state = EntityDecoderState.NumericDecimal;
          return this.stateNumericDecimal(str, offset);
        };
        EntityDecoder2.prototype.addToNumericResult = function(str, start, end, base) {
          if (start !== end) {
            var digitCount = end - start;
            this.result = this.result * Math.pow(base, digitCount) + parseInt(str.substr(start, digitCount), base);
            this.consumed += digitCount;
          }
        };
        EntityDecoder2.prototype.stateNumericHex = function(str, offset) {
          var startIdx = offset;
          while (offset < str.length) {
            var char = str.charCodeAt(offset);
            if (isNumber(char) || isHexadecimalCharacter(char)) {
              offset += 1;
            } else {
              this.addToNumericResult(str, startIdx, offset, 16);
              return this.emitNumericEntity(char, 3);
            }
          }
          this.addToNumericResult(str, startIdx, offset, 16);
          return -1;
        };
        EntityDecoder2.prototype.stateNumericDecimal = function(str, offset) {
          var startIdx = offset;
          while (offset < str.length) {
            var char = str.charCodeAt(offset);
            if (isNumber(char)) {
              offset += 1;
            } else {
              this.addToNumericResult(str, startIdx, offset, 10);
              return this.emitNumericEntity(char, 2);
            }
          }
          this.addToNumericResult(str, startIdx, offset, 10);
          return -1;
        };
        EntityDecoder2.prototype.emitNumericEntity = function(lastCp, expectedLength) {
          var _a;
          if (this.consumed <= expectedLength) {
            (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
            return 0;
          }
          if (lastCp === CharCodes.SEMI) {
            this.consumed += 1;
          } else if (this.decodeMode === DecodingMode.Strict) {
            return 0;
          }
          this.emitCodePoint((0, decode_codepoint_js_1.replaceCodePoint)(this.result), this.consumed);
          if (this.errors) {
            if (lastCp !== CharCodes.SEMI) {
              this.errors.missingSemicolonAfterCharacterReference();
            }
            this.errors.validateNumericCharacterReference(this.result);
          }
          return this.consumed;
        };
        EntityDecoder2.prototype.stateNamedEntity = function(str, offset) {
          var decodeTree = this.decodeTree;
          var current = decodeTree[this.treeIndex];
          var valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
          for (; offset < str.length; offset++, this.excess++) {
            var char = str.charCodeAt(offset);
            this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
            if (this.treeIndex < 0) {
              return this.result === 0 || // If we are parsing an attribute
              this.decodeMode === DecodingMode.Attribute && // We shouldn't have consumed any characters after the entity,
              (valueLength === 0 || // And there should be no invalid characters.
              isEntityInAttributeInvalidEnd(char)) ? 0 : this.emitNotTerminatedNamedEntity();
            }
            current = decodeTree[this.treeIndex];
            valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
            if (valueLength !== 0) {
              if (char === CharCodes.SEMI) {
                return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
              }
              if (this.decodeMode !== DecodingMode.Strict) {
                this.result = this.treeIndex;
                this.consumed += this.excess;
                this.excess = 0;
              }
            }
          }
          return -1;
        };
        EntityDecoder2.prototype.emitNotTerminatedNamedEntity = function() {
          var _a;
          var _b = this, result = _b.result, decodeTree = _b.decodeTree;
          var valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;
          this.emitNamedEntityData(result, valueLength, this.consumed);
          (_a = this.errors) === null || _a === void 0 ? void 0 : _a.missingSemicolonAfterCharacterReference();
          return this.consumed;
        };
        EntityDecoder2.prototype.emitNamedEntityData = function(result, valueLength, consumed) {
          var decodeTree = this.decodeTree;
          this.emitCodePoint(valueLength === 1 ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH : decodeTree[result + 1], consumed);
          if (valueLength === 3) {
            this.emitCodePoint(decodeTree[result + 2], consumed);
          }
          return consumed;
        };
        EntityDecoder2.prototype.end = function() {
          var _a;
          switch (this.state) {
            case EntityDecoderState.NamedEntity: {
              return this.result !== 0 && (this.decodeMode !== DecodingMode.Attribute || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;
            }
            // Otherwise, emit a numeric entity if we have one.
            case EntityDecoderState.NumericDecimal: {
              return this.emitNumericEntity(0, 2);
            }
            case EntityDecoderState.NumericHex: {
              return this.emitNumericEntity(0, 3);
            }
            case EntityDecoderState.NumericStart: {
              (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
              return 0;
            }
            case EntityDecoderState.EntityStart: {
              return 0;
            }
          }
        };
        return EntityDecoder2;
      })()
    );
    exports2.EntityDecoder = EntityDecoder;
    function getDecoder(decodeTree) {
      var ret = "";
      var decoder = new EntityDecoder(decodeTree, function(str) {
        return ret += (0, decode_codepoint_js_1.fromCodePoint)(str);
      });
      return function decodeWithTrie(str, decodeMode) {
        var lastIndex = 0;
        var offset = 0;
        while ((offset = str.indexOf("&", offset)) >= 0) {
          ret += str.slice(lastIndex, offset);
          decoder.startEntity(decodeMode);
          var len = decoder.write(
            str,
            // Skip the "&"
            offset + 1
          );
          if (len < 0) {
            lastIndex = offset + decoder.end();
            break;
          }
          lastIndex = offset + len;
          offset = len === 0 ? lastIndex + 1 : lastIndex;
        }
        var result = ret + str.slice(lastIndex);
        ret = "";
        return result;
      };
    }
    function determineBranch(decodeTree, current, nodeIdx, char) {
      var branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
      var jumpOffset = current & BinTrieFlags.JUMP_TABLE;
      if (branchCount === 0) {
        return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1;
      }
      if (jumpOffset) {
        var value = char - jumpOffset;
        return value < 0 || value >= branchCount ? -1 : decodeTree[nodeIdx + value] - 1;
      }
      var lo = nodeIdx;
      var hi = lo + branchCount - 1;
      while (lo <= hi) {
        var mid = lo + hi >>> 1;
        var midVal = decodeTree[mid];
        if (midVal < char) {
          lo = mid + 1;
        } else if (midVal > char) {
          hi = mid - 1;
        } else {
          return decodeTree[mid + branchCount];
        }
      }
      return -1;
    }
    exports2.determineBranch = determineBranch;
    var htmlDecoder = getDecoder(decode_data_html_js_1.default);
    var xmlDecoder = getDecoder(decode_data_xml_js_1.default);
    function decodeHTML(str, mode) {
      if (mode === void 0) {
        mode = DecodingMode.Legacy;
      }
      return htmlDecoder(str, mode);
    }
    exports2.decodeHTML = decodeHTML;
    function decodeHTMLAttribute(str) {
      return htmlDecoder(str, DecodingMode.Attribute);
    }
    exports2.decodeHTMLAttribute = decodeHTMLAttribute;
    function decodeHTMLStrict(str) {
      return htmlDecoder(str, DecodingMode.Strict);
    }
    exports2.decodeHTMLStrict = decodeHTMLStrict;
    function decodeXML(str) {
      return xmlDecoder(str, DecodingMode.Strict);
    }
    exports2.decodeXML = decodeXML;
  }
});

// node_modules/prosemirror-markdown/node_modules/entities/lib/generated/encode-html.js
var require_encode_html = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/entities/lib/generated/encode-html.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    function restoreDiff(arr) {
      for (var i = 1; i < arr.length; i++) {
        arr[i][0] += arr[i - 1][0] + 1;
      }
      return arr;
    }
    exports2.default = new Map(/* @__PURE__ */ restoreDiff([[9, "&Tab;"], [0, "&NewLine;"], [22, "&excl;"], [0, "&quot;"], [0, "&num;"], [0, "&dollar;"], [0, "&percnt;"], [0, "&amp;"], [0, "&apos;"], [0, "&lpar;"], [0, "&rpar;"], [0, "&ast;"], [0, "&plus;"], [0, "&comma;"], [1, "&period;"], [0, "&sol;"], [10, "&colon;"], [0, "&semi;"], [0, { v: "&lt;", n: 8402, o: "&nvlt;" }], [0, { v: "&equals;", n: 8421, o: "&bne;" }], [0, { v: "&gt;", n: 8402, o: "&nvgt;" }], [0, "&quest;"], [0, "&commat;"], [26, "&lbrack;"], [0, "&bsol;"], [0, "&rbrack;"], [0, "&Hat;"], [0, "&lowbar;"], [0, "&DiacriticalGrave;"], [5, { n: 106, o: "&fjlig;" }], [20, "&lbrace;"], [0, "&verbar;"], [0, "&rbrace;"], [34, "&nbsp;"], [0, "&iexcl;"], [0, "&cent;"], [0, "&pound;"], [0, "&curren;"], [0, "&yen;"], [0, "&brvbar;"], [0, "&sect;"], [0, "&die;"], [0, "&copy;"], [0, "&ordf;"], [0, "&laquo;"], [0, "&not;"], [0, "&shy;"], [0, "&circledR;"], [0, "&macr;"], [0, "&deg;"], [0, "&PlusMinus;"], [0, "&sup2;"], [0, "&sup3;"], [0, "&acute;"], [0, "&micro;"], [0, "&para;"], [0, "&centerdot;"], [0, "&cedil;"], [0, "&sup1;"], [0, "&ordm;"], [0, "&raquo;"], [0, "&frac14;"], [0, "&frac12;"], [0, "&frac34;"], [0, "&iquest;"], [0, "&Agrave;"], [0, "&Aacute;"], [0, "&Acirc;"], [0, "&Atilde;"], [0, "&Auml;"], [0, "&angst;"], [0, "&AElig;"], [0, "&Ccedil;"], [0, "&Egrave;"], [0, "&Eacute;"], [0, "&Ecirc;"], [0, "&Euml;"], [0, "&Igrave;"], [0, "&Iacute;"], [0, "&Icirc;"], [0, "&Iuml;"], [0, "&ETH;"], [0, "&Ntilde;"], [0, "&Ograve;"], [0, "&Oacute;"], [0, "&Ocirc;"], [0, "&Otilde;"], [0, "&Ouml;"], [0, "&times;"], [0, "&Oslash;"], [0, "&Ugrave;"], [0, "&Uacute;"], [0, "&Ucirc;"], [0, "&Uuml;"], [0, "&Yacute;"], [0, "&THORN;"], [0, "&szlig;"], [0, "&agrave;"], [0, "&aacute;"], [0, "&acirc;"], [0, "&atilde;"], [0, "&auml;"], [0, "&aring;"], [0, "&aelig;"], [0, "&ccedil;"], [0, "&egrave;"], [0, "&eacute;"], [0, "&ecirc;"], [0, "&euml;"], [0, "&igrave;"], [0, "&iacute;"], [0, "&icirc;"], [0, "&iuml;"], [0, "&eth;"], [0, "&ntilde;"], [0, "&ograve;"], [0, "&oacute;"], [0, "&ocirc;"], [0, "&otilde;"], [0, "&ouml;"], [0, "&div;"], [0, "&oslash;"], [0, "&ugrave;"], [0, "&uacute;"], [0, "&ucirc;"], [0, "&uuml;"], [0, "&yacute;"], [0, "&thorn;"], [0, "&yuml;"], [0, "&Amacr;"], [0, "&amacr;"], [0, "&Abreve;"], [0, "&abreve;"], [0, "&Aogon;"], [0, "&aogon;"], [0, "&Cacute;"], [0, "&cacute;"], [0, "&Ccirc;"], [0, "&ccirc;"], [0, "&Cdot;"], [0, "&cdot;"], [0, "&Ccaron;"], [0, "&ccaron;"], [0, "&Dcaron;"], [0, "&dcaron;"], [0, "&Dstrok;"], [0, "&dstrok;"], [0, "&Emacr;"], [0, "&emacr;"], [2, "&Edot;"], [0, "&edot;"], [0, "&Eogon;"], [0, "&eogon;"], [0, "&Ecaron;"], [0, "&ecaron;"], [0, "&Gcirc;"], [0, "&gcirc;"], [0, "&Gbreve;"], [0, "&gbreve;"], [0, "&Gdot;"], [0, "&gdot;"], [0, "&Gcedil;"], [1, "&Hcirc;"], [0, "&hcirc;"], [0, "&Hstrok;"], [0, "&hstrok;"], [0, "&Itilde;"], [0, "&itilde;"], [0, "&Imacr;"], [0, "&imacr;"], [2, "&Iogon;"], [0, "&iogon;"], [0, "&Idot;"], [0, "&imath;"], [0, "&IJlig;"], [0, "&ijlig;"], [0, "&Jcirc;"], [0, "&jcirc;"], [0, "&Kcedil;"], [0, "&kcedil;"], [0, "&kgreen;"], [0, "&Lacute;"], [0, "&lacute;"], [0, "&Lcedil;"], [0, "&lcedil;"], [0, "&Lcaron;"], [0, "&lcaron;"], [0, "&Lmidot;"], [0, "&lmidot;"], [0, "&Lstrok;"], [0, "&lstrok;"], [0, "&Nacute;"], [0, "&nacute;"], [0, "&Ncedil;"], [0, "&ncedil;"], [0, "&Ncaron;"], [0, "&ncaron;"], [0, "&napos;"], [0, "&ENG;"], [0, "&eng;"], [0, "&Omacr;"], [0, "&omacr;"], [2, "&Odblac;"], [0, "&odblac;"], [0, "&OElig;"], [0, "&oelig;"], [0, "&Racute;"], [0, "&racute;"], [0, "&Rcedil;"], [0, "&rcedil;"], [0, "&Rcaron;"], [0, "&rcaron;"], [0, "&Sacute;"], [0, "&sacute;"], [0, "&Scirc;"], [0, "&scirc;"], [0, "&Scedil;"], [0, "&scedil;"], [0, "&Scaron;"], [0, "&scaron;"], [0, "&Tcedil;"], [0, "&tcedil;"], [0, "&Tcaron;"], [0, "&tcaron;"], [0, "&Tstrok;"], [0, "&tstrok;"], [0, "&Utilde;"], [0, "&utilde;"], [0, "&Umacr;"], [0, "&umacr;"], [0, "&Ubreve;"], [0, "&ubreve;"], [0, "&Uring;"], [0, "&uring;"], [0, "&Udblac;"], [0, "&udblac;"], [0, "&Uogon;"], [0, "&uogon;"], [0, "&Wcirc;"], [0, "&wcirc;"], [0, "&Ycirc;"], [0, "&ycirc;"], [0, "&Yuml;"], [0, "&Zacute;"], [0, "&zacute;"], [0, "&Zdot;"], [0, "&zdot;"], [0, "&Zcaron;"], [0, "&zcaron;"], [19, "&fnof;"], [34, "&imped;"], [63, "&gacute;"], [65, "&jmath;"], [142, "&circ;"], [0, "&caron;"], [16, "&breve;"], [0, "&DiacriticalDot;"], [0, "&ring;"], [0, "&ogon;"], [0, "&DiacriticalTilde;"], [0, "&dblac;"], [51, "&DownBreve;"], [127, "&Alpha;"], [0, "&Beta;"], [0, "&Gamma;"], [0, "&Delta;"], [0, "&Epsilon;"], [0, "&Zeta;"], [0, "&Eta;"], [0, "&Theta;"], [0, "&Iota;"], [0, "&Kappa;"], [0, "&Lambda;"], [0, "&Mu;"], [0, "&Nu;"], [0, "&Xi;"], [0, "&Omicron;"], [0, "&Pi;"], [0, "&Rho;"], [1, "&Sigma;"], [0, "&Tau;"], [0, "&Upsilon;"], [0, "&Phi;"], [0, "&Chi;"], [0, "&Psi;"], [0, "&ohm;"], [7, "&alpha;"], [0, "&beta;"], [0, "&gamma;"], [0, "&delta;"], [0, "&epsi;"], [0, "&zeta;"], [0, "&eta;"], [0, "&theta;"], [0, "&iota;"], [0, "&kappa;"], [0, "&lambda;"], [0, "&mu;"], [0, "&nu;"], [0, "&xi;"], [0, "&omicron;"], [0, "&pi;"], [0, "&rho;"], [0, "&sigmaf;"], [0, "&sigma;"], [0, "&tau;"], [0, "&upsi;"], [0, "&phi;"], [0, "&chi;"], [0, "&psi;"], [0, "&omega;"], [7, "&thetasym;"], [0, "&Upsi;"], [2, "&phiv;"], [0, "&piv;"], [5, "&Gammad;"], [0, "&digamma;"], [18, "&kappav;"], [0, "&rhov;"], [3, "&epsiv;"], [0, "&backepsilon;"], [10, "&IOcy;"], [0, "&DJcy;"], [0, "&GJcy;"], [0, "&Jukcy;"], [0, "&DScy;"], [0, "&Iukcy;"], [0, "&YIcy;"], [0, "&Jsercy;"], [0, "&LJcy;"], [0, "&NJcy;"], [0, "&TSHcy;"], [0, "&KJcy;"], [1, "&Ubrcy;"], [0, "&DZcy;"], [0, "&Acy;"], [0, "&Bcy;"], [0, "&Vcy;"], [0, "&Gcy;"], [0, "&Dcy;"], [0, "&IEcy;"], [0, "&ZHcy;"], [0, "&Zcy;"], [0, "&Icy;"], [0, "&Jcy;"], [0, "&Kcy;"], [0, "&Lcy;"], [0, "&Mcy;"], [0, "&Ncy;"], [0, "&Ocy;"], [0, "&Pcy;"], [0, "&Rcy;"], [0, "&Scy;"], [0, "&Tcy;"], [0, "&Ucy;"], [0, "&Fcy;"], [0, "&KHcy;"], [0, "&TScy;"], [0, "&CHcy;"], [0, "&SHcy;"], [0, "&SHCHcy;"], [0, "&HARDcy;"], [0, "&Ycy;"], [0, "&SOFTcy;"], [0, "&Ecy;"], [0, "&YUcy;"], [0, "&YAcy;"], [0, "&acy;"], [0, "&bcy;"], [0, "&vcy;"], [0, "&gcy;"], [0, "&dcy;"], [0, "&iecy;"], [0, "&zhcy;"], [0, "&zcy;"], [0, "&icy;"], [0, "&jcy;"], [0, "&kcy;"], [0, "&lcy;"], [0, "&mcy;"], [0, "&ncy;"], [0, "&ocy;"], [0, "&pcy;"], [0, "&rcy;"], [0, "&scy;"], [0, "&tcy;"], [0, "&ucy;"], [0, "&fcy;"], [0, "&khcy;"], [0, "&tscy;"], [0, "&chcy;"], [0, "&shcy;"], [0, "&shchcy;"], [0, "&hardcy;"], [0, "&ycy;"], [0, "&softcy;"], [0, "&ecy;"], [0, "&yucy;"], [0, "&yacy;"], [1, "&iocy;"], [0, "&djcy;"], [0, "&gjcy;"], [0, "&jukcy;"], [0, "&dscy;"], [0, "&iukcy;"], [0, "&yicy;"], [0, "&jsercy;"], [0, "&ljcy;"], [0, "&njcy;"], [0, "&tshcy;"], [0, "&kjcy;"], [1, "&ubrcy;"], [0, "&dzcy;"], [7074, "&ensp;"], [0, "&emsp;"], [0, "&emsp13;"], [0, "&emsp14;"], [1, "&numsp;"], [0, "&puncsp;"], [0, "&ThinSpace;"], [0, "&hairsp;"], [0, "&NegativeMediumSpace;"], [0, "&zwnj;"], [0, "&zwj;"], [0, "&lrm;"], [0, "&rlm;"], [0, "&dash;"], [2, "&ndash;"], [0, "&mdash;"], [0, "&horbar;"], [0, "&Verbar;"], [1, "&lsquo;"], [0, "&CloseCurlyQuote;"], [0, "&lsquor;"], [1, "&ldquo;"], [0, "&CloseCurlyDoubleQuote;"], [0, "&bdquo;"], [1, "&dagger;"], [0, "&Dagger;"], [0, "&bull;"], [2, "&nldr;"], [0, "&hellip;"], [9, "&permil;"], [0, "&pertenk;"], [0, "&prime;"], [0, "&Prime;"], [0, "&tprime;"], [0, "&backprime;"], [3, "&lsaquo;"], [0, "&rsaquo;"], [3, "&oline;"], [2, "&caret;"], [1, "&hybull;"], [0, "&frasl;"], [10, "&bsemi;"], [7, "&qprime;"], [7, { v: "&MediumSpace;", n: 8202, o: "&ThickSpace;" }], [0, "&NoBreak;"], [0, "&af;"], [0, "&InvisibleTimes;"], [0, "&ic;"], [72, "&euro;"], [46, "&tdot;"], [0, "&DotDot;"], [37, "&complexes;"], [2, "&incare;"], [4, "&gscr;"], [0, "&hamilt;"], [0, "&Hfr;"], [0, "&Hopf;"], [0, "&planckh;"], [0, "&hbar;"], [0, "&imagline;"], [0, "&Ifr;"], [0, "&lagran;"], [0, "&ell;"], [1, "&naturals;"], [0, "&numero;"], [0, "&copysr;"], [0, "&weierp;"], [0, "&Popf;"], [0, "&Qopf;"], [0, "&realine;"], [0, "&real;"], [0, "&reals;"], [0, "&rx;"], [3, "&trade;"], [1, "&integers;"], [2, "&mho;"], [0, "&zeetrf;"], [0, "&iiota;"], [2, "&bernou;"], [0, "&Cayleys;"], [1, "&escr;"], [0, "&Escr;"], [0, "&Fouriertrf;"], [1, "&Mellintrf;"], [0, "&order;"], [0, "&alefsym;"], [0, "&beth;"], [0, "&gimel;"], [0, "&daleth;"], [12, "&CapitalDifferentialD;"], [0, "&dd;"], [0, "&ee;"], [0, "&ii;"], [10, "&frac13;"], [0, "&frac23;"], [0, "&frac15;"], [0, "&frac25;"], [0, "&frac35;"], [0, "&frac45;"], [0, "&frac16;"], [0, "&frac56;"], [0, "&frac18;"], [0, "&frac38;"], [0, "&frac58;"], [0, "&frac78;"], [49, "&larr;"], [0, "&ShortUpArrow;"], [0, "&rarr;"], [0, "&darr;"], [0, "&harr;"], [0, "&updownarrow;"], [0, "&nwarr;"], [0, "&nearr;"], [0, "&LowerRightArrow;"], [0, "&LowerLeftArrow;"], [0, "&nlarr;"], [0, "&nrarr;"], [1, { v: "&rarrw;", n: 824, o: "&nrarrw;" }], [0, "&Larr;"], [0, "&Uarr;"], [0, "&Rarr;"], [0, "&Darr;"], [0, "&larrtl;"], [0, "&rarrtl;"], [0, "&LeftTeeArrow;"], [0, "&mapstoup;"], [0, "&map;"], [0, "&DownTeeArrow;"], [1, "&hookleftarrow;"], [0, "&hookrightarrow;"], [0, "&larrlp;"], [0, "&looparrowright;"], [0, "&harrw;"], [0, "&nharr;"], [1, "&lsh;"], [0, "&rsh;"], [0, "&ldsh;"], [0, "&rdsh;"], [1, "&crarr;"], [0, "&cularr;"], [0, "&curarr;"], [2, "&circlearrowleft;"], [0, "&circlearrowright;"], [0, "&leftharpoonup;"], [0, "&DownLeftVector;"], [0, "&RightUpVector;"], [0, "&LeftUpVector;"], [0, "&rharu;"], [0, "&DownRightVector;"], [0, "&dharr;"], [0, "&dharl;"], [0, "&RightArrowLeftArrow;"], [0, "&udarr;"], [0, "&LeftArrowRightArrow;"], [0, "&leftleftarrows;"], [0, "&upuparrows;"], [0, "&rightrightarrows;"], [0, "&ddarr;"], [0, "&leftrightharpoons;"], [0, "&Equilibrium;"], [0, "&nlArr;"], [0, "&nhArr;"], [0, "&nrArr;"], [0, "&DoubleLeftArrow;"], [0, "&DoubleUpArrow;"], [0, "&DoubleRightArrow;"], [0, "&dArr;"], [0, "&DoubleLeftRightArrow;"], [0, "&DoubleUpDownArrow;"], [0, "&nwArr;"], [0, "&neArr;"], [0, "&seArr;"], [0, "&swArr;"], [0, "&lAarr;"], [0, "&rAarr;"], [1, "&zigrarr;"], [6, "&larrb;"], [0, "&rarrb;"], [15, "&DownArrowUpArrow;"], [7, "&loarr;"], [0, "&roarr;"], [0, "&hoarr;"], [0, "&forall;"], [0, "&comp;"], [0, { v: "&part;", n: 824, o: "&npart;" }], [0, "&exist;"], [0, "&nexist;"], [0, "&empty;"], [1, "&Del;"], [0, "&Element;"], [0, "&NotElement;"], [1, "&ni;"], [0, "&notni;"], [2, "&prod;"], [0, "&coprod;"], [0, "&sum;"], [0, "&minus;"], [0, "&MinusPlus;"], [0, "&dotplus;"], [1, "&Backslash;"], [0, "&lowast;"], [0, "&compfn;"], [1, "&radic;"], [2, "&prop;"], [0, "&infin;"], [0, "&angrt;"], [0, { v: "&ang;", n: 8402, o: "&nang;" }], [0, "&angmsd;"], [0, "&angsph;"], [0, "&mid;"], [0, "&nmid;"], [0, "&DoubleVerticalBar;"], [0, "&NotDoubleVerticalBar;"], [0, "&and;"], [0, "&or;"], [0, { v: "&cap;", n: 65024, o: "&caps;" }], [0, { v: "&cup;", n: 65024, o: "&cups;" }], [0, "&int;"], [0, "&Int;"], [0, "&iiint;"], [0, "&conint;"], [0, "&Conint;"], [0, "&Cconint;"], [0, "&cwint;"], [0, "&ClockwiseContourIntegral;"], [0, "&awconint;"], [0, "&there4;"], [0, "&becaus;"], [0, "&ratio;"], [0, "&Colon;"], [0, "&dotminus;"], [1, "&mDDot;"], [0, "&homtht;"], [0, { v: "&sim;", n: 8402, o: "&nvsim;" }], [0, { v: "&backsim;", n: 817, o: "&race;" }], [0, { v: "&ac;", n: 819, o: "&acE;" }], [0, "&acd;"], [0, "&VerticalTilde;"], [0, "&NotTilde;"], [0, { v: "&eqsim;", n: 824, o: "&nesim;" }], [0, "&sime;"], [0, "&NotTildeEqual;"], [0, "&cong;"], [0, "&simne;"], [0, "&ncong;"], [0, "&ap;"], [0, "&nap;"], [0, "&ape;"], [0, { v: "&apid;", n: 824, o: "&napid;" }], [0, "&backcong;"], [0, { v: "&asympeq;", n: 8402, o: "&nvap;" }], [0, { v: "&bump;", n: 824, o: "&nbump;" }], [0, { v: "&bumpe;", n: 824, o: "&nbumpe;" }], [0, { v: "&doteq;", n: 824, o: "&nedot;" }], [0, "&doteqdot;"], [0, "&efDot;"], [0, "&erDot;"], [0, "&Assign;"], [0, "&ecolon;"], [0, "&ecir;"], [0, "&circeq;"], [1, "&wedgeq;"], [0, "&veeeq;"], [1, "&triangleq;"], [2, "&equest;"], [0, "&ne;"], [0, { v: "&Congruent;", n: 8421, o: "&bnequiv;" }], [0, "&nequiv;"], [1, { v: "&le;", n: 8402, o: "&nvle;" }], [0, { v: "&ge;", n: 8402, o: "&nvge;" }], [0, { v: "&lE;", n: 824, o: "&nlE;" }], [0, { v: "&gE;", n: 824, o: "&ngE;" }], [0, { v: "&lnE;", n: 65024, o: "&lvertneqq;" }], [0, { v: "&gnE;", n: 65024, o: "&gvertneqq;" }], [0, { v: "&ll;", n: new Map(/* @__PURE__ */ restoreDiff([[824, "&nLtv;"], [7577, "&nLt;"]])) }], [0, { v: "&gg;", n: new Map(/* @__PURE__ */ restoreDiff([[824, "&nGtv;"], [7577, "&nGt;"]])) }], [0, "&between;"], [0, "&NotCupCap;"], [0, "&nless;"], [0, "&ngt;"], [0, "&nle;"], [0, "&nge;"], [0, "&lesssim;"], [0, "&GreaterTilde;"], [0, "&nlsim;"], [0, "&ngsim;"], [0, "&LessGreater;"], [0, "&gl;"], [0, "&NotLessGreater;"], [0, "&NotGreaterLess;"], [0, "&pr;"], [0, "&sc;"], [0, "&prcue;"], [0, "&sccue;"], [0, "&PrecedesTilde;"], [0, { v: "&scsim;", n: 824, o: "&NotSucceedsTilde;" }], [0, "&NotPrecedes;"], [0, "&NotSucceeds;"], [0, { v: "&sub;", n: 8402, o: "&NotSubset;" }], [0, { v: "&sup;", n: 8402, o: "&NotSuperset;" }], [0, "&nsub;"], [0, "&nsup;"], [0, "&sube;"], [0, "&supe;"], [0, "&NotSubsetEqual;"], [0, "&NotSupersetEqual;"], [0, { v: "&subne;", n: 65024, o: "&varsubsetneq;" }], [0, { v: "&supne;", n: 65024, o: "&varsupsetneq;" }], [1, "&cupdot;"], [0, "&UnionPlus;"], [0, { v: "&sqsub;", n: 824, o: "&NotSquareSubset;" }], [0, { v: "&sqsup;", n: 824, o: "&NotSquareSuperset;" }], [0, "&sqsube;"], [0, "&sqsupe;"], [0, { v: "&sqcap;", n: 65024, o: "&sqcaps;" }], [0, { v: "&sqcup;", n: 65024, o: "&sqcups;" }], [0, "&CirclePlus;"], [0, "&CircleMinus;"], [0, "&CircleTimes;"], [0, "&osol;"], [0, "&CircleDot;"], [0, "&circledcirc;"], [0, "&circledast;"], [1, "&circleddash;"], [0, "&boxplus;"], [0, "&boxminus;"], [0, "&boxtimes;"], [0, "&dotsquare;"], [0, "&RightTee;"], [0, "&dashv;"], [0, "&DownTee;"], [0, "&bot;"], [1, "&models;"], [0, "&DoubleRightTee;"], [0, "&Vdash;"], [0, "&Vvdash;"], [0, "&VDash;"], [0, "&nvdash;"], [0, "&nvDash;"], [0, "&nVdash;"], [0, "&nVDash;"], [0, "&prurel;"], [1, "&LeftTriangle;"], [0, "&RightTriangle;"], [0, { v: "&LeftTriangleEqual;", n: 8402, o: "&nvltrie;" }], [0, { v: "&RightTriangleEqual;", n: 8402, o: "&nvrtrie;" }], [0, "&origof;"], [0, "&imof;"], [0, "&multimap;"], [0, "&hercon;"], [0, "&intcal;"], [0, "&veebar;"], [1, "&barvee;"], [0, "&angrtvb;"], [0, "&lrtri;"], [0, "&bigwedge;"], [0, "&bigvee;"], [0, "&bigcap;"], [0, "&bigcup;"], [0, "&diam;"], [0, "&sdot;"], [0, "&sstarf;"], [0, "&divideontimes;"], [0, "&bowtie;"], [0, "&ltimes;"], [0, "&rtimes;"], [0, "&leftthreetimes;"], [0, "&rightthreetimes;"], [0, "&backsimeq;"], [0, "&curlyvee;"], [0, "&curlywedge;"], [0, "&Sub;"], [0, "&Sup;"], [0, "&Cap;"], [0, "&Cup;"], [0, "&fork;"], [0, "&epar;"], [0, "&lessdot;"], [0, "&gtdot;"], [0, { v: "&Ll;", n: 824, o: "&nLl;" }], [0, { v: "&Gg;", n: 824, o: "&nGg;" }], [0, { v: "&leg;", n: 65024, o: "&lesg;" }], [0, { v: "&gel;", n: 65024, o: "&gesl;" }], [2, "&cuepr;"], [0, "&cuesc;"], [0, "&NotPrecedesSlantEqual;"], [0, "&NotSucceedsSlantEqual;"], [0, "&NotSquareSubsetEqual;"], [0, "&NotSquareSupersetEqual;"], [2, "&lnsim;"], [0, "&gnsim;"], [0, "&precnsim;"], [0, "&scnsim;"], [0, "&nltri;"], [0, "&NotRightTriangle;"], [0, "&nltrie;"], [0, "&NotRightTriangleEqual;"], [0, "&vellip;"], [0, "&ctdot;"], [0, "&utdot;"], [0, "&dtdot;"], [0, "&disin;"], [0, "&isinsv;"], [0, "&isins;"], [0, { v: "&isindot;", n: 824, o: "&notindot;" }], [0, "&notinvc;"], [0, "&notinvb;"], [1, { v: "&isinE;", n: 824, o: "&notinE;" }], [0, "&nisd;"], [0, "&xnis;"], [0, "&nis;"], [0, "&notnivc;"], [0, "&notnivb;"], [6, "&barwed;"], [0, "&Barwed;"], [1, "&lceil;"], [0, "&rceil;"], [0, "&LeftFloor;"], [0, "&rfloor;"], [0, "&drcrop;"], [0, "&dlcrop;"], [0, "&urcrop;"], [0, "&ulcrop;"], [0, "&bnot;"], [1, "&profline;"], [0, "&profsurf;"], [1, "&telrec;"], [0, "&target;"], [5, "&ulcorn;"], [0, "&urcorn;"], [0, "&dlcorn;"], [0, "&drcorn;"], [2, "&frown;"], [0, "&smile;"], [9, "&cylcty;"], [0, "&profalar;"], [7, "&topbot;"], [6, "&ovbar;"], [1, "&solbar;"], [60, "&angzarr;"], [51, "&lmoustache;"], [0, "&rmoustache;"], [2, "&OverBracket;"], [0, "&bbrk;"], [0, "&bbrktbrk;"], [37, "&OverParenthesis;"], [0, "&UnderParenthesis;"], [0, "&OverBrace;"], [0, "&UnderBrace;"], [2, "&trpezium;"], [4, "&elinters;"], [59, "&blank;"], [164, "&circledS;"], [55, "&boxh;"], [1, "&boxv;"], [9, "&boxdr;"], [3, "&boxdl;"], [3, "&boxur;"], [3, "&boxul;"], [3, "&boxvr;"], [7, "&boxvl;"], [7, "&boxhd;"], [7, "&boxhu;"], [7, "&boxvh;"], [19, "&boxH;"], [0, "&boxV;"], [0, "&boxdR;"], [0, "&boxDr;"], [0, "&boxDR;"], [0, "&boxdL;"], [0, "&boxDl;"], [0, "&boxDL;"], [0, "&boxuR;"], [0, "&boxUr;"], [0, "&boxUR;"], [0, "&boxuL;"], [0, "&boxUl;"], [0, "&boxUL;"], [0, "&boxvR;"], [0, "&boxVr;"], [0, "&boxVR;"], [0, "&boxvL;"], [0, "&boxVl;"], [0, "&boxVL;"], [0, "&boxHd;"], [0, "&boxhD;"], [0, "&boxHD;"], [0, "&boxHu;"], [0, "&boxhU;"], [0, "&boxHU;"], [0, "&boxvH;"], [0, "&boxVh;"], [0, "&boxVH;"], [19, "&uhblk;"], [3, "&lhblk;"], [3, "&block;"], [8, "&blk14;"], [0, "&blk12;"], [0, "&blk34;"], [13, "&square;"], [8, "&blacksquare;"], [0, "&EmptyVerySmallSquare;"], [1, "&rect;"], [0, "&marker;"], [2, "&fltns;"], [1, "&bigtriangleup;"], [0, "&blacktriangle;"], [0, "&triangle;"], [2, "&blacktriangleright;"], [0, "&rtri;"], [3, "&bigtriangledown;"], [0, "&blacktriangledown;"], [0, "&dtri;"], [2, "&blacktriangleleft;"], [0, "&ltri;"], [6, "&loz;"], [0, "&cir;"], [32, "&tridot;"], [2, "&bigcirc;"], [8, "&ultri;"], [0, "&urtri;"], [0, "&lltri;"], [0, "&EmptySmallSquare;"], [0, "&FilledSmallSquare;"], [8, "&bigstar;"], [0, "&star;"], [7, "&phone;"], [49, "&female;"], [1, "&male;"], [29, "&spades;"], [2, "&clubs;"], [1, "&hearts;"], [0, "&diamondsuit;"], [3, "&sung;"], [2, "&flat;"], [0, "&natural;"], [0, "&sharp;"], [163, "&check;"], [3, "&cross;"], [8, "&malt;"], [21, "&sext;"], [33, "&VerticalSeparator;"], [25, "&lbbrk;"], [0, "&rbbrk;"], [84, "&bsolhsub;"], [0, "&suphsol;"], [28, "&LeftDoubleBracket;"], [0, "&RightDoubleBracket;"], [0, "&lang;"], [0, "&rang;"], [0, "&Lang;"], [0, "&Rang;"], [0, "&loang;"], [0, "&roang;"], [7, "&longleftarrow;"], [0, "&longrightarrow;"], [0, "&longleftrightarrow;"], [0, "&DoubleLongLeftArrow;"], [0, "&DoubleLongRightArrow;"], [0, "&DoubleLongLeftRightArrow;"], [1, "&longmapsto;"], [2, "&dzigrarr;"], [258, "&nvlArr;"], [0, "&nvrArr;"], [0, "&nvHarr;"], [0, "&Map;"], [6, "&lbarr;"], [0, "&bkarow;"], [0, "&lBarr;"], [0, "&dbkarow;"], [0, "&drbkarow;"], [0, "&DDotrahd;"], [0, "&UpArrowBar;"], [0, "&DownArrowBar;"], [2, "&Rarrtl;"], [2, "&latail;"], [0, "&ratail;"], [0, "&lAtail;"], [0, "&rAtail;"], [0, "&larrfs;"], [0, "&rarrfs;"], [0, "&larrbfs;"], [0, "&rarrbfs;"], [2, "&nwarhk;"], [0, "&nearhk;"], [0, "&hksearow;"], [0, "&hkswarow;"], [0, "&nwnear;"], [0, "&nesear;"], [0, "&seswar;"], [0, "&swnwar;"], [8, { v: "&rarrc;", n: 824, o: "&nrarrc;" }], [1, "&cudarrr;"], [0, "&ldca;"], [0, "&rdca;"], [0, "&cudarrl;"], [0, "&larrpl;"], [2, "&curarrm;"], [0, "&cularrp;"], [7, "&rarrpl;"], [2, "&harrcir;"], [0, "&Uarrocir;"], [0, "&lurdshar;"], [0, "&ldrushar;"], [2, "&LeftRightVector;"], [0, "&RightUpDownVector;"], [0, "&DownLeftRightVector;"], [0, "&LeftUpDownVector;"], [0, "&LeftVectorBar;"], [0, "&RightVectorBar;"], [0, "&RightUpVectorBar;"], [0, "&RightDownVectorBar;"], [0, "&DownLeftVectorBar;"], [0, "&DownRightVectorBar;"], [0, "&LeftUpVectorBar;"], [0, "&LeftDownVectorBar;"], [0, "&LeftTeeVector;"], [0, "&RightTeeVector;"], [0, "&RightUpTeeVector;"], [0, "&RightDownTeeVector;"], [0, "&DownLeftTeeVector;"], [0, "&DownRightTeeVector;"], [0, "&LeftUpTeeVector;"], [0, "&LeftDownTeeVector;"], [0, "&lHar;"], [0, "&uHar;"], [0, "&rHar;"], [0, "&dHar;"], [0, "&luruhar;"], [0, "&ldrdhar;"], [0, "&ruluhar;"], [0, "&rdldhar;"], [0, "&lharul;"], [0, "&llhard;"], [0, "&rharul;"], [0, "&lrhard;"], [0, "&udhar;"], [0, "&duhar;"], [0, "&RoundImplies;"], [0, "&erarr;"], [0, "&simrarr;"], [0, "&larrsim;"], [0, "&rarrsim;"], [0, "&rarrap;"], [0, "&ltlarr;"], [1, "&gtrarr;"], [0, "&subrarr;"], [1, "&suplarr;"], [0, "&lfisht;"], [0, "&rfisht;"], [0, "&ufisht;"], [0, "&dfisht;"], [5, "&lopar;"], [0, "&ropar;"], [4, "&lbrke;"], [0, "&rbrke;"], [0, "&lbrkslu;"], [0, "&rbrksld;"], [0, "&lbrksld;"], [0, "&rbrkslu;"], [0, "&langd;"], [0, "&rangd;"], [0, "&lparlt;"], [0, "&rpargt;"], [0, "&gtlPar;"], [0, "&ltrPar;"], [3, "&vzigzag;"], [1, "&vangrt;"], [0, "&angrtvbd;"], [6, "&ange;"], [0, "&range;"], [0, "&dwangle;"], [0, "&uwangle;"], [0, "&angmsdaa;"], [0, "&angmsdab;"], [0, "&angmsdac;"], [0, "&angmsdad;"], [0, "&angmsdae;"], [0, "&angmsdaf;"], [0, "&angmsdag;"], [0, "&angmsdah;"], [0, "&bemptyv;"], [0, "&demptyv;"], [0, "&cemptyv;"], [0, "&raemptyv;"], [0, "&laemptyv;"], [0, "&ohbar;"], [0, "&omid;"], [0, "&opar;"], [1, "&operp;"], [1, "&olcross;"], [0, "&odsold;"], [1, "&olcir;"], [0, "&ofcir;"], [0, "&olt;"], [0, "&ogt;"], [0, "&cirscir;"], [0, "&cirE;"], [0, "&solb;"], [0, "&bsolb;"], [3, "&boxbox;"], [3, "&trisb;"], [0, "&rtriltri;"], [0, { v: "&LeftTriangleBar;", n: 824, o: "&NotLeftTriangleBar;" }], [0, { v: "&RightTriangleBar;", n: 824, o: "&NotRightTriangleBar;" }], [11, "&iinfin;"], [0, "&infintie;"], [0, "&nvinfin;"], [4, "&eparsl;"], [0, "&smeparsl;"], [0, "&eqvparsl;"], [5, "&blacklozenge;"], [8, "&RuleDelayed;"], [1, "&dsol;"], [9, "&bigodot;"], [0, "&bigoplus;"], [0, "&bigotimes;"], [1, "&biguplus;"], [1, "&bigsqcup;"], [5, "&iiiint;"], [0, "&fpartint;"], [2, "&cirfnint;"], [0, "&awint;"], [0, "&rppolint;"], [0, "&scpolint;"], [0, "&npolint;"], [0, "&pointint;"], [0, "&quatint;"], [0, "&intlarhk;"], [10, "&pluscir;"], [0, "&plusacir;"], [0, "&simplus;"], [0, "&plusdu;"], [0, "&plussim;"], [0, "&plustwo;"], [1, "&mcomma;"], [0, "&minusdu;"], [2, "&loplus;"], [0, "&roplus;"], [0, "&Cross;"], [0, "&timesd;"], [0, "&timesbar;"], [1, "&smashp;"], [0, "&lotimes;"], [0, "&rotimes;"], [0, "&otimesas;"], [0, "&Otimes;"], [0, "&odiv;"], [0, "&triplus;"], [0, "&triminus;"], [0, "&tritime;"], [0, "&intprod;"], [2, "&amalg;"], [0, "&capdot;"], [1, "&ncup;"], [0, "&ncap;"], [0, "&capand;"], [0, "&cupor;"], [0, "&cupcap;"], [0, "&capcup;"], [0, "&cupbrcap;"], [0, "&capbrcup;"], [0, "&cupcup;"], [0, "&capcap;"], [0, "&ccups;"], [0, "&ccaps;"], [2, "&ccupssm;"], [2, "&And;"], [0, "&Or;"], [0, "&andand;"], [0, "&oror;"], [0, "&orslope;"], [0, "&andslope;"], [1, "&andv;"], [0, "&orv;"], [0, "&andd;"], [0, "&ord;"], [1, "&wedbar;"], [6, "&sdote;"], [3, "&simdot;"], [2, { v: "&congdot;", n: 824, o: "&ncongdot;" }], [0, "&easter;"], [0, "&apacir;"], [0, { v: "&apE;", n: 824, o: "&napE;" }], [0, "&eplus;"], [0, "&pluse;"], [0, "&Esim;"], [0, "&Colone;"], [0, "&Equal;"], [1, "&ddotseq;"], [0, "&equivDD;"], [0, "&ltcir;"], [0, "&gtcir;"], [0, "&ltquest;"], [0, "&gtquest;"], [0, { v: "&leqslant;", n: 824, o: "&nleqslant;" }], [0, { v: "&geqslant;", n: 824, o: "&ngeqslant;" }], [0, "&lesdot;"], [0, "&gesdot;"], [0, "&lesdoto;"], [0, "&gesdoto;"], [0, "&lesdotor;"], [0, "&gesdotol;"], [0, "&lap;"], [0, "&gap;"], [0, "&lne;"], [0, "&gne;"], [0, "&lnap;"], [0, "&gnap;"], [0, "&lEg;"], [0, "&gEl;"], [0, "&lsime;"], [0, "&gsime;"], [0, "&lsimg;"], [0, "&gsiml;"], [0, "&lgE;"], [0, "&glE;"], [0, "&lesges;"], [0, "&gesles;"], [0, "&els;"], [0, "&egs;"], [0, "&elsdot;"], [0, "&egsdot;"], [0, "&el;"], [0, "&eg;"], [2, "&siml;"], [0, "&simg;"], [0, "&simlE;"], [0, "&simgE;"], [0, { v: "&LessLess;", n: 824, o: "&NotNestedLessLess;" }], [0, { v: "&GreaterGreater;", n: 824, o: "&NotNestedGreaterGreater;" }], [1, "&glj;"], [0, "&gla;"], [0, "&ltcc;"], [0, "&gtcc;"], [0, "&lescc;"], [0, "&gescc;"], [0, "&smt;"], [0, "&lat;"], [0, { v: "&smte;", n: 65024, o: "&smtes;" }], [0, { v: "&late;", n: 65024, o: "&lates;" }], [0, "&bumpE;"], [0, { v: "&PrecedesEqual;", n: 824, o: "&NotPrecedesEqual;" }], [0, { v: "&sce;", n: 824, o: "&NotSucceedsEqual;" }], [2, "&prE;"], [0, "&scE;"], [0, "&precneqq;"], [0, "&scnE;"], [0, "&prap;"], [0, "&scap;"], [0, "&precnapprox;"], [0, "&scnap;"], [0, "&Pr;"], [0, "&Sc;"], [0, "&subdot;"], [0, "&supdot;"], [0, "&subplus;"], [0, "&supplus;"], [0, "&submult;"], [0, "&supmult;"], [0, "&subedot;"], [0, "&supedot;"], [0, { v: "&subE;", n: 824, o: "&nsubE;" }], [0, { v: "&supE;", n: 824, o: "&nsupE;" }], [0, "&subsim;"], [0, "&supsim;"], [2, { v: "&subnE;", n: 65024, o: "&varsubsetneqq;" }], [0, { v: "&supnE;", n: 65024, o: "&varsupsetneqq;" }], [2, "&csub;"], [0, "&csup;"], [0, "&csube;"], [0, "&csupe;"], [0, "&subsup;"], [0, "&supsub;"], [0, "&subsub;"], [0, "&supsup;"], [0, "&suphsub;"], [0, "&supdsub;"], [0, "&forkv;"], [0, "&topfork;"], [0, "&mlcp;"], [8, "&Dashv;"], [1, "&Vdashl;"], [0, "&Barv;"], [0, "&vBar;"], [0, "&vBarv;"], [1, "&Vbar;"], [0, "&Not;"], [0, "&bNot;"], [0, "&rnmid;"], [0, "&cirmid;"], [0, "&midcir;"], [0, "&topcir;"], [0, "&nhpar;"], [0, "&parsim;"], [9, { v: "&parsl;", n: 8421, o: "&nparsl;" }], [44343, { n: new Map(/* @__PURE__ */ restoreDiff([[56476, "&Ascr;"], [1, "&Cscr;"], [0, "&Dscr;"], [2, "&Gscr;"], [2, "&Jscr;"], [0, "&Kscr;"], [2, "&Nscr;"], [0, "&Oscr;"], [0, "&Pscr;"], [0, "&Qscr;"], [1, "&Sscr;"], [0, "&Tscr;"], [0, "&Uscr;"], [0, "&Vscr;"], [0, "&Wscr;"], [0, "&Xscr;"], [0, "&Yscr;"], [0, "&Zscr;"], [0, "&ascr;"], [0, "&bscr;"], [0, "&cscr;"], [0, "&dscr;"], [1, "&fscr;"], [1, "&hscr;"], [0, "&iscr;"], [0, "&jscr;"], [0, "&kscr;"], [0, "&lscr;"], [0, "&mscr;"], [0, "&nscr;"], [1, "&pscr;"], [0, "&qscr;"], [0, "&rscr;"], [0, "&sscr;"], [0, "&tscr;"], [0, "&uscr;"], [0, "&vscr;"], [0, "&wscr;"], [0, "&xscr;"], [0, "&yscr;"], [0, "&zscr;"], [52, "&Afr;"], [0, "&Bfr;"], [1, "&Dfr;"], [0, "&Efr;"], [0, "&Ffr;"], [0, "&Gfr;"], [2, "&Jfr;"], [0, "&Kfr;"], [0, "&Lfr;"], [0, "&Mfr;"], [0, "&Nfr;"], [0, "&Ofr;"], [0, "&Pfr;"], [0, "&Qfr;"], [1, "&Sfr;"], [0, "&Tfr;"], [0, "&Ufr;"], [0, "&Vfr;"], [0, "&Wfr;"], [0, "&Xfr;"], [0, "&Yfr;"], [1, "&afr;"], [0, "&bfr;"], [0, "&cfr;"], [0, "&dfr;"], [0, "&efr;"], [0, "&ffr;"], [0, "&gfr;"], [0, "&hfr;"], [0, "&ifr;"], [0, "&jfr;"], [0, "&kfr;"], [0, "&lfr;"], [0, "&mfr;"], [0, "&nfr;"], [0, "&ofr;"], [0, "&pfr;"], [0, "&qfr;"], [0, "&rfr;"], [0, "&sfr;"], [0, "&tfr;"], [0, "&ufr;"], [0, "&vfr;"], [0, "&wfr;"], [0, "&xfr;"], [0, "&yfr;"], [0, "&zfr;"], [0, "&Aopf;"], [0, "&Bopf;"], [1, "&Dopf;"], [0, "&Eopf;"], [0, "&Fopf;"], [0, "&Gopf;"], [1, "&Iopf;"], [0, "&Jopf;"], [0, "&Kopf;"], [0, "&Lopf;"], [0, "&Mopf;"], [1, "&Oopf;"], [3, "&Sopf;"], [0, "&Topf;"], [0, "&Uopf;"], [0, "&Vopf;"], [0, "&Wopf;"], [0, "&Xopf;"], [0, "&Yopf;"], [1, "&aopf;"], [0, "&bopf;"], [0, "&copf;"], [0, "&dopf;"], [0, "&eopf;"], [0, "&fopf;"], [0, "&gopf;"], [0, "&hopf;"], [0, "&iopf;"], [0, "&jopf;"], [0, "&kopf;"], [0, "&lopf;"], [0, "&mopf;"], [0, "&nopf;"], [0, "&oopf;"], [0, "&popf;"], [0, "&qopf;"], [0, "&ropf;"], [0, "&sopf;"], [0, "&topf;"], [0, "&uopf;"], [0, "&vopf;"], [0, "&wopf;"], [0, "&xopf;"], [0, "&yopf;"], [0, "&zopf;"]])) }], [8906, "&fflig;"], [0, "&filig;"], [0, "&fllig;"], [0, "&ffilig;"], [0, "&ffllig;"]]));
  }
});

// node_modules/prosemirror-markdown/node_modules/entities/lib/escape.js
var require_escape2 = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/entities/lib/escape.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.escapeText = exports2.escapeAttribute = exports2.escapeUTF8 = exports2.escape = exports2.encodeXML = exports2.getCodePoint = exports2.xmlReplacer = void 0;
    exports2.xmlReplacer = /["&'<>$\x80-\uFFFF]/g;
    var xmlCodeMap = /* @__PURE__ */ new Map([
      [34, "&quot;"],
      [38, "&amp;"],
      [39, "&apos;"],
      [60, "&lt;"],
      [62, "&gt;"]
    ]);
    exports2.getCodePoint = // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
    String.prototype.codePointAt != null ? function(str, index) {
      return str.codePointAt(index);
    } : (
      // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
      function(c, index) {
        return (c.charCodeAt(index) & 64512) === 55296 ? (c.charCodeAt(index) - 55296) * 1024 + c.charCodeAt(index + 1) - 56320 + 65536 : c.charCodeAt(index);
      }
    );
    function encodeXML(str) {
      var ret = "";
      var lastIdx = 0;
      var match;
      while ((match = exports2.xmlReplacer.exec(str)) !== null) {
        var i = match.index;
        var char = str.charCodeAt(i);
        var next = xmlCodeMap.get(char);
        if (next !== void 0) {
          ret += str.substring(lastIdx, i) + next;
          lastIdx = i + 1;
        } else {
          ret += "".concat(str.substring(lastIdx, i), "&#x").concat((0, exports2.getCodePoint)(str, i).toString(16), ";");
          lastIdx = exports2.xmlReplacer.lastIndex += Number((char & 64512) === 55296);
        }
      }
      return ret + str.substr(lastIdx);
    }
    exports2.encodeXML = encodeXML;
    exports2.escape = encodeXML;
    function getEscaper(regex, map) {
      return function escape(data) {
        var match;
        var lastIdx = 0;
        var result = "";
        while (match = regex.exec(data)) {
          if (lastIdx !== match.index) {
            result += data.substring(lastIdx, match.index);
          }
          result += map.get(match[0].charCodeAt(0));
          lastIdx = match.index + 1;
        }
        return result + data.substring(lastIdx);
      };
    }
    exports2.escapeUTF8 = getEscaper(/[&<>'"]/g, xmlCodeMap);
    exports2.escapeAttribute = getEscaper(/["&\u00A0]/g, /* @__PURE__ */ new Map([
      [34, "&quot;"],
      [38, "&amp;"],
      [160, "&nbsp;"]
    ]));
    exports2.escapeText = getEscaper(/[&<>\u00A0]/g, /* @__PURE__ */ new Map([
      [38, "&amp;"],
      [60, "&lt;"],
      [62, "&gt;"],
      [160, "&nbsp;"]
    ]));
  }
});

// node_modules/prosemirror-markdown/node_modules/entities/lib/encode.js
var require_encode2 = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/entities/lib/encode.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.encodeNonAsciiHTML = exports2.encodeHTML = void 0;
    var encode_html_js_1 = __importDefault(require_encode_html());
    var escape_js_1 = require_escape2();
    var htmlReplacer = /[\t\n!-,./:-@[-`\f{-}$\x80-\uFFFF]/g;
    function encodeHTML(data) {
      return encodeHTMLTrieRe(htmlReplacer, data);
    }
    exports2.encodeHTML = encodeHTML;
    function encodeNonAsciiHTML(data) {
      return encodeHTMLTrieRe(escape_js_1.xmlReplacer, data);
    }
    exports2.encodeNonAsciiHTML = encodeNonAsciiHTML;
    function encodeHTMLTrieRe(regExp, str) {
      var ret = "";
      var lastIdx = 0;
      var match;
      while ((match = regExp.exec(str)) !== null) {
        var i = match.index;
        ret += str.substring(lastIdx, i);
        var char = str.charCodeAt(i);
        var next = encode_html_js_1.default.get(char);
        if (typeof next === "object") {
          if (i + 1 < str.length) {
            var nextChar = str.charCodeAt(i + 1);
            var value = typeof next.n === "number" ? next.n === nextChar ? next.o : void 0 : next.n.get(nextChar);
            if (value !== void 0) {
              ret += value;
              lastIdx = regExp.lastIndex += 1;
              continue;
            }
          }
          next = next.v;
        }
        if (next !== void 0) {
          ret += next;
          lastIdx = i + 1;
        } else {
          var cp = (0, escape_js_1.getCodePoint)(str, i);
          ret += "&#x".concat(cp.toString(16), ";");
          lastIdx = regExp.lastIndex += Number(cp !== char);
        }
      }
      return ret + str.substr(lastIdx);
    }
  }
});

// node_modules/prosemirror-markdown/node_modules/entities/lib/index.js
var require_lib2 = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/entities/lib/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.decodeXMLStrict = exports2.decodeHTML5Strict = exports2.decodeHTML4Strict = exports2.decodeHTML5 = exports2.decodeHTML4 = exports2.decodeHTMLAttribute = exports2.decodeHTMLStrict = exports2.decodeHTML = exports2.decodeXML = exports2.DecodingMode = exports2.EntityDecoder = exports2.encodeHTML5 = exports2.encodeHTML4 = exports2.encodeNonAsciiHTML = exports2.encodeHTML = exports2.escapeText = exports2.escapeAttribute = exports2.escapeUTF8 = exports2.escape = exports2.encodeXML = exports2.encode = exports2.decodeStrict = exports2.decode = exports2.EncodingMode = exports2.EntityLevel = void 0;
    var decode_js_1 = require_decode2();
    var encode_js_1 = require_encode2();
    var escape_js_1 = require_escape2();
    var EntityLevel;
    (function(EntityLevel2) {
      EntityLevel2[EntityLevel2["XML"] = 0] = "XML";
      EntityLevel2[EntityLevel2["HTML"] = 1] = "HTML";
    })(EntityLevel = exports2.EntityLevel || (exports2.EntityLevel = {}));
    var EncodingMode;
    (function(EncodingMode2) {
      EncodingMode2[EncodingMode2["UTF8"] = 0] = "UTF8";
      EncodingMode2[EncodingMode2["ASCII"] = 1] = "ASCII";
      EncodingMode2[EncodingMode2["Extensive"] = 2] = "Extensive";
      EncodingMode2[EncodingMode2["Attribute"] = 3] = "Attribute";
      EncodingMode2[EncodingMode2["Text"] = 4] = "Text";
    })(EncodingMode = exports2.EncodingMode || (exports2.EncodingMode = {}));
    function decode(data, options) {
      if (options === void 0) {
        options = EntityLevel.XML;
      }
      var level = typeof options === "number" ? options : options.level;
      if (level === EntityLevel.HTML) {
        var mode = typeof options === "object" ? options.mode : void 0;
        return (0, decode_js_1.decodeHTML)(data, mode);
      }
      return (0, decode_js_1.decodeXML)(data);
    }
    exports2.decode = decode;
    function decodeStrict(data, options) {
      var _a;
      if (options === void 0) {
        options = EntityLevel.XML;
      }
      var opts = typeof options === "number" ? { level: options } : options;
      (_a = opts.mode) !== null && _a !== void 0 ? _a : opts.mode = decode_js_1.DecodingMode.Strict;
      return decode(data, opts);
    }
    exports2.decodeStrict = decodeStrict;
    function encode(data, options) {
      if (options === void 0) {
        options = EntityLevel.XML;
      }
      var opts = typeof options === "number" ? { level: options } : options;
      if (opts.mode === EncodingMode.UTF8)
        return (0, escape_js_1.escapeUTF8)(data);
      if (opts.mode === EncodingMode.Attribute)
        return (0, escape_js_1.escapeAttribute)(data);
      if (opts.mode === EncodingMode.Text)
        return (0, escape_js_1.escapeText)(data);
      if (opts.level === EntityLevel.HTML) {
        if (opts.mode === EncodingMode.ASCII) {
          return (0, encode_js_1.encodeNonAsciiHTML)(data);
        }
        return (0, encode_js_1.encodeHTML)(data);
      }
      return (0, escape_js_1.encodeXML)(data);
    }
    exports2.encode = encode;
    var escape_js_2 = require_escape2();
    Object.defineProperty(exports2, "encodeXML", { enumerable: true, get: function() {
      return escape_js_2.encodeXML;
    } });
    Object.defineProperty(exports2, "escape", { enumerable: true, get: function() {
      return escape_js_2.escape;
    } });
    Object.defineProperty(exports2, "escapeUTF8", { enumerable: true, get: function() {
      return escape_js_2.escapeUTF8;
    } });
    Object.defineProperty(exports2, "escapeAttribute", { enumerable: true, get: function() {
      return escape_js_2.escapeAttribute;
    } });
    Object.defineProperty(exports2, "escapeText", { enumerable: true, get: function() {
      return escape_js_2.escapeText;
    } });
    var encode_js_2 = require_encode2();
    Object.defineProperty(exports2, "encodeHTML", { enumerable: true, get: function() {
      return encode_js_2.encodeHTML;
    } });
    Object.defineProperty(exports2, "encodeNonAsciiHTML", { enumerable: true, get: function() {
      return encode_js_2.encodeNonAsciiHTML;
    } });
    Object.defineProperty(exports2, "encodeHTML4", { enumerable: true, get: function() {
      return encode_js_2.encodeHTML;
    } });
    Object.defineProperty(exports2, "encodeHTML5", { enumerable: true, get: function() {
      return encode_js_2.encodeHTML;
    } });
    var decode_js_2 = require_decode2();
    Object.defineProperty(exports2, "EntityDecoder", { enumerable: true, get: function() {
      return decode_js_2.EntityDecoder;
    } });
    Object.defineProperty(exports2, "DecodingMode", { enumerable: true, get: function() {
      return decode_js_2.DecodingMode;
    } });
    Object.defineProperty(exports2, "decodeXML", { enumerable: true, get: function() {
      return decode_js_2.decodeXML;
    } });
    Object.defineProperty(exports2, "decodeHTML", { enumerable: true, get: function() {
      return decode_js_2.decodeHTML;
    } });
    Object.defineProperty(exports2, "decodeHTMLStrict", { enumerable: true, get: function() {
      return decode_js_2.decodeHTMLStrict;
    } });
    Object.defineProperty(exports2, "decodeHTMLAttribute", { enumerable: true, get: function() {
      return decode_js_2.decodeHTMLAttribute;
    } });
    Object.defineProperty(exports2, "decodeHTML4", { enumerable: true, get: function() {
      return decode_js_2.decodeHTML;
    } });
    Object.defineProperty(exports2, "decodeHTML5", { enumerable: true, get: function() {
      return decode_js_2.decodeHTML;
    } });
    Object.defineProperty(exports2, "decodeHTML4Strict", { enumerable: true, get: function() {
      return decode_js_2.decodeHTMLStrict;
    } });
    Object.defineProperty(exports2, "decodeHTML5Strict", { enumerable: true, get: function() {
      return decode_js_2.decodeHTMLStrict;
    } });
    Object.defineProperty(exports2, "decodeXMLStrict", { enumerable: true, get: function() {
      return decode_js_2.decodeXML;
    } });
  }
});

// node_modules/prosemirror-markdown/node_modules/linkify-it/build/index.cjs.js
var require_index_cjs3 = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/linkify-it/build/index.cjs.js"(exports2, module2) {
    "use strict";
    var uc_micro = require_index_cjs2();
    function reFactory(opts) {
      const re = {};
      opts = opts || {};
      re.src_Any = uc_micro.Any.source;
      re.src_Cc = uc_micro.Cc.source;
      re.src_Z = uc_micro.Z.source;
      re.src_P = uc_micro.P.source;
      re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join("|");
      re.src_ZCc = [re.src_Z, re.src_Cc].join("|");
      const text_separators = "[><\uFF5C]";
      re.src_pseudo_letter = "(?:(?!" + text_separators + "|" + re.src_ZPCc + ")" + re.src_Any + ")";
      re.src_ip4 = "(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)";
      re.src_auth = "(?:(?:(?!" + re.src_ZCc + "|[@/\\[\\]()]).)+@)?";
      re.src_port = "(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?";
      re.src_host_terminator = "(?=$|" + text_separators + "|" + re.src_ZPCc + ")(?!" + (opts["---"] ? "-(?!--)|" : "-|") + "_|:\\d|\\.-|\\.(?!$|" + re.src_ZPCc + "))";
      re.src_path = "(?:[/?#](?:(?!" + re.src_ZCc + "|" + text_separators + `|[()[\\]{}.,"'?!\\-;]).|\\[(?:(?!` + re.src_ZCc + "|\\]).)*\\]|\\((?:(?!" + re.src_ZCc + "|[)]).)*\\)|\\{(?:(?!" + re.src_ZCc + '|[}]).)*\\}|\\"(?:(?!' + re.src_ZCc + `|["]).)+\\"|\\'(?:(?!` + re.src_ZCc + "|[']).)+\\'|\\'(?=" + re.src_pseudo_letter + "|[-])|\\.{2,}[a-zA-Z0-9%/&]|\\.(?!" + re.src_ZCc + "|[.]|$)|" + (opts["---"] ? "\\-(?!--(?:[^-]|$))(?:-*)|" : "\\-+|") + // allow `,,,` in paths
      ",(?!" + re.src_ZCc + "|$)|;(?!" + re.src_ZCc + "|$)|\\!+(?!" + re.src_ZCc + "|[!]|$)|\\?(?!" + re.src_ZCc + "|[?]|$))+|\\/)?";
      re.src_email_name = '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
      re.src_xn = "xn--[a-z0-9\\-]{1,59}";
      re.src_domain_root = // Allow letters & digits (http://test1)
      "(?:" + re.src_xn + "|" + re.src_pseudo_letter + "{1,63})";
      re.src_domain = "(?:" + re.src_xn + "|(?:" + re.src_pseudo_letter + ")|(?:" + re.src_pseudo_letter + "(?:-|" + re.src_pseudo_letter + "){0,61}" + re.src_pseudo_letter + "))";
      re.src_host = "(?:(?:(?:(?:" + re.src_domain + ")\\.)*" + re.src_domain + "))";
      re.tpl_host_fuzzy = "(?:" + re.src_ip4 + "|(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%)))";
      re.tpl_host_no_ip_fuzzy = "(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%))";
      re.src_host_strict = re.src_host + re.src_host_terminator;
      re.tpl_host_fuzzy_strict = re.tpl_host_fuzzy + re.src_host_terminator;
      re.src_host_port_strict = re.src_host + re.src_port + re.src_host_terminator;
      re.tpl_host_port_fuzzy_strict = re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
      re.tpl_host_port_no_ip_fuzzy_strict = re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;
      re.tpl_host_fuzzy_test = "localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:" + re.src_ZPCc + "|>|$))";
      re.tpl_email_fuzzy = "(^|" + text_separators + '|"|\\(|' + re.src_ZCc + ")(" + re.src_email_name + "@" + re.tpl_host_fuzzy_strict + ")";
      re.tpl_link_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
      // but can start with > (markdown blockquote)
      "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_fuzzy_strict + re.src_path + ")";
      re.tpl_link_no_ip_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
      // but can start with > (markdown blockquote)
      "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" + re.src_ZPCc + "))((?![$+<=>^`|\uFF5C])" + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ")";
      return re;
    }
    function assign(obj) {
      const sources = Array.prototype.slice.call(arguments, 1);
      sources.forEach(function(source) {
        if (!source) {
          return;
        }
        Object.keys(source).forEach(function(key) {
          obj[key] = source[key];
        });
      });
      return obj;
    }
    function _class(obj) {
      return Object.prototype.toString.call(obj);
    }
    function isString(obj) {
      return _class(obj) === "[object String]";
    }
    function isObject(obj) {
      return _class(obj) === "[object Object]";
    }
    function isRegExp(obj) {
      return _class(obj) === "[object RegExp]";
    }
    function isFunction(obj) {
      return _class(obj) === "[object Function]";
    }
    function escapeRE(str) {
      return str.replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&");
    }
    var defaultOptions = {
      fuzzyLink: true,
      fuzzyEmail: true,
      fuzzyIP: false
    };
    function isOptionsObj(obj) {
      return Object.keys(obj || {}).reduce(function(acc, k) {
        return acc || defaultOptions.hasOwnProperty(k);
      }, false);
    }
    var defaultSchemas = {
      "http:": {
        validate: function(text, pos, self2) {
          const tail = text.slice(pos);
          if (!self2.re.http) {
            self2.re.http = new RegExp(
              "^\\/\\/" + self2.re.src_auth + self2.re.src_host_port_strict + self2.re.src_path,
              "i"
            );
          }
          if (self2.re.http.test(tail)) {
            return tail.match(self2.re.http)[0].length;
          }
          return 0;
        }
      },
      "https:": "http:",
      "ftp:": "http:",
      "//": {
        validate: function(text, pos, self2) {
          const tail = text.slice(pos);
          if (!self2.re.no_http) {
            self2.re.no_http = new RegExp(
              "^" + self2.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'
              // with code comments
              "(?:localhost|(?:(?:" + self2.re.src_domain + ")\\.)+" + self2.re.src_domain_root + ")" + self2.re.src_port + self2.re.src_host_terminator + self2.re.src_path,
              "i"
            );
          }
          if (self2.re.no_http.test(tail)) {
            if (pos >= 3 && text[pos - 3] === ":") {
              return 0;
            }
            if (pos >= 3 && text[pos - 3] === "/") {
              return 0;
            }
            return tail.match(self2.re.no_http)[0].length;
          }
          return 0;
        }
      },
      "mailto:": {
        validate: function(text, pos, self2) {
          const tail = text.slice(pos);
          if (!self2.re.mailto) {
            self2.re.mailto = new RegExp(
              "^" + self2.re.src_email_name + "@" + self2.re.src_host_strict,
              "i"
            );
          }
          if (self2.re.mailto.test(tail)) {
            return tail.match(self2.re.mailto)[0].length;
          }
          return 0;
        }
      }
    };
    var tlds_2ch_src_re = "a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]";
    var tlds_default = "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|\u0440\u0444".split("|");
    function resetScanCache(self2) {
      self2.__index__ = -1;
      self2.__text_cache__ = "";
    }
    function createValidator(re) {
      return function(text, pos) {
        const tail = text.slice(pos);
        if (re.test(tail)) {
          return tail.match(re)[0].length;
        }
        return 0;
      };
    }
    function createNormalizer() {
      return function(match, self2) {
        self2.normalize(match);
      };
    }
    function compile(self2) {
      const re = self2.re = reFactory(self2.__opts__);
      const tlds = self2.__tlds__.slice();
      self2.onCompile();
      if (!self2.__tlds_replaced__) {
        tlds.push(tlds_2ch_src_re);
      }
      tlds.push(re.src_xn);
      re.src_tlds = tlds.join("|");
      function untpl(tpl) {
        return tpl.replace("%TLDS%", re.src_tlds);
      }
      re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), "i");
      re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), "i");
      re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "i");
      re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), "i");
      const aliases = [];
      self2.__compiled__ = {};
      function schemaError(name, val) {
        throw new Error('(LinkifyIt) Invalid schema "' + name + '": ' + val);
      }
      Object.keys(self2.__schemas__).forEach(function(name) {
        const val = self2.__schemas__[name];
        if (val === null) {
          return;
        }
        const compiled = { validate: null, link: null };
        self2.__compiled__[name] = compiled;
        if (isObject(val)) {
          if (isRegExp(val.validate)) {
            compiled.validate = createValidator(val.validate);
          } else if (isFunction(val.validate)) {
            compiled.validate = val.validate;
          } else {
            schemaError(name, val);
          }
          if (isFunction(val.normalize)) {
            compiled.normalize = val.normalize;
          } else if (!val.normalize) {
            compiled.normalize = createNormalizer();
          } else {
            schemaError(name, val);
          }
          return;
        }
        if (isString(val)) {
          aliases.push(name);
          return;
        }
        schemaError(name, val);
      });
      aliases.forEach(function(alias) {
        if (!self2.__compiled__[self2.__schemas__[alias]]) {
          return;
        }
        self2.__compiled__[alias].validate = self2.__compiled__[self2.__schemas__[alias]].validate;
        self2.__compiled__[alias].normalize = self2.__compiled__[self2.__schemas__[alias]].normalize;
      });
      self2.__compiled__[""] = { validate: null, normalize: createNormalizer() };
      const slist = Object.keys(self2.__compiled__).filter(function(name) {
        return name.length > 0 && self2.__compiled__[name];
      }).map(escapeRE).join("|");
      self2.re.schema_test = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "i");
      self2.re.schema_search = RegExp("(^|(?!_)(?:[><\uFF5C]|" + re.src_ZPCc + "))(" + slist + ")", "ig");
      self2.re.schema_at_start = RegExp("^" + self2.re.schema_search.source, "i");
      self2.re.pretest = RegExp(
        "(" + self2.re.schema_test.source + ")|(" + self2.re.host_fuzzy_test.source + ")|@",
        "i"
      );
      resetScanCache(self2);
    }
    function Match(self2, shift) {
      const start = self2.__index__;
      const end = self2.__last_index__;
      const text = self2.__text_cache__.slice(start, end);
      this.schema = self2.__schema__.toLowerCase();
      this.index = start + shift;
      this.lastIndex = end + shift;
      this.raw = text;
      this.text = text;
      this.url = text;
    }
    function createMatch(self2, shift) {
      const match = new Match(self2, shift);
      self2.__compiled__[match.schema].normalize(match, self2);
      return match;
    }
    function LinkifyIt(schemas, options) {
      if (!(this instanceof LinkifyIt)) {
        return new LinkifyIt(schemas, options);
      }
      if (!options) {
        if (isOptionsObj(schemas)) {
          options = schemas;
          schemas = {};
        }
      }
      this.__opts__ = assign({}, defaultOptions, options);
      this.__index__ = -1;
      this.__last_index__ = -1;
      this.__schema__ = "";
      this.__text_cache__ = "";
      this.__schemas__ = assign({}, defaultSchemas, schemas);
      this.__compiled__ = {};
      this.__tlds__ = tlds_default;
      this.__tlds_replaced__ = false;
      this.re = {};
      compile(this);
    }
    LinkifyIt.prototype.add = function add(schema, definition) {
      this.__schemas__[schema] = definition;
      compile(this);
      return this;
    };
    LinkifyIt.prototype.set = function set(options) {
      this.__opts__ = assign(this.__opts__, options);
      return this;
    };
    LinkifyIt.prototype.test = function test(text) {
      this.__text_cache__ = text;
      this.__index__ = -1;
      if (!text.length) {
        return false;
      }
      let m, ml, me, len, shift, next, re, tld_pos, at_pos;
      if (this.re.schema_test.test(text)) {
        re = this.re.schema_search;
        re.lastIndex = 0;
        while ((m = re.exec(text)) !== null) {
          len = this.testSchemaAt(text, m[2], re.lastIndex);
          if (len) {
            this.__schema__ = m[2];
            this.__index__ = m.index + m[1].length;
            this.__last_index__ = m.index + m[0].length + len;
            break;
          }
        }
      }
      if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
        tld_pos = text.search(this.re.host_fuzzy_test);
        if (tld_pos >= 0) {
          if (this.__index__ < 0 || tld_pos < this.__index__) {
            if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {
              shift = ml.index + ml[1].length;
              if (this.__index__ < 0 || shift < this.__index__) {
                this.__schema__ = "";
                this.__index__ = shift;
                this.__last_index__ = ml.index + ml[0].length;
              }
            }
          }
        }
      }
      if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
        at_pos = text.indexOf("@");
        if (at_pos >= 0) {
          if ((me = text.match(this.re.email_fuzzy)) !== null) {
            shift = me.index + me[1].length;
            next = me.index + me[0].length;
            if (this.__index__ < 0 || shift < this.__index__ || shift === this.__index__ && next > this.__last_index__) {
              this.__schema__ = "mailto:";
              this.__index__ = shift;
              this.__last_index__ = next;
            }
          }
        }
      }
      return this.__index__ >= 0;
    };
    LinkifyIt.prototype.pretest = function pretest(text) {
      return this.re.pretest.test(text);
    };
    LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {
      if (!this.__compiled__[schema.toLowerCase()]) {
        return 0;
      }
      return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);
    };
    LinkifyIt.prototype.match = function match(text) {
      const result = [];
      let shift = 0;
      if (this.__index__ >= 0 && this.__text_cache__ === text) {
        result.push(createMatch(this, shift));
        shift = this.__last_index__;
      }
      let tail = shift ? text.slice(shift) : text;
      while (this.test(tail)) {
        result.push(createMatch(this, shift));
        tail = tail.slice(this.__last_index__);
        shift += this.__last_index__;
      }
      if (result.length) {
        return result;
      }
      return null;
    };
    LinkifyIt.prototype.matchAtStart = function matchAtStart(text) {
      this.__text_cache__ = text;
      this.__index__ = -1;
      if (!text.length) return null;
      const m = this.re.schema_at_start.exec(text);
      if (!m) return null;
      const len = this.testSchemaAt(text, m[2], m[0].length);
      if (!len) return null;
      this.__schema__ = m[2];
      this.__index__ = m.index + m[1].length;
      this.__last_index__ = m.index + m[0].length + len;
      return createMatch(this, 0);
    };
    LinkifyIt.prototype.tlds = function tlds(list, keepOld) {
      list = Array.isArray(list) ? list : [list];
      if (!keepOld) {
        this.__tlds__ = list.slice();
        this.__tlds_replaced__ = true;
        compile(this);
        return this;
      }
      this.__tlds__ = this.__tlds__.concat(list).sort().filter(function(el, idx, arr) {
        return el !== arr[idx - 1];
      }).reverse();
      compile(this);
      return this;
    };
    LinkifyIt.prototype.normalize = function normalize(match) {
      if (!match.schema) {
        match.url = "http://" + match.url;
      }
      if (match.schema === "mailto:" && !/^mailto:/i.test(match.url)) {
        match.url = "mailto:" + match.url;
      }
    };
    LinkifyIt.prototype.onCompile = function onCompile() {
    };
    module2.exports = LinkifyIt;
  }
});

// node_modules/punycode.js/punycode.js
var require_punycode = __commonJS({
  "node_modules/punycode.js/punycode.js"(exports2, module2) {
    "use strict";
    var maxInt = 2147483647;
    var base = 36;
    var tMin = 1;
    var tMax = 26;
    var skew = 38;
    var damp = 700;
    var initialBias = 72;
    var initialN = 128;
    var delimiter = "-";
    var regexPunycode = /^xn--/;
    var regexNonASCII = /[^\0-\x7F]/;
    var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
    var errors = {
      "overflow": "Overflow: input needs wider integers to process",
      "not-basic": "Illegal input >= 0x80 (not a basic code point)",
      "invalid-input": "Invalid input"
    };
    var baseMinusTMin = base - tMin;
    var floor = Math.floor;
    var stringFromCharCode = String.fromCharCode;
    function error(type) {
      throw new RangeError(errors[type]);
    }
    function map(array, callback) {
      const result = [];
      let length = array.length;
      while (length--) {
        result[length] = callback(array[length]);
      }
      return result;
    }
    function mapDomain(domain, callback) {
      const parts = domain.split("@");
      let result = "";
      if (parts.length > 1) {
        result = parts[0] + "@";
        domain = parts[1];
      }
      domain = domain.replace(regexSeparators, ".");
      const labels = domain.split(".");
      const encoded = map(labels, callback).join(".");
      return result + encoded;
    }
    function ucs2decode(string) {
      const output = [];
      let counter = 0;
      const length = string.length;
      while (counter < length) {
        const value = string.charCodeAt(counter++);
        if (value >= 55296 && value <= 56319 && counter < length) {
          const extra = string.charCodeAt(counter++);
          if ((extra & 64512) == 56320) {
            output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
          } else {
            output.push(value);
            counter--;
          }
        } else {
          output.push(value);
        }
      }
      return output;
    }
    var ucs2encode = (codePoints) => String.fromCodePoint(...codePoints);
    var basicToDigit = function(codePoint) {
      if (codePoint >= 48 && codePoint < 58) {
        return 26 + (codePoint - 48);
      }
      if (codePoint >= 65 && codePoint < 91) {
        return codePoint - 65;
      }
      if (codePoint >= 97 && codePoint < 123) {
        return codePoint - 97;
      }
      return base;
    };
    var digitToBasic = function(digit, flag) {
      return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
    };
    var adapt = function(delta, numPoints, firstTime) {
      let k = 0;
      delta = firstTime ? floor(delta / damp) : delta >> 1;
      delta += floor(delta / numPoints);
      for (; delta > baseMinusTMin * tMax >> 1; k += base) {
        delta = floor(delta / baseMinusTMin);
      }
      return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
    };
    var decode = function(input2) {
      const output = [];
      const inputLength = input2.length;
      let i = 0;
      let n = initialN;
      let bias = initialBias;
      let basic = input2.lastIndexOf(delimiter);
      if (basic < 0) {
        basic = 0;
      }
      for (let j = 0; j < basic; ++j) {
        if (input2.charCodeAt(j) >= 128) {
          error("not-basic");
        }
        output.push(input2.charCodeAt(j));
      }
      for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
        const oldi = i;
        for (let w = 1, k = base; ; k += base) {
          if (index >= inputLength) {
            error("invalid-input");
          }
          const digit = basicToDigit(input2.charCodeAt(index++));
          if (digit >= base) {
            error("invalid-input");
          }
          if (digit > floor((maxInt - i) / w)) {
            error("overflow");
          }
          i += digit * w;
          const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
          if (digit < t) {
            break;
          }
          const baseMinusT = base - t;
          if (w > floor(maxInt / baseMinusT)) {
            error("overflow");
          }
          w *= baseMinusT;
        }
        const out = output.length + 1;
        bias = adapt(i - oldi, out, oldi == 0);
        if (floor(i / out) > maxInt - n) {
          error("overflow");
        }
        n += floor(i / out);
        i %= out;
        output.splice(i++, 0, n);
      }
      return String.fromCodePoint(...output);
    };
    var encode = function(input2) {
      const output = [];
      input2 = ucs2decode(input2);
      const inputLength = input2.length;
      let n = initialN;
      let delta = 0;
      let bias = initialBias;
      for (const currentValue of input2) {
        if (currentValue < 128) {
          output.push(stringFromCharCode(currentValue));
        }
      }
      const basicLength = output.length;
      let handledCPCount = basicLength;
      if (basicLength) {
        output.push(delimiter);
      }
      while (handledCPCount < inputLength) {
        let m = maxInt;
        for (const currentValue of input2) {
          if (currentValue >= n && currentValue < m) {
            m = currentValue;
          }
        }
        const handledCPCountPlusOne = handledCPCount + 1;
        if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
          error("overflow");
        }
        delta += (m - n) * handledCPCountPlusOne;
        n = m;
        for (const currentValue of input2) {
          if (currentValue < n && ++delta > maxInt) {
            error("overflow");
          }
          if (currentValue === n) {
            let q = delta;
            for (let k = base; ; k += base) {
              const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
              if (q < t) {
                break;
              }
              const qMinusT = q - t;
              const baseMinusT = base - t;
              output.push(
                stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
              );
              q = floor(qMinusT / baseMinusT);
            }
            output.push(stringFromCharCode(digitToBasic(q, 0)));
            bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
            delta = 0;
            ++handledCPCount;
          }
        }
        ++delta;
        ++n;
      }
      return output.join("");
    };
    var toUnicode = function(input2) {
      return mapDomain(input2, function(string) {
        return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
      });
    };
    var toASCII = function(input2) {
      return mapDomain(input2, function(string) {
        return regexNonASCII.test(string) ? "xn--" + encode(string) : string;
      });
    };
    var punycode = {
      /**
       * A string representing the current Punycode.js version number.
       * @memberOf punycode
       * @type String
       */
      "version": "2.3.1",
      /**
       * An object of methods to convert from JavaScript's internal character
       * representation (UCS-2) to Unicode code points, and back.
       * @see <https://mathiasbynens.be/notes/javascript-encoding>
       * @memberOf punycode
       * @type Object
       */
      "ucs2": {
        "decode": ucs2decode,
        "encode": ucs2encode
      },
      "decode": decode,
      "encode": encode,
      "toASCII": toASCII,
      "toUnicode": toUnicode
    };
    module2.exports = punycode;
  }
});

// node_modules/prosemirror-markdown/node_modules/markdown-it/dist/index.cjs.js
var require_index_cjs4 = __commonJS({
  "node_modules/prosemirror-markdown/node_modules/markdown-it/dist/index.cjs.js"(exports2, module2) {
    "use strict";
    var mdurl = require_index_cjs();
    var ucmicro = require_index_cjs2();
    var entities = require_lib2();
    var LinkifyIt = require_index_cjs3();
    var punycode = require_punycode();
    function _interopNamespaceDefault(e) {
      var n = /* @__PURE__ */ Object.create(null);
      if (e) {
        Object.keys(e).forEach(function(k) {
          if (k !== "default") {
            var d = Object.getOwnPropertyDescriptor(e, k);
            Object.defineProperty(n, k, d.get ? d : {
              enumerable: true,
              get: function() {
                return e[k];
              }
            });
          }
        });
      }
      n.default = e;
      return Object.freeze(n);
    }
    var mdurl__namespace = /* @__PURE__ */ _interopNamespaceDefault(mdurl);
    var ucmicro__namespace = /* @__PURE__ */ _interopNamespaceDefault(ucmicro);
    function _class(obj) {
      return Object.prototype.toString.call(obj);
    }
    function isString(obj) {
      return _class(obj) === "[object String]";
    }
    var _hasOwnProperty = Object.prototype.hasOwnProperty;
    function has(object, key) {
      return _hasOwnProperty.call(object, key);
    }
    function assign(obj) {
      const sources = Array.prototype.slice.call(arguments, 1);
      sources.forEach(function(source) {
        if (!source) {
          return;
        }
        if (typeof source !== "object") {
          throw new TypeError(source + "must be object");
        }
        Object.keys(source).forEach(function(key) {
          obj[key] = source[key];
        });
      });
      return obj;
    }
    function arrayReplaceAt(src, pos, newElements) {
      return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));
    }
    function isValidEntityCode(c) {
      if (c >= 55296 && c <= 57343) {
        return false;
      }
      if (c >= 64976 && c <= 65007) {
        return false;
      }
      if ((c & 65535) === 65535 || (c & 65535) === 65534) {
        return false;
      }
      if (c >= 0 && c <= 8) {
        return false;
      }
      if (c === 11) {
        return false;
      }
      if (c >= 14 && c <= 31) {
        return false;
      }
      if (c >= 127 && c <= 159) {
        return false;
      }
      if (c > 1114111) {
        return false;
      }
      return true;
    }
    function fromCodePoint(c) {
      if (c > 65535) {
        c -= 65536;
        const surrogate1 = 55296 + (c >> 10);
        const surrogate2 = 56320 + (c & 1023);
        return String.fromCharCode(surrogate1, surrogate2);
      }
      return String.fromCharCode(c);
    }
    var UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
    var ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;
    var UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + "|" + ENTITY_RE.source, "gi");
    var DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i;
    function replaceEntityPattern(match, name) {
      if (name.charCodeAt(0) === 35 && DIGITAL_ENTITY_TEST_RE.test(name)) {
        const code2 = name[1].toLowerCase() === "x" ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
        if (isValidEntityCode(code2)) {
          return fromCodePoint(code2);
        }
        return match;
      }
      const decoded = entities.decodeHTML(match);
      if (decoded !== match) {
        return decoded;
      }
      return match;
    }
    function unescapeMd(str) {
      if (str.indexOf("\\") < 0) {
        return str;
      }
      return str.replace(UNESCAPE_MD_RE, "$1");
    }
    function unescapeAll(str) {
      if (str.indexOf("\\") < 0 && str.indexOf("&") < 0) {
        return str;
      }
      return str.replace(UNESCAPE_ALL_RE, function(match, escaped, entity2) {
        if (escaped) {
          return escaped;
        }
        return replaceEntityPattern(match, entity2);
      });
    }
    var HTML_ESCAPE_TEST_RE = /[&<>"]/;
    var HTML_ESCAPE_REPLACE_RE = /[&<>"]/g;
    var HTML_REPLACEMENTS = {
      "&": "&amp;",
      "<": "&lt;",
      ">": "&gt;",
      '"': "&quot;"
    };
    function replaceUnsafeChar(ch) {
      return HTML_REPLACEMENTS[ch];
    }
    function escapeHtml(str) {
      if (HTML_ESCAPE_TEST_RE.test(str)) {
        return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
      }
      return str;
    }
    var REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g;
    function escapeRE(str) {
      return str.replace(REGEXP_ESCAPE_RE, "\\$&");
    }
    function isSpace(code2) {
      switch (code2) {
        case 9:
        case 32:
          return true;
      }
      return false;
    }
    function isWhiteSpace(code2) {
      if (code2 >= 8192 && code2 <= 8202) {
        return true;
      }
      switch (code2) {
        case 9:
        // \t
        case 10:
        // \n
        case 11:
        // \v
        case 12:
        // \f
        case 13:
        // \r
        case 32:
        case 160:
        case 5760:
        case 8239:
        case 8287:
        case 12288:
          return true;
      }
      return false;
    }
    function isPunctChar(ch) {
      return ucmicro__namespace.P.test(ch) || ucmicro__namespace.S.test(ch);
    }
    function isMdAsciiPunct(ch) {
      switch (ch) {
        case 33:
        case 34:
        case 35:
        case 36:
        case 37:
        case 38:
        case 39:
        case 40:
        case 41:
        case 42:
        case 43:
        case 44:
        case 45:
        case 46:
        case 47:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 91:
        case 92:
        case 93:
        case 94:
        case 95:
        case 96:
        case 123:
        case 124:
        case 125:
        case 126:
          return true;
        default:
          return false;
      }
    }
    function normalizeReference(str) {
      str = str.trim().replace(/\s+/g, " ");
      if ("\u1E9E".toLowerCase() === "\u1E7E") {
        str = str.replace(/ẞ/g, "\xDF");
      }
      return str.toLowerCase().toUpperCase();
    }
    var lib = {
      mdurl: mdurl__namespace,
      ucmicro: ucmicro__namespace
    };
    var utils = /* @__PURE__ */ Object.freeze({
      __proto__: null,
      arrayReplaceAt,
      assign,
      escapeHtml,
      escapeRE,
      fromCodePoint,
      has,
      isMdAsciiPunct,
      isPunctChar,
      isSpace,
      isString,
      isValidEntityCode,
      isWhiteSpace,
      lib,
      normalizeReference,
      unescapeAll,
      unescapeMd
    });
    function parseLinkLabel(state, start, disableNested) {
      let level, found, marker, prevPos;
      const max = state.posMax;
      const oldPos = state.pos;
      state.pos = start + 1;
      level = 1;
      while (state.pos < max) {
        marker = state.src.charCodeAt(state.pos);
        if (marker === 93) {
          level--;
          if (level === 0) {
            found = true;
            break;
          }
        }
        prevPos = state.pos;
        state.md.inline.skipToken(state);
        if (marker === 91) {
          if (prevPos === state.pos - 1) {
            level++;
          } else if (disableNested) {
            state.pos = oldPos;
            return -1;
          }
        }
      }
      let labelEnd = -1;
      if (found) {
        labelEnd = state.pos;
      }
      state.pos = oldPos;
      return labelEnd;
    }
    function parseLinkDestination(str, start, max) {
      let code2;
      let pos = start;
      const result = {
        ok: false,
        pos: 0,
        str: ""
      };
      if (str.charCodeAt(pos) === 60) {
        pos++;
        while (pos < max) {
          code2 = str.charCodeAt(pos);
          if (code2 === 10) {
            return result;
          }
          if (code2 === 60) {
            return result;
          }
          if (code2 === 62) {
            result.pos = pos + 1;
            result.str = unescapeAll(str.slice(start + 1, pos));
            result.ok = true;
            return result;
          }
          if (code2 === 92 && pos + 1 < max) {
            pos += 2;
            continue;
          }
          pos++;
        }
        return result;
      }
      let level = 0;
      while (pos < max) {
        code2 = str.charCodeAt(pos);
        if (code2 === 32) {
          break;
        }
        if (code2 < 32 || code2 === 127) {
          break;
        }
        if (code2 === 92 && pos + 1 < max) {
          if (str.charCodeAt(pos + 1) === 32) {
            break;
          }
          pos += 2;
          continue;
        }
        if (code2 === 40) {
          level++;
          if (level > 32) {
            return result;
          }
        }
        if (code2 === 41) {
          if (level === 0) {
            break;
          }
          level--;
        }
        pos++;
      }
      if (start === pos) {
        return result;
      }
      if (level !== 0) {
        return result;
      }
      result.str = unescapeAll(str.slice(start, pos));
      result.pos = pos;
      result.ok = true;
      return result;
    }
    function parseLinkTitle(str, start, max, prev_state) {
      let code2;
      let pos = start;
      const state = {
        // if `true`, this is a valid link title
        ok: false,
        // if `true`, this link can be continued on the next line
        can_continue: false,
        // if `ok`, it's the position of the first character after the closing marker
        pos: 0,
        // if `ok`, it's the unescaped title
        str: "",
        // expected closing marker character code
        marker: 0
      };
      if (prev_state) {
        state.str = prev_state.str;
        state.marker = prev_state.marker;
      } else {
        if (pos >= max) {
          return state;
        }
        let marker = str.charCodeAt(pos);
        if (marker !== 34 && marker !== 39 && marker !== 40) {
          return state;
        }
        start++;
        pos++;
        if (marker === 40) {
          marker = 41;
        }
        state.marker = marker;
      }
      while (pos < max) {
        code2 = str.charCodeAt(pos);
        if (code2 === state.marker) {
          state.pos = pos + 1;
          state.str += unescapeAll(str.slice(start, pos));
          state.ok = true;
          return state;
        } else if (code2 === 40 && state.marker === 41) {
          return state;
        } else if (code2 === 92 && pos + 1 < max) {
          pos++;
        }
        pos++;
      }
      state.can_continue = true;
      state.str += unescapeAll(str.slice(start, pos));
      return state;
    }
    var helpers = /* @__PURE__ */ Object.freeze({
      __proto__: null,
      parseLinkDestination,
      parseLinkLabel,
      parseLinkTitle
    });
    var default_rules = {};
    default_rules.code_inline = function(tokens, idx, options, env, slf) {
      const token = tokens[idx];
      return "<code" + slf.renderAttrs(token) + ">" + escapeHtml(token.content) + "</code>";
    };
    default_rules.code_block = function(tokens, idx, options, env, slf) {
      const token = tokens[idx];
      return "<pre" + slf.renderAttrs(token) + "><code>" + escapeHtml(tokens[idx].content) + "</code></pre>\n";
    };
    default_rules.fence = function(tokens, idx, options, env, slf) {
      const token = tokens[idx];
      const info = token.info ? unescapeAll(token.info).trim() : "";
      let langName = "";
      let langAttrs = "";
      if (info) {
        const arr = info.split(/(\s+)/g);
        langName = arr[0];
        langAttrs = arr.slice(2).join("");
      }
      let highlighted;
      if (options.highlight) {
        highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content);
      } else {
        highlighted = escapeHtml(token.content);
      }
      if (highlighted.indexOf("<pre") === 0) {
        return highlighted + "\n";
      }
      if (info) {
        const i = token.attrIndex("class");
        const tmpAttrs = token.attrs ? token.attrs.slice() : [];
        if (i < 0) {
          tmpAttrs.push(["class", options.langPrefix + langName]);
        } else {
          tmpAttrs[i] = tmpAttrs[i].slice();
          tmpAttrs[i][1] += " " + options.langPrefix + langName;
        }
        const tmpToken = {
          attrs: tmpAttrs
        };
        return `<pre><code${slf.renderAttrs(tmpToken)}>${highlighted}</code></pre>
`;
      }
      return `<pre><code${slf.renderAttrs(token)}>${highlighted}</code></pre>
`;
    };
    default_rules.image = function(tokens, idx, options, env, slf) {
      const token = tokens[idx];
      token.attrs[token.attrIndex("alt")][1] = slf.renderInlineAsText(token.children, options, env);
      return slf.renderToken(tokens, idx, options);
    };
    default_rules.hardbreak = function(tokens, idx, options) {
      return options.xhtmlOut ? "<br />\n" : "<br>\n";
    };
    default_rules.softbreak = function(tokens, idx, options) {
      return options.breaks ? options.xhtmlOut ? "<br />\n" : "<br>\n" : "\n";
    };
    default_rules.text = function(tokens, idx) {
      return escapeHtml(tokens[idx].content);
    };
    default_rules.html_block = function(tokens, idx) {
      return tokens[idx].content;
    };
    default_rules.html_inline = function(tokens, idx) {
      return tokens[idx].content;
    };
    function Renderer() {
      this.rules = assign({}, default_rules);
    }
    Renderer.prototype.renderAttrs = function renderAttrs(token) {
      let i, l, result;
      if (!token.attrs) {
        return "";
      }
      result = "";
      for (i = 0, l = token.attrs.length; i < l; i++) {
        result += " " + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"';
      }
      return result;
    };
    Renderer.prototype.renderToken = function renderToken(tokens, idx, options) {
      const token = tokens[idx];
      let result = "";
      if (token.hidden) {
        return "";
      }
      if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
        result += "\n";
      }
      result += (token.nesting === -1 ? "</" : "<") + token.tag;
      result += this.renderAttrs(token);
      if (token.nesting === 0 && options.xhtmlOut) {
        result += " /";
      }
      let needLf = false;
      if (token.block) {
        needLf = true;
        if (token.nesting === 1) {
          if (idx + 1 < tokens.length) {
            const nextToken = tokens[idx + 1];
            if (nextToken.type === "inline" || nextToken.hidden) {
              needLf = false;
            } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
              needLf = false;
            }
          }
        }
      }
      result += needLf ? ">\n" : ">";
      return result;
    };
    Renderer.prototype.renderInline = function(tokens, options, env) {
      let result = "";
      const rules = this.rules;
      for (let i = 0, len = tokens.length; i < len; i++) {
        const type = tokens[i].type;
        if (typeof rules[type] !== "undefined") {
          result += rules[type](tokens, i, options, env, this);
        } else {
          result += this.renderToken(tokens, i, options);
        }
      }
      return result;
    };
    Renderer.prototype.renderInlineAsText = function(tokens, options, env) {
      let result = "";
      for (let i = 0, len = tokens.length; i < len; i++) {
        switch (tokens[i].type) {
          case "text":
            result += tokens[i].content;
            break;
          case "image":
            result += this.renderInlineAsText(tokens[i].children, options, env);
            break;
          case "html_inline":
          case "html_block":
            result += tokens[i].content;
            break;
          case "softbreak":
          case "hardbreak":
            result += "\n";
            break;
        }
      }
      return result;
    };
    Renderer.prototype.render = function(tokens, options, env) {
      let result = "";
      const rules = this.rules;
      for (let i = 0, len = tokens.length; i < len; i++) {
        const type = tokens[i].type;
        if (type === "inline") {
          result += this.renderInline(tokens[i].children, options, env);
        } else if (typeof rules[type] !== "undefined") {
          result += rules[type](tokens, i, options, env, this);
        } else {
          result += this.renderToken(tokens, i, options, env);
        }
      }
      return result;
    };
    function Ruler() {
      this.__rules__ = [];
      this.__cache__ = null;
    }
    Ruler.prototype.__find__ = function(name) {
      for (let i = 0; i < this.__rules__.length; i++) {
        if (this.__rules__[i].name === name) {
          return i;
        }
      }
      return -1;
    };
    Ruler.prototype.__compile__ = function() {
      const self2 = this;
      const chains = [""];
      self2.__rules__.forEach(function(rule) {
        if (!rule.enabled) {
          return;
        }
        rule.alt.forEach(function(altName) {
          if (chains.indexOf(altName) < 0) {
            chains.push(altName);
          }
        });
      });
      self2.__cache__ = {};
      chains.forEach(function(chain) {
        self2.__cache__[chain] = [];
        self2.__rules__.forEach(function(rule) {
          if (!rule.enabled) {
            return;
          }
          if (chain && rule.alt.indexOf(chain) < 0) {
            return;
          }
          self2.__cache__[chain].push(rule.fn);
        });
      });
    };
    Ruler.prototype.at = function(name, fn, options) {
      const index = this.__find__(name);
      const opt = options || {};
      if (index === -1) {
        throw new Error("Parser rule not found: " + name);
      }
      this.__rules__[index].fn = fn;
      this.__rules__[index].alt = opt.alt || [];
      this.__cache__ = null;
    };
    Ruler.prototype.before = function(beforeName, ruleName, fn, options) {
      const index = this.__find__(beforeName);
      const opt = options || {};
      if (index === -1) {
        throw new Error("Parser rule not found: " + beforeName);
      }
      this.__rules__.splice(index, 0, {
        name: ruleName,
        enabled: true,
        fn,
        alt: opt.alt || []
      });
      this.__cache__ = null;
    };
    Ruler.prototype.after = function(afterName, ruleName, fn, options) {
      const index = this.__find__(afterName);
      const opt = options || {};
      if (index === -1) {
        throw new Error("Parser rule not found: " + afterName);
      }
      this.__rules__.splice(index + 1, 0, {
        name: ruleName,
        enabled: true,
        fn,
        alt: opt.alt || []
      });
      this.__cache__ = null;
    };
    Ruler.prototype.push = function(ruleName, fn, options) {
      const opt = options || {};
      this.__rules__.push({
        name: ruleName,
        enabled: true,
        fn,
        alt: opt.alt || []
      });
      this.__cache__ = null;
    };
    Ruler.prototype.enable = function(list2, ignoreInvalid) {
      if (!Array.isArray(list2)) {
        list2 = [list2];
      }
      const result = [];
      list2.forEach(function(name) {
        const idx = this.__find__(name);
        if (idx < 0) {
          if (ignoreInvalid) {
            return;
          }
          throw new Error("Rules manager: invalid rule name " + name);
        }
        this.__rules__[idx].enabled = true;
        result.push(name);
      }, this);
      this.__cache__ = null;
      return result;
    };
    Ruler.prototype.enableOnly = function(list2, ignoreInvalid) {
      if (!Array.isArray(list2)) {
        list2 = [list2];
      }
      this.__rules__.forEach(function(rule) {
        rule.enabled = false;
      });
      this.enable(list2, ignoreInvalid);
    };
    Ruler.prototype.disable = function(list2, ignoreInvalid) {
      if (!Array.isArray(list2)) {
        list2 = [list2];
      }
      const result = [];
      list2.forEach(function(name) {
        const idx = this.__find__(name);
        if (idx < 0) {
          if (ignoreInvalid) {
            return;
          }
          throw new Error("Rules manager: invalid rule name " + name);
        }
        this.__rules__[idx].enabled = false;
        result.push(name);
      }, this);
      this.__cache__ = null;
      return result;
    };
    Ruler.prototype.getRules = function(chainName) {
      if (this.__cache__ === null) {
        this.__compile__();
      }
      return this.__cache__[chainName] || [];
    };
    function Token(type, tag, nesting) {
      this.type = type;
      this.tag = tag;
      this.attrs = null;
      this.map = null;
      this.nesting = nesting;
      this.level = 0;
      this.children = null;
      this.content = "";
      this.markup = "";
      this.info = "";
      this.meta = null;
      this.block = false;
      this.hidden = false;
    }
    Token.prototype.attrIndex = function attrIndex(name) {
      if (!this.attrs) {
        return -1;
      }
      const attrs = this.attrs;
      for (let i = 0, len = attrs.length; i < len; i++) {
        if (attrs[i][0] === name) {
          return i;
        }
      }
      return -1;
    };
    Token.prototype.attrPush = function attrPush(attrData) {
      if (this.attrs) {
        this.attrs.push(attrData);
      } else {
        this.attrs = [attrData];
      }
    };
    Token.prototype.attrSet = function attrSet(name, value) {
      const idx = this.attrIndex(name);
      const attrData = [name, value];
      if (idx < 0) {
        this.attrPush(attrData);
      } else {
        this.attrs[idx] = attrData;
      }
    };
    Token.prototype.attrGet = function attrGet(name) {
      const idx = this.attrIndex(name);
      let value = null;
      if (idx >= 0) {
        value = this.attrs[idx][1];
      }
      return value;
    };
    Token.prototype.attrJoin = function attrJoin(name, value) {
      const idx = this.attrIndex(name);
      if (idx < 0) {
        this.attrPush([name, value]);
      } else {
        this.attrs[idx][1] = this.attrs[idx][1] + " " + value;
      }
    };
    function StateCore(src, md, env) {
      this.src = src;
      this.env = env;
      this.tokens = [];
      this.inlineMode = false;
      this.md = md;
    }
    StateCore.prototype.Token = Token;
    var NEWLINES_RE = /\r\n?|\n/g;
    var NULL_RE = /\0/g;
    function normalize(state) {
      let str;
      str = state.src.replace(NEWLINES_RE, "\n");
      str = str.replace(NULL_RE, "\uFFFD");
      state.src = str;
    }
    function block(state) {
      let token;
      if (state.inlineMode) {
        token = new state.Token("inline", "", 0);
        token.content = state.src;
        token.map = [0, 1];
        token.children = [];
        state.tokens.push(token);
      } else {
        state.md.block.parse(state.src, state.md, state.env, state.tokens);
      }
    }
    function inline(state) {
      const tokens = state.tokens;
      for (let i = 0, l = tokens.length; i < l; i++) {
        const tok = tokens[i];
        if (tok.type === "inline") {
          state.md.inline.parse(tok.content, state.md, state.env, tok.children);
        }
      }
    }
    function isLinkOpen$1(str) {
      return /^<a[>\s]/i.test(str);
    }
    function isLinkClose$1(str) {
      return /^<\/a\s*>/i.test(str);
    }
    function linkify$1(state) {
      const blockTokens = state.tokens;
      if (!state.md.options.linkify) {
        return;
      }
      for (let j = 0, l = blockTokens.length; j < l; j++) {
        if (blockTokens[j].type !== "inline" || !state.md.linkify.pretest(blockTokens[j].content)) {
          continue;
        }
        let tokens = blockTokens[j].children;
        let htmlLinkLevel = 0;
        for (let i = tokens.length - 1; i >= 0; i--) {
          const currentToken = tokens[i];
          if (currentToken.type === "link_close") {
            i--;
            while (tokens[i].level !== currentToken.level && tokens[i].type !== "link_open") {
              i--;
            }
            continue;
          }
          if (currentToken.type === "html_inline") {
            if (isLinkOpen$1(currentToken.content) && htmlLinkLevel > 0) {
              htmlLinkLevel--;
            }
            if (isLinkClose$1(currentToken.content)) {
              htmlLinkLevel++;
            }
          }
          if (htmlLinkLevel > 0) {
            continue;
          }
          if (currentToken.type === "text" && state.md.linkify.test(currentToken.content)) {
            const text2 = currentToken.content;
            let links = state.md.linkify.match(text2);
            const nodes = [];
            let level = currentToken.level;
            let lastPos = 0;
            if (links.length > 0 && links[0].index === 0 && i > 0 && tokens[i - 1].type === "text_special") {
              links = links.slice(1);
            }
            for (let ln = 0; ln < links.length; ln++) {
              const url = links[ln].url;
              const fullUrl = state.md.normalizeLink(url);
              if (!state.md.validateLink(fullUrl)) {
                continue;
              }
              let urlText = links[ln].text;
              if (!links[ln].schema) {
                urlText = state.md.normalizeLinkText("http://" + urlText).replace(/^http:\/\//, "");
              } else if (links[ln].schema === "mailto:" && !/^mailto:/i.test(urlText)) {
                urlText = state.md.normalizeLinkText("mailto:" + urlText).replace(/^mailto:/, "");
              } else {
                urlText = state.md.normalizeLinkText(urlText);
              }
              const pos = links[ln].index;
              if (pos > lastPos) {
                const token = new state.Token("text", "", 0);
                token.content = text2.slice(lastPos, pos);
                token.level = level;
                nodes.push(token);
              }
              const token_o = new state.Token("link_open", "a", 1);
              token_o.attrs = [["href", fullUrl]];
              token_o.level = level++;
              token_o.markup = "linkify";
              token_o.info = "auto";
              nodes.push(token_o);
              const token_t = new state.Token("text", "", 0);
              token_t.content = urlText;
              token_t.level = level;
              nodes.push(token_t);
              const token_c = new state.Token("link_close", "a", -1);
              token_c.level = --level;
              token_c.markup = "linkify";
              token_c.info = "auto";
              nodes.push(token_c);
              lastPos = links[ln].lastIndex;
            }
            if (lastPos < text2.length) {
              const token = new state.Token("text", "", 0);
              token.content = text2.slice(lastPos);
              token.level = level;
              nodes.push(token);
            }
            blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
          }
        }
      }
    }
    var RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/;
    var SCOPED_ABBR_TEST_RE = /\((c|tm|r)\)/i;
    var SCOPED_ABBR_RE = /\((c|tm|r)\)/ig;
    var SCOPED_ABBR = {
      c: "\xA9",
      r: "\xAE",
      tm: "\u2122"
    };
    function replaceFn(match, name) {
      return SCOPED_ABBR[name.toLowerCase()];
    }
    function replace_scoped(inlineTokens) {
      let inside_autolink = 0;
      for (let i = inlineTokens.length - 1; i >= 0; i--) {
        const token = inlineTokens[i];
        if (token.type === "text" && !inside_autolink) {
          token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);
        }
        if (token.type === "link_open" && token.info === "auto") {
          inside_autolink--;
        }
        if (token.type === "link_close" && token.info === "auto") {
          inside_autolink++;
        }
      }
    }
    function replace_rare(inlineTokens) {
      let inside_autolink = 0;
      for (let i = inlineTokens.length - 1; i >= 0; i--) {
        const token = inlineTokens[i];
        if (token.type === "text" && !inside_autolink) {
          if (RARE_RE.test(token.content)) {
            token.content = token.content.replace(/\+-/g, "\xB1").replace(/\.{2,}/g, "\u2026").replace(/([?!])…/g, "$1..").replace(/([?!]){4,}/g, "$1$1$1").replace(/,{2,}/g, ",").replace(/(^|[^-])---(?=[^-]|$)/mg, "$1\u2014").replace(/(^|\s)--(?=\s|$)/mg, "$1\u2013").replace(/(^|[^-\s])--(?=[^-\s]|$)/mg, "$1\u2013");
          }
        }
        if (token.type === "link_open" && token.info === "auto") {
          inside_autolink--;
        }
        if (token.type === "link_close" && token.info === "auto") {
          inside_autolink++;
        }
      }
    }
    function replace(state) {
      let blkIdx;
      if (!state.md.options.typographer) {
        return;
      }
      for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
        if (state.tokens[blkIdx].type !== "inline") {
          continue;
        }
        if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
          replace_scoped(state.tokens[blkIdx].children);
        }
        if (RARE_RE.test(state.tokens[blkIdx].content)) {
          replace_rare(state.tokens[blkIdx].children);
        }
      }
    }
    var QUOTE_TEST_RE = /['"]/;
    var QUOTE_RE = /['"]/g;
    var APOSTROPHE = "\u2019";
    function replaceAt(str, index, ch) {
      return str.slice(0, index) + ch + str.slice(index + 1);
    }
    function process_inlines(tokens, state) {
      let j;
      const stack = [];
      for (let i = 0; i < tokens.length; i++) {
        const token = tokens[i];
        const thisLevel = tokens[i].level;
        for (j = stack.length - 1; j >= 0; j--) {
          if (stack[j].level <= thisLevel) {
            break;
          }
        }
        stack.length = j + 1;
        if (token.type !== "text") {
          continue;
        }
        let text2 = token.content;
        let pos = 0;
        let max = text2.length;
        OUTER: while (pos < max) {
          QUOTE_RE.lastIndex = pos;
          const t = QUOTE_RE.exec(text2);
          if (!t) {
            break;
          }
          let canOpen = true;
          let canClose = true;
          pos = t.index + 1;
          const isSingle = t[0] === "'";
          let lastChar = 32;
          if (t.index - 1 >= 0) {
            lastChar = text2.charCodeAt(t.index - 1);
          } else {
            for (j = i - 1; j >= 0; j--) {
              if (tokens[j].type === "softbreak" || tokens[j].type === "hardbreak") break;
              if (!tokens[j].content) continue;
              lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);
              break;
            }
          }
          let nextChar = 32;
          if (pos < max) {
            nextChar = text2.charCodeAt(pos);
          } else {
            for (j = i + 1; j < tokens.length; j++) {
              if (tokens[j].type === "softbreak" || tokens[j].type === "hardbreak") break;
              if (!tokens[j].content) continue;
              nextChar = tokens[j].content.charCodeAt(0);
              break;
            }
          }
          const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
          const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
          const isLastWhiteSpace = isWhiteSpace(lastChar);
          const isNextWhiteSpace = isWhiteSpace(nextChar);
          if (isNextWhiteSpace) {
            canOpen = false;
          } else if (isNextPunctChar) {
            if (!(isLastWhiteSpace || isLastPunctChar)) {
              canOpen = false;
            }
          }
          if (isLastWhiteSpace) {
            canClose = false;
          } else if (isLastPunctChar) {
            if (!(isNextWhiteSpace || isNextPunctChar)) {
              canClose = false;
            }
          }
          if (nextChar === 34 && t[0] === '"') {
            if (lastChar >= 48 && lastChar <= 57) {
              canClose = canOpen = false;
            }
          }
          if (canOpen && canClose) {
            canOpen = isLastPunctChar;
            canClose = isNextPunctChar;
          }
          if (!canOpen && !canClose) {
            if (isSingle) {
              token.content = replaceAt(token.content, t.index, APOSTROPHE);
            }
            continue;
          }
          if (canClose) {
            for (j = stack.length - 1; j >= 0; j--) {
              let item = stack[j];
              if (stack[j].level < thisLevel) {
                break;
              }
              if (item.single === isSingle && stack[j].level === thisLevel) {
                item = stack[j];
                let openQuote;
                let closeQuote;
                if (isSingle) {
                  openQuote = state.md.options.quotes[2];
                  closeQuote = state.md.options.quotes[3];
                } else {
                  openQuote = state.md.options.quotes[0];
                  closeQuote = state.md.options.quotes[1];
                }
                token.content = replaceAt(token.content, t.index, closeQuote);
                tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, openQuote);
                pos += closeQuote.length - 1;
                if (item.token === i) {
                  pos += openQuote.length - 1;
                }
                text2 = token.content;
                max = text2.length;
                stack.length = j;
                continue OUTER;
              }
            }
          }
          if (canOpen) {
            stack.push({
              token: i,
              pos: t.index,
              single: isSingle,
              level: thisLevel
            });
          } else if (canClose && isSingle) {
            token.content = replaceAt(token.content, t.index, APOSTROPHE);
          }
        }
      }
    }
    function smartquotes(state) {
      if (!state.md.options.typographer) {
        return;
      }
      for (let blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
        if (state.tokens[blkIdx].type !== "inline" || !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {
          continue;
        }
        process_inlines(state.tokens[blkIdx].children, state);
      }
    }
    function text_join(state) {
      let curr, last;
      const blockTokens = state.tokens;
      const l = blockTokens.length;
      for (let j = 0; j < l; j++) {
        if (blockTokens[j].type !== "inline") continue;
        const tokens = blockTokens[j].children;
        const max = tokens.length;
        for (curr = 0; curr < max; curr++) {
          if (tokens[curr].type === "text_special") {
            tokens[curr].type = "text";
          }
        }
        for (curr = last = 0; curr < max; curr++) {
          if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") {
            tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
          } else {
            if (curr !== last) {
              tokens[last] = tokens[curr];
            }
            last++;
          }
        }
        if (curr !== last) {
          tokens.length = last;
        }
      }
    }
    var _rules$2 = [
      ["normalize", normalize],
      ["block", block],
      ["inline", inline],
      ["linkify", linkify$1],
      ["replacements", replace],
      ["smartquotes", smartquotes],
      // `text_join` finds `text_special` tokens (for escape sequences)
      // and joins them with the rest of the text
      ["text_join", text_join]
    ];
    function Core() {
      this.ruler = new Ruler();
      for (let i = 0; i < _rules$2.length; i++) {
        this.ruler.push(_rules$2[i][0], _rules$2[i][1]);
      }
    }
    Core.prototype.process = function(state) {
      const rules = this.ruler.getRules("");
      for (let i = 0, l = rules.length; i < l; i++) {
        rules[i](state);
      }
    };
    Core.prototype.State = StateCore;
    function StateBlock(src, md, env, tokens) {
      this.src = src;
      this.md = md;
      this.env = env;
      this.tokens = tokens;
      this.bMarks = [];
      this.eMarks = [];
      this.tShift = [];
      this.sCount = [];
      this.bsCount = [];
      this.blkIndent = 0;
      this.line = 0;
      this.lineMax = 0;
      this.tight = false;
      this.ddIndent = -1;
      this.listIndent = -1;
      this.parentType = "root";
      this.level = 0;
      const s = this.src;
      for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos < len; pos++) {
        const ch = s.charCodeAt(pos);
        if (!indent_found) {
          if (isSpace(ch)) {
            indent++;
            if (ch === 9) {
              offset += 4 - offset % 4;
            } else {
              offset++;
            }
            continue;
          } else {
            indent_found = true;
          }
        }
        if (ch === 10 || pos === len - 1) {
          if (ch !== 10) {
            pos++;
          }
          this.bMarks.push(start);
          this.eMarks.push(pos);
          this.tShift.push(indent);
          this.sCount.push(offset);
          this.bsCount.push(0);
          indent_found = false;
          indent = 0;
          offset = 0;
          start = pos + 1;
        }
      }
      this.bMarks.push(s.length);
      this.eMarks.push(s.length);
      this.tShift.push(0);
      this.sCount.push(0);
      this.bsCount.push(0);
      this.lineMax = this.bMarks.length - 1;
    }
    StateBlock.prototype.push = function(type, tag, nesting) {
      const token = new Token(type, tag, nesting);
      token.block = true;
      if (nesting < 0) this.level--;
      token.level = this.level;
      if (nesting > 0) this.level++;
      this.tokens.push(token);
      return token;
    };
    StateBlock.prototype.isEmpty = function isEmpty(line) {
      return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];
    };
    StateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {
      for (let max = this.lineMax; from < max; from++) {
        if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {
          break;
        }
      }
      return from;
    };
    StateBlock.prototype.skipSpaces = function skipSpaces(pos) {
      for (let max = this.src.length; pos < max; pos++) {
        const ch = this.src.charCodeAt(pos);
        if (!isSpace(ch)) {
          break;
        }
      }
      return pos;
    };
    StateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {
      if (pos <= min) {
        return pos;
      }
      while (pos > min) {
        if (!isSpace(this.src.charCodeAt(--pos))) {
          return pos + 1;
        }
      }
      return pos;
    };
    StateBlock.prototype.skipChars = function skipChars(pos, code2) {
      for (let max = this.src.length; pos < max; pos++) {
        if (this.src.charCodeAt(pos) !== code2) {
          break;
        }
      }
      return pos;
    };
    StateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code2, min) {
      if (pos <= min) {
        return pos;
      }
      while (pos > min) {
        if (code2 !== this.src.charCodeAt(--pos)) {
          return pos + 1;
        }
      }
      return pos;
    };
    StateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {
      if (begin >= end) {
        return "";
      }
      const queue = new Array(end - begin);
      for (let i = 0, line = begin; line < end; line++, i++) {
        let lineIndent = 0;
        const lineStart = this.bMarks[line];
        let first = lineStart;
        let last;
        if (line + 1 < end || keepLastLF) {
          last = this.eMarks[line] + 1;
        } else {
          last = this.eMarks[line];
        }
        while (first < last && lineIndent < indent) {
          const ch = this.src.charCodeAt(first);
          if (isSpace(ch)) {
            if (ch === 9) {
              lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
            } else {
              lineIndent++;
            }
          } else if (first - lineStart < this.tShift[line]) {
            lineIndent++;
          } else {
            break;
          }
          first++;
        }
        if (lineIndent > indent) {
          queue[i] = new Array(lineIndent - indent + 1).join(" ") + this.src.slice(first, last);
        } else {
          queue[i] = this.src.slice(first, last);
        }
      }
      return queue.join("");
    };
    StateBlock.prototype.Token = Token;
    var MAX_AUTOCOMPLETED_CELLS = 65536;
    function getLine(state, line) {
      const pos = state.bMarks[line] + state.tShift[line];
      const max = state.eMarks[line];
      return state.src.slice(pos, max);
    }
    function escapedSplit(str) {
      const result = [];
      const max = str.length;
      let pos = 0;
      let ch = str.charCodeAt(pos);
      let isEscaped = false;
      let lastPos = 0;
      let current = "";
      while (pos < max) {
        if (ch === 124) {
          if (!isEscaped) {
            result.push(current + str.substring(lastPos, pos));
            current = "";
            lastPos = pos + 1;
          } else {
            current += str.substring(lastPos, pos - 1);
            lastPos = pos;
          }
        }
        isEscaped = ch === 92;
        pos++;
        ch = str.charCodeAt(pos);
      }
      result.push(current + str.substring(lastPos));
      return result;
    }
    function table(state, startLine, endLine, silent) {
      if (startLine + 2 > endLine) {
        return false;
      }
      let nextLine = startLine + 1;
      if (state.sCount[nextLine] < state.blkIndent) {
        return false;
      }
      if (state.sCount[nextLine] - state.blkIndent >= 4) {
        return false;
      }
      let pos = state.bMarks[nextLine] + state.tShift[nextLine];
      if (pos >= state.eMarks[nextLine]) {
        return false;
      }
      const firstCh = state.src.charCodeAt(pos++);
      if (firstCh !== 124 && firstCh !== 45 && firstCh !== 58) {
        return false;
      }
      if (pos >= state.eMarks[nextLine]) {
        return false;
      }
      const secondCh = state.src.charCodeAt(pos++);
      if (secondCh !== 124 && secondCh !== 45 && secondCh !== 58 && !isSpace(secondCh)) {
        return false;
      }
      if (firstCh === 45 && isSpace(secondCh)) {
        return false;
      }
      while (pos < state.eMarks[nextLine]) {
        const ch = state.src.charCodeAt(pos);
        if (ch !== 124 && ch !== 45 && ch !== 58 && !isSpace(ch)) {
          return false;
        }
        pos++;
      }
      let lineText = getLine(state, startLine + 1);
      let columns = lineText.split("|");
      const aligns = [];
      for (let i = 0; i < columns.length; i++) {
        const t = columns[i].trim();
        if (!t) {
          if (i === 0 || i === columns.length - 1) {
            continue;
          } else {
            return false;
          }
        }
        if (!/^:?-+:?$/.test(t)) {
          return false;
        }
        if (t.charCodeAt(t.length - 1) === 58) {
          aligns.push(t.charCodeAt(0) === 58 ? "center" : "right");
        } else if (t.charCodeAt(0) === 58) {
          aligns.push("left");
        } else {
          aligns.push("");
        }
      }
      lineText = getLine(state, startLine).trim();
      if (lineText.indexOf("|") === -1) {
        return false;
      }
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      columns = escapedSplit(lineText);
      if (columns.length && columns[0] === "") columns.shift();
      if (columns.length && columns[columns.length - 1] === "") columns.pop();
      const columnCount = columns.length;
      if (columnCount === 0 || columnCount !== aligns.length) {
        return false;
      }
      if (silent) {
        return true;
      }
      const oldParentType = state.parentType;
      state.parentType = "table";
      const terminatorRules = state.md.block.ruler.getRules("blockquote");
      const token_to = state.push("table_open", "table", 1);
      const tableLines = [startLine, 0];
      token_to.map = tableLines;
      const token_tho = state.push("thead_open", "thead", 1);
      token_tho.map = [startLine, startLine + 1];
      const token_htro = state.push("tr_open", "tr", 1);
      token_htro.map = [startLine, startLine + 1];
      for (let i = 0; i < columns.length; i++) {
        const token_ho = state.push("th_open", "th", 1);
        if (aligns[i]) {
          token_ho.attrs = [["style", "text-align:" + aligns[i]]];
        }
        const token_il = state.push("inline", "", 0);
        token_il.content = columns[i].trim();
        token_il.children = [];
        state.push("th_close", "th", -1);
      }
      state.push("tr_close", "tr", -1);
      state.push("thead_close", "thead", -1);
      let tbodyLines;
      let autocompletedCells = 0;
      for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
        if (state.sCount[nextLine] < state.blkIndent) {
          break;
        }
        let terminate = false;
        for (let i = 0, l = terminatorRules.length; i < l; i++) {
          if (terminatorRules[i](state, nextLine, endLine, true)) {
            terminate = true;
            break;
          }
        }
        if (terminate) {
          break;
        }
        lineText = getLine(state, nextLine).trim();
        if (!lineText) {
          break;
        }
        if (state.sCount[nextLine] - state.blkIndent >= 4) {
          break;
        }
        columns = escapedSplit(lineText);
        if (columns.length && columns[0] === "") columns.shift();
        if (columns.length && columns[columns.length - 1] === "") columns.pop();
        autocompletedCells += columnCount - columns.length;
        if (autocompletedCells > MAX_AUTOCOMPLETED_CELLS) {
          break;
        }
        if (nextLine === startLine + 2) {
          const token_tbo = state.push("tbody_open", "tbody", 1);
          token_tbo.map = tbodyLines = [startLine + 2, 0];
        }
        const token_tro = state.push("tr_open", "tr", 1);
        token_tro.map = [nextLine, nextLine + 1];
        for (let i = 0; i < columnCount; i++) {
          const token_tdo = state.push("td_open", "td", 1);
          if (aligns[i]) {
            token_tdo.attrs = [["style", "text-align:" + aligns[i]]];
          }
          const token_il = state.push("inline", "", 0);
          token_il.content = columns[i] ? columns[i].trim() : "";
          token_il.children = [];
          state.push("td_close", "td", -1);
        }
        state.push("tr_close", "tr", -1);
      }
      if (tbodyLines) {
        state.push("tbody_close", "tbody", -1);
        tbodyLines[1] = nextLine;
      }
      state.push("table_close", "table", -1);
      tableLines[1] = nextLine;
      state.parentType = oldParentType;
      state.line = nextLine;
      return true;
    }
    function code(state, startLine, endLine) {
      if (state.sCount[startLine] - state.blkIndent < 4) {
        return false;
      }
      let nextLine = startLine + 1;
      let last = nextLine;
      while (nextLine < endLine) {
        if (state.isEmpty(nextLine)) {
          nextLine++;
          continue;
        }
        if (state.sCount[nextLine] - state.blkIndent >= 4) {
          nextLine++;
          last = nextLine;
          continue;
        }
        break;
      }
      state.line = last;
      const token = state.push("code_block", "code", 0);
      token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + "\n";
      token.map = [startLine, state.line];
      return true;
    }
    function fence(state, startLine, endLine, silent) {
      let pos = state.bMarks[startLine] + state.tShift[startLine];
      let max = state.eMarks[startLine];
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      if (pos + 3 > max) {
        return false;
      }
      const marker = state.src.charCodeAt(pos);
      if (marker !== 126 && marker !== 96) {
        return false;
      }
      let mem = pos;
      pos = state.skipChars(pos, marker);
      let len = pos - mem;
      if (len < 3) {
        return false;
      }
      const markup = state.src.slice(mem, pos);
      const params = state.src.slice(pos, max);
      if (marker === 96) {
        if (params.indexOf(String.fromCharCode(marker)) >= 0) {
          return false;
        }
      }
      if (silent) {
        return true;
      }
      let nextLine = startLine;
      let haveEndMarker = false;
      for (; ; ) {
        nextLine++;
        if (nextLine >= endLine) {
          break;
        }
        pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];
        max = state.eMarks[nextLine];
        if (pos < max && state.sCount[nextLine] < state.blkIndent) {
          break;
        }
        if (state.src.charCodeAt(pos) !== marker) {
          continue;
        }
        if (state.sCount[nextLine] - state.blkIndent >= 4) {
          continue;
        }
        pos = state.skipChars(pos, marker);
        if (pos - mem < len) {
          continue;
        }
        pos = state.skipSpaces(pos);
        if (pos < max) {
          continue;
        }
        haveEndMarker = true;
        break;
      }
      len = state.sCount[startLine];
      state.line = nextLine + (haveEndMarker ? 1 : 0);
      const token = state.push("fence", "code", 0);
      token.info = params;
      token.content = state.getLines(startLine + 1, nextLine, len, true);
      token.markup = markup;
      token.map = [startLine, state.line];
      return true;
    }
    function blockquote(state, startLine, endLine, silent) {
      let pos = state.bMarks[startLine] + state.tShift[startLine];
      let max = state.eMarks[startLine];
      const oldLineMax = state.lineMax;
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      if (state.src.charCodeAt(pos) !== 62) {
        return false;
      }
      if (silent) {
        return true;
      }
      const oldBMarks = [];
      const oldBSCount = [];
      const oldSCount = [];
      const oldTShift = [];
      const terminatorRules = state.md.block.ruler.getRules("blockquote");
      const oldParentType = state.parentType;
      state.parentType = "blockquote";
      let lastLineEmpty = false;
      let nextLine;
      for (nextLine = startLine; nextLine < endLine; nextLine++) {
        const isOutdented = state.sCount[nextLine] < state.blkIndent;
        pos = state.bMarks[nextLine] + state.tShift[nextLine];
        max = state.eMarks[nextLine];
        if (pos >= max) {
          break;
        }
        if (state.src.charCodeAt(pos++) === 62 && !isOutdented) {
          let initial = state.sCount[nextLine] + 1;
          let spaceAfterMarker;
          let adjustTab;
          if (state.src.charCodeAt(pos) === 32) {
            pos++;
            initial++;
            adjustTab = false;
            spaceAfterMarker = true;
          } else if (state.src.charCodeAt(pos) === 9) {
            spaceAfterMarker = true;
            if ((state.bsCount[nextLine] + initial) % 4 === 3) {
              pos++;
              initial++;
              adjustTab = false;
            } else {
              adjustTab = true;
            }
          } else {
            spaceAfterMarker = false;
          }
          let offset = initial;
          oldBMarks.push(state.bMarks[nextLine]);
          state.bMarks[nextLine] = pos;
          while (pos < max) {
            const ch = state.src.charCodeAt(pos);
            if (isSpace(ch)) {
              if (ch === 9) {
                offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;
              } else {
                offset++;
              }
            } else {
              break;
            }
            pos++;
          }
          lastLineEmpty = pos >= max;
          oldBSCount.push(state.bsCount[nextLine]);
          state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);
          oldSCount.push(state.sCount[nextLine]);
          state.sCount[nextLine] = offset - initial;
          oldTShift.push(state.tShift[nextLine]);
          state.tShift[nextLine] = pos - state.bMarks[nextLine];
          continue;
        }
        if (lastLineEmpty) {
          break;
        }
        let terminate = false;
        for (let i = 0, l = terminatorRules.length; i < l; i++) {
          if (terminatorRules[i](state, nextLine, endLine, true)) {
            terminate = true;
            break;
          }
        }
        if (terminate) {
          state.lineMax = nextLine;
          if (state.blkIndent !== 0) {
            oldBMarks.push(state.bMarks[nextLine]);
            oldBSCount.push(state.bsCount[nextLine]);
            oldTShift.push(state.tShift[nextLine]);
            oldSCount.push(state.sCount[nextLine]);
            state.sCount[nextLine] -= state.blkIndent;
          }
          break;
        }
        oldBMarks.push(state.bMarks[nextLine]);
        oldBSCount.push(state.bsCount[nextLine]);
        oldTShift.push(state.tShift[nextLine]);
        oldSCount.push(state.sCount[nextLine]);
        state.sCount[nextLine] = -1;
      }
      const oldIndent = state.blkIndent;
      state.blkIndent = 0;
      const token_o = state.push("blockquote_open", "blockquote", 1);
      token_o.markup = ">";
      const lines = [startLine, 0];
      token_o.map = lines;
      state.md.block.tokenize(state, startLine, nextLine);
      const token_c = state.push("blockquote_close", "blockquote", -1);
      token_c.markup = ">";
      state.lineMax = oldLineMax;
      state.parentType = oldParentType;
      lines[1] = state.line;
      for (let i = 0; i < oldTShift.length; i++) {
        state.bMarks[i + startLine] = oldBMarks[i];
        state.tShift[i + startLine] = oldTShift[i];
        state.sCount[i + startLine] = oldSCount[i];
        state.bsCount[i + startLine] = oldBSCount[i];
      }
      state.blkIndent = oldIndent;
      return true;
    }
    function hr(state, startLine, endLine, silent) {
      const max = state.eMarks[startLine];
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      let pos = state.bMarks[startLine] + state.tShift[startLine];
      const marker = state.src.charCodeAt(pos++);
      if (marker !== 42 && marker !== 45 && marker !== 95) {
        return false;
      }
      let cnt = 1;
      while (pos < max) {
        const ch = state.src.charCodeAt(pos++);
        if (ch !== marker && !isSpace(ch)) {
          return false;
        }
        if (ch === marker) {
          cnt++;
        }
      }
      if (cnt < 3) {
        return false;
      }
      if (silent) {
        return true;
      }
      state.line = startLine + 1;
      const token = state.push("hr", "hr", 0);
      token.map = [startLine, state.line];
      token.markup = Array(cnt + 1).join(String.fromCharCode(marker));
      return true;
    }
    function skipBulletListMarker(state, startLine) {
      const max = state.eMarks[startLine];
      let pos = state.bMarks[startLine] + state.tShift[startLine];
      const marker = state.src.charCodeAt(pos++);
      if (marker !== 42 && marker !== 45 && marker !== 43) {
        return -1;
      }
      if (pos < max) {
        const ch = state.src.charCodeAt(pos);
        if (!isSpace(ch)) {
          return -1;
        }
      }
      return pos;
    }
    function skipOrderedListMarker(state, startLine) {
      const start = state.bMarks[startLine] + state.tShift[startLine];
      const max = state.eMarks[startLine];
      let pos = start;
      if (pos + 1 >= max) {
        return -1;
      }
      let ch = state.src.charCodeAt(pos++);
      if (ch < 48 || ch > 57) {
        return -1;
      }
      for (; ; ) {
        if (pos >= max) {
          return -1;
        }
        ch = state.src.charCodeAt(pos++);
        if (ch >= 48 && ch <= 57) {
          if (pos - start >= 10) {
            return -1;
          }
          continue;
        }
        if (ch === 41 || ch === 46) {
          break;
        }
        return -1;
      }
      if (pos < max) {
        ch = state.src.charCodeAt(pos);
        if (!isSpace(ch)) {
          return -1;
        }
      }
      return pos;
    }
    function markTightParagraphs(state, idx) {
      const level = state.level + 2;
      for (let i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
        if (state.tokens[i].level === level && state.tokens[i].type === "paragraph_open") {
          state.tokens[i + 2].hidden = true;
          state.tokens[i].hidden = true;
          i += 2;
        }
      }
    }
    function list(state, startLine, endLine, silent) {
      let max, pos, start, token;
      let nextLine = startLine;
      let tight = true;
      if (state.sCount[nextLine] - state.blkIndent >= 4) {
        return false;
      }
      if (state.listIndent >= 0 && state.sCount[nextLine] - state.listIndent >= 4 && state.sCount[nextLine] < state.blkIndent) {
        return false;
      }
      let isTerminatingParagraph = false;
      if (silent && state.parentType === "paragraph") {
        if (state.sCount[nextLine] >= state.blkIndent) {
          isTerminatingParagraph = true;
        }
      }
      let isOrdered;
      let markerValue;
      let posAfterMarker;
      if ((posAfterMarker = skipOrderedListMarker(state, nextLine)) >= 0) {
        isOrdered = true;
        start = state.bMarks[nextLine] + state.tShift[nextLine];
        markerValue = Number(state.src.slice(start, posAfterMarker - 1));
        if (isTerminatingParagraph && markerValue !== 1) return false;
      } else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) >= 0) {
        isOrdered = false;
      } else {
        return false;
      }
      if (isTerminatingParagraph) {
        if (state.skipSpaces(posAfterMarker) >= state.eMarks[nextLine]) return false;
      }
      if (silent) {
        return true;
      }
      const markerCharCode = state.src.charCodeAt(posAfterMarker - 1);
      const listTokIdx = state.tokens.length;
      if (isOrdered) {
        token = state.push("ordered_list_open", "ol", 1);
        if (markerValue !== 1) {
          token.attrs = [["start", markerValue]];
        }
      } else {
        token = state.push("bullet_list_open", "ul", 1);
      }
      const listLines = [nextLine, 0];
      token.map = listLines;
      token.markup = String.fromCharCode(markerCharCode);
      let prevEmptyEnd = false;
      const terminatorRules = state.md.block.ruler.getRules("list");
      const oldParentType = state.parentType;
      state.parentType = "list";
      while (nextLine < endLine) {
        pos = posAfterMarker;
        max = state.eMarks[nextLine];
        const initial = state.sCount[nextLine] + posAfterMarker - (state.bMarks[nextLine] + state.tShift[nextLine]);
        let offset = initial;
        while (pos < max) {
          const ch = state.src.charCodeAt(pos);
          if (ch === 9) {
            offset += 4 - (offset + state.bsCount[nextLine]) % 4;
          } else if (ch === 32) {
            offset++;
          } else {
            break;
          }
          pos++;
        }
        const contentStart = pos;
        let indentAfterMarker;
        if (contentStart >= max) {
          indentAfterMarker = 1;
        } else {
          indentAfterMarker = offset - initial;
        }
        if (indentAfterMarker > 4) {
          indentAfterMarker = 1;
        }
        const indent = initial + indentAfterMarker;
        token = state.push("list_item_open", "li", 1);
        token.markup = String.fromCharCode(markerCharCode);
        const itemLines = [nextLine, 0];
        token.map = itemLines;
        if (isOrdered) {
          token.info = state.src.slice(start, posAfterMarker - 1);
        }
        const oldTight = state.tight;
        const oldTShift = state.tShift[nextLine];
        const oldSCount = state.sCount[nextLine];
        const oldListIndent = state.listIndent;
        state.listIndent = state.blkIndent;
        state.blkIndent = indent;
        state.tight = true;
        state.tShift[nextLine] = contentStart - state.bMarks[nextLine];
        state.sCount[nextLine] = offset;
        if (contentStart >= max && state.isEmpty(nextLine + 1)) {
          state.line = Math.min(state.line + 2, endLine);
        } else {
          state.md.block.tokenize(state, nextLine, endLine, true);
        }
        if (!state.tight || prevEmptyEnd) {
          tight = false;
        }
        prevEmptyEnd = state.line - nextLine > 1 && state.isEmpty(state.line - 1);
        state.blkIndent = state.listIndent;
        state.listIndent = oldListIndent;
        state.tShift[nextLine] = oldTShift;
        state.sCount[nextLine] = oldSCount;
        state.tight = oldTight;
        token = state.push("list_item_close", "li", -1);
        token.markup = String.fromCharCode(markerCharCode);
        nextLine = state.line;
        itemLines[1] = nextLine;
        if (nextLine >= endLine) {
          break;
        }
        if (state.sCount[nextLine] < state.blkIndent) {
          break;
        }
        if (state.sCount[nextLine] - state.blkIndent >= 4) {
          break;
        }
        let terminate = false;
        for (let i = 0, l = terminatorRules.length; i < l; i++) {
          if (terminatorRules[i](state, nextLine, endLine, true)) {
            terminate = true;
            break;
          }
        }
        if (terminate) {
          break;
        }
        if (isOrdered) {
          posAfterMarker = skipOrderedListMarker(state, nextLine);
          if (posAfterMarker < 0) {
            break;
          }
          start = state.bMarks[nextLine] + state.tShift[nextLine];
        } else {
          posAfterMarker = skipBulletListMarker(state, nextLine);
          if (posAfterMarker < 0) {
            break;
          }
        }
        if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) {
          break;
        }
      }
      if (isOrdered) {
        token = state.push("ordered_list_close", "ol", -1);
      } else {
        token = state.push("bullet_list_close", "ul", -1);
      }
      token.markup = String.fromCharCode(markerCharCode);
      listLines[1] = nextLine;
      state.line = nextLine;
      state.parentType = oldParentType;
      if (tight) {
        markTightParagraphs(state, listTokIdx);
      }
      return true;
    }
    function reference(state, startLine, _endLine, silent) {
      let pos = state.bMarks[startLine] + state.tShift[startLine];
      let max = state.eMarks[startLine];
      let nextLine = startLine + 1;
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      if (state.src.charCodeAt(pos) !== 91) {
        return false;
      }
      function getNextLine(nextLine2) {
        const endLine = state.lineMax;
        if (nextLine2 >= endLine || state.isEmpty(nextLine2)) {
          return null;
        }
        let isContinuation = false;
        if (state.sCount[nextLine2] - state.blkIndent > 3) {
          isContinuation = true;
        }
        if (state.sCount[nextLine2] < 0) {
          isContinuation = true;
        }
        if (!isContinuation) {
          const terminatorRules = state.md.block.ruler.getRules("reference");
          const oldParentType = state.parentType;
          state.parentType = "reference";
          let terminate = false;
          for (let i = 0, l = terminatorRules.length; i < l; i++) {
            if (terminatorRules[i](state, nextLine2, endLine, true)) {
              terminate = true;
              break;
            }
          }
          state.parentType = oldParentType;
          if (terminate) {
            return null;
          }
        }
        const pos2 = state.bMarks[nextLine2] + state.tShift[nextLine2];
        const max2 = state.eMarks[nextLine2];
        return state.src.slice(pos2, max2 + 1);
      }
      let str = state.src.slice(pos, max + 1);
      max = str.length;
      let labelEnd = -1;
      for (pos = 1; pos < max; pos++) {
        const ch = str.charCodeAt(pos);
        if (ch === 91) {
          return false;
        } else if (ch === 93) {
          labelEnd = pos;
          break;
        } else if (ch === 10) {
          const lineContent = getNextLine(nextLine);
          if (lineContent !== null) {
            str += lineContent;
            max = str.length;
            nextLine++;
          }
        } else if (ch === 92) {
          pos++;
          if (pos < max && str.charCodeAt(pos) === 10) {
            const lineContent = getNextLine(nextLine);
            if (lineContent !== null) {
              str += lineContent;
              max = str.length;
              nextLine++;
            }
          }
        }
      }
      if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 58) {
        return false;
      }
      for (pos = labelEnd + 2; pos < max; pos++) {
        const ch = str.charCodeAt(pos);
        if (ch === 10) {
          const lineContent = getNextLine(nextLine);
          if (lineContent !== null) {
            str += lineContent;
            max = str.length;
            nextLine++;
          }
        } else if (isSpace(ch)) ;
        else {
          break;
        }
      }
      const destRes = state.md.helpers.parseLinkDestination(str, pos, max);
      if (!destRes.ok) {
        return false;
      }
      const href = state.md.normalizeLink(destRes.str);
      if (!state.md.validateLink(href)) {
        return false;
      }
      pos = destRes.pos;
      const destEndPos = pos;
      const destEndLineNo = nextLine;
      const start = pos;
      for (; pos < max; pos++) {
        const ch = str.charCodeAt(pos);
        if (ch === 10) {
          const lineContent = getNextLine(nextLine);
          if (lineContent !== null) {
            str += lineContent;
            max = str.length;
            nextLine++;
          }
        } else if (isSpace(ch)) ;
        else {
          break;
        }
      }
      let titleRes = state.md.helpers.parseLinkTitle(str, pos, max);
      while (titleRes.can_continue) {
        const lineContent = getNextLine(nextLine);
        if (lineContent === null) break;
        str += lineContent;
        pos = max;
        max = str.length;
        nextLine++;
        titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes);
      }
      let title;
      if (pos < max && start !== pos && titleRes.ok) {
        title = titleRes.str;
        pos = titleRes.pos;
      } else {
        title = "";
        pos = destEndPos;
        nextLine = destEndLineNo;
      }
      while (pos < max) {
        const ch = str.charCodeAt(pos);
        if (!isSpace(ch)) {
          break;
        }
        pos++;
      }
      if (pos < max && str.charCodeAt(pos) !== 10) {
        if (title) {
          title = "";
          pos = destEndPos;
          nextLine = destEndLineNo;
          while (pos < max) {
            const ch = str.charCodeAt(pos);
            if (!isSpace(ch)) {
              break;
            }
            pos++;
          }
        }
      }
      if (pos < max && str.charCodeAt(pos) !== 10) {
        return false;
      }
      const label = normalizeReference(str.slice(1, labelEnd));
      if (!label) {
        return false;
      }
      if (silent) {
        return true;
      }
      if (typeof state.env.references === "undefined") {
        state.env.references = {};
      }
      if (typeof state.env.references[label] === "undefined") {
        state.env.references[label] = {
          title,
          href
        };
      }
      state.line = nextLine;
      return true;
    }
    var block_names = ["address", "article", "aside", "base", "basefont", "blockquote", "body", "caption", "center", "col", "colgroup", "dd", "details", "dialog", "dir", "div", "dl", "dt", "fieldset", "figcaption", "figure", "footer", "form", "frame", "frameset", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hr", "html", "iframe", "legend", "li", "link", "main", "menu", "menuitem", "nav", "noframes", "ol", "optgroup", "option", "p", "param", "search", "section", "summary", "table", "tbody", "td", "tfoot", "th", "thead", "title", "tr", "track", "ul"];
    var attr_name = "[a-zA-Z_:][a-zA-Z0-9:._-]*";
    var unquoted = "[^\"'=<>`\\x00-\\x20]+";
    var single_quoted = "'[^']*'";
    var double_quoted = '"[^"]*"';
    var attr_value = "(?:" + unquoted + "|" + single_quoted + "|" + double_quoted + ")";
    var attribute = "(?:\\s+" + attr_name + "(?:\\s*=\\s*" + attr_value + ")?)";
    var open_tag = "<[A-Za-z][A-Za-z0-9\\-]*" + attribute + "*\\s*\\/?>";
    var close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>";
    var comment = "<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->";
    var processing = "<[?][\\s\\S]*?[?]>";
    var declaration = "<![A-Za-z][^>]*>";
    var cdata = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>";
    var HTML_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + "|" + comment + "|" + processing + "|" + declaration + "|" + cdata + ")");
    var HTML_OPEN_CLOSE_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + ")");
    var HTML_SEQUENCES = [[/^<(script|pre|style|textarea)(?=(\s|>|$))/i, /<\/(script|pre|style|textarea)>/i, true], [/^<!--/, /-->/, true], [/^<\?/, /\?>/, true], [/^<![A-Z]/, />/, true], [/^<!\[CDATA\[/, /\]\]>/, true], [new RegExp("^</?(" + block_names.join("|") + ")(?=(\\s|/?>|$))", "i"), /^$/, true], [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + "\\s*$"), /^$/, false]];
    function html_block(state, startLine, endLine, silent) {
      let pos = state.bMarks[startLine] + state.tShift[startLine];
      let max = state.eMarks[startLine];
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      if (!state.md.options.html) {
        return false;
      }
      if (state.src.charCodeAt(pos) !== 60) {
        return false;
      }
      let lineText = state.src.slice(pos, max);
      let i = 0;
      for (; i < HTML_SEQUENCES.length; i++) {
        if (HTML_SEQUENCES[i][0].test(lineText)) {
          break;
        }
      }
      if (i === HTML_SEQUENCES.length) {
        return false;
      }
      if (silent) {
        return HTML_SEQUENCES[i][2];
      }
      let nextLine = startLine + 1;
      if (!HTML_SEQUENCES[i][1].test(lineText)) {
        for (; nextLine < endLine; nextLine++) {
          if (state.sCount[nextLine] < state.blkIndent) {
            break;
          }
          pos = state.bMarks[nextLine] + state.tShift[nextLine];
          max = state.eMarks[nextLine];
          lineText = state.src.slice(pos, max);
          if (HTML_SEQUENCES[i][1].test(lineText)) {
            if (lineText.length !== 0) {
              nextLine++;
            }
            break;
          }
        }
      }
      state.line = nextLine;
      const token = state.push("html_block", "", 0);
      token.map = [startLine, nextLine];
      token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
      return true;
    }
    function heading(state, startLine, endLine, silent) {
      let pos = state.bMarks[startLine] + state.tShift[startLine];
      let max = state.eMarks[startLine];
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      let ch = state.src.charCodeAt(pos);
      if (ch !== 35 || pos >= max) {
        return false;
      }
      let level = 1;
      ch = state.src.charCodeAt(++pos);
      while (ch === 35 && pos < max && level <= 6) {
        level++;
        ch = state.src.charCodeAt(++pos);
      }
      if (level > 6 || pos < max && !isSpace(ch)) {
        return false;
      }
      if (silent) {
        return true;
      }
      max = state.skipSpacesBack(max, pos);
      const tmp = state.skipCharsBack(max, 35, pos);
      if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {
        max = tmp;
      }
      state.line = startLine + 1;
      const token_o = state.push("heading_open", "h" + String(level), 1);
      token_o.markup = "########".slice(0, level);
      token_o.map = [startLine, state.line];
      const token_i = state.push("inline", "", 0);
      token_i.content = state.src.slice(pos, max).trim();
      token_i.map = [startLine, state.line];
      token_i.children = [];
      const token_c = state.push("heading_close", "h" + String(level), -1);
      token_c.markup = "########".slice(0, level);
      return true;
    }
    function lheading(state, startLine, endLine) {
      const terminatorRules = state.md.block.ruler.getRules("paragraph");
      if (state.sCount[startLine] - state.blkIndent >= 4) {
        return false;
      }
      const oldParentType = state.parentType;
      state.parentType = "paragraph";
      let level = 0;
      let marker;
      let nextLine = startLine + 1;
      for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
        if (state.sCount[nextLine] - state.blkIndent > 3) {
          continue;
        }
        if (state.sCount[nextLine] >= state.blkIndent) {
          let pos = state.bMarks[nextLine] + state.tShift[nextLine];
          const max = state.eMarks[nextLine];
          if (pos < max) {
            marker = state.src.charCodeAt(pos);
            if (marker === 45 || marker === 61) {
              pos = state.skipChars(pos, marker);
              pos = state.skipSpaces(pos);
              if (pos >= max) {
                level = marker === 61 ? 1 : 2;
                break;
              }
            }
          }
        }
        if (state.sCount[nextLine] < 0) {
          continue;
        }
        let terminate = false;
        for (let i = 0, l = terminatorRules.length; i < l; i++) {
          if (terminatorRules[i](state, nextLine, endLine, true)) {
            terminate = true;
            break;
          }
        }
        if (terminate) {
          break;
        }
      }
      if (!level) {
        return false;
      }
      const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
      state.line = nextLine + 1;
      const token_o = state.push("heading_open", "h" + String(level), 1);
      token_o.markup = String.fromCharCode(marker);
      token_o.map = [startLine, state.line];
      const token_i = state.push("inline", "", 0);
      token_i.content = content;
      token_i.map = [startLine, state.line - 1];
      token_i.children = [];
      const token_c = state.push("heading_close", "h" + String(level), -1);
      token_c.markup = String.fromCharCode(marker);
      state.parentType = oldParentType;
      return true;
    }
    function paragraph(state, startLine, endLine) {
      const terminatorRules = state.md.block.ruler.getRules("paragraph");
      const oldParentType = state.parentType;
      let nextLine = startLine + 1;
      state.parentType = "paragraph";
      for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
        if (state.sCount[nextLine] - state.blkIndent > 3) {
          continue;
        }
        if (state.sCount[nextLine] < 0) {
          continue;
        }
        let terminate = false;
        for (let i = 0, l = terminatorRules.length; i < l; i++) {
          if (terminatorRules[i](state, nextLine, endLine, true)) {
            terminate = true;
            break;
          }
        }
        if (terminate) {
          break;
        }
      }
      const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();
      state.line = nextLine;
      const token_o = state.push("paragraph_open", "p", 1);
      token_o.map = [startLine, state.line];
      const token_i = state.push("inline", "", 0);
      token_i.content = content;
      token_i.map = [startLine, state.line];
      token_i.children = [];
      state.push("paragraph_close", "p", -1);
      state.parentType = oldParentType;
      return true;
    }
    var _rules$1 = [
      // First 2 params - rule name & source. Secondary array - list of rules,
      // which can be terminated by this one.
      ["table", table, ["paragraph", "reference"]],
      ["code", code],
      ["fence", fence, ["paragraph", "reference", "blockquote", "list"]],
      ["blockquote", blockquote, ["paragraph", "reference", "blockquote", "list"]],
      ["hr", hr, ["paragraph", "reference", "blockquote", "list"]],
      ["list", list, ["paragraph", "reference", "blockquote"]],
      ["reference", reference],
      ["html_block", html_block, ["paragraph", "reference", "blockquote"]],
      ["heading", heading, ["paragraph", "reference", "blockquote"]],
      ["lheading", lheading],
      ["paragraph", paragraph]
    ];
    function ParserBlock() {
      this.ruler = new Ruler();
      for (let i = 0; i < _rules$1.length; i++) {
        this.ruler.push(_rules$1[i][0], _rules$1[i][1], {
          alt: (_rules$1[i][2] || []).slice()
        });
      }
    }
    ParserBlock.prototype.tokenize = function(state, startLine, endLine) {
      const rules = this.ruler.getRules("");
      const len = rules.length;
      const maxNesting = state.md.options.maxNesting;
      let line = startLine;
      let hasEmptyLines = false;
      while (line < endLine) {
        state.line = line = state.skipEmptyLines(line);
        if (line >= endLine) {
          break;
        }
        if (state.sCount[line] < state.blkIndent) {
          break;
        }
        if (state.level >= maxNesting) {
          state.line = endLine;
          break;
        }
        const prevLine = state.line;
        let ok = false;
        for (let i = 0; i < len; i++) {
          ok = rules[i](state, line, endLine, false);
          if (ok) {
            if (prevLine >= state.line) {
              throw new Error("block rule didn't increment state.line");
            }
            break;
          }
        }
        if (!ok) throw new Error("none of the block rules matched");
        state.tight = !hasEmptyLines;
        if (state.isEmpty(state.line - 1)) {
          hasEmptyLines = true;
        }
        line = state.line;
        if (line < endLine && state.isEmpty(line)) {
          hasEmptyLines = true;
          line++;
          state.line = line;
        }
      }
    };
    ParserBlock.prototype.parse = function(src, md, env, outTokens) {
      if (!src) {
        return;
      }
      const state = new this.State(src, md, env, outTokens);
      this.tokenize(state, state.line, state.lineMax);
    };
    ParserBlock.prototype.State = StateBlock;
    function StateInline(src, md, env, outTokens) {
      this.src = src;
      this.env = env;
      this.md = md;
      this.tokens = outTokens;
      this.tokens_meta = Array(outTokens.length);
      this.pos = 0;
      this.posMax = this.src.length;
      this.level = 0;
      this.pending = "";
      this.pendingLevel = 0;
      this.cache = {};
      this.delimiters = [];
      this._prev_delimiters = [];
      this.backticks = {};
      this.backticksScanned = false;
      this.linkLevel = 0;
    }
    StateInline.prototype.pushPending = function() {
      const token = new Token("text", "", 0);
      token.content = this.pending;
      token.level = this.pendingLevel;
      this.tokens.push(token);
      this.pending = "";
      return token;
    };
    StateInline.prototype.push = function(type, tag, nesting) {
      if (this.pending) {
        this.pushPending();
      }
      const token = new Token(type, tag, nesting);
      let token_meta = null;
      if (nesting < 0) {
        this.level--;
        this.delimiters = this._prev_delimiters.pop();
      }
      token.level = this.level;
      if (nesting > 0) {
        this.level++;
        this._prev_delimiters.push(this.delimiters);
        this.delimiters = [];
        token_meta = {
          delimiters: this.delimiters
        };
      }
      this.pendingLevel = this.level;
      this.tokens.push(token);
      this.tokens_meta.push(token_meta);
      return token;
    };
    StateInline.prototype.scanDelims = function(start, canSplitWord) {
      const max = this.posMax;
      const marker = this.src.charCodeAt(start);
      const lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 32;
      let pos = start;
      while (pos < max && this.src.charCodeAt(pos) === marker) {
        pos++;
      }
      const count = pos - start;
      const nextChar = pos < max ? this.src.charCodeAt(pos) : 32;
      const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
      const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
      const isLastWhiteSpace = isWhiteSpace(lastChar);
      const isNextWhiteSpace = isWhiteSpace(nextChar);
      const left_flanking = !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar);
      const right_flanking = !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar);
      const can_open = left_flanking && (canSplitWord || !right_flanking || isLastPunctChar);
      const can_close = right_flanking && (canSplitWord || !left_flanking || isNextPunctChar);
      return {
        can_open,
        can_close,
        length: count
      };
    };
    StateInline.prototype.Token = Token;
    function isTerminatorChar(ch) {
      switch (ch) {
        case 10:
        case 33:
        case 35:
        case 36:
        case 37:
        case 38:
        case 42:
        case 43:
        case 45:
        case 58:
        case 60:
        case 61:
        case 62:
        case 64:
        case 91:
        case 92:
        case 93:
        case 94:
        case 95:
        case 96:
        case 123:
        case 125:
        case 126:
          return true;
        default:
          return false;
      }
    }
    function text(state, silent) {
      let pos = state.pos;
      while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {
        pos++;
      }
      if (pos === state.pos) {
        return false;
      }
      if (!silent) {
        state.pending += state.src.slice(state.pos, pos);
      }
      state.pos = pos;
      return true;
    }
    var SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;
    function linkify(state, silent) {
      if (!state.md.options.linkify) return false;
      if (state.linkLevel > 0) return false;
      const pos = state.pos;
      const max = state.posMax;
      if (pos + 3 > max) return false;
      if (state.src.charCodeAt(pos) !== 58) return false;
      if (state.src.charCodeAt(pos + 1) !== 47) return false;
      if (state.src.charCodeAt(pos + 2) !== 47) return false;
      const match = state.pending.match(SCHEME_RE);
      if (!match) return false;
      const proto = match[1];
      const link2 = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length));
      if (!link2) return false;
      let url = link2.url;
      if (url.length <= proto.length) return false;
      url = url.replace(/\*+$/, "");
      const fullUrl = state.md.normalizeLink(url);
      if (!state.md.validateLink(fullUrl)) return false;
      if (!silent) {
        state.pending = state.pending.slice(0, -proto.length);
        const token_o = state.push("link_open", "a", 1);
        token_o.attrs = [["href", fullUrl]];
        token_o.markup = "linkify";
        token_o.info = "auto";
        const token_t = state.push("text", "", 0);
        token_t.content = state.md.normalizeLinkText(url);
        const token_c = state.push("link_close", "a", -1);
        token_c.markup = "linkify";
        token_c.info = "auto";
      }
      state.pos += url.length - proto.length;
      return true;
    }
    function newline(state, silent) {
      let pos = state.pos;
      if (state.src.charCodeAt(pos) !== 10) {
        return false;
      }
      const pmax = state.pending.length - 1;
      const max = state.posMax;
      if (!silent) {
        if (pmax >= 0 && state.pending.charCodeAt(pmax) === 32) {
          if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 32) {
            let ws = pmax - 1;
            while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 32) ws--;
            state.pending = state.pending.slice(0, ws);
            state.push("hardbreak", "br", 0);
          } else {
            state.pending = state.pending.slice(0, -1);
            state.push("softbreak", "br", 0);
          }
        } else {
          state.push("softbreak", "br", 0);
        }
      }
      pos++;
      while (pos < max && isSpace(state.src.charCodeAt(pos))) {
        pos++;
      }
      state.pos = pos;
      return true;
    }
    var ESCAPED = [];
    for (let i = 0; i < 256; i++) {
      ESCAPED.push(0);
    }
    "\\!\"#$%&'()*+,./:;<=>?@[]^_`{|}~-".split("").forEach(function(ch) {
      ESCAPED[ch.charCodeAt(0)] = 1;
    });
    function escape(state, silent) {
      let pos = state.pos;
      const max = state.posMax;
      if (state.src.charCodeAt(pos) !== 92) return false;
      pos++;
      if (pos >= max) return false;
      let ch1 = state.src.charCodeAt(pos);
      if (ch1 === 10) {
        if (!silent) {
          state.push("hardbreak", "br", 0);
        }
        pos++;
        while (pos < max) {
          ch1 = state.src.charCodeAt(pos);
          if (!isSpace(ch1)) break;
          pos++;
        }
        state.pos = pos;
        return true;
      }
      let escapedStr = state.src[pos];
      if (ch1 >= 55296 && ch1 <= 56319 && pos + 1 < max) {
        const ch2 = state.src.charCodeAt(pos + 1);
        if (ch2 >= 56320 && ch2 <= 57343) {
          escapedStr += state.src[pos + 1];
          pos++;
        }
      }
      const origStr = "\\" + escapedStr;
      if (!silent) {
        const token = state.push("text_special", "", 0);
        if (ch1 < 256 && ESCAPED[ch1] !== 0) {
          token.content = escapedStr;
        } else {
          token.content = origStr;
        }
        token.markup = origStr;
        token.info = "escape";
      }
      state.pos = pos + 1;
      return true;
    }
    function backtick(state, silent) {
      let pos = state.pos;
      const ch = state.src.charCodeAt(pos);
      if (ch !== 96) {
        return false;
      }
      const start = pos;
      pos++;
      const max = state.posMax;
      while (pos < max && state.src.charCodeAt(pos) === 96) {
        pos++;
      }
      const marker = state.src.slice(start, pos);
      const openerLength = marker.length;
      if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {
        if (!silent) state.pending += marker;
        state.pos += openerLength;
        return true;
      }
      let matchEnd = pos;
      let matchStart;
      while ((matchStart = state.src.indexOf("`", matchEnd)) !== -1) {
        matchEnd = matchStart + 1;
        while (matchEnd < max && state.src.charCodeAt(matchEnd) === 96) {
          matchEnd++;
        }
        const closerLength = matchEnd - matchStart;
        if (closerLength === openerLength) {
          if (!silent) {
            const token = state.push("code_inline", "code", 0);
            token.markup = marker;
            token.content = state.src.slice(pos, matchStart).replace(/\n/g, " ").replace(/^ (.+) $/, "$1");
          }
          state.pos = matchEnd;
          return true;
        }
        state.backticks[closerLength] = matchStart;
      }
      state.backticksScanned = true;
      if (!silent) state.pending += marker;
      state.pos += openerLength;
      return true;
    }
    function strikethrough_tokenize(state, silent) {
      const start = state.pos;
      const marker = state.src.charCodeAt(start);
      if (silent) {
        return false;
      }
      if (marker !== 126) {
        return false;
      }
      const scanned = state.scanDelims(state.pos, true);
      let len = scanned.length;
      const ch = String.fromCharCode(marker);
      if (len < 2) {
        return false;
      }
      let token;
      if (len % 2) {
        token = state.push("text", "", 0);
        token.content = ch;
        len--;
      }
      for (let i = 0; i < len; i += 2) {
        token = state.push("text", "", 0);
        token.content = ch + ch;
        state.delimiters.push({
          marker,
          length: 0,
          // disable "rule of 3" length checks meant for emphasis
          token: state.tokens.length - 1,
          end: -1,
          open: scanned.can_open,
          close: scanned.can_close
        });
      }
      state.pos += scanned.length;
      return true;
    }
    function postProcess$1(state, delimiters) {
      let token;
      const loneMarkers = [];
      const max = delimiters.length;
      for (let i = 0; i < max; i++) {
        const startDelim = delimiters[i];
        if (startDelim.marker !== 126) {
          continue;
        }
        if (startDelim.end === -1) {
          continue;
        }
        const endDelim = delimiters[startDelim.end];
        token = state.tokens[startDelim.token];
        token.type = "s_open";
        token.tag = "s";
        token.nesting = 1;
        token.markup = "~~";
        token.content = "";
        token = state.tokens[endDelim.token];
        token.type = "s_close";
        token.tag = "s";
        token.nesting = -1;
        token.markup = "~~";
        token.content = "";
        if (state.tokens[endDelim.token - 1].type === "text" && state.tokens[endDelim.token - 1].content === "~") {
          loneMarkers.push(endDelim.token - 1);
        }
      }
      while (loneMarkers.length) {
        const i = loneMarkers.pop();
        let j = i + 1;
        while (j < state.tokens.length && state.tokens[j].type === "s_close") {
          j++;
        }
        j--;
        if (i !== j) {
          token = state.tokens[j];
          state.tokens[j] = state.tokens[i];
          state.tokens[i] = token;
        }
      }
    }
    function strikethrough_postProcess(state) {
      const tokens_meta = state.tokens_meta;
      const max = state.tokens_meta.length;
      postProcess$1(state, state.delimiters);
      for (let curr = 0; curr < max; curr++) {
        if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
          postProcess$1(state, tokens_meta[curr].delimiters);
        }
      }
    }
    var r_strikethrough = {
      tokenize: strikethrough_tokenize,
      postProcess: strikethrough_postProcess
    };
    function emphasis_tokenize(state, silent) {
      const start = state.pos;
      const marker = state.src.charCodeAt(start);
      if (silent) {
        return false;
      }
      if (marker !== 95 && marker !== 42) {
        return false;
      }
      const scanned = state.scanDelims(state.pos, marker === 42);
      for (let i = 0; i < scanned.length; i++) {
        const token = state.push("text", "", 0);
        token.content = String.fromCharCode(marker);
        state.delimiters.push({
          // Char code of the starting marker (number).
          //
          marker,
          // Total length of these series of delimiters.
          //
          length: scanned.length,
          // A position of the token this delimiter corresponds to.
          //
          token: state.tokens.length - 1,
          // If this delimiter is matched as a valid opener, `end` will be
          // equal to its position, otherwise it's `-1`.
          //
          end: -1,
          // Boolean flags that determine if this delimiter could open or close
          // an emphasis.
          //
          open: scanned.can_open,
          close: scanned.can_close
        });
      }
      state.pos += scanned.length;
      return true;
    }
    function postProcess(state, delimiters) {
      const max = delimiters.length;
      for (let i = max - 1; i >= 0; i--) {
        const startDelim = delimiters[i];
        if (startDelim.marker !== 95 && startDelim.marker !== 42) {
          continue;
        }
        if (startDelim.end === -1) {
          continue;
        }
        const endDelim = delimiters[startDelim.end];
        const isStrong = i > 0 && delimiters[i - 1].end === startDelim.end + 1 && // check that first two markers match and adjacent
        delimiters[i - 1].marker === startDelim.marker && delimiters[i - 1].token === startDelim.token - 1 && // check that last two markers are adjacent (we can safely assume they match)
        delimiters[startDelim.end + 1].token === endDelim.token + 1;
        const ch = String.fromCharCode(startDelim.marker);
        const token_o = state.tokens[startDelim.token];
        token_o.type = isStrong ? "strong_open" : "em_open";
        token_o.tag = isStrong ? "strong" : "em";
        token_o.nesting = 1;
        token_o.markup = isStrong ? ch + ch : ch;
        token_o.content = "";
        const token_c = state.tokens[endDelim.token];
        token_c.type = isStrong ? "strong_close" : "em_close";
        token_c.tag = isStrong ? "strong" : "em";
        token_c.nesting = -1;
        token_c.markup = isStrong ? ch + ch : ch;
        token_c.content = "";
        if (isStrong) {
          state.tokens[delimiters[i - 1].token].content = "";
          state.tokens[delimiters[startDelim.end + 1].token].content = "";
          i--;
        }
      }
    }
    function emphasis_post_process(state) {
      const tokens_meta = state.tokens_meta;
      const max = state.tokens_meta.length;
      postProcess(state, state.delimiters);
      for (let curr = 0; curr < max; curr++) {
        if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
          postProcess(state, tokens_meta[curr].delimiters);
        }
      }
    }
    var r_emphasis = {
      tokenize: emphasis_tokenize,
      postProcess: emphasis_post_process
    };
    function link(state, silent) {
      let code2, label, res, ref;
      let href = "";
      let title = "";
      let start = state.pos;
      let parseReference = true;
      if (state.src.charCodeAt(state.pos) !== 91) {
        return false;
      }
      const oldPos = state.pos;
      const max = state.posMax;
      const labelStart = state.pos + 1;
      const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);
      if (labelEnd < 0) {
        return false;
      }
      let pos = labelEnd + 1;
      if (pos < max && state.src.charCodeAt(pos) === 40) {
        parseReference = false;
        pos++;
        for (; pos < max; pos++) {
          code2 = state.src.charCodeAt(pos);
          if (!isSpace(code2) && code2 !== 10) {
            break;
          }
        }
        if (pos >= max) {
          return false;
        }
        start = pos;
        res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
        if (res.ok) {
          href = state.md.normalizeLink(res.str);
          if (state.md.validateLink(href)) {
            pos = res.pos;
          } else {
            href = "";
          }
          start = pos;
          for (; pos < max; pos++) {
            code2 = state.src.charCodeAt(pos);
            if (!isSpace(code2) && code2 !== 10) {
              break;
            }
          }
          res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
          if (pos < max && start !== pos && res.ok) {
            title = res.str;
            pos = res.pos;
            for (; pos < max; pos++) {
              code2 = state.src.charCodeAt(pos);
              if (!isSpace(code2) && code2 !== 10) {
                break;
              }
            }
          }
        }
        if (pos >= max || state.src.charCodeAt(pos) !== 41) {
          parseReference = true;
        }
        pos++;
      }
      if (parseReference) {
        if (typeof state.env.references === "undefined") {
          return false;
        }
        if (pos < max && state.src.charCodeAt(pos) === 91) {
          start = pos + 1;
          pos = state.md.helpers.parseLinkLabel(state, pos);
          if (pos >= 0) {
            label = state.src.slice(start, pos++);
          } else {
            pos = labelEnd + 1;
          }
        } else {
          pos = labelEnd + 1;
        }
        if (!label) {
          label = state.src.slice(labelStart, labelEnd);
        }
        ref = state.env.references[normalizeReference(label)];
        if (!ref) {
          state.pos = oldPos;
          return false;
        }
        href = ref.href;
        title = ref.title;
      }
      if (!silent) {
        state.pos = labelStart;
        state.posMax = labelEnd;
        const token_o = state.push("link_open", "a", 1);
        const attrs = [["href", href]];
        token_o.attrs = attrs;
        if (title) {
          attrs.push(["title", title]);
        }
        state.linkLevel++;
        state.md.inline.tokenize(state);
        state.linkLevel--;
        state.push("link_close", "a", -1);
      }
      state.pos = pos;
      state.posMax = max;
      return true;
    }
    function image(state, silent) {
      let code2, content, label, pos, ref, res, title, start;
      let href = "";
      const oldPos = state.pos;
      const max = state.posMax;
      if (state.src.charCodeAt(state.pos) !== 33) {
        return false;
      }
      if (state.src.charCodeAt(state.pos + 1) !== 91) {
        return false;
      }
      const labelStart = state.pos + 2;
      const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);
      if (labelEnd < 0) {
        return false;
      }
      pos = labelEnd + 1;
      if (pos < max && state.src.charCodeAt(pos) === 40) {
        pos++;
        for (; pos < max; pos++) {
          code2 = state.src.charCodeAt(pos);
          if (!isSpace(code2) && code2 !== 10) {
            break;
          }
        }
        if (pos >= max) {
          return false;
        }
        start = pos;
        res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);
        if (res.ok) {
          href = state.md.normalizeLink(res.str);
          if (state.md.validateLink(href)) {
            pos = res.pos;
          } else {
            href = "";
          }
        }
        start = pos;
        for (; pos < max; pos++) {
          code2 = state.src.charCodeAt(pos);
          if (!isSpace(code2) && code2 !== 10) {
            break;
          }
        }
        res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
        if (pos < max && start !== pos && res.ok) {
          title = res.str;
          pos = res.pos;
          for (; pos < max; pos++) {
            code2 = state.src.charCodeAt(pos);
            if (!isSpace(code2) && code2 !== 10) {
              break;
            }
          }
        } else {
          title = "";
        }
        if (pos >= max || state.src.charCodeAt(pos) !== 41) {
          state.pos = oldPos;
          return false;
        }
        pos++;
      } else {
        if (typeof state.env.references === "undefined") {
          return false;
        }
        if (pos < max && state.src.charCodeAt(pos) === 91) {
          start = pos + 1;
          pos = state.md.helpers.parseLinkLabel(state, pos);
          if (pos >= 0) {
            label = state.src.slice(start, pos++);
          } else {
            pos = labelEnd + 1;
          }
        } else {
          pos = labelEnd + 1;
        }
        if (!label) {
          label = state.src.slice(labelStart, labelEnd);
        }
        ref = state.env.references[normalizeReference(label)];
        if (!ref) {
          state.pos = oldPos;
          return false;
        }
        href = ref.href;
        title = ref.title;
      }
      if (!silent) {
        content = state.src.slice(labelStart, labelEnd);
        const tokens = [];
        state.md.inline.parse(content, state.md, state.env, tokens);
        const token = state.push("image", "img", 0);
        const attrs = [["src", href], ["alt", ""]];
        token.attrs = attrs;
        token.children = tokens;
        token.content = content;
        if (title) {
          attrs.push(["title", title]);
        }
      }
      state.pos = pos;
      state.posMax = max;
      return true;
    }
    var EMAIL_RE = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;
    var AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\x00-\x20]*)$/;
    function autolink(state, silent) {
      let pos = state.pos;
      if (state.src.charCodeAt(pos) !== 60) {
        return false;
      }
      const start = state.pos;
      const max = state.posMax;
      for (; ; ) {
        if (++pos >= max) return false;
        const ch = state.src.charCodeAt(pos);
        if (ch === 60) return false;
        if (ch === 62) break;
      }
      const url = state.src.slice(start + 1, pos);
      if (AUTOLINK_RE.test(url)) {
        const fullUrl = state.md.normalizeLink(url);
        if (!state.md.validateLink(fullUrl)) {
          return false;
        }
        if (!silent) {
          const token_o = state.push("link_open", "a", 1);
          token_o.attrs = [["href", fullUrl]];
          token_o.markup = "autolink";
          token_o.info = "auto";
          const token_t = state.push("text", "", 0);
          token_t.content = state.md.normalizeLinkText(url);
          const token_c = state.push("link_close", "a", -1);
          token_c.markup = "autolink";
          token_c.info = "auto";
        }
        state.pos += url.length + 2;
        return true;
      }
      if (EMAIL_RE.test(url)) {
        const fullUrl = state.md.normalizeLink("mailto:" + url);
        if (!state.md.validateLink(fullUrl)) {
          return false;
        }
        if (!silent) {
          const token_o = state.push("link_open", "a", 1);
          token_o.attrs = [["href", fullUrl]];
          token_o.markup = "autolink";
          token_o.info = "auto";
          const token_t = state.push("text", "", 0);
          token_t.content = state.md.normalizeLinkText(url);
          const token_c = state.push("link_close", "a", -1);
          token_c.markup = "autolink";
          token_c.info = "auto";
        }
        state.pos += url.length + 2;
        return true;
      }
      return false;
    }
    function isLinkOpen(str) {
      return /^<a[>\s]/i.test(str);
    }
    function isLinkClose(str) {
      return /^<\/a\s*>/i.test(str);
    }
    function isLetter(ch) {
      const lc = ch | 32;
      return lc >= 97 && lc <= 122;
    }
    function html_inline(state, silent) {
      if (!state.md.options.html) {
        return false;
      }
      const max = state.posMax;
      const pos = state.pos;
      if (state.src.charCodeAt(pos) !== 60 || pos + 2 >= max) {
        return false;
      }
      const ch = state.src.charCodeAt(pos + 1);
      if (ch !== 33 && ch !== 63 && ch !== 47 && !isLetter(ch)) {
        return false;
      }
      const match = state.src.slice(pos).match(HTML_TAG_RE);
      if (!match) {
        return false;
      }
      if (!silent) {
        const token = state.push("html_inline", "", 0);
        token.content = match[0];
        if (isLinkOpen(token.content)) state.linkLevel++;
        if (isLinkClose(token.content)) state.linkLevel--;
      }
      state.pos += match[0].length;
      return true;
    }
    var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
    var NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;
    function entity(state, silent) {
      const pos = state.pos;
      const max = state.posMax;
      if (state.src.charCodeAt(pos) !== 38) return false;
      if (pos + 1 >= max) return false;
      const ch = state.src.charCodeAt(pos + 1);
      if (ch === 35) {
        const match = state.src.slice(pos).match(DIGITAL_RE);
        if (match) {
          if (!silent) {
            const code2 = match[1][0].toLowerCase() === "x" ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);
            const token = state.push("text_special", "", 0);
            token.content = isValidEntityCode(code2) ? fromCodePoint(code2) : fromCodePoint(65533);
            token.markup = match[0];
            token.info = "entity";
          }
          state.pos += match[0].length;
          return true;
        }
      } else {
        const match = state.src.slice(pos).match(NAMED_RE);
        if (match) {
          const decoded = entities.decodeHTML(match[0]);
          if (decoded !== match[0]) {
            if (!silent) {
              const token = state.push("text_special", "", 0);
              token.content = decoded;
              token.markup = match[0];
              token.info = "entity";
            }
            state.pos += match[0].length;
            return true;
          }
        }
      }
      return false;
    }
    function processDelimiters(delimiters) {
      const openersBottom = {};
      const max = delimiters.length;
      if (!max) return;
      let headerIdx = 0;
      let lastTokenIdx = -2;
      const jumps = [];
      for (let closerIdx = 0; closerIdx < max; closerIdx++) {
        const closer = delimiters[closerIdx];
        jumps.push(0);
        if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {
          headerIdx = closerIdx;
        }
        lastTokenIdx = closer.token;
        closer.length = closer.length || 0;
        if (!closer.close) continue;
        if (!openersBottom.hasOwnProperty(closer.marker)) {
          openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1];
        }
        const minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + closer.length % 3];
        let openerIdx = headerIdx - jumps[headerIdx] - 1;
        let newMinOpenerIdx = openerIdx;
        for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {
          const opener = delimiters[openerIdx];
          if (opener.marker !== closer.marker) continue;
          if (opener.open && opener.end < 0) {
            let isOddMatch = false;
            if (opener.close || closer.open) {
              if ((opener.length + closer.length) % 3 === 0) {
                if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {
                  isOddMatch = true;
                }
              }
            }
            if (!isOddMatch) {
              const lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open ? jumps[openerIdx - 1] + 1 : 0;
              jumps[closerIdx] = closerIdx - openerIdx + lastJump;
              jumps[openerIdx] = lastJump;
              closer.open = false;
              opener.end = closerIdx;
              opener.close = false;
              newMinOpenerIdx = -1;
              lastTokenIdx = -2;
              break;
            }
          }
        }
        if (newMinOpenerIdx !== -1) {
          openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length || 0) % 3] = newMinOpenerIdx;
        }
      }
    }
    function link_pairs(state) {
      const tokens_meta = state.tokens_meta;
      const max = state.tokens_meta.length;
      processDelimiters(state.delimiters);
      for (let curr = 0; curr < max; curr++) {
        if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
          processDelimiters(tokens_meta[curr].delimiters);
        }
      }
    }
    function fragments_join(state) {
      let curr, last;
      let level = 0;
      const tokens = state.tokens;
      const max = state.tokens.length;
      for (curr = last = 0; curr < max; curr++) {
        if (tokens[curr].nesting < 0) level--;
        tokens[curr].level = level;
        if (tokens[curr].nesting > 0) level++;
        if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") {
          tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
        } else {
          if (curr !== last) {
            tokens[last] = tokens[curr];
          }
          last++;
        }
      }
      if (curr !== last) {
        tokens.length = last;
      }
    }
    var _rules = [["text", text], ["linkify", linkify], ["newline", newline], ["escape", escape], ["backticks", backtick], ["strikethrough", r_strikethrough.tokenize], ["emphasis", r_emphasis.tokenize], ["link", link], ["image", image], ["autolink", autolink], ["html_inline", html_inline], ["entity", entity]];
    var _rules2 = [
      ["balance_pairs", link_pairs],
      ["strikethrough", r_strikethrough.postProcess],
      ["emphasis", r_emphasis.postProcess],
      // rules for pairs separate '**' into its own text tokens, which may be left unused,
      // rule below merges unused segments back with the rest of the text
      ["fragments_join", fragments_join]
    ];
    function ParserInline() {
      this.ruler = new Ruler();
      for (let i = 0; i < _rules.length; i++) {
        this.ruler.push(_rules[i][0], _rules[i][1]);
      }
      this.ruler2 = new Ruler();
      for (let i = 0; i < _rules2.length; i++) {
        this.ruler2.push(_rules2[i][0], _rules2[i][1]);
      }
    }
    ParserInline.prototype.skipToken = function(state) {
      const pos = state.pos;
      const rules = this.ruler.getRules("");
      const len = rules.length;
      const maxNesting = state.md.options.maxNesting;
      const cache = state.cache;
      if (typeof cache[pos] !== "undefined") {
        state.pos = cache[pos];
        return;
      }
      let ok = false;
      if (state.level < maxNesting) {
        for (let i = 0; i < len; i++) {
          state.level++;
          ok = rules[i](state, true);
          state.level--;
          if (ok) {
            if (pos >= state.pos) {
              throw new Error("inline rule didn't increment state.pos");
            }
            break;
          }
        }
      } else {
        state.pos = state.posMax;
      }
      if (!ok) {
        state.pos++;
      }
      cache[pos] = state.pos;
    };
    ParserInline.prototype.tokenize = function(state) {
      const rules = this.ruler.getRules("");
      const len = rules.length;
      const end = state.posMax;
      const maxNesting = state.md.options.maxNesting;
      while (state.pos < end) {
        const prevPos = state.pos;
        let ok = false;
        if (state.level < maxNesting) {
          for (let i = 0; i < len; i++) {
            ok = rules[i](state, false);
            if (ok) {
              if (prevPos >= state.pos) {
                throw new Error("inline rule didn't increment state.pos");
              }
              break;
            }
          }
        }
        if (ok) {
          if (state.pos >= end) {
            break;
          }
          continue;
        }
        state.pending += state.src[state.pos++];
      }
      if (state.pending) {
        state.pushPending();
      }
    };
    ParserInline.prototype.parse = function(str, md, env, outTokens) {
      const state = new this.State(str, md, env, outTokens);
      this.tokenize(state);
      const rules = this.ruler2.getRules("");
      const len = rules.length;
      for (let i = 0; i < len; i++) {
        rules[i](state);
      }
    };
    ParserInline.prototype.State = StateInline;
    var cfg_default = {
      options: {
        // Enable HTML tags in source
        html: false,
        // Use '/' to close single tags (<br />)
        xhtmlOut: false,
        // Convert '\n' in paragraphs into <br>
        breaks: false,
        // CSS language prefix for fenced blocks
        langPrefix: "language-",
        // autoconvert URL-like texts to links
        linkify: false,
        // Enable some language-neutral replacements + quotes beautification
        typographer: false,
        // Double + single quotes replacement pairs, when typographer enabled,
        // and smartquotes on. Could be either a String or an Array.
        //
        // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
        // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
        quotes: "\u201C\u201D\u2018\u2019",
        /* “”‘’ */
        // Highlighter function. Should return escaped HTML,
        // or '' if the source string is not changed and should be escaped externaly.
        // If result starts with <pre... internal wrapper is skipped.
        //
        // function (/*str, lang*/) { return ''; }
        //
        highlight: null,
        // Internal protection, recursion limit
        maxNesting: 100
      },
      components: {
        core: {},
        block: {},
        inline: {}
      }
    };
    var cfg_zero = {
      options: {
        // Enable HTML tags in source
        html: false,
        // Use '/' to close single tags (<br />)
        xhtmlOut: false,
        // Convert '\n' in paragraphs into <br>
        breaks: false,
        // CSS language prefix for fenced blocks
        langPrefix: "language-",
        // autoconvert URL-like texts to links
        linkify: false,
        // Enable some language-neutral replacements + quotes beautification
        typographer: false,
        // Double + single quotes replacement pairs, when typographer enabled,
        // and smartquotes on. Could be either a String or an Array.
        //
        // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
        // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
        quotes: "\u201C\u201D\u2018\u2019",
        /* “”‘’ */
        // Highlighter function. Should return escaped HTML,
        // or '' if the source string is not changed and should be escaped externaly.
        // If result starts with <pre... internal wrapper is skipped.
        //
        // function (/*str, lang*/) { return ''; }
        //
        highlight: null,
        // Internal protection, recursion limit
        maxNesting: 20
      },
      components: {
        core: {
          rules: ["normalize", "block", "inline", "text_join"]
        },
        block: {
          rules: ["paragraph"]
        },
        inline: {
          rules: ["text"],
          rules2: ["balance_pairs", "fragments_join"]
        }
      }
    };
    var cfg_commonmark = {
      options: {
        // Enable HTML tags in source
        html: true,
        // Use '/' to close single tags (<br />)
        xhtmlOut: true,
        // Convert '\n' in paragraphs into <br>
        breaks: false,
        // CSS language prefix for fenced blocks
        langPrefix: "language-",
        // autoconvert URL-like texts to links
        linkify: false,
        // Enable some language-neutral replacements + quotes beautification
        typographer: false,
        // Double + single quotes replacement pairs, when typographer enabled,
        // and smartquotes on. Could be either a String or an Array.
        //
        // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
        // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
        quotes: "\u201C\u201D\u2018\u2019",
        /* “”‘’ */
        // Highlighter function. Should return escaped HTML,
        // or '' if the source string is not changed and should be escaped externaly.
        // If result starts with <pre... internal wrapper is skipped.
        //
        // function (/*str, lang*/) { return ''; }
        //
        highlight: null,
        // Internal protection, recursion limit
        maxNesting: 20
      },
      components: {
        core: {
          rules: ["normalize", "block", "inline", "text_join"]
        },
        block: {
          rules: ["blockquote", "code", "fence", "heading", "hr", "html_block", "lheading", "list", "reference", "paragraph"]
        },
        inline: {
          rules: ["autolink", "backticks", "emphasis", "entity", "escape", "html_inline", "image", "link", "newline", "text"],
          rules2: ["balance_pairs", "emphasis", "fragments_join"]
        }
      }
    };
    var config = {
      default: cfg_default,
      zero: cfg_zero,
      commonmark: cfg_commonmark
    };
    var BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
    var GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/;
    function validateLink(url) {
      const str = url.trim().toLowerCase();
      return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : true;
    }
    var RECODE_HOSTNAME_FOR = ["http:", "https:", "mailto:"];
    function normalizeLink(url) {
      const parsed = mdurl__namespace.parse(url, true);
      if (parsed.hostname) {
        if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
          try {
            parsed.hostname = punycode.toASCII(parsed.hostname);
          } catch (er) {
          }
        }
      }
      return mdurl__namespace.encode(mdurl__namespace.format(parsed));
    }
    function normalizeLinkText(url) {
      const parsed = mdurl__namespace.parse(url, true);
      if (parsed.hostname) {
        if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
          try {
            parsed.hostname = punycode.toUnicode(parsed.hostname);
          } catch (er) {
          }
        }
      }
      return mdurl__namespace.decode(mdurl__namespace.format(parsed), mdurl__namespace.decode.defaultChars + "%");
    }
    function MarkdownIt(presetName, options) {
      if (!(this instanceof MarkdownIt)) {
        return new MarkdownIt(presetName, options);
      }
      if (!options) {
        if (!isString(presetName)) {
          options = presetName || {};
          presetName = "default";
        }
      }
      this.inline = new ParserInline();
      this.block = new ParserBlock();
      this.core = new Core();
      this.renderer = new Renderer();
      this.linkify = new LinkifyIt();
      this.validateLink = validateLink;
      this.normalizeLink = normalizeLink;
      this.normalizeLinkText = normalizeLinkText;
      this.utils = utils;
      this.helpers = assign({}, helpers);
      this.options = {};
      this.configure(presetName);
      if (options) {
        this.set(options);
      }
    }
    MarkdownIt.prototype.set = function(options) {
      assign(this.options, options);
      return this;
    };
    MarkdownIt.prototype.configure = function(presets) {
      const self2 = this;
      if (isString(presets)) {
        const presetName = presets;
        presets = config[presetName];
        if (!presets) {
          throw new Error('Wrong `markdown-it` preset "' + presetName + '", check name');
        }
      }
      if (!presets) {
        throw new Error("Wrong `markdown-it` preset, can't be empty");
      }
      if (presets.options) {
        self2.set(presets.options);
      }
      if (presets.components) {
        Object.keys(presets.components).forEach(function(name) {
          if (presets.components[name].rules) {
            self2[name].ruler.enableOnly(presets.components[name].rules);
          }
          if (presets.components[name].rules2) {
            self2[name].ruler2.enableOnly(presets.components[name].rules2);
          }
        });
      }
      return this;
    };
    MarkdownIt.prototype.enable = function(list2, ignoreInvalid) {
      let result = [];
      if (!Array.isArray(list2)) {
        list2 = [list2];
      }
      ["core", "block", "inline"].forEach(function(chain) {
        result = result.concat(this[chain].ruler.enable(list2, true));
      }, this);
      result = result.concat(this.inline.ruler2.enable(list2, true));
      const missed = list2.filter(function(name) {
        return result.indexOf(name) < 0;
      });
      if (missed.length && !ignoreInvalid) {
        throw new Error("MarkdownIt. Failed to enable unknown rule(s): " + missed);
      }
      return this;
    };
    MarkdownIt.prototype.disable = function(list2, ignoreInvalid) {
      let result = [];
      if (!Array.isArray(list2)) {
        list2 = [list2];
      }
      ["core", "block", "inline"].forEach(function(chain) {
        result = result.concat(this[chain].ruler.disable(list2, true));
      }, this);
      result = result.concat(this.inline.ruler2.disable(list2, true));
      const missed = list2.filter(function(name) {
        return result.indexOf(name) < 0;
      });
      if (missed.length && !ignoreInvalid) {
        throw new Error("MarkdownIt. Failed to disable unknown rule(s): " + missed);
      }
      return this;
    };
    MarkdownIt.prototype.use = function(plugin) {
      const args2 = [this].concat(Array.prototype.slice.call(arguments, 1));
      plugin.apply(plugin, args2);
      return this;
    };
    MarkdownIt.prototype.parse = function(src, env) {
      if (typeof src !== "string") {
        throw new Error("Input data should be a String");
      }
      const state = new this.core.State(src, this, env);
      this.core.process(state);
      return state.tokens;
    };
    MarkdownIt.prototype.render = function(src, env) {
      env = env || {};
      return this.renderer.render(this.parse(src, env), this.options, env);
    };
    MarkdownIt.prototype.parseInline = function(src, env) {
      const state = new this.core.State(src, this, env);
      state.inlineMode = true;
      this.core.process(state);
      return state.tokens;
    };
    MarkdownIt.prototype.renderInline = function(src, env) {
      env = env || {};
      return this.renderer.render(this.parseInline(src, env), this.options, env);
    };
    module2.exports = MarkdownIt;
  }
});

// node_modules/prosemirror-markdown/dist/index.cjs
var require_dist3 = __commonJS({
  "node_modules/prosemirror-markdown/dist/index.cjs"(exports2) {
    "use strict";
    function _slicedToArray(arr, i) {
      return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
    }
    function _nonIterableRest() {
      throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
    }
    function _unsupportedIterableToArray(o, minLen) {
      if (!o) return;
      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
      var n = Object.prototype.toString.call(o).slice(8, -1);
      if (n === "Object" && o.constructor) n = o.constructor.name;
      if (n === "Map" || n === "Set") return Array.from(o);
      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
    }
    function _arrayLikeToArray(arr, len) {
      if (len == null || len > arr.length) len = arr.length;
      for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
      return arr2;
    }
    function _iterableToArrayLimit(r, l) {
      var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
      if (null != t) {
        var e, n, i, u, a = [], f = true, o = false;
        try {
          if (i = (t = t.call(r)).next, 0 === l) {
            if (Object(t) !== t) return;
            f = false;
          } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
        } catch (r2) {
          o = true, n = r2;
        } finally {
          try {
            if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
          } finally {
            if (o) throw n;
          }
        }
        return a;
      }
    }
    function _arrayWithHoles(arr) {
      if (Array.isArray(arr)) return arr;
    }
    function _typeof(o) {
      "@babel/helpers - typeof";
      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
        return typeof o2;
      } : function(o2) {
        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
      }, _typeof(o);
    }
    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
    function _defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
      }
    }
    function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
      if (staticProps) _defineProperties(Constructor, staticProps);
      Object.defineProperty(Constructor, "prototype", { writable: false });
      return Constructor;
    }
    function _toPropertyKey(arg) {
      var key = _toPrimitive(arg, "string");
      return _typeof(key) === "symbol" ? key : String(key);
    }
    function _toPrimitive(input2, hint) {
      if (_typeof(input2) !== "object" || input2 === null) return input2;
      var prim = input2[Symbol.toPrimitive];
      if (prim !== void 0) {
        var res = prim.call(input2, hint || "default");
        if (_typeof(res) !== "object") return res;
        throw new TypeError("@@toPrimitive must return a primitive value.");
      }
      return (hint === "string" ? String : Number)(input2);
    }
    var prosemirrorModel = require_dist2();
    var MarkdownIt = require_index_cjs4();
    var schema = new prosemirrorModel.Schema({
      nodes: {
        doc: {
          content: "block+"
        },
        paragraph: {
          content: "inline*",
          group: "block",
          parseDOM: [{
            tag: "p"
          }],
          toDOM: function toDOM() {
            return ["p", 0];
          }
        },
        blockquote: {
          content: "block+",
          group: "block",
          parseDOM: [{
            tag: "blockquote"
          }],
          toDOM: function toDOM() {
            return ["blockquote", 0];
          }
        },
        horizontal_rule: {
          group: "block",
          parseDOM: [{
            tag: "hr"
          }],
          toDOM: function toDOM() {
            return ["div", ["hr"]];
          }
        },
        heading: {
          attrs: {
            level: {
              "default": 1
            }
          },
          content: "(text | image)*",
          group: "block",
          defining: true,
          parseDOM: [{
            tag: "h1",
            attrs: {
              level: 1
            }
          }, {
            tag: "h2",
            attrs: {
              level: 2
            }
          }, {
            tag: "h3",
            attrs: {
              level: 3
            }
          }, {
            tag: "h4",
            attrs: {
              level: 4
            }
          }, {
            tag: "h5",
            attrs: {
              level: 5
            }
          }, {
            tag: "h6",
            attrs: {
              level: 6
            }
          }],
          toDOM: function toDOM(node) {
            return ["h" + node.attrs.level, 0];
          }
        },
        code_block: {
          content: "text*",
          group: "block",
          code: true,
          defining: true,
          marks: "",
          attrs: {
            params: {
              "default": ""
            }
          },
          parseDOM: [{
            tag: "pre",
            preserveWhitespace: "full",
            getAttrs: function getAttrs(node) {
              return {
                params: node.getAttribute("data-params") || ""
              };
            }
          }],
          toDOM: function toDOM(node) {
            return ["pre", node.attrs.params ? {
              "data-params": node.attrs.params
            } : {}, ["code", 0]];
          }
        },
        ordered_list: {
          content: "list_item+",
          group: "block",
          attrs: {
            order: {
              "default": 1
            },
            tight: {
              "default": false
            }
          },
          parseDOM: [{
            tag: "ol",
            getAttrs: function getAttrs(dom) {
              return {
                order: dom.hasAttribute("start") ? +dom.getAttribute("start") : 1,
                tight: dom.hasAttribute("data-tight")
              };
            }
          }],
          toDOM: function toDOM(node) {
            return ["ol", {
              start: node.attrs.order == 1 ? null : node.attrs.order,
              "data-tight": node.attrs.tight ? "true" : null
            }, 0];
          }
        },
        bullet_list: {
          content: "list_item+",
          group: "block",
          attrs: {
            tight: {
              "default": false
            }
          },
          parseDOM: [{
            tag: "ul",
            getAttrs: function getAttrs(dom) {
              return {
                tight: dom.hasAttribute("data-tight")
              };
            }
          }],
          toDOM: function toDOM(node) {
            return ["ul", {
              "data-tight": node.attrs.tight ? "true" : null
            }, 0];
          }
        },
        list_item: {
          content: "block+",
          defining: true,
          parseDOM: [{
            tag: "li"
          }],
          toDOM: function toDOM() {
            return ["li", 0];
          }
        },
        text: {
          group: "inline"
        },
        image: {
          inline: true,
          attrs: {
            src: {},
            alt: {
              "default": null
            },
            title: {
              "default": null
            }
          },
          group: "inline",
          draggable: true,
          parseDOM: [{
            tag: "img[src]",
            getAttrs: function getAttrs(dom) {
              return {
                src: dom.getAttribute("src"),
                title: dom.getAttribute("title"),
                alt: dom.getAttribute("alt")
              };
            }
          }],
          toDOM: function toDOM(node) {
            return ["img", node.attrs];
          }
        },
        hard_break: {
          inline: true,
          group: "inline",
          selectable: false,
          parseDOM: [{
            tag: "br"
          }],
          toDOM: function toDOM() {
            return ["br"];
          }
        }
      },
      marks: {
        em: {
          parseDOM: [{
            tag: "i"
          }, {
            tag: "em"
          }, {
            style: "font-style=italic"
          }, {
            style: "font-style=normal",
            clearMark: function clearMark(m) {
              return m.type.name == "em";
            }
          }],
          toDOM: function toDOM() {
            return ["em"];
          }
        },
        strong: {
          parseDOM: [{
            tag: "strong"
          }, {
            tag: "b",
            getAttrs: function getAttrs(node) {
              return node.style.fontWeight != "normal" && null;
            }
          }, {
            style: "font-weight=400",
            clearMark: function clearMark(m) {
              return m.type.name == "strong";
            }
          }, {
            style: "font-weight",
            getAttrs: function getAttrs(value) {
              return /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null;
            }
          }],
          toDOM: function toDOM() {
            return ["strong"];
          }
        },
        link: {
          attrs: {
            href: {},
            title: {
              "default": null
            }
          },
          inclusive: false,
          parseDOM: [{
            tag: "a[href]",
            getAttrs: function getAttrs(dom) {
              return {
                href: dom.getAttribute("href"),
                title: dom.getAttribute("title")
              };
            }
          }],
          toDOM: function toDOM(node) {
            return ["a", node.attrs];
          }
        },
        code: {
          parseDOM: [{
            tag: "code"
          }],
          toDOM: function toDOM() {
            return ["code"];
          }
        }
      }
    });
    function maybeMerge(a, b) {
      if (a.isText && b.isText && prosemirrorModel.Mark.sameSet(a.marks, b.marks)) return a.withText(a.text + b.text);
    }
    var MarkdownParseState = (function() {
      function MarkdownParseState2(schema2, tokenHandlers2) {
        _classCallCheck(this, MarkdownParseState2);
        this.schema = schema2;
        this.tokenHandlers = tokenHandlers2;
        this.stack = [{
          type: schema2.topNodeType,
          attrs: null,
          content: [],
          marks: prosemirrorModel.Mark.none
        }];
      }
      _createClass(MarkdownParseState2, [{
        key: "top",
        value: function top() {
          return this.stack[this.stack.length - 1];
        }
      }, {
        key: "push",
        value: function push(elt) {
          if (this.stack.length) this.top().content.push(elt);
        }
      }, {
        key: "addText",
        value: function addText(text) {
          if (!text) return;
          var top = this.top(), nodes = top.content, last = nodes[nodes.length - 1];
          var node = this.schema.text(text, top.marks), merged;
          if (last && (merged = maybeMerge(last, node))) nodes[nodes.length - 1] = merged;
          else nodes.push(node);
        }
      }, {
        key: "openMark",
        value: function openMark(mark) {
          var top = this.top();
          top.marks = mark.addToSet(top.marks);
        }
      }, {
        key: "closeMark",
        value: function closeMark(mark) {
          var top = this.top();
          top.marks = mark.removeFromSet(top.marks);
        }
      }, {
        key: "parseTokens",
        value: function parseTokens(toks) {
          for (var i = 0; i < toks.length; i++) {
            var tok = toks[i];
            var handler = this.tokenHandlers[tok.type];
            if (!handler) throw new Error("Token type `" + tok.type + "` not supported by Markdown parser");
            handler(this, tok, toks, i);
          }
        }
      }, {
        key: "addNode",
        value: function addNode(type, attrs2, content) {
          var top = this.top();
          var node = type.createAndFill(attrs2, content, top ? top.marks : []);
          if (!node) return null;
          this.push(node);
          return node;
        }
      }, {
        key: "openNode",
        value: function openNode(type, attrs2) {
          this.stack.push({
            type,
            attrs: attrs2,
            content: [],
            marks: prosemirrorModel.Mark.none
          });
        }
      }, {
        key: "closeNode",
        value: function closeNode() {
          var info = this.stack.pop();
          return this.addNode(info.type, info.attrs, info.content);
        }
      }]);
      return MarkdownParseState2;
    })();
    function attrs(spec, token, tokens, i) {
      if (spec.getAttrs) return spec.getAttrs(token, tokens, i);
      else if (spec.attrs instanceof Function) return spec.attrs(token);
      else return spec.attrs;
    }
    function noCloseToken(spec, type) {
      return spec.noCloseToken || type == "code_inline" || type == "code_block" || type == "fence";
    }
    function withoutTrailingNewline(str) {
      return str[str.length - 1] == "\n" ? str.slice(0, str.length - 1) : str;
    }
    function noOp() {
    }
    function tokenHandlers(schema2, tokens) {
      var handlers = /* @__PURE__ */ Object.create(null);
      var _loop = function _loop2() {
        var spec = tokens[type];
        if (spec.block) {
          var nodeType = schema2.nodeType(spec.block);
          if (noCloseToken(spec, type)) {
            handlers[type] = function(state, tok, tokens2, i) {
              state.openNode(nodeType, attrs(spec, tok, tokens2, i));
              state.addText(withoutTrailingNewline(tok.content));
              state.closeNode();
            };
          } else {
            handlers[type + "_open"] = function(state, tok, tokens2, i) {
              return state.openNode(nodeType, attrs(spec, tok, tokens2, i));
            };
            handlers[type + "_close"] = function(state) {
              return state.closeNode();
            };
          }
        } else if (spec.node) {
          var _nodeType = schema2.nodeType(spec.node);
          handlers[type] = function(state, tok, tokens2, i) {
            return state.addNode(_nodeType, attrs(spec, tok, tokens2, i));
          };
        } else if (spec.mark) {
          var markType = schema2.marks[spec.mark];
          if (noCloseToken(spec, type)) {
            handlers[type] = function(state, tok, tokens2, i) {
              state.openMark(markType.create(attrs(spec, tok, tokens2, i)));
              state.addText(withoutTrailingNewline(tok.content));
              state.closeMark(markType);
            };
          } else {
            handlers[type + "_open"] = function(state, tok, tokens2, i) {
              return state.openMark(markType.create(attrs(spec, tok, tokens2, i)));
            };
            handlers[type + "_close"] = function(state) {
              return state.closeMark(markType);
            };
          }
        } else if (spec.ignore) {
          if (noCloseToken(spec, type)) {
            handlers[type] = noOp;
          } else {
            handlers[type + "_open"] = noOp;
            handlers[type + "_close"] = noOp;
          }
        } else {
          throw new RangeError("Unrecognized parsing spec " + JSON.stringify(spec));
        }
      };
      for (var type in tokens) {
        _loop();
      }
      handlers.text = function(state, tok) {
        return state.addText(tok.content);
      };
      handlers.inline = function(state, tok) {
        return state.parseTokens(tok.children);
      };
      handlers.softbreak = handlers.softbreak || function(state) {
        return state.addText(" ");
      };
      return handlers;
    }
    var MarkdownParser = (function() {
      function MarkdownParser2(schema2, tokenizer, tokens) {
        _classCallCheck(this, MarkdownParser2);
        this.schema = schema2;
        this.tokenizer = tokenizer;
        this.tokens = tokens;
        this.tokenHandlers = tokenHandlers(schema2, tokens);
      }
      _createClass(MarkdownParser2, [{
        key: "parse",
        value: function parse(text) {
          var markdownEnv = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          var state = new MarkdownParseState(this.schema, this.tokenHandlers), doc;
          state.parseTokens(this.tokenizer.parse(text, markdownEnv));
          do {
            doc = state.closeNode();
          } while (state.stack.length);
          return doc || this.schema.topNodeType.createAndFill();
        }
      }]);
      return MarkdownParser2;
    })();
    function listIsTight(tokens, i) {
      while (++i < tokens.length) if (tokens[i].type != "list_item_open") return tokens[i].hidden;
      return false;
    }
    var defaultMarkdownParser = new MarkdownParser(schema, MarkdownIt("commonmark", {
      html: false
    }), {
      blockquote: {
        block: "blockquote"
      },
      paragraph: {
        block: "paragraph"
      },
      list_item: {
        block: "list_item"
      },
      bullet_list: {
        block: "bullet_list",
        getAttrs: function getAttrs(_, tokens, i) {
          return {
            tight: listIsTight(tokens, i)
          };
        }
      },
      ordered_list: {
        block: "ordered_list",
        getAttrs: function getAttrs(tok, tokens, i) {
          return {
            order: +tok.attrGet("start") || 1,
            tight: listIsTight(tokens, i)
          };
        }
      },
      heading: {
        block: "heading",
        getAttrs: function getAttrs(tok) {
          return {
            level: +tok.tag.slice(1)
          };
        }
      },
      code_block: {
        block: "code_block",
        noCloseToken: true
      },
      fence: {
        block: "code_block",
        getAttrs: function getAttrs(tok) {
          return {
            params: tok.info || ""
          };
        },
        noCloseToken: true
      },
      hr: {
        node: "horizontal_rule"
      },
      image: {
        node: "image",
        getAttrs: function getAttrs(tok) {
          return {
            src: tok.attrGet("src"),
            title: tok.attrGet("title") || null,
            alt: tok.children[0] && tok.children[0].content || null
          };
        }
      },
      hardbreak: {
        node: "hard_break"
      },
      em: {
        mark: "em"
      },
      strong: {
        mark: "strong"
      },
      link: {
        mark: "link",
        getAttrs: function getAttrs(tok) {
          return {
            href: tok.attrGet("href"),
            title: tok.attrGet("title") || null
          };
        }
      },
      code_inline: {
        mark: "code",
        noCloseToken: true
      }
    });
    var blankMark = {
      open: "",
      close: "",
      mixable: true
    };
    var MarkdownSerializer = (function() {
      function MarkdownSerializer2(nodes, marks) {
        var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
        _classCallCheck(this, MarkdownSerializer2);
        this.nodes = nodes;
        this.marks = marks;
        this.options = options;
      }
      _createClass(MarkdownSerializer2, [{
        key: "serialize",
        value: function serialize(content) {
          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          options = Object.assign({}, this.options, options);
          var state = new MarkdownSerializerState(this.nodes, this.marks, options);
          state.renderContent(content);
          return state.out;
        }
      }]);
      return MarkdownSerializer2;
    })();
    var defaultMarkdownSerializer = new MarkdownSerializer({
      blockquote: function blockquote(state, node) {
        state.wrapBlock("> ", null, node, function() {
          return state.renderContent(node);
        });
      },
      code_block: function code_block(state, node) {
        var backticks = node.textContent.match(/`{3,}/gm);
        var fence = backticks ? backticks.sort().slice(-1)[0] + "`" : "```";
        state.write(fence + (node.attrs.params || "") + "\n");
        state.text(node.textContent, false);
        state.write("\n");
        state.write(fence);
        state.closeBlock(node);
      },
      heading: function heading(state, node) {
        state.write(state.repeat("#", node.attrs.level) + " ");
        state.renderInline(node, false);
        state.closeBlock(node);
      },
      horizontal_rule: function horizontal_rule(state, node) {
        state.write(node.attrs.markup || "---");
        state.closeBlock(node);
      },
      bullet_list: function bullet_list(state, node) {
        state.renderList(node, "  ", function() {
          return (node.attrs.bullet || "*") + " ";
        });
      },
      ordered_list: function ordered_list(state, node) {
        var start = node.attrs.order || 1;
        var maxW = String(start + node.childCount - 1).length;
        var space = state.repeat(" ", maxW + 2);
        state.renderList(node, space, function(i) {
          var nStr = String(start + i);
          return state.repeat(" ", maxW - nStr.length) + nStr + ". ";
        });
      },
      list_item: function list_item(state, node) {
        state.renderContent(node);
      },
      paragraph: function paragraph(state, node) {
        state.renderInline(node);
        state.closeBlock(node);
      },
      image: function image(state, node) {
        state.write("![" + state.esc(node.attrs.alt || "") + "](" + node.attrs.src.replace(/[\(\)]/g, "\\$&") + (node.attrs.title ? ' "' + node.attrs.title.replace(/"/g, '\\"') + '"' : "") + ")");
      },
      hard_break: function hard_break(state, node, parent, index) {
        for (var i = index + 1; i < parent.childCount; i++) if (parent.child(i).type != node.type) {
          state.write("\\\n");
          return;
        }
      },
      text: function text(state, node) {
        state.text(node.text, !state.inAutolink);
      }
    }, {
      em: {
        open: "*",
        close: "*",
        mixable: true,
        expelEnclosingWhitespace: true
      },
      strong: {
        open: "**",
        close: "**",
        mixable: true,
        expelEnclosingWhitespace: true
      },
      link: {
        open: function open(state, mark, parent, index) {
          state.inAutolink = isPlainURL(mark, parent, index);
          return state.inAutolink ? "<" : "[";
        },
        close: function close(state, mark, parent, index) {
          var inAutolink = state.inAutolink;
          state.inAutolink = void 0;
          return inAutolink ? ">" : "](" + mark.attrs.href.replace(/[\(\)"]/g, "\\$&") + (mark.attrs.title ? ' "'.concat(mark.attrs.title.replace(/"/g, '\\"'), '"') : "") + ")";
        },
        mixable: true
      },
      code: {
        open: function open(_state, _mark, parent, index) {
          return backticksFor(parent.child(index), -1);
        },
        close: function close(_state, _mark, parent, index) {
          return backticksFor(parent.child(index - 1), 1);
        },
        escape: false
      }
    });
    function backticksFor(node, side) {
      var ticks = /`+/g, m, len = 0;
      if (node.isText) while (m = ticks.exec(node.text)) len = Math.max(len, m[0].length);
      var result = len > 0 && side > 0 ? " `" : "`";
      for (var i = 0; i < len; i++) result += "`";
      if (len > 0 && side < 0) result += " ";
      return result;
    }
    function isPlainURL(link, parent, index) {
      if (link.attrs.title || !/^\w+:/.test(link.attrs.href)) return false;
      var content = parent.child(index);
      if (!content.isText || content.text != link.attrs.href || content.marks[content.marks.length - 1] != link) return false;
      return index == parent.childCount - 1 || !link.isInSet(parent.child(index + 1).marks);
    }
    var MarkdownSerializerState = (function() {
      function MarkdownSerializerState2(nodes, marks, options) {
        _classCallCheck(this, MarkdownSerializerState2);
        this.nodes = nodes;
        this.marks = marks;
        this.options = options;
        this.delim = "";
        this.out = "";
        this.closed = null;
        this.inAutolink = void 0;
        this.atBlockStart = false;
        this.inTightList = false;
        if (typeof this.options.tightLists == "undefined") this.options.tightLists = false;
        if (typeof this.options.hardBreakNodeName == "undefined") this.options.hardBreakNodeName = "hard_break";
      }
      _createClass(MarkdownSerializerState2, [{
        key: "flushClose",
        value: function flushClose() {
          var size = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 2;
          if (this.closed) {
            if (!this.atBlank()) this.out += "\n";
            if (size > 1) {
              var delimMin = this.delim;
              var trim = /\s+$/.exec(delimMin);
              if (trim) delimMin = delimMin.slice(0, delimMin.length - trim[0].length);
              for (var i = 1; i < size; i++) this.out += delimMin + "\n";
            }
            this.closed = null;
          }
        }
      }, {
        key: "getMark",
        value: function getMark(name) {
          var info = this.marks[name];
          if (!info) {
            if (this.options.strict !== false) throw new Error("Mark type `".concat(name, "` not supported by Markdown renderer"));
            info = blankMark;
          }
          return info;
        }
      }, {
        key: "wrapBlock",
        value: function wrapBlock(delim, firstDelim, node, f) {
          var old = this.delim;
          this.write(firstDelim != null ? firstDelim : delim);
          this.delim += delim;
          f();
          this.delim = old;
          this.closeBlock(node);
        }
      }, {
        key: "atBlank",
        value: function atBlank() {
          return /(^|\n)$/.test(this.out);
        }
      }, {
        key: "ensureNewLine",
        value: function ensureNewLine() {
          if (!this.atBlank()) this.out += "\n";
        }
      }, {
        key: "write",
        value: function write(content) {
          this.flushClose();
          if (this.delim && this.atBlank()) this.out += this.delim;
          if (content) this.out += content;
        }
      }, {
        key: "closeBlock",
        value: function closeBlock(node) {
          this.closed = node;
        }
      }, {
        key: "text",
        value: function text(_text) {
          var escape = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
          var lines = _text.split("\n");
          for (var i = 0; i < lines.length; i++) {
            this.write();
            if (!escape && lines[i][0] == "[" && /(^|[^\\])\!$/.test(this.out)) this.out = this.out.slice(0, this.out.length - 1) + "\\!";
            this.out += escape ? this.esc(lines[i], this.atBlockStart) : lines[i];
            if (i != lines.length - 1) this.out += "\n";
          }
        }
      }, {
        key: "render",
        value: function render(node, parent, index) {
          if (this.nodes[node.type.name]) {
            this.nodes[node.type.name](this, node, parent, index);
          } else {
            if (this.options.strict !== false) {
              throw new Error("Token type `" + node.type.name + "` not supported by Markdown renderer");
            } else if (!node.type.isLeaf) {
              if (node.type.inlineContent) this.renderInline(node);
              else this.renderContent(node);
              if (node.isBlock) this.closeBlock(node);
            }
          }
        }
      }, {
        key: "renderContent",
        value: function renderContent(parent) {
          var _this = this;
          parent.forEach(function(node, _, i) {
            return _this.render(node, parent, i);
          });
        }
      }, {
        key: "renderInline",
        value: function renderInline(parent) {
          var _this2 = this;
          var fromBlockStart = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
          this.atBlockStart = fromBlockStart;
          var active = [], trailing = "";
          var progress = function progress2(node, offset, index) {
            var marks = node ? node.marks : [];
            if (node && node.type.name === _this2.options.hardBreakNodeName) marks = marks.filter(function(m) {
              if (index + 1 == parent.childCount) return false;
              var next = parent.child(index + 1);
              return m.isInSet(next.marks) && (!next.isText || /\S/.test(next.text));
            });
            var leading = trailing;
            trailing = "";
            if (node && node.isText && marks.some(function(mark2) {
              var info = _this2.getMark(mark2.type.name);
              return info && info.expelEnclosingWhitespace && !mark2.isInSet(active);
            })) {
              var _exec = /^(\s*)(.*)$/m.exec(node.text), _exec2 = _slicedToArray(_exec, 3), _ = _exec2[0], lead = _exec2[1], rest = _exec2[2];
              if (lead) {
                leading += lead;
                node = rest ? node.withText(rest) : null;
                if (!node) marks = active;
              }
            }
            if (node && node.isText && marks.some(function(mark2) {
              var info = _this2.getMark(mark2.type.name);
              return info && info.expelEnclosingWhitespace && (index == parent.childCount - 1 || !mark2.isInSet(parent.child(index + 1).marks));
            })) {
              var _exec3 = /^(.*?)(\s*)$/m.exec(node.text), _exec4 = _slicedToArray(_exec3, 3), _2 = _exec4[0], _rest = _exec4[1], trail = _exec4[2];
              if (trail) {
                trailing = trail;
                node = _rest ? node.withText(_rest) : null;
                if (!node) marks = active;
              }
            }
            var inner = marks.length ? marks[marks.length - 1] : null;
            var noEsc = inner && _this2.getMark(inner.type.name).escape === false;
            var len = marks.length - (noEsc ? 1 : 0);
            outer: for (var i = 0; i < len; i++) {
              var mark = marks[i];
              if (!_this2.getMark(mark.type.name).mixable) break;
              for (var j = 0; j < active.length; j++) {
                var other = active[j];
                if (!_this2.getMark(other.type.name).mixable) break;
                if (mark.eq(other)) {
                  if (i > j) marks = marks.slice(0, j).concat(mark).concat(marks.slice(j, i)).concat(marks.slice(i + 1, len));
                  else if (j > i) marks = marks.slice(0, i).concat(marks.slice(i + 1, j)).concat(mark).concat(marks.slice(j, len));
                  continue outer;
                }
              }
            }
            var keep = 0;
            while (keep < Math.min(active.length, len) && marks[keep].eq(active[keep])) ++keep;
            while (keep < active.length) _this2.text(_this2.markString(active.pop(), false, parent, index), false);
            if (leading) _this2.text(leading);
            if (node) {
              while (active.length < len) {
                var add = marks[active.length];
                active.push(add);
                _this2.text(_this2.markString(add, true, parent, index), false);
                _this2.atBlockStart = false;
              }
              if (noEsc && node.isText) _this2.text(_this2.markString(inner, true, parent, index) + node.text + _this2.markString(inner, false, parent, index + 1), false);
              else _this2.render(node, parent, index);
              _this2.atBlockStart = false;
            }
            if ((node === null || node === void 0 ? void 0 : node.isText) && node.nodeSize > 0) {
              _this2.atBlockStart = false;
            }
          };
          parent.forEach(progress);
          progress(null, 0, parent.childCount);
          this.atBlockStart = false;
        }
      }, {
        key: "renderList",
        value: function renderList(node, delim, firstDelim) {
          var _this3 = this;
          if (this.closed && this.closed.type == node.type) this.flushClose(3);
          else if (this.inTightList) this.flushClose(1);
          var isTight = typeof node.attrs.tight != "undefined" ? node.attrs.tight : this.options.tightLists;
          var prevTight = this.inTightList;
          this.inTightList = isTight;
          node.forEach(function(child, _, i) {
            if (i && isTight) _this3.flushClose(1);
            _this3.wrapBlock(delim, firstDelim(i), node, function() {
              return _this3.render(child, node, i);
            });
          });
          this.inTightList = prevTight;
        }
      }, {
        key: "esc",
        value: function esc(str) {
          var startOfLine = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
          str = str.replace(/[`*\\~\[\]_]/g, function(m, i) {
            return m == "_" && i > 0 && i + 1 < str.length && str[i - 1].match(/\w/) && str[i + 1].match(/\w/) ? m : "\\" + m;
          });
          if (startOfLine) str = str.replace(/^(\+[ ]|[\-*>])/, "\\$&").replace(/^(\s*)(#{1,6})(\s|$)/, "$1\\$2$3").replace(/^(\s*\d+)\.\s/, "$1\\. ");
          if (this.options.escapeExtraCharacters) str = str.replace(this.options.escapeExtraCharacters, "\\$&");
          return str;
        }
      }, {
        key: "quote",
        value: function quote(str) {
          var wrap = str.indexOf('"') == -1 ? '""' : str.indexOf("'") == -1 ? "''" : "()";
          return wrap[0] + str + wrap[1];
        }
      }, {
        key: "repeat",
        value: function repeat(str, n) {
          var out = "";
          for (var i = 0; i < n; i++) out += str;
          return out;
        }
      }, {
        key: "markString",
        value: function markString(mark, open, parent, index) {
          var info = this.getMark(mark.type.name);
          var value = open ? info.open : info.close;
          return typeof value == "string" ? value : value(this, mark, parent, index);
        }
      }, {
        key: "getEnclosingWhitespace",
        value: function getEnclosingWhitespace(text) {
          return {
            leading: (text.match(/^(\s+)/) || [void 0])[0],
            trailing: (text.match(/(\s+)$/) || [void 0])[0]
          };
        }
      }]);
      return MarkdownSerializerState2;
    })();
    exports2.MarkdownParser = MarkdownParser;
    exports2.MarkdownSerializer = MarkdownSerializer;
    exports2.MarkdownSerializerState = MarkdownSerializerState;
    exports2.defaultMarkdownParser = defaultMarkdownParser;
    exports2.defaultMarkdownSerializer = defaultMarkdownSerializer;
    exports2.schema = schema;
  }
});

// node_modules/@atlaskit/editor-prosemirror/dist/cjs/markdown.js
var require_markdown = __commonJS({
  "node_modules/@atlaskit/editor-prosemirror/dist/cjs/markdown.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "MarkdownParser", {
      enumerable: true,
      get: function get() {
        return _prosemirrorMarkdown.MarkdownParser;
      }
    });
    Object.defineProperty(exports2, "MarkdownSerializer", {
      enumerable: true,
      get: function get() {
        return _prosemirrorMarkdown.MarkdownSerializer;
      }
    });
    Object.defineProperty(exports2, "MarkdownSerializerState", {
      enumerable: true,
      get: function get() {
        return _prosemirrorMarkdown.MarkdownSerializerState;
      }
    });
    Object.defineProperty(exports2, "defaultMarkdownParser", {
      enumerable: true,
      get: function get() {
        return _prosemirrorMarkdown.defaultMarkdownParser;
      }
    });
    Object.defineProperty(exports2, "defaultMarkdownSerializer", {
      enumerable: true,
      get: function get() {
        return _prosemirrorMarkdown.defaultMarkdownSerializer;
      }
    });
    var _prosemirrorMarkdown = require_dist3();
  }
});

// node_modules/@atlaskit/editor-markdown-transformer/dist/cjs/media.js
var require_media2 = __commonJS({
  "node_modules/@atlaskit/editor-markdown-transformer/dist/cjs/media.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.markdownItMedia = void 0;
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    function createRule() {
      var regx = /!\[([^\]]*)\]\(([^)]*?)\s*(?:"([^")]*)"\s*)?\)/g;
      var validParentTokens = ["th_open", "td_open", "list_item_open", "blockquote_open"];
      return function media(State) {
        var getUrl = function getUrl2(str) {
          var res = State.md.helpers.parseLinkDestination(str, str.indexOf("(") + 1, str.length);
          if (res.ok) {
            var href = State.md.normalizeLink(res.str);
            if (State.md.validateLink(href)) {
              return href;
            }
          }
          return "";
        };
        var createMediaTokens = function createMediaTokens2(url) {
          var alt = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
          var mediaSingleOpen = new State.Token("media_single_open", "", 1);
          var media2 = new State.Token("media", "", 0);
          media2.attrs = [["url", getUrl(url)], ["type", "external"], ["alt", alt]];
          var mediaSingleClose = new State.Token("media_single_close", "", -1);
          return [mediaSingleOpen, media2, mediaSingleClose];
        };
        var createInlineTokens = function createInlineTokens2(str, openingTokens, closingTokens) {
          if (!str || str.length === 0) {
            return [];
          }
          var inlineBefore = new State.Token("inline", "", 1);
          inlineBefore.content = str;
          inlineBefore.children = [];
          return [].concat((0, _toConsumableArray2.default)(openingTokens), [inlineBefore], (0, _toConsumableArray2.default)(closingTokens));
        };
        var processedTokens = [];
        var newTokens = State.tokens.reduce(function(tokens, token, i, arr) {
          var matchAll = Array.from(token.content.matchAll(regx));
          if (token.type === "inline" && matchAll.length) {
            var openingTokens = [];
            var cursor = i - 1;
            var previousToken = arr[cursor];
            var subTree = [];
            while (previousToken && previousToken.level > 0 && validParentTokens.indexOf(previousToken.type) === -1) {
              openingTokens.unshift(previousToken);
              cursor--;
              previousToken = arr[cursor];
            }
            if (validParentTokens.indexOf(previousToken.type) === -1) {
              openingTokens.unshift(previousToken);
            } else {
              cursor++;
            }
            var closingTokens = openingTokens.map(function(token2) {
              return new State.Token(token2.type.replace("_open", "_close"), token2.tag, -1);
            }).reverse();
            var inlineContentStack = token.content;
            matchAll.forEach(function(match, j) {
              var _match = (0, _slicedToArray2.default)(match, 3), matchString = _match[0], alt = _match[1], url = _match[2];
              var start = inlineContentStack.indexOf(matchString);
              var contentBefore = inlineContentStack.substr(0, start);
              inlineContentStack = inlineContentStack.substr(start + matchString.length);
              subTree = [].concat((0, _toConsumableArray2.default)(subTree), (0, _toConsumableArray2.default)(createInlineTokens(contentBefore, openingTokens, closingTokens)), (0, _toConsumableArray2.default)(createMediaTokens(url, alt)));
            });
            if (inlineContentStack.length) {
              subTree = [].concat((0, _toConsumableArray2.default)(subTree), (0, _toConsumableArray2.default)(createInlineTokens(inlineContentStack, openingTokens, closingTokens)));
            }
            processedTokens = [].concat((0, _toConsumableArray2.default)(processedTokens), (0, _toConsumableArray2.default)(closingTokens.map(function(c) {
              return c.type;
            })));
            tokens = [].concat((0, _toConsumableArray2.default)(tokens.slice(0, cursor)), (0, _toConsumableArray2.default)(subTree));
          } else if (processedTokens.indexOf(token.type) !== -1) {
            processedTokens.splice(processedTokens.indexOf(token.type), 1);
          } else {
            tokens.push(token);
          }
          return tokens;
        }, []);
        State.tokens = newTokens;
        return true;
      };
    }
    var markdownItMedia = exports2.markdownItMedia = function markdownItMedia2(md) {
      md.core.ruler.before("inline", "media", createRule());
    };
  }
});

// node_modules/@atlaskit/editor-markdown-transformer/dist/cjs/index.js
var require_cjs4 = __commonJS({
  "node_modules/@atlaskit/editor-markdown-transformer/dist/cjs/index.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.MarkdownTransformer = void 0;
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _schemaDefault = require_default_schema();
    var _markdownIt = _interopRequireDefault(require_markdown_it());
    var _markdownItTable = require_cjs3();
    var _markdown = require_markdown();
    var _media = require_media2();
    function filterMdToPmSchemaMapping(schema, map) {
      return Object.keys(map).reduce(function(newMap, key) {
        var value = map[key];
        var block = value.block || value.node;
        var mark = value.mark;
        if (block && schema.nodes[block] || mark && schema.marks[mark]) {
          newMap[key] = value;
        }
        return newMap;
      }, {});
    }
    var pmSchemaToMdMapping = {
      nodes: {
        blockquote: "blockquote",
        paragraph: "paragraph",
        rule: "hr",
        // lheading (---, ===)
        heading: ["heading", "lheading"],
        codeBlock: ["code", "fence"],
        listItem: "list",
        image: "image"
      },
      marks: {
        em: "emphasis",
        strong: "text",
        link: ["link", "autolink", "reference", "linkify"],
        strike: "strikethrough",
        code: "backticks"
      }
    };
    var mdToPmMapping = {
      blockquote: {
        block: "blockquote"
      },
      paragraph: {
        block: "paragraph"
      },
      em: {
        mark: "em"
      },
      strong: {
        mark: "strong"
      },
      link: {
        mark: "link",
        // Ignored via go/ees005
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        attrs: function attrs(tok) {
          return {
            href: tok.attrGet("href"),
            title: tok.attrGet("title") || null
          };
        }
      },
      hr: {
        node: "rule"
      },
      heading: {
        block: "heading",
        // Ignored via go/ees005
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        attrs: function attrs(tok) {
          return {
            level: +tok.tag.slice(1)
          };
        }
      },
      softbreak: {
        node: "hardBreak"
      },
      hardbreak: {
        node: "hardBreak"
      },
      code_block: {
        block: "codeBlock"
      },
      list_item: {
        block: "listItem"
      },
      bullet_list: {
        block: "bulletList"
      },
      ordered_list: {
        block: "orderedList",
        // Ignored via go/ees005
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        attrs: function attrs(tok) {
          return {
            order: typeof tok.attrGet("start") === "number" ? tok.attrGet("start") : 1
          };
        }
      },
      code_inline: {
        mark: "code"
      },
      fence: {
        block: "codeBlock",
        // we trim any whitespaces around language definition
        // Ignored via go/ees005
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        attrs: function attrs(tok) {
          return {
            language: tok.info && tok.info.trim() || null
          };
        }
      },
      media_single: {
        block: "mediaSingle",
        attrs: function attrs() {
          return {};
        }
      },
      media: {
        node: "media",
        // Ignored via go/ees005
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        attrs: function attrs(tok) {
          return {
            url: tok.attrGet("url"),
            alt: tok.attrGet("alt"),
            type: "external"
          };
        }
      },
      emoji: {
        node: "emoji",
        // Ignored via go/ees005
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        attrs: function attrs(tok) {
          return {
            shortName: ":".concat(tok.markup, ":"),
            text: tok.content
          };
        }
      },
      table: {
        block: "table"
      },
      tr: {
        block: "tableRow"
      },
      th: {
        block: "tableHeader"
      },
      td: {
        block: "tableCell"
      },
      s: {
        mark: "strike"
      },
      task_list: {
        block: "taskList"
      },
      task_item: {
        block: "taskItem",
        // Ignored via go/ees005
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        attrs: function attrs(tok) {
          return {
            state: tok.meta
          };
        }
      }
    };
    var md = (0, _markdownIt.default)("zero", {
      html: false
    });
    md.enable([
      // Process html entity - &#123;, &#xAF;, &quot;, ...
      "entity",
      // Process escaped chars and hardbreaks
      "escape"
    ]);
    var MarkdownTransformer2 = exports2.MarkdownTransformer = /* @__PURE__ */ (function() {
      function MarkdownTransformer3() {
        var schema = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : _schemaDefault.defaultSchema;
        var tokenizer = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : md;
        (0, _classCallCheck2.default)(this, MarkdownTransformer3);
        ["nodes", "marks"].forEach(function(key) {
          for (var idx in pmSchemaToMdMapping[key]) {
            if (schema[key][idx]) {
              tokenizer.enable(pmSchemaToMdMapping[key][idx]);
            }
          }
        });
        if (schema.nodes.table) {
          tokenizer.use(_markdownItTable.markdownItTable);
        }
        if (schema.nodes.media && schema.nodes.mediaSingle) {
          tokenizer.use(_media.markdownItMedia);
        }
        this.markdownParser = new _markdown.MarkdownParser(schema, tokenizer, filterMdToPmSchemaMapping(schema, mdToPmMapping));
      }
      return (0, _createClass2.default)(MarkdownTransformer3, [{
        key: "encode",
        value: function encode(_node) {
          throw new Error("This is not implemented yet");
        }
      }, {
        key: "parse",
        value: function parse(content) {
          return this.markdownParser.parse(content);
        }
      }]);
    })();
  }
});

// node_modules/lodash/_listCacheClear.js
var require_listCacheClear = __commonJS({
  "node_modules/lodash/_listCacheClear.js"(exports2, module2) {
    function listCacheClear() {
      this.__data__ = [];
      this.size = 0;
    }
    module2.exports = listCacheClear;
  }
});

// node_modules/lodash/eq.js
var require_eq = __commonJS({
  "node_modules/lodash/eq.js"(exports2, module2) {
    function eq(value, other) {
      return value === other || value !== value && other !== other;
    }
    module2.exports = eq;
  }
});

// node_modules/lodash/_assocIndexOf.js
var require_assocIndexOf = __commonJS({
  "node_modules/lodash/_assocIndexOf.js"(exports2, module2) {
    var eq = require_eq();
    function assocIndexOf(array, key) {
      var length = array.length;
      while (length--) {
        if (eq(array[length][0], key)) {
          return length;
        }
      }
      return -1;
    }
    module2.exports = assocIndexOf;
  }
});

// node_modules/lodash/_listCacheDelete.js
var require_listCacheDelete = __commonJS({
  "node_modules/lodash/_listCacheDelete.js"(exports2, module2) {
    var assocIndexOf = require_assocIndexOf();
    var arrayProto = Array.prototype;
    var splice = arrayProto.splice;
    function listCacheDelete(key) {
      var data = this.__data__, index = assocIndexOf(data, key);
      if (index < 0) {
        return false;
      }
      var lastIndex = data.length - 1;
      if (index == lastIndex) {
        data.pop();
      } else {
        splice.call(data, index, 1);
      }
      --this.size;
      return true;
    }
    module2.exports = listCacheDelete;
  }
});

// node_modules/lodash/_listCacheGet.js
var require_listCacheGet = __commonJS({
  "node_modules/lodash/_listCacheGet.js"(exports2, module2) {
    var assocIndexOf = require_assocIndexOf();
    function listCacheGet(key) {
      var data = this.__data__, index = assocIndexOf(data, key);
      return index < 0 ? void 0 : data[index][1];
    }
    module2.exports = listCacheGet;
  }
});

// node_modules/lodash/_listCacheHas.js
var require_listCacheHas = __commonJS({
  "node_modules/lodash/_listCacheHas.js"(exports2, module2) {
    var assocIndexOf = require_assocIndexOf();
    function listCacheHas(key) {
      return assocIndexOf(this.__data__, key) > -1;
    }
    module2.exports = listCacheHas;
  }
});

// node_modules/lodash/_listCacheSet.js
var require_listCacheSet = __commonJS({
  "node_modules/lodash/_listCacheSet.js"(exports2, module2) {
    var assocIndexOf = require_assocIndexOf();
    function listCacheSet(key, value) {
      var data = this.__data__, index = assocIndexOf(data, key);
      if (index < 0) {
        ++this.size;
        data.push([key, value]);
      } else {
        data[index][1] = value;
      }
      return this;
    }
    module2.exports = listCacheSet;
  }
});

// node_modules/lodash/_ListCache.js
var require_ListCache = __commonJS({
  "node_modules/lodash/_ListCache.js"(exports2, module2) {
    var listCacheClear = require_listCacheClear();
    var listCacheDelete = require_listCacheDelete();
    var listCacheGet = require_listCacheGet();
    var listCacheHas = require_listCacheHas();
    var listCacheSet = require_listCacheSet();
    function ListCache(entries) {
      var index = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    ListCache.prototype.clear = listCacheClear;
    ListCache.prototype["delete"] = listCacheDelete;
    ListCache.prototype.get = listCacheGet;
    ListCache.prototype.has = listCacheHas;
    ListCache.prototype.set = listCacheSet;
    module2.exports = ListCache;
  }
});

// node_modules/lodash/_stackClear.js
var require_stackClear = __commonJS({
  "node_modules/lodash/_stackClear.js"(exports2, module2) {
    var ListCache = require_ListCache();
    function stackClear() {
      this.__data__ = new ListCache();
      this.size = 0;
    }
    module2.exports = stackClear;
  }
});

// node_modules/lodash/_stackDelete.js
var require_stackDelete = __commonJS({
  "node_modules/lodash/_stackDelete.js"(exports2, module2) {
    function stackDelete(key) {
      var data = this.__data__, result = data["delete"](key);
      this.size = data.size;
      return result;
    }
    module2.exports = stackDelete;
  }
});

// node_modules/lodash/_stackGet.js
var require_stackGet = __commonJS({
  "node_modules/lodash/_stackGet.js"(exports2, module2) {
    function stackGet(key) {
      return this.__data__.get(key);
    }
    module2.exports = stackGet;
  }
});

// node_modules/lodash/_stackHas.js
var require_stackHas = __commonJS({
  "node_modules/lodash/_stackHas.js"(exports2, module2) {
    function stackHas(key) {
      return this.__data__.has(key);
    }
    module2.exports = stackHas;
  }
});

// node_modules/lodash/_freeGlobal.js
var require_freeGlobal = __commonJS({
  "node_modules/lodash/_freeGlobal.js"(exports2, module2) {
    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
    module2.exports = freeGlobal;
  }
});

// node_modules/lodash/_root.js
var require_root = __commonJS({
  "node_modules/lodash/_root.js"(exports2, module2) {
    var freeGlobal = require_freeGlobal();
    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
    var root = freeGlobal || freeSelf || Function("return this")();
    module2.exports = root;
  }
});

// node_modules/lodash/_Symbol.js
var require_Symbol = __commonJS({
  "node_modules/lodash/_Symbol.js"(exports2, module2) {
    var root = require_root();
    var Symbol2 = root.Symbol;
    module2.exports = Symbol2;
  }
});

// node_modules/lodash/_getRawTag.js
var require_getRawTag = __commonJS({
  "node_modules/lodash/_getRawTag.js"(exports2, module2) {
    var Symbol2 = require_Symbol();
    var objectProto = Object.prototype;
    var hasOwnProperty = objectProto.hasOwnProperty;
    var nativeObjectToString = objectProto.toString;
    var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
    function getRawTag(value) {
      var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
      try {
        value[symToStringTag] = void 0;
        var unmasked = true;
      } catch (e) {
      }
      var result = nativeObjectToString.call(value);
      if (unmasked) {
        if (isOwn) {
          value[symToStringTag] = tag;
        } else {
          delete value[symToStringTag];
        }
      }
      return result;
    }
    module2.exports = getRawTag;
  }
});

// node_modules/lodash/_objectToString.js
var require_objectToString = __commonJS({
  "node_modules/lodash/_objectToString.js"(exports2, module2) {
    var objectProto = Object.prototype;
    var nativeObjectToString = objectProto.toString;
    function objectToString(value) {
      return nativeObjectToString.call(value);
    }
    module2.exports = objectToString;
  }
});

// node_modules/lodash/_baseGetTag.js
var require_baseGetTag = __commonJS({
  "node_modules/lodash/_baseGetTag.js"(exports2, module2) {
    var Symbol2 = require_Symbol();
    var getRawTag = require_getRawTag();
    var objectToString = require_objectToString();
    var nullTag = "[object Null]";
    var undefinedTag = "[object Undefined]";
    var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
    function baseGetTag(value) {
      if (value == null) {
        return value === void 0 ? undefinedTag : nullTag;
      }
      return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
    }
    module2.exports = baseGetTag;
  }
});

// node_modules/lodash/isObject.js
var require_isObject = __commonJS({
  "node_modules/lodash/isObject.js"(exports2, module2) {
    function isObject(value) {
      var type = typeof value;
      return value != null && (type == "object" || type == "function");
    }
    module2.exports = isObject;
  }
});

// node_modules/lodash/isFunction.js
var require_isFunction = __commonJS({
  "node_modules/lodash/isFunction.js"(exports2, module2) {
    var baseGetTag = require_baseGetTag();
    var isObject = require_isObject();
    var asyncTag = "[object AsyncFunction]";
    var funcTag = "[object Function]";
    var genTag = "[object GeneratorFunction]";
    var proxyTag = "[object Proxy]";
    function isFunction(value) {
      if (!isObject(value)) {
        return false;
      }
      var tag = baseGetTag(value);
      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
    }
    module2.exports = isFunction;
  }
});

// node_modules/lodash/_coreJsData.js
var require_coreJsData = __commonJS({
  "node_modules/lodash/_coreJsData.js"(exports2, module2) {
    var root = require_root();
    var coreJsData = root["__core-js_shared__"];
    module2.exports = coreJsData;
  }
});

// node_modules/lodash/_isMasked.js
var require_isMasked = __commonJS({
  "node_modules/lodash/_isMasked.js"(exports2, module2) {
    var coreJsData = require_coreJsData();
    var maskSrcKey = (function() {
      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
      return uid ? "Symbol(src)_1." + uid : "";
    })();
    function isMasked(func) {
      return !!maskSrcKey && maskSrcKey in func;
    }
    module2.exports = isMasked;
  }
});

// node_modules/lodash/_toSource.js
var require_toSource = __commonJS({
  "node_modules/lodash/_toSource.js"(exports2, module2) {
    var funcProto = Function.prototype;
    var funcToString = funcProto.toString;
    function toSource(func) {
      if (func != null) {
        try {
          return funcToString.call(func);
        } catch (e) {
        }
        try {
          return func + "";
        } catch (e) {
        }
      }
      return "";
    }
    module2.exports = toSource;
  }
});

// node_modules/lodash/_baseIsNative.js
var require_baseIsNative = __commonJS({
  "node_modules/lodash/_baseIsNative.js"(exports2, module2) {
    var isFunction = require_isFunction();
    var isMasked = require_isMasked();
    var isObject = require_isObject();
    var toSource = require_toSource();
    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
    var reIsHostCtor = /^\[object .+?Constructor\]$/;
    var funcProto = Function.prototype;
    var objectProto = Object.prototype;
    var funcToString = funcProto.toString;
    var hasOwnProperty = objectProto.hasOwnProperty;
    var reIsNative = RegExp(
      "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
    );
    function baseIsNative(value) {
      if (!isObject(value) || isMasked(value)) {
        return false;
      }
      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
      return pattern.test(toSource(value));
    }
    module2.exports = baseIsNative;
  }
});

// node_modules/lodash/_getValue.js
var require_getValue = __commonJS({
  "node_modules/lodash/_getValue.js"(exports2, module2) {
    function getValue(object, key) {
      return object == null ? void 0 : object[key];
    }
    module2.exports = getValue;
  }
});

// node_modules/lodash/_getNative.js
var require_getNative = __commonJS({
  "node_modules/lodash/_getNative.js"(exports2, module2) {
    var baseIsNative = require_baseIsNative();
    var getValue = require_getValue();
    function getNative(object, key) {
      var value = getValue(object, key);
      return baseIsNative(value) ? value : void 0;
    }
    module2.exports = getNative;
  }
});

// node_modules/lodash/_Map.js
var require_Map = __commonJS({
  "node_modules/lodash/_Map.js"(exports2, module2) {
    var getNative = require_getNative();
    var root = require_root();
    var Map2 = getNative(root, "Map");
    module2.exports = Map2;
  }
});

// node_modules/lodash/_nativeCreate.js
var require_nativeCreate = __commonJS({
  "node_modules/lodash/_nativeCreate.js"(exports2, module2) {
    var getNative = require_getNative();
    var nativeCreate = getNative(Object, "create");
    module2.exports = nativeCreate;
  }
});

// node_modules/lodash/_hashClear.js
var require_hashClear = __commonJS({
  "node_modules/lodash/_hashClear.js"(exports2, module2) {
    var nativeCreate = require_nativeCreate();
    function hashClear() {
      this.__data__ = nativeCreate ? nativeCreate(null) : {};
      this.size = 0;
    }
    module2.exports = hashClear;
  }
});

// node_modules/lodash/_hashDelete.js
var require_hashDelete = __commonJS({
  "node_modules/lodash/_hashDelete.js"(exports2, module2) {
    function hashDelete(key) {
      var result = this.has(key) && delete this.__data__[key];
      this.size -= result ? 1 : 0;
      return result;
    }
    module2.exports = hashDelete;
  }
});

// node_modules/lodash/_hashGet.js
var require_hashGet = __commonJS({
  "node_modules/lodash/_hashGet.js"(exports2, module2) {
    var nativeCreate = require_nativeCreate();
    var HASH_UNDEFINED = "__lodash_hash_undefined__";
    var objectProto = Object.prototype;
    var hasOwnProperty = objectProto.hasOwnProperty;
    function hashGet(key) {
      var data = this.__data__;
      if (nativeCreate) {
        var result = data[key];
        return result === HASH_UNDEFINED ? void 0 : result;
      }
      return hasOwnProperty.call(data, key) ? data[key] : void 0;
    }
    module2.exports = hashGet;
  }
});

// node_modules/lodash/_hashHas.js
var require_hashHas = __commonJS({
  "node_modules/lodash/_hashHas.js"(exports2, module2) {
    var nativeCreate = require_nativeCreate();
    var objectProto = Object.prototype;
    var hasOwnProperty = objectProto.hasOwnProperty;
    function hashHas(key) {
      var data = this.__data__;
      return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
    }
    module2.exports = hashHas;
  }
});

// node_modules/lodash/_hashSet.js
var require_hashSet = __commonJS({
  "node_modules/lodash/_hashSet.js"(exports2, module2) {
    var nativeCreate = require_nativeCreate();
    var HASH_UNDEFINED = "__lodash_hash_undefined__";
    function hashSet(key, value) {
      var data = this.__data__;
      this.size += this.has(key) ? 0 : 1;
      data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
      return this;
    }
    module2.exports = hashSet;
  }
});

// node_modules/lodash/_Hash.js
var require_Hash = __commonJS({
  "node_modules/lodash/_Hash.js"(exports2, module2) {
    var hashClear = require_hashClear();
    var hashDelete = require_hashDelete();
    var hashGet = require_hashGet();
    var hashHas = require_hashHas();
    var hashSet = require_hashSet();
    function Hash(entries) {
      var index = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    Hash.prototype.clear = hashClear;
    Hash.prototype["delete"] = hashDelete;
    Hash.prototype.get = hashGet;
    Hash.prototype.has = hashHas;
    Hash.prototype.set = hashSet;
    module2.exports = Hash;
  }
});

// node_modules/lodash/_mapCacheClear.js
var require_mapCacheClear = __commonJS({
  "node_modules/lodash/_mapCacheClear.js"(exports2, module2) {
    var Hash = require_Hash();
    var ListCache = require_ListCache();
    var Map2 = require_Map();
    function mapCacheClear() {
      this.size = 0;
      this.__data__ = {
        "hash": new Hash(),
        "map": new (Map2 || ListCache)(),
        "string": new Hash()
      };
    }
    module2.exports = mapCacheClear;
  }
});

// node_modules/lodash/_isKeyable.js
var require_isKeyable = __commonJS({
  "node_modules/lodash/_isKeyable.js"(exports2, module2) {
    function isKeyable(value) {
      var type = typeof value;
      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
    }
    module2.exports = isKeyable;
  }
});

// node_modules/lodash/_getMapData.js
var require_getMapData = __commonJS({
  "node_modules/lodash/_getMapData.js"(exports2, module2) {
    var isKeyable = require_isKeyable();
    function getMapData(map, key) {
      var data = map.__data__;
      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
    }
    module2.exports = getMapData;
  }
});

// node_modules/lodash/_mapCacheDelete.js
var require_mapCacheDelete = __commonJS({
  "node_modules/lodash/_mapCacheDelete.js"(exports2, module2) {
    var getMapData = require_getMapData();
    function mapCacheDelete(key) {
      var result = getMapData(this, key)["delete"](key);
      this.size -= result ? 1 : 0;
      return result;
    }
    module2.exports = mapCacheDelete;
  }
});

// node_modules/lodash/_mapCacheGet.js
var require_mapCacheGet = __commonJS({
  "node_modules/lodash/_mapCacheGet.js"(exports2, module2) {
    var getMapData = require_getMapData();
    function mapCacheGet(key) {
      return getMapData(this, key).get(key);
    }
    module2.exports = mapCacheGet;
  }
});

// node_modules/lodash/_mapCacheHas.js
var require_mapCacheHas = __commonJS({
  "node_modules/lodash/_mapCacheHas.js"(exports2, module2) {
    var getMapData = require_getMapData();
    function mapCacheHas(key) {
      return getMapData(this, key).has(key);
    }
    module2.exports = mapCacheHas;
  }
});

// node_modules/lodash/_mapCacheSet.js
var require_mapCacheSet = __commonJS({
  "node_modules/lodash/_mapCacheSet.js"(exports2, module2) {
    var getMapData = require_getMapData();
    function mapCacheSet(key, value) {
      var data = getMapData(this, key), size = data.size;
      data.set(key, value);
      this.size += data.size == size ? 0 : 1;
      return this;
    }
    module2.exports = mapCacheSet;
  }
});

// node_modules/lodash/_MapCache.js
var require_MapCache = __commonJS({
  "node_modules/lodash/_MapCache.js"(exports2, module2) {
    var mapCacheClear = require_mapCacheClear();
    var mapCacheDelete = require_mapCacheDelete();
    var mapCacheGet = require_mapCacheGet();
    var mapCacheHas = require_mapCacheHas();
    var mapCacheSet = require_mapCacheSet();
    function MapCache(entries) {
      var index = -1, length = entries == null ? 0 : entries.length;
      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }
    MapCache.prototype.clear = mapCacheClear;
    MapCache.prototype["delete"] = mapCacheDelete;
    MapCache.prototype.get = mapCacheGet;
    MapCache.prototype.has = mapCacheHas;
    MapCache.prototype.set = mapCacheSet;
    module2.exports = MapCache;
  }
});

// node_modules/lodash/_stackSet.js
var require_stackSet = __commonJS({
  "node_modules/lodash/_stackSet.js"(exports2, module2) {
    var ListCache = require_ListCache();
    var Map2 = require_Map();
    var MapCache = require_MapCache();
    var LARGE_ARRAY_SIZE = 200;
    function stackSet(key, value) {
      var data = this.__data__;
      if (data instanceof ListCache) {
        var pairs = data.__data__;
        if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
          pairs.push([key, value]);
          this.size = ++data.size;
          return this;
        }
        data = this.__data__ = new MapCache(pairs);
      }
      data.set(key, value);
      this.size = data.size;
      return this;
    }
    module2.exports = stackSet;
  }
});

// node_modules/lodash/_Stack.js
var require_Stack = __commonJS({
  "node_modules/lodash/_Stack.js"(exports2, module2) {
    var ListCache = require_ListCache();
    var stackClear = require_stackClear();
    var stackDelete = require_stackDelete();
    var stackGet = require_stackGet();
    var stackHas = require_stackHas();
    var stackSet = require_stackSet();
    function Stack(entries) {
      var data = this.__data__ = new ListCache(entries);
      this.size = data.size;
    }
    Stack.prototype.clear = stackClear;
    Stack.prototype["delete"] = stackDelete;
    Stack.prototype.get = stackGet;
    Stack.prototype.has = stackHas;
    Stack.prototype.set = stackSet;
    module2.exports = Stack;
  }
});

// node_modules/lodash/_setCacheAdd.js
var require_setCacheAdd = __commonJS({
  "node_modules/lodash/_setCacheAdd.js"(exports2, module2) {
    var HASH_UNDEFINED = "__lodash_hash_undefined__";
    function setCacheAdd(value) {
      this.__data__.set(value, HASH_UNDEFINED);
      return this;
    }
    module2.exports = setCacheAdd;
  }
});

// node_modules/lodash/_setCacheHas.js
var require_setCacheHas = __commonJS({
  "node_modules/lodash/_setCacheHas.js"(exports2, module2) {
    function setCacheHas(value) {
      return this.__data__.has(value);
    }
    module2.exports = setCacheHas;
  }
});

// node_modules/lodash/_SetCache.js
var require_SetCache = __commonJS({
  "node_modules/lodash/_SetCache.js"(exports2, module2) {
    var MapCache = require_MapCache();
    var setCacheAdd = require_setCacheAdd();
    var setCacheHas = require_setCacheHas();
    function SetCache(values) {
      var index = -1, length = values == null ? 0 : values.length;
      this.__data__ = new MapCache();
      while (++index < length) {
        this.add(values[index]);
      }
    }
    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
    SetCache.prototype.has = setCacheHas;
    module2.exports = SetCache;
  }
});

// node_modules/lodash/_arraySome.js
var require_arraySome = __commonJS({
  "node_modules/lodash/_arraySome.js"(exports2, module2) {
    function arraySome(array, predicate) {
      var index = -1, length = array == null ? 0 : array.length;
      while (++index < length) {
        if (predicate(array[index], index, array)) {
          return true;
        }
      }
      return false;
    }
    module2.exports = arraySome;
  }
});

// node_modules/lodash/_cacheHas.js
var require_cacheHas = __commonJS({
  "node_modules/lodash/_cacheHas.js"(exports2, module2) {
    function cacheHas(cache, key) {
      return cache.has(key);
    }
    module2.exports = cacheHas;
  }
});

// node_modules/lodash/_equalArrays.js
var require_equalArrays = __commonJS({
  "node_modules/lodash/_equalArrays.js"(exports2, module2) {
    var SetCache = require_SetCache();
    var arraySome = require_arraySome();
    var cacheHas = require_cacheHas();
    var COMPARE_PARTIAL_FLAG = 1;
    var COMPARE_UNORDERED_FLAG = 2;
    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
        return false;
      }
      var arrStacked = stack.get(array);
      var othStacked = stack.get(other);
      if (arrStacked && othStacked) {
        return arrStacked == other && othStacked == array;
      }
      var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
      stack.set(array, other);
      stack.set(other, array);
      while (++index < arrLength) {
        var arrValue = array[index], othValue = other[index];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
        }
        if (compared !== void 0) {
          if (compared) {
            continue;
          }
          result = false;
          break;
        }
        if (seen) {
          if (!arraySome(other, function(othValue2, othIndex) {
            if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
              return seen.push(othIndex);
            }
          })) {
            result = false;
            break;
          }
        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
          result = false;
          break;
        }
      }
      stack["delete"](array);
      stack["delete"](other);
      return result;
    }
    module2.exports = equalArrays;
  }
});

// node_modules/lodash/_Uint8Array.js
var require_Uint8Array = __commonJS({
  "node_modules/lodash/_Uint8Array.js"(exports2, module2) {
    var root = require_root();
    var Uint8Array2 = root.Uint8Array;
    module2.exports = Uint8Array2;
  }
});

// node_modules/lodash/_mapToArray.js
var require_mapToArray = __commonJS({
  "node_modules/lodash/_mapToArray.js"(exports2, module2) {
    function mapToArray(map) {
      var index = -1, result = Array(map.size);
      map.forEach(function(value, key) {
        result[++index] = [key, value];
      });
      return result;
    }
    module2.exports = mapToArray;
  }
});

// node_modules/lodash/_setToArray.js
var require_setToArray = __commonJS({
  "node_modules/lodash/_setToArray.js"(exports2, module2) {
    function setToArray(set) {
      var index = -1, result = Array(set.size);
      set.forEach(function(value) {
        result[++index] = value;
      });
      return result;
    }
    module2.exports = setToArray;
  }
});

// node_modules/lodash/_equalByTag.js
var require_equalByTag = __commonJS({
  "node_modules/lodash/_equalByTag.js"(exports2, module2) {
    var Symbol2 = require_Symbol();
    var Uint8Array2 = require_Uint8Array();
    var eq = require_eq();
    var equalArrays = require_equalArrays();
    var mapToArray = require_mapToArray();
    var setToArray = require_setToArray();
    var COMPARE_PARTIAL_FLAG = 1;
    var COMPARE_UNORDERED_FLAG = 2;
    var boolTag = "[object Boolean]";
    var dateTag = "[object Date]";
    var errorTag = "[object Error]";
    var mapTag = "[object Map]";
    var numberTag = "[object Number]";
    var regexpTag = "[object RegExp]";
    var setTag = "[object Set]";
    var stringTag = "[object String]";
    var symbolTag = "[object Symbol]";
    var arrayBufferTag = "[object ArrayBuffer]";
    var dataViewTag = "[object DataView]";
    var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
    var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
      switch (tag) {
        case dataViewTag:
          if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
            return false;
          }
          object = object.buffer;
          other = other.buffer;
        case arrayBufferTag:
          if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
            return false;
          }
          return true;
        case boolTag:
        case dateTag:
        case numberTag:
          return eq(+object, +other);
        case errorTag:
          return object.name == other.name && object.message == other.message;
        case regexpTag:
        case stringTag:
          return object == other + "";
        case mapTag:
          var convert = mapToArray;
        case setTag:
          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
          convert || (convert = setToArray);
          if (object.size != other.size && !isPartial) {
            return false;
          }
          var stacked = stack.get(object);
          if (stacked) {
            return stacked == other;
          }
          bitmask |= COMPARE_UNORDERED_FLAG;
          stack.set(object, other);
          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
          stack["delete"](object);
          return result;
        case symbolTag:
          if (symbolValueOf) {
            return symbolValueOf.call(object) == symbolValueOf.call(other);
          }
      }
      return false;
    }
    module2.exports = equalByTag;
  }
});

// node_modules/lodash/_arrayPush.js
var require_arrayPush = __commonJS({
  "node_modules/lodash/_arrayPush.js"(exports2, module2) {
    function arrayPush(array, values) {
      var index = -1, length = values.length, offset = array.length;
      while (++index < length) {
        array[offset + index] = values[index];
      }
      return array;
    }
    module2.exports = arrayPush;
  }
});

// node_modules/lodash/isArray.js
var require_isArray = __commonJS({
  "node_modules/lodash/isArray.js"(exports2, module2) {
    var isArray = Array.isArray;
    module2.exports = isArray;
  }
});

// node_modules/lodash/_baseGetAllKeys.js
var require_baseGetAllKeys = __commonJS({
  "node_modules/lodash/_baseGetAllKeys.js"(exports2, module2) {
    var arrayPush = require_arrayPush();
    var isArray = require_isArray();
    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
      var result = keysFunc(object);
      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
    }
    module2.exports = baseGetAllKeys;
  }
});

// node_modules/lodash/_arrayFilter.js
var require_arrayFilter = __commonJS({
  "node_modules/lodash/_arrayFilter.js"(exports2, module2) {
    function arrayFilter(array, predicate) {
      var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
      while (++index < length) {
        var value = array[index];
        if (predicate(value, index, array)) {
          result[resIndex++] = value;
        }
      }
      return result;
    }
    module2.exports = arrayFilter;
  }
});

// node_modules/lodash/stubArray.js
var require_stubArray = __commonJS({
  "node_modules/lodash/stubArray.js"(exports2, module2) {
    function stubArray() {
      return [];
    }
    module2.exports = stubArray;
  }
});

// node_modules/lodash/_getSymbols.js
var require_getSymbols = __commonJS({
  "node_modules/lodash/_getSymbols.js"(exports2, module2) {
    var arrayFilter = require_arrayFilter();
    var stubArray = require_stubArray();
    var objectProto = Object.prototype;
    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
    var nativeGetSymbols = Object.getOwnPropertySymbols;
    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
      if (object == null) {
        return [];
      }
      object = Object(object);
      return arrayFilter(nativeGetSymbols(object), function(symbol) {
        return propertyIsEnumerable.call(object, symbol);
      });
    };
    module2.exports = getSymbols;
  }
});

// node_modules/lodash/_baseTimes.js
var require_baseTimes = __commonJS({
  "node_modules/lodash/_baseTimes.js"(exports2, module2) {
    function baseTimes(n, iteratee) {
      var index = -1, result = Array(n);
      while (++index < n) {
        result[index] = iteratee(index);
      }
      return result;
    }
    module2.exports = baseTimes;
  }
});

// node_modules/lodash/isObjectLike.js
var require_isObjectLike = __commonJS({
  "node_modules/lodash/isObjectLike.js"(exports2, module2) {
    function isObjectLike(value) {
      return value != null && typeof value == "object";
    }
    module2.exports = isObjectLike;
  }
});

// node_modules/lodash/_baseIsArguments.js
var require_baseIsArguments = __commonJS({
  "node_modules/lodash/_baseIsArguments.js"(exports2, module2) {
    var baseGetTag = require_baseGetTag();
    var isObjectLike = require_isObjectLike();
    var argsTag = "[object Arguments]";
    function baseIsArguments(value) {
      return isObjectLike(value) && baseGetTag(value) == argsTag;
    }
    module2.exports = baseIsArguments;
  }
});

// node_modules/lodash/isArguments.js
var require_isArguments = __commonJS({
  "node_modules/lodash/isArguments.js"(exports2, module2) {
    var baseIsArguments = require_baseIsArguments();
    var isObjectLike = require_isObjectLike();
    var objectProto = Object.prototype;
    var hasOwnProperty = objectProto.hasOwnProperty;
    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
    var isArguments = baseIsArguments(/* @__PURE__ */ (function() {
      return arguments;
    })()) ? baseIsArguments : function(value) {
      return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
    };
    module2.exports = isArguments;
  }
});

// node_modules/lodash/stubFalse.js
var require_stubFalse = __commonJS({
  "node_modules/lodash/stubFalse.js"(exports2, module2) {
    function stubFalse() {
      return false;
    }
    module2.exports = stubFalse;
  }
});

// node_modules/lodash/isBuffer.js
var require_isBuffer = __commonJS({
  "node_modules/lodash/isBuffer.js"(exports2, module2) {
    var root = require_root();
    var stubFalse = require_stubFalse();
    var freeExports = typeof exports2 == "object" && exports2 && !exports2.nodeType && exports2;
    var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2;
    var moduleExports = freeModule && freeModule.exports === freeExports;
    var Buffer2 = moduleExports ? root.Buffer : void 0;
    var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
    var isBuffer = nativeIsBuffer || stubFalse;
    module2.exports = isBuffer;
  }
});

// node_modules/lodash/_isIndex.js
var require_isIndex = __commonJS({
  "node_modules/lodash/_isIndex.js"(exports2, module2) {
    var MAX_SAFE_INTEGER = 9007199254740991;
    var reIsUint = /^(?:0|[1-9]\d*)$/;
    function isIndex(value, length) {
      var type = typeof value;
      length = length == null ? MAX_SAFE_INTEGER : length;
      return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
    }
    module2.exports = isIndex;
  }
});

// node_modules/lodash/isLength.js
var require_isLength = __commonJS({
  "node_modules/lodash/isLength.js"(exports2, module2) {
    var MAX_SAFE_INTEGER = 9007199254740991;
    function isLength(value) {
      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
    }
    module2.exports = isLength;
  }
});

// node_modules/lodash/_baseIsTypedArray.js
var require_baseIsTypedArray = __commonJS({
  "node_modules/lodash/_baseIsTypedArray.js"(exports2, module2) {
    var baseGetTag = require_baseGetTag();
    var isLength = require_isLength();
    var isObjectLike = require_isObjectLike();
    var argsTag = "[object Arguments]";
    var arrayTag = "[object Array]";
    var boolTag = "[object Boolean]";
    var dateTag = "[object Date]";
    var errorTag = "[object Error]";
    var funcTag = "[object Function]";
    var mapTag = "[object Map]";
    var numberTag = "[object Number]";
    var objectTag = "[object Object]";
    var regexpTag = "[object RegExp]";
    var setTag = "[object Set]";
    var stringTag = "[object String]";
    var weakMapTag = "[object WeakMap]";
    var arrayBufferTag = "[object ArrayBuffer]";
    var dataViewTag = "[object DataView]";
    var float32Tag = "[object Float32Array]";
    var float64Tag = "[object Float64Array]";
    var int8Tag = "[object Int8Array]";
    var int16Tag = "[object Int16Array]";
    var int32Tag = "[object Int32Array]";
    var uint8Tag = "[object Uint8Array]";
    var uint8ClampedTag = "[object Uint8ClampedArray]";
    var uint16Tag = "[object Uint16Array]";
    var uint32Tag = "[object Uint32Array]";
    var typedArrayTags = {};
    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
    function baseIsTypedArray(value) {
      return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
    }
    module2.exports = baseIsTypedArray;
  }
});

// node_modules/lodash/_baseUnary.js
var require_baseUnary = __commonJS({
  "node_modules/lodash/_baseUnary.js"(exports2, module2) {
    function baseUnary(func) {
      return function(value) {
        return func(value);
      };
    }
    module2.exports = baseUnary;
  }
});

// node_modules/lodash/_nodeUtil.js
var require_nodeUtil = __commonJS({
  "node_modules/lodash/_nodeUtil.js"(exports2, module2) {
    var freeGlobal = require_freeGlobal();
    var freeExports = typeof exports2 == "object" && exports2 && !exports2.nodeType && exports2;
    var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2;
    var moduleExports = freeModule && freeModule.exports === freeExports;
    var freeProcess = moduleExports && freeGlobal.process;
    var nodeUtil = (function() {
      try {
        var types = freeModule && freeModule.require && freeModule.require("util").types;
        if (types) {
          return types;
        }
        return freeProcess && freeProcess.binding && freeProcess.binding("util");
      } catch (e) {
      }
    })();
    module2.exports = nodeUtil;
  }
});

// node_modules/lodash/isTypedArray.js
var require_isTypedArray = __commonJS({
  "node_modules/lodash/isTypedArray.js"(exports2, module2) {
    var baseIsTypedArray = require_baseIsTypedArray();
    var baseUnary = require_baseUnary();
    var nodeUtil = require_nodeUtil();
    var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
    module2.exports = isTypedArray;
  }
});

// node_modules/lodash/_arrayLikeKeys.js
var require_arrayLikeKeys = __commonJS({
  "node_modules/lodash/_arrayLikeKeys.js"(exports2, module2) {
    var baseTimes = require_baseTimes();
    var isArguments = require_isArguments();
    var isArray = require_isArray();
    var isBuffer = require_isBuffer();
    var isIndex = require_isIndex();
    var isTypedArray = require_isTypedArray();
    var objectProto = Object.prototype;
    var hasOwnProperty = objectProto.hasOwnProperty;
    function arrayLikeKeys(value, inherited) {
      var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
      for (var key in value) {
        if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
        (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
        isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
        isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
        isIndex(key, length)))) {
          result.push(key);
        }
      }
      return result;
    }
    module2.exports = arrayLikeKeys;
  }
});

// node_modules/lodash/_isPrototype.js
var require_isPrototype = __commonJS({
  "node_modules/lodash/_isPrototype.js"(exports2, module2) {
    var objectProto = Object.prototype;
    function isPrototype(value) {
      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
      return value === proto;
    }
    module2.exports = isPrototype;
  }
});

// node_modules/lodash/_overArg.js
var require_overArg = __commonJS({
  "node_modules/lodash/_overArg.js"(exports2, module2) {
    function overArg(func, transform) {
      return function(arg) {
        return func(transform(arg));
      };
    }
    module2.exports = overArg;
  }
});

// node_modules/lodash/_nativeKeys.js
var require_nativeKeys = __commonJS({
  "node_modules/lodash/_nativeKeys.js"(exports2, module2) {
    var overArg = require_overArg();
    var nativeKeys = overArg(Object.keys, Object);
    module2.exports = nativeKeys;
  }
});

// node_modules/lodash/_baseKeys.js
var require_baseKeys = __commonJS({
  "node_modules/lodash/_baseKeys.js"(exports2, module2) {
    var isPrototype = require_isPrototype();
    var nativeKeys = require_nativeKeys();
    var objectProto = Object.prototype;
    var hasOwnProperty = objectProto.hasOwnProperty;
    function baseKeys(object) {
      if (!isPrototype(object)) {
        return nativeKeys(object);
      }
      var result = [];
      for (var key in Object(object)) {
        if (hasOwnProperty.call(object, key) && key != "constructor") {
          result.push(key);
        }
      }
      return result;
    }
    module2.exports = baseKeys;
  }
});

// node_modules/lodash/isArrayLike.js
var require_isArrayLike = __commonJS({
  "node_modules/lodash/isArrayLike.js"(exports2, module2) {
    var isFunction = require_isFunction();
    var isLength = require_isLength();
    function isArrayLike(value) {
      return value != null && isLength(value.length) && !isFunction(value);
    }
    module2.exports = isArrayLike;
  }
});

// node_modules/lodash/keys.js
var require_keys = __commonJS({
  "node_modules/lodash/keys.js"(exports2, module2) {
    var arrayLikeKeys = require_arrayLikeKeys();
    var baseKeys = require_baseKeys();
    var isArrayLike = require_isArrayLike();
    function keys(object) {
      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
    }
    module2.exports = keys;
  }
});

// node_modules/lodash/_getAllKeys.js
var require_getAllKeys = __commonJS({
  "node_modules/lodash/_getAllKeys.js"(exports2, module2) {
    var baseGetAllKeys = require_baseGetAllKeys();
    var getSymbols = require_getSymbols();
    var keys = require_keys();
    function getAllKeys(object) {
      return baseGetAllKeys(object, keys, getSymbols);
    }
    module2.exports = getAllKeys;
  }
});

// node_modules/lodash/_equalObjects.js
var require_equalObjects = __commonJS({
  "node_modules/lodash/_equalObjects.js"(exports2, module2) {
    var getAllKeys = require_getAllKeys();
    var COMPARE_PARTIAL_FLAG = 1;
    var objectProto = Object.prototype;
    var hasOwnProperty = objectProto.hasOwnProperty;
    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
      if (objLength != othLength && !isPartial) {
        return false;
      }
      var index = objLength;
      while (index--) {
        var key = objProps[index];
        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
          return false;
        }
      }
      var objStacked = stack.get(object);
      var othStacked = stack.get(other);
      if (objStacked && othStacked) {
        return objStacked == other && othStacked == object;
      }
      var result = true;
      stack.set(object, other);
      stack.set(other, object);
      var skipCtor = isPartial;
      while (++index < objLength) {
        key = objProps[index];
        var objValue = object[key], othValue = other[key];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
        }
        if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
          result = false;
          break;
        }
        skipCtor || (skipCtor = key == "constructor");
      }
      if (result && !skipCtor) {
        var objCtor = object.constructor, othCtor = other.constructor;
        if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
          result = false;
        }
      }
      stack["delete"](object);
      stack["delete"](other);
      return result;
    }
    module2.exports = equalObjects;
  }
});

// node_modules/lodash/_DataView.js
var require_DataView = __commonJS({
  "node_modules/lodash/_DataView.js"(exports2, module2) {
    var getNative = require_getNative();
    var root = require_root();
    var DataView = getNative(root, "DataView");
    module2.exports = DataView;
  }
});

// node_modules/lodash/_Promise.js
var require_Promise = __commonJS({
  "node_modules/lodash/_Promise.js"(exports2, module2) {
    var getNative = require_getNative();
    var root = require_root();
    var Promise2 = getNative(root, "Promise");
    module2.exports = Promise2;
  }
});

// node_modules/lodash/_Set.js
var require_Set = __commonJS({
  "node_modules/lodash/_Set.js"(exports2, module2) {
    var getNative = require_getNative();
    var root = require_root();
    var Set2 = getNative(root, "Set");
    module2.exports = Set2;
  }
});

// node_modules/lodash/_WeakMap.js
var require_WeakMap = __commonJS({
  "node_modules/lodash/_WeakMap.js"(exports2, module2) {
    var getNative = require_getNative();
    var root = require_root();
    var WeakMap2 = getNative(root, "WeakMap");
    module2.exports = WeakMap2;
  }
});

// node_modules/lodash/_getTag.js
var require_getTag = __commonJS({
  "node_modules/lodash/_getTag.js"(exports2, module2) {
    var DataView = require_DataView();
    var Map2 = require_Map();
    var Promise2 = require_Promise();
    var Set2 = require_Set();
    var WeakMap2 = require_WeakMap();
    var baseGetTag = require_baseGetTag();
    var toSource = require_toSource();
    var mapTag = "[object Map]";
    var objectTag = "[object Object]";
    var promiseTag = "[object Promise]";
    var setTag = "[object Set]";
    var weakMapTag = "[object WeakMap]";
    var dataViewTag = "[object DataView]";
    var dataViewCtorString = toSource(DataView);
    var mapCtorString = toSource(Map2);
    var promiseCtorString = toSource(Promise2);
    var setCtorString = toSource(Set2);
    var weakMapCtorString = toSource(WeakMap2);
    var getTag = baseGetTag;
    if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
      getTag = function(value) {
        var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
        if (ctorString) {
          switch (ctorString) {
            case dataViewCtorString:
              return dataViewTag;
            case mapCtorString:
              return mapTag;
            case promiseCtorString:
              return promiseTag;
            case setCtorString:
              return setTag;
            case weakMapCtorString:
              return weakMapTag;
          }
        }
        return result;
      };
    }
    module2.exports = getTag;
  }
});

// node_modules/lodash/_baseIsEqualDeep.js
var require_baseIsEqualDeep = __commonJS({
  "node_modules/lodash/_baseIsEqualDeep.js"(exports2, module2) {
    var Stack = require_Stack();
    var equalArrays = require_equalArrays();
    var equalByTag = require_equalByTag();
    var equalObjects = require_equalObjects();
    var getTag = require_getTag();
    var isArray = require_isArray();
    var isBuffer = require_isBuffer();
    var isTypedArray = require_isTypedArray();
    var COMPARE_PARTIAL_FLAG = 1;
    var argsTag = "[object Arguments]";
    var arrayTag = "[object Array]";
    var objectTag = "[object Object]";
    var objectProto = Object.prototype;
    var hasOwnProperty = objectProto.hasOwnProperty;
    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
      var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
      objTag = objTag == argsTag ? objectTag : objTag;
      othTag = othTag == argsTag ? objectTag : othTag;
      var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
      if (isSameTag && isBuffer(object)) {
        if (!isBuffer(other)) {
          return false;
        }
        objIsArr = true;
        objIsObj = false;
      }
      if (isSameTag && !objIsObj) {
        stack || (stack = new Stack());
        return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
      }
      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
        var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
        if (objIsWrapped || othIsWrapped) {
          var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
          stack || (stack = new Stack());
          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
        }
      }
      if (!isSameTag) {
        return false;
      }
      stack || (stack = new Stack());
      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
    }
    module2.exports = baseIsEqualDeep;
  }
});

// node_modules/lodash/_baseIsEqual.js
var require_baseIsEqual = __commonJS({
  "node_modules/lodash/_baseIsEqual.js"(exports2, module2) {
    var baseIsEqualDeep = require_baseIsEqualDeep();
    var isObjectLike = require_isObjectLike();
    function baseIsEqual(value, other, bitmask, customizer, stack) {
      if (value === other) {
        return true;
      }
      if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
        return value !== value && other !== other;
      }
      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
    }
    module2.exports = baseIsEqual;
  }
});

// node_modules/lodash/isEqual.js
var require_isEqual = __commonJS({
  "node_modules/lodash/isEqual.js"(exports2, module2) {
    var baseIsEqual = require_baseIsEqual();
    function isEqual(value, other) {
      return baseIsEqual(value, other);
    }
    module2.exports = isEqual;
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/unsupported.js
var require_unsupported = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/unsupported.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.unsupportedNodeTypesForMediaCards = void 0;
    var unsupportedNodeTypesForMediaCards = exports2.unsupportedNodeTypesForMediaCards = /* @__PURE__ */ new Set(["decisionItem", "taskItem"]);
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/inline-nodes.js
var require_inline_nodes = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/inline-nodes.js"(exports2) {
    "use strict";
    var _typeof = require_typeof();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.inlineNodes = void 0;
    var nodes = _interopRequireWildcard(require_nodes());
    function _interopRequireWildcard(e, t) {
      if ("function" == typeof WeakMap) var r = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
      return (_interopRequireWildcard = function _interopRequireWildcard2(e2, t2) {
        if (!t2 && e2 && e2.__esModule) return e2;
        var o, i, f = { __proto__: null, default: e2 };
        if (null === e2 || "object" != _typeof(e2) && "function" != typeof e2) return f;
        if (o = t2 ? n : r) {
          if (o.has(e2)) return o.get(e2);
          o.set(e2, f);
        }
        for (var _t in e2) "default" !== _t && {}.hasOwnProperty.call(e2, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e2, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e2[_t]);
        return f;
      })(e, t);
    }
    var typedNodes = nodes;
    var inlineNodes = exports2.inlineNodes = new Set(Object.keys(typedNodes).filter(function(key) {
      return typedNodes[key] && typedNodes[key].group === "inline";
    }));
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/schema/index.js
var require_schema = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/schema/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "AnnotationMarkStates", {
      enumerable: true,
      get: function get() {
        return _marks.AnnotationMarkStates;
      }
    });
    Object.defineProperty(exports2, "AnnotationTypes", {
      enumerable: true,
      get: function get() {
        return _marks.AnnotationTypes;
      }
    });
    Object.defineProperty(exports2, "PanelType", {
      enumerable: true,
      get: function get() {
        return _nodes.PanelType;
      }
    });
    Object.defineProperty(exports2, "alignment", {
      enumerable: true,
      get: function get() {
        return _marks.alignment;
      }
    });
    Object.defineProperty(exports2, "alignmentPositionMap", {
      enumerable: true,
      get: function get() {
        return _marks.alignmentPositionMap;
      }
    });
    Object.defineProperty(exports2, "annotation", {
      enumerable: true,
      get: function get() {
        return _marks.annotation;
      }
    });
    Object.defineProperty(exports2, "backgroundColor", {
      enumerable: true,
      get: function get() {
        return _marks.backgroundColor;
      }
    });
    Object.defineProperty(exports2, "backgroundColorPalette", {
      enumerable: true,
      get: function get() {
        return _marks.backgroundColorPalette;
      }
    });
    Object.defineProperty(exports2, "backgroundColorPaletteNext", {
      enumerable: true,
      get: function get() {
        return _marks.backgroundColorPaletteNext;
      }
    });
    Object.defineProperty(exports2, "blockCard", {
      enumerable: true,
      get: function get() {
        return _nodes.blockCard;
      }
    });
    Object.defineProperty(exports2, "blockCardWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.blockCardWithLocalId;
      }
    });
    Object.defineProperty(exports2, "blockTaskItem", {
      enumerable: true,
      get: function get() {
        return _nodes.blockTaskItem;
      }
    });
    Object.defineProperty(exports2, "blockquote", {
      enumerable: true,
      get: function get() {
        return _nodes.blockquote;
      }
    });
    Object.defineProperty(exports2, "bodiedExtension", {
      enumerable: true,
      get: function get() {
        return _nodes.bodiedExtension;
      }
    });
    Object.defineProperty(exports2, "border", {
      enumerable: true,
      get: function get() {
        return _marks.border;
      }
    });
    Object.defineProperty(exports2, "borderColorPalette", {
      enumerable: true,
      get: function get() {
        return _marks.borderColorPalette;
      }
    });
    Object.defineProperty(exports2, "breakout", {
      enumerable: true,
      get: function get() {
        return _marks.breakout;
      }
    });
    Object.defineProperty(exports2, "buildAnnotationMarkDataAttributes", {
      enumerable: true,
      get: function get() {
        return _marks.buildAnnotationMarkDataAttributes;
      }
    });
    Object.defineProperty(exports2, "bulletList", {
      enumerable: true,
      get: function get() {
        return _nodes.bulletList;
      }
    });
    Object.defineProperty(exports2, "bulletListSelector", {
      enumerable: true,
      get: function get() {
        return _nodes.bulletListSelector;
      }
    });
    Object.defineProperty(exports2, "bulletListWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.bulletListWithLocalId;
      }
    });
    Object.defineProperty(exports2, "caption", {
      enumerable: true,
      get: function get() {
        return _nodes.caption;
      }
    });
    Object.defineProperty(exports2, "captionWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.captionWithLocalId;
      }
    });
    Object.defineProperty(exports2, "code", {
      enumerable: true,
      get: function get() {
        return _marks.code;
      }
    });
    Object.defineProperty(exports2, "codeBlock", {
      enumerable: true,
      get: function get() {
        return _nodes.codeBlock;
      }
    });
    Object.defineProperty(exports2, "codeBlockToJSON", {
      enumerable: true,
      get: function get() {
        return _nodes.codeBlockToJSON;
      }
    });
    Object.defineProperty(exports2, "codeBlockWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.codeBlockWithLocalId;
      }
    });
    Object.defineProperty(exports2, "colorPalette", {
      enumerable: true,
      get: function get() {
        return _marks.colorPalette;
      }
    });
    Object.defineProperty(exports2, "colorPaletteExtended", {
      enumerable: true,
      get: function get() {
        return _marks.colorPaletteExtended;
      }
    });
    Object.defineProperty(exports2, "confluenceInlineComment", {
      enumerable: true,
      get: function get() {
        return _marks.confluenceInlineComment;
      }
    });
    Object.defineProperty(exports2, "confluenceJiraIssue", {
      enumerable: true,
      get: function get() {
        return _nodes.confluenceJiraIssue;
      }
    });
    Object.defineProperty(exports2, "confluenceUnsupportedBlock", {
      enumerable: true,
      get: function get() {
        return _nodes.confluenceUnsupportedBlock;
      }
    });
    Object.defineProperty(exports2, "confluenceUnsupportedInline", {
      enumerable: true,
      get: function get() {
        return _nodes.confluenceUnsupportedInline;
      }
    });
    Object.defineProperty(exports2, "copyPrivateMediaAttributes", {
      enumerable: true,
      get: function get() {
        return _nodes.copyPrivateMediaAttributes;
      }
    });
    Object.defineProperty(exports2, "createPMMarkSpecFactory", {
      enumerable: true,
      get: function get() {
        return _createPMSpecFactory.createPMMarkSpecFactory;
      }
    });
    Object.defineProperty(exports2, "createPMNodeSpecFactory", {
      enumerable: true,
      get: function get() {
        return _createPMSpecFactory.createPMNodeSpecFactory;
      }
    });
    Object.defineProperty(exports2, "createSchema", {
      enumerable: true,
      get: function get() {
        return _createSchema.createSchema;
      }
    });
    Object.defineProperty(exports2, "dataConsumer", {
      enumerable: true,
      get: function get() {
        return _marks.dataConsumer;
      }
    });
    Object.defineProperty(exports2, "dataConsumerToJSON", {
      enumerable: true,
      get: function get() {
        return _marks.dataConsumerToJSON;
      }
    });
    Object.defineProperty(exports2, "date", {
      enumerable: true,
      get: function get() {
        return _nodes.date;
      }
    });
    Object.defineProperty(exports2, "dateWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.dateWithLocalId;
      }
    });
    Object.defineProperty(exports2, "decisionItem", {
      enumerable: true,
      get: function get() {
        return _nodes.decisionItem;
      }
    });
    Object.defineProperty(exports2, "decisionList", {
      enumerable: true,
      get: function get() {
        return _nodes.decisionList;
      }
    });
    Object.defineProperty(exports2, "decisionListSelector", {
      enumerable: true,
      get: function get() {
        return _nodes.decisionListSelector;
      }
    });
    Object.defineProperty(exports2, "doc", {
      enumerable: true,
      get: function get() {
        return _nodes.doc;
      }
    });
    Object.defineProperty(exports2, "em", {
      enumerable: true,
      get: function get() {
        return _marks.em;
      }
    });
    Object.defineProperty(exports2, "embedCard", {
      enumerable: true,
      get: function get() {
        return _nodes.embedCard;
      }
    });
    Object.defineProperty(exports2, "embedCardWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.embedCardWithLocalId;
      }
    });
    Object.defineProperty(exports2, "emoji", {
      enumerable: true,
      get: function get() {
        return _nodes.emoji;
      }
    });
    Object.defineProperty(exports2, "emojiWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.emojiWithLocalId;
      }
    });
    Object.defineProperty(exports2, "expandToJSON", {
      enumerable: true,
      get: function get() {
        return _nodes.expandToJSON;
      }
    });
    Object.defineProperty(exports2, "expandWithNestedExpand", {
      enumerable: true,
      get: function get() {
        return _nodes.expandWithNestedExpand;
      }
    });
    Object.defineProperty(exports2, "expandWithNestedExpandLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.expandWithNestedExpandLocalId;
      }
    });
    Object.defineProperty(exports2, "extendedBlockquote", {
      enumerable: true,
      get: function get() {
        return _nodes.extendedBlockquote;
      }
    });
    Object.defineProperty(exports2, "extendedBlockquoteWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.extendedBlockquoteWithLocalId;
      }
    });
    Object.defineProperty(exports2, "extendedPanel", {
      enumerable: true,
      get: function get() {
        return _nodes.extendedPanel;
      }
    });
    Object.defineProperty(exports2, "extendedPanelWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.extendedPanelWithLocalId;
      }
    });
    Object.defineProperty(exports2, "extension", {
      enumerable: true,
      get: function get() {
        return _nodes.extension;
      }
    });
    Object.defineProperty(exports2, "extensionFrame", {
      enumerable: true,
      get: function get() {
        return _nodes.extensionFrame;
      }
    });
    Object.defineProperty(exports2, "fragment", {
      enumerable: true,
      get: function get() {
        return _marks.fragment;
      }
    });
    Object.defineProperty(exports2, "fragmentToJSON", {
      enumerable: true,
      get: function get() {
        return _marks.fragmentToJSON;
      }
    });
    Object.defineProperty(exports2, "getCellAttrs", {
      enumerable: true,
      get: function get() {
        return _nodes.getCellAttrs;
      }
    });
    Object.defineProperty(exports2, "getCellDomAttrs", {
      enumerable: true,
      get: function get() {
        return _nodes.getCellDomAttrs;
      }
    });
    Object.defineProperty(exports2, "hardBreak", {
      enumerable: true,
      get: function get() {
        return _nodes.hardBreak;
      }
    });
    Object.defineProperty(exports2, "heading", {
      enumerable: true,
      get: function get() {
        return _nodes.heading;
      }
    });
    Object.defineProperty(exports2, "image", {
      enumerable: true,
      get: function get() {
        return _nodes.image;
      }
    });
    Object.defineProperty(exports2, "indentation", {
      enumerable: true,
      get: function get() {
        return _marks.indentation;
      }
    });
    Object.defineProperty(exports2, "inlineCard", {
      enumerable: true,
      get: function get() {
        return _nodes.inlineCard;
      }
    });
    Object.defineProperty(exports2, "inlineCardWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.inlineCardWithLocalId;
      }
    });
    Object.defineProperty(exports2, "inlineExtension", {
      enumerable: true,
      get: function get() {
        return _nodes.inlineExtension;
      }
    });
    Object.defineProperty(exports2, "inlineNodes", {
      enumerable: true,
      get: function get() {
        return _inlineNodes.inlineNodes;
      }
    });
    Object.defineProperty(exports2, "layoutColumn", {
      enumerable: true,
      get: function get() {
        return _nodes.layoutColumn;
      }
    });
    Object.defineProperty(exports2, "layoutColumnWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.layoutColumnWithLocalId;
      }
    });
    Object.defineProperty(exports2, "layoutSection", {
      enumerable: true,
      get: function get() {
        return _nodes.layoutSection;
      }
    });
    Object.defineProperty(exports2, "layoutSectionWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.layoutSectionWithLocalId;
      }
    });
    Object.defineProperty(exports2, "layoutSectionWithSingleColumn", {
      enumerable: true,
      get: function get() {
        return _nodes.layoutSectionWithSingleColumn;
      }
    });
    Object.defineProperty(exports2, "layoutSectionWithSingleColumnLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.layoutSectionWithSingleColumnLocalId;
      }
    });
    Object.defineProperty(exports2, "link", {
      enumerable: true,
      get: function get() {
        return _marks.link;
      }
    });
    Object.defineProperty(exports2, "linkToJSON", {
      enumerable: true,
      get: function get() {
        return _marks.linkToJSON;
      }
    });
    Object.defineProperty(exports2, "listItem", {
      enumerable: true,
      get: function get() {
        return _nodes.listItem;
      }
    });
    Object.defineProperty(exports2, "listItemWithDecisionStage0", {
      enumerable: true,
      get: function get() {
        return _nodes.listItemWithDecisionStage0;
      }
    });
    Object.defineProperty(exports2, "listItemWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.listItemWithLocalId;
      }
    });
    Object.defineProperty(exports2, "media", {
      enumerable: true,
      get: function get() {
        return _nodes.media;
      }
    });
    Object.defineProperty(exports2, "mediaGroup", {
      enumerable: true,
      get: function get() {
        return _nodes.mediaGroup;
      }
    });
    Object.defineProperty(exports2, "mediaInline", {
      enumerable: true,
      get: function get() {
        return _nodes.mediaInline;
      }
    });
    Object.defineProperty(exports2, "mediaSingle", {
      enumerable: true,
      get: function get() {
        return _nodes.mediaSingle;
      }
    });
    Object.defineProperty(exports2, "mediaSingleFull", {
      enumerable: true,
      get: function get() {
        return _nodes.mediaSingleFull;
      }
    });
    Object.defineProperty(exports2, "mediaSingleFullWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.mediaSingleFullWithLocalId;
      }
    });
    Object.defineProperty(exports2, "mediaSingleSpec", {
      enumerable: true,
      get: function get() {
        return _nodes.mediaSingleSpec;
      }
    });
    Object.defineProperty(exports2, "mediaSingleToJSON", {
      enumerable: true,
      get: function get() {
        return _nodes.mediaSingleToJSON;
      }
    });
    Object.defineProperty(exports2, "mediaSingleWithCaption", {
      enumerable: true,
      get: function get() {
        return _nodes.mediaSingleWithCaption;
      }
    });
    Object.defineProperty(exports2, "mediaSingleWithWidthType", {
      enumerable: true,
      get: function get() {
        return _nodes.mediaSingleWithWidthType;
      }
    });
    Object.defineProperty(exports2, "mediaToJSON", {
      enumerable: true,
      get: function get() {
        return _nodes.mediaToJSON;
      }
    });
    Object.defineProperty(exports2, "mention", {
      enumerable: true,
      get: function get() {
        return _nodes.mention;
      }
    });
    Object.defineProperty(exports2, "mentionToJSON", {
      enumerable: true,
      get: function get() {
        return _nodes.mentionToJSON;
      }
    });
    Object.defineProperty(exports2, "multiBodiedExtension", {
      enumerable: true,
      get: function get() {
        return _nodes.multiBodiedExtension;
      }
    });
    Object.defineProperty(exports2, "nestedExpand", {
      enumerable: true,
      get: function get() {
        return _nodes.nestedExpand;
      }
    });
    Object.defineProperty(exports2, "nestedExpandWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.nestedExpandWithLocalId;
      }
    });
    Object.defineProperty(exports2, "orderedList", {
      enumerable: true,
      get: function get() {
        return _nodes.orderedList;
      }
    });
    Object.defineProperty(exports2, "orderedListSelector", {
      enumerable: true,
      get: function get() {
        return _nodes.orderedListSelector;
      }
    });
    Object.defineProperty(exports2, "orderedListWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.orderedListWithLocalId;
      }
    });
    Object.defineProperty(exports2, "orderedListWithOrder", {
      enumerable: true,
      get: function get() {
        return _nodes.orderedListWithOrder;
      }
    });
    Object.defineProperty(exports2, "orderedListWithOrderAndLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.orderedListWithOrderAndLocalId;
      }
    });
    Object.defineProperty(exports2, "paragraph", {
      enumerable: true,
      get: function get() {
        return _nodes.paragraph;
      }
    });
    Object.defineProperty(exports2, "placeholder", {
      enumerable: true,
      get: function get() {
        return _nodes.placeholder;
      }
    });
    Object.defineProperty(exports2, "placeholderWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.placeholderWithLocalId;
      }
    });
    Object.defineProperty(exports2, "rule", {
      enumerable: true,
      get: function get() {
        return _nodes.rule;
      }
    });
    Object.defineProperty(exports2, "ruleWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.ruleWithLocalId;
      }
    });
    Object.defineProperty(exports2, "sanitizeNodes", {
      enumerable: true,
      get: function get() {
        return _sanitizeNodes.sanitizeNodes;
      }
    });
    Object.defineProperty(exports2, "status", {
      enumerable: true,
      get: function get() {
        return _nodes.status;
      }
    });
    Object.defineProperty(exports2, "strike", {
      enumerable: true,
      get: function get() {
        return _marks.strike;
      }
    });
    Object.defineProperty(exports2, "strong", {
      enumerable: true,
      get: function get() {
        return _marks.strong;
      }
    });
    Object.defineProperty(exports2, "subsup", {
      enumerable: true,
      get: function get() {
        return _marks.subsup;
      }
    });
    Object.defineProperty(exports2, "syncBlock", {
      enumerable: true,
      get: function get() {
        return _nodes.syncBlock;
      }
    });
    Object.defineProperty(exports2, "table", {
      enumerable: true,
      get: function get() {
        return _nodes.table;
      }
    });
    Object.defineProperty(exports2, "tableBackgroundBorderColor", {
      enumerable: true,
      get: function get() {
        return _nodes.tableBackgroundBorderColor;
      }
    });
    Object.defineProperty(exports2, "tableBackgroundColorNames", {
      enumerable: true,
      get: function get() {
        return _nodes.tableBackgroundColorNames;
      }
    });
    Object.defineProperty(exports2, "tableBackgroundColorPalette", {
      enumerable: true,
      get: function get() {
        return _nodes.tableBackgroundColorPalette;
      }
    });
    Object.defineProperty(exports2, "tableCell", {
      enumerable: true,
      get: function get() {
        return _nodes.tableCell;
      }
    });
    Object.defineProperty(exports2, "tableCellContentDomSelector", {
      enumerable: true,
      get: function get() {
        return _nodes.tableCellContentDomSelector;
      }
    });
    Object.defineProperty(exports2, "tableCellContentWrapperSelector", {
      enumerable: true,
      get: function get() {
        return _nodes.tableCellContentWrapperSelector;
      }
    });
    Object.defineProperty(exports2, "tableCellSelector", {
      enumerable: true,
      get: function get() {
        return _nodes.tableCellSelector;
      }
    });
    Object.defineProperty(exports2, "tableCellWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.tableCellWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableCellWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _nodes.tableCellWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "tableCellWithNestedTableWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.tableCellWithNestedTableWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableHeader", {
      enumerable: true,
      get: function get() {
        return _nodes.tableHeader;
      }
    });
    Object.defineProperty(exports2, "tableHeaderSelector", {
      enumerable: true,
      get: function get() {
        return _nodes.tableHeaderSelector;
      }
    });
    Object.defineProperty(exports2, "tableHeaderWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.tableHeaderWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableHeaderWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _nodes.tableHeaderWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "tableHeaderWithNestedTableWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.tableHeaderWithNestedTableWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tablePrefixSelector", {
      enumerable: true,
      get: function get() {
        return _nodes.tablePrefixSelector;
      }
    });
    Object.defineProperty(exports2, "tableRow", {
      enumerable: true,
      get: function get() {
        return _nodes.tableRow;
      }
    });
    Object.defineProperty(exports2, "tableRowWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.tableRowWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableRowWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _nodes.tableRowWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "tableRowWithNestedTableWithLocalId", {
      enumerable: true,
      get: function get() {
        return _nodes.tableRowWithNestedTableWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableStage0", {
      enumerable: true,
      get: function get() {
        return _nodes.tableStage0;
      }
    });
    Object.defineProperty(exports2, "tableToJSON", {
      enumerable: true,
      get: function get() {
        return _nodes.tableToJSON;
      }
    });
    Object.defineProperty(exports2, "tableWithCustomWidth", {
      enumerable: true,
      get: function get() {
        return _nodes.tableWithCustomWidth;
      }
    });
    Object.defineProperty(exports2, "tableWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _nodes.tableWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "taskItem", {
      enumerable: true,
      get: function get() {
        return _nodes.taskItem;
      }
    });
    Object.defineProperty(exports2, "taskList", {
      enumerable: true,
      get: function get() {
        return _nodes.taskList;
      }
    });
    Object.defineProperty(exports2, "taskListSelector", {
      enumerable: true,
      get: function get() {
        return _nodes.taskListSelector;
      }
    });
    Object.defineProperty(exports2, "text", {
      enumerable: true,
      get: function get() {
        return _nodes.text;
      }
    });
    Object.defineProperty(exports2, "textColor", {
      enumerable: true,
      get: function get() {
        return _marks.textColor;
      }
    });
    Object.defineProperty(exports2, "toJSONTableCell", {
      enumerable: true,
      get: function get() {
        return _nodes.toJSONTableCell;
      }
    });
    Object.defineProperty(exports2, "toJSONTableHeader", {
      enumerable: true,
      get: function get() {
        return _nodes.toJSONTableHeader;
      }
    });
    Object.defineProperty(exports2, "typeAheadQuery", {
      enumerable: true,
      get: function get() {
        return _marks.typeAheadQuery;
      }
    });
    Object.defineProperty(exports2, "underline", {
      enumerable: true,
      get: function get() {
        return _marks.underline;
      }
    });
    Object.defineProperty(exports2, "unknownBlock", {
      enumerable: true,
      get: function get() {
        return _nodes.unknownBlock;
      }
    });
    Object.defineProperty(exports2, "unsupportedBlock", {
      enumerable: true,
      get: function get() {
        return _nodes.unsupportedBlock;
      }
    });
    Object.defineProperty(exports2, "unsupportedInline", {
      enumerable: true,
      get: function get() {
        return _nodes.unsupportedInline;
      }
    });
    Object.defineProperty(exports2, "unsupportedMark", {
      enumerable: true,
      get: function get() {
        return _marks.unsupportedMark;
      }
    });
    Object.defineProperty(exports2, "unsupportedNodeAttribute", {
      enumerable: true,
      get: function get() {
        return _marks.unsupportedNodeAttribute;
      }
    });
    Object.defineProperty(exports2, "unsupportedNodeTypesForMediaCards", {
      enumerable: true,
      get: function get() {
        return _unsupported.unsupportedNodeTypesForMediaCards;
      }
    });
    var _nodes = require_nodes();
    var _marks = require_marks();
    var _unsupported = require_unsupported();
    var _inlineNodes = require_inline_nodes();
    var _createSchema = require_create_schema();
    var _sanitizeNodes = require_sanitizeNodes();
    var _createPMSpecFactory = require_createPMSpecFactory();
  }
});

// node_modules/@atlaskit/adf-schema/dist/cjs/index.js
var require_cjs5 = __commonJS({
  "node_modules/@atlaskit/adf-schema/dist/cjs/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "AnnotationMarkStates", {
      enumerable: true,
      get: function get() {
        return _schema.AnnotationMarkStates;
      }
    });
    Object.defineProperty(exports2, "AnnotationTypes", {
      enumerable: true,
      get: function get() {
        return _schema.AnnotationTypes;
      }
    });
    Object.defineProperty(exports2, "B100", {
      enumerable: true,
      get: function get() {
        return _utils.B100;
      }
    });
    Object.defineProperty(exports2, "B400", {
      enumerable: true,
      get: function get() {
        return _utils.B400;
      }
    });
    Object.defineProperty(exports2, "B50", {
      enumerable: true,
      get: function get() {
        return _utils.B50;
      }
    });
    Object.defineProperty(exports2, "B500", {
      enumerable: true,
      get: function get() {
        return _utils.B500;
      }
    });
    Object.defineProperty(exports2, "B75", {
      enumerable: true,
      get: function get() {
        return _utils.B75;
      }
    });
    Object.defineProperty(exports2, "G200", {
      enumerable: true,
      get: function get() {
        return _utils.G200;
      }
    });
    Object.defineProperty(exports2, "G300", {
      enumerable: true,
      get: function get() {
        return _utils.G300;
      }
    });
    Object.defineProperty(exports2, "G400", {
      enumerable: true,
      get: function get() {
        return _utils.G400;
      }
    });
    Object.defineProperty(exports2, "G50", {
      enumerable: true,
      get: function get() {
        return _utils.G50;
      }
    });
    Object.defineProperty(exports2, "G500", {
      enumerable: true,
      get: function get() {
        return _utils.G500;
      }
    });
    Object.defineProperty(exports2, "G75", {
      enumerable: true,
      get: function get() {
        return _utils.G75;
      }
    });
    Object.defineProperty(exports2, "N0", {
      enumerable: true,
      get: function get() {
        return _utils.N0;
      }
    });
    Object.defineProperty(exports2, "N20", {
      enumerable: true,
      get: function get() {
        return _utils.N20;
      }
    });
    Object.defineProperty(exports2, "N200", {
      enumerable: true,
      get: function get() {
        return _utils.N200;
      }
    });
    Object.defineProperty(exports2, "N30", {
      enumerable: true,
      get: function get() {
        return _utils.N30;
      }
    });
    Object.defineProperty(exports2, "N300", {
      enumerable: true,
      get: function get() {
        return _utils.N300;
      }
    });
    Object.defineProperty(exports2, "N40", {
      enumerable: true,
      get: function get() {
        return _utils.N40;
      }
    });
    Object.defineProperty(exports2, "N50", {
      enumerable: true,
      get: function get() {
        return _utils.N50;
      }
    });
    Object.defineProperty(exports2, "N500", {
      enumerable: true,
      get: function get() {
        return _utils.N500;
      }
    });
    Object.defineProperty(exports2, "N60", {
      enumerable: true,
      get: function get() {
        return _utils.N60;
      }
    });
    Object.defineProperty(exports2, "N80", {
      enumerable: true,
      get: function get() {
        return _utils.N80;
      }
    });
    Object.defineProperty(exports2, "N800", {
      enumerable: true,
      get: function get() {
        return _utils.N800;
      }
    });
    Object.defineProperty(exports2, "N90", {
      enumerable: true,
      get: function get() {
        return _utils.N90;
      }
    });
    Object.defineProperty(exports2, "P100", {
      enumerable: true,
      get: function get() {
        return _utils.P100;
      }
    });
    Object.defineProperty(exports2, "P300", {
      enumerable: true,
      get: function get() {
        return _utils.P300;
      }
    });
    Object.defineProperty(exports2, "P400", {
      enumerable: true,
      get: function get() {
        return _utils.P400;
      }
    });
    Object.defineProperty(exports2, "P50", {
      enumerable: true,
      get: function get() {
        return _utils.P50;
      }
    });
    Object.defineProperty(exports2, "P500", {
      enumerable: true,
      get: function get() {
        return _utils.P500;
      }
    });
    Object.defineProperty(exports2, "P75", {
      enumerable: true,
      get: function get() {
        return _utils.P75;
      }
    });
    Object.defineProperty(exports2, "PanelType", {
      enumerable: true,
      get: function get() {
        return _schema.PanelType;
      }
    });
    Object.defineProperty(exports2, "R100", {
      enumerable: true,
      get: function get() {
        return _utils.R100;
      }
    });
    Object.defineProperty(exports2, "R300", {
      enumerable: true,
      get: function get() {
        return _utils.R300;
      }
    });
    Object.defineProperty(exports2, "R400", {
      enumerable: true,
      get: function get() {
        return _utils.R400;
      }
    });
    Object.defineProperty(exports2, "R50", {
      enumerable: true,
      get: function get() {
        return _utils.R50;
      }
    });
    Object.defineProperty(exports2, "R500", {
      enumerable: true,
      get: function get() {
        return _utils.R500;
      }
    });
    Object.defineProperty(exports2, "R75", {
      enumerable: true,
      get: function get() {
        return _utils.R75;
      }
    });
    Object.defineProperty(exports2, "T100", {
      enumerable: true,
      get: function get() {
        return _utils.T100;
      }
    });
    Object.defineProperty(exports2, "T300", {
      enumerable: true,
      get: function get() {
        return _utils.T300;
      }
    });
    Object.defineProperty(exports2, "T50", {
      enumerable: true,
      get: function get() {
        return _utils.T50;
      }
    });
    Object.defineProperty(exports2, "T500", {
      enumerable: true,
      get: function get() {
        return _utils.T500;
      }
    });
    Object.defineProperty(exports2, "T75", {
      enumerable: true,
      get: function get() {
        return _utils.T75;
      }
    });
    Object.defineProperty(exports2, "Y200", {
      enumerable: true,
      get: function get() {
        return _utils.Y200;
      }
    });
    Object.defineProperty(exports2, "Y400", {
      enumerable: true,
      get: function get() {
        return _utils.Y400;
      }
    });
    Object.defineProperty(exports2, "Y50", {
      enumerable: true,
      get: function get() {
        return _utils.Y50;
      }
    });
    Object.defineProperty(exports2, "Y500", {
      enumerable: true,
      get: function get() {
        return _utils.Y500;
      }
    });
    Object.defineProperty(exports2, "Y75", {
      enumerable: true,
      get: function get() {
        return _utils.Y75;
      }
    });
    Object.defineProperty(exports2, "acNameToEmoji", {
      enumerable: true,
      get: function get() {
        return _utils.acNameToEmoji;
      }
    });
    Object.defineProperty(exports2, "acShortcutToEmoji", {
      enumerable: true,
      get: function get() {
        return _utils.acShortcutToEmoji;
      }
    });
    Object.defineProperty(exports2, "alignment", {
      enumerable: true,
      get: function get() {
        return _schema.alignment;
      }
    });
    Object.defineProperty(exports2, "alignmentPositionMap", {
      enumerable: true,
      get: function get() {
        return _schema.alignmentPositionMap;
      }
    });
    Object.defineProperty(exports2, "annotation", {
      enumerable: true,
      get: function get() {
        return _schema.annotation;
      }
    });
    Object.defineProperty(exports2, "backgroundColor", {
      enumerable: true,
      get: function get() {
        return _schema.backgroundColor;
      }
    });
    Object.defineProperty(exports2, "backgroundColorPalette", {
      enumerable: true,
      get: function get() {
        return _schema.backgroundColorPalette;
      }
    });
    Object.defineProperty(exports2, "backgroundColorPaletteNext", {
      enumerable: true,
      get: function get() {
        return _schema.backgroundColorPaletteNext;
      }
    });
    Object.defineProperty(exports2, "blockCard", {
      enumerable: true,
      get: function get() {
        return _schema.blockCard;
      }
    });
    Object.defineProperty(exports2, "blockCardWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.blockCardWithLocalId;
      }
    });
    Object.defineProperty(exports2, "blockTaskItem", {
      enumerable: true,
      get: function get() {
        return _schema.blockTaskItem;
      }
    });
    Object.defineProperty(exports2, "blockquote", {
      enumerable: true,
      get: function get() {
        return _schema.blockquote;
      }
    });
    Object.defineProperty(exports2, "bodiedExtension", {
      enumerable: true,
      get: function get() {
        return _schema.bodiedExtension;
      }
    });
    Object.defineProperty(exports2, "border", {
      enumerable: true,
      get: function get() {
        return _schema.border;
      }
    });
    Object.defineProperty(exports2, "borderColorPalette", {
      enumerable: true,
      get: function get() {
        return _schema.borderColorPalette;
      }
    });
    Object.defineProperty(exports2, "breakout", {
      enumerable: true,
      get: function get() {
        return _schema.breakout;
      }
    });
    Object.defineProperty(exports2, "buildAnnotationMarkDataAttributes", {
      enumerable: true,
      get: function get() {
        return _schema.buildAnnotationMarkDataAttributes;
      }
    });
    Object.defineProperty(exports2, "bulletList", {
      enumerable: true,
      get: function get() {
        return _schema.bulletList;
      }
    });
    Object.defineProperty(exports2, "bulletListSelector", {
      enumerable: true,
      get: function get() {
        return _schema.bulletListSelector;
      }
    });
    Object.defineProperty(exports2, "bulletListWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.bulletListWithLocalId;
      }
    });
    Object.defineProperty(exports2, "caption", {
      enumerable: true,
      get: function get() {
        return _schema.caption;
      }
    });
    Object.defineProperty(exports2, "captionWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.captionWithLocalId;
      }
    });
    Object.defineProperty(exports2, "code", {
      enumerable: true,
      get: function get() {
        return _schema.code;
      }
    });
    Object.defineProperty(exports2, "codeBlock", {
      enumerable: true,
      get: function get() {
        return _schema.codeBlock;
      }
    });
    Object.defineProperty(exports2, "codeBlockToJSON", {
      enumerable: true,
      get: function get() {
        return _schema.codeBlockToJSON;
      }
    });
    Object.defineProperty(exports2, "codeBlockWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.codeBlockWithLocalId;
      }
    });
    Object.defineProperty(exports2, "colorPalette", {
      enumerable: true,
      get: function get() {
        return _schema.colorPalette;
      }
    });
    Object.defineProperty(exports2, "colorPaletteExtended", {
      enumerable: true,
      get: function get() {
        return _schema.colorPaletteExtended;
      }
    });
    Object.defineProperty(exports2, "confluenceInlineComment", {
      enumerable: true,
      get: function get() {
        return _schema.confluenceInlineComment;
      }
    });
    Object.defineProperty(exports2, "confluenceJiraIssue", {
      enumerable: true,
      get: function get() {
        return _schema.confluenceJiraIssue;
      }
    });
    Object.defineProperty(exports2, "confluenceUnsupportedBlock", {
      enumerable: true,
      get: function get() {
        return _schema.confluenceUnsupportedBlock;
      }
    });
    Object.defineProperty(exports2, "confluenceUnsupportedInline", {
      enumerable: true,
      get: function get() {
        return _schema.confluenceUnsupportedInline;
      }
    });
    Object.defineProperty(exports2, "copyPrivateMediaAttributes", {
      enumerable: true,
      get: function get() {
        return _schema.copyPrivateMediaAttributes;
      }
    });
    Object.defineProperty(exports2, "createPMMarkSpecFactory", {
      enumerable: true,
      get: function get() {
        return _schema.createPMMarkSpecFactory;
      }
    });
    Object.defineProperty(exports2, "createPMNodeSpecFactory", {
      enumerable: true,
      get: function get() {
        return _schema.createPMNodeSpecFactory;
      }
    });
    Object.defineProperty(exports2, "createSchema", {
      enumerable: true,
      get: function get() {
        return _schema.createSchema;
      }
    });
    Object.defineProperty(exports2, "dataConsumer", {
      enumerable: true,
      get: function get() {
        return _schema.dataConsumer;
      }
    });
    Object.defineProperty(exports2, "dataConsumerToJSON", {
      enumerable: true,
      get: function get() {
        return _schema.dataConsumerToJSON;
      }
    });
    Object.defineProperty(exports2, "date", {
      enumerable: true,
      get: function get() {
        return _schema.date;
      }
    });
    Object.defineProperty(exports2, "dateWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.dateWithLocalId;
      }
    });
    Object.defineProperty(exports2, "decisionItem", {
      enumerable: true,
      get: function get() {
        return _schema.decisionItem;
      }
    });
    Object.defineProperty(exports2, "decisionList", {
      enumerable: true,
      get: function get() {
        return _schema.decisionList;
      }
    });
    Object.defineProperty(exports2, "decisionListSelector", {
      enumerable: true,
      get: function get() {
        return _schema.decisionListSelector;
      }
    });
    Object.defineProperty(exports2, "doc", {
      enumerable: true,
      get: function get() {
        return _schema.doc;
      }
    });
    Object.defineProperty(exports2, "em", {
      enumerable: true,
      get: function get() {
        return _schema.em;
      }
    });
    Object.defineProperty(exports2, "embedCard", {
      enumerable: true,
      get: function get() {
        return _schema.embedCard;
      }
    });
    Object.defineProperty(exports2, "embedCardWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.embedCardWithLocalId;
      }
    });
    Object.defineProperty(exports2, "emoji", {
      enumerable: true,
      get: function get() {
        return _schema.emoji;
      }
    });
    Object.defineProperty(exports2, "emojiIdToAcName", {
      enumerable: true,
      get: function get() {
        return _utils.emojiIdToAcName;
      }
    });
    Object.defineProperty(exports2, "emojiWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.emojiWithLocalId;
      }
    });
    Object.defineProperty(exports2, "expandToJSON", {
      enumerable: true,
      get: function get() {
        return _schema.expandToJSON;
      }
    });
    Object.defineProperty(exports2, "expandWithNestedExpand", {
      enumerable: true,
      get: function get() {
        return _schema.expandWithNestedExpand;
      }
    });
    Object.defineProperty(exports2, "expandWithNestedExpandLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.expandWithNestedExpandLocalId;
      }
    });
    Object.defineProperty(exports2, "extendedBlockquote", {
      enumerable: true,
      get: function get() {
        return _schema.extendedBlockquote;
      }
    });
    Object.defineProperty(exports2, "extendedBlockquoteWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.extendedBlockquoteWithLocalId;
      }
    });
    Object.defineProperty(exports2, "extendedPanel", {
      enumerable: true,
      get: function get() {
        return _schema.extendedPanel;
      }
    });
    Object.defineProperty(exports2, "extendedPanelWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.extendedPanelWithLocalId;
      }
    });
    Object.defineProperty(exports2, "extension", {
      enumerable: true,
      get: function get() {
        return _schema.extension;
      }
    });
    Object.defineProperty(exports2, "extensionFrame", {
      enumerable: true,
      get: function get() {
        return _schema.extensionFrame;
      }
    });
    Object.defineProperty(exports2, "fragment", {
      enumerable: true,
      get: function get() {
        return _schema.fragment;
      }
    });
    Object.defineProperty(exports2, "fragmentToJSON", {
      enumerable: true,
      get: function get() {
        return _schema.fragmentToJSON;
      }
    });
    Object.defineProperty(exports2, "generateUuid", {
      enumerable: true,
      get: function get() {
        return _utils.generateUuid;
      }
    });
    Object.defineProperty(exports2, "getCellAttrs", {
      enumerable: true,
      get: function get() {
        return _schema.getCellAttrs;
      }
    });
    Object.defineProperty(exports2, "getCellDomAttrs", {
      enumerable: true,
      get: function get() {
        return _schema.getCellDomAttrs;
      }
    });
    Object.defineProperty(exports2, "getDarkModeLCHColor", {
      enumerable: true,
      get: function get() {
        return _utils.getDarkModeLCHColor;
      }
    });
    Object.defineProperty(exports2, "getEmojiAcName", {
      enumerable: true,
      get: function get() {
        return _utils.getEmojiAcName;
      }
    });
    Object.defineProperty(exports2, "getLinkMatch", {
      enumerable: true,
      get: function get() {
        return _utils.getLinkMatch;
      }
    });
    Object.defineProperty(exports2, "hardBreak", {
      enumerable: true,
      get: function get() {
        return _schema.hardBreak;
      }
    });
    Object.defineProperty(exports2, "heading", {
      enumerable: true,
      get: function get() {
        return _schema.heading;
      }
    });
    Object.defineProperty(exports2, "hexToRgb", {
      enumerable: true,
      get: function get() {
        return _utils.hexToRgb;
      }
    });
    Object.defineProperty(exports2, "hexToRgba", {
      enumerable: true,
      get: function get() {
        return _utils.hexToRgba;
      }
    });
    Object.defineProperty(exports2, "image", {
      enumerable: true,
      get: function get() {
        return _schema.image;
      }
    });
    Object.defineProperty(exports2, "indentation", {
      enumerable: true,
      get: function get() {
        return _schema.indentation;
      }
    });
    Object.defineProperty(exports2, "inlineCard", {
      enumerable: true,
      get: function get() {
        return _schema.inlineCard;
      }
    });
    Object.defineProperty(exports2, "inlineCardWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.inlineCardWithLocalId;
      }
    });
    Object.defineProperty(exports2, "inlineExtension", {
      enumerable: true,
      get: function get() {
        return _schema.inlineExtension;
      }
    });
    Object.defineProperty(exports2, "inlineNodes", {
      enumerable: true,
      get: function get() {
        return _schema.inlineNodes;
      }
    });
    Object.defineProperty(exports2, "isHex", {
      enumerable: true,
      get: function get() {
        return _utils.isHex;
      }
    });
    Object.defineProperty(exports2, "isRgb", {
      enumerable: true,
      get: function get() {
        return _utils.isRgb;
      }
    });
    Object.defineProperty(exports2, "isSafeUrl", {
      enumerable: true,
      get: function get() {
        return _utils.isSafeUrl;
      }
    });
    Object.defineProperty(exports2, "layoutColumn", {
      enumerable: true,
      get: function get() {
        return _schema.layoutColumn;
      }
    });
    Object.defineProperty(exports2, "layoutColumnWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.layoutColumnWithLocalId;
      }
    });
    Object.defineProperty(exports2, "layoutSection", {
      enumerable: true,
      get: function get() {
        return _schema.layoutSection;
      }
    });
    Object.defineProperty(exports2, "layoutSectionWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.layoutSectionWithLocalId;
      }
    });
    Object.defineProperty(exports2, "layoutSectionWithSingleColumn", {
      enumerable: true,
      get: function get() {
        return _schema.layoutSectionWithSingleColumn;
      }
    });
    Object.defineProperty(exports2, "layoutSectionWithSingleColumnLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.layoutSectionWithSingleColumnLocalId;
      }
    });
    Object.defineProperty(exports2, "link", {
      enumerable: true,
      get: function get() {
        return _schema.link;
      }
    });
    Object.defineProperty(exports2, "linkToJSON", {
      enumerable: true,
      get: function get() {
        return _schema.linkToJSON;
      }
    });
    Object.defineProperty(exports2, "linkify", {
      enumerable: true,
      get: function get() {
        return _utils.linkify;
      }
    });
    Object.defineProperty(exports2, "linkifyMatch", {
      enumerable: true,
      get: function get() {
        return _utils.linkifyMatch;
      }
    });
    Object.defineProperty(exports2, "listItem", {
      enumerable: true,
      get: function get() {
        return _schema.listItem;
      }
    });
    Object.defineProperty(exports2, "listItemWithDecisionStage0", {
      enumerable: true,
      get: function get() {
        return _schema.listItemWithDecisionStage0;
      }
    });
    Object.defineProperty(exports2, "listItemWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.listItemWithLocalId;
      }
    });
    Object.defineProperty(exports2, "media", {
      enumerable: true,
      get: function get() {
        return _schema.media;
      }
    });
    Object.defineProperty(exports2, "mediaGroup", {
      enumerable: true,
      get: function get() {
        return _schema.mediaGroup;
      }
    });
    Object.defineProperty(exports2, "mediaInline", {
      enumerable: true,
      get: function get() {
        return _schema.mediaInline;
      }
    });
    Object.defineProperty(exports2, "mediaSingle", {
      enumerable: true,
      get: function get() {
        return _schema.mediaSingle;
      }
    });
    Object.defineProperty(exports2, "mediaSingleFull", {
      enumerable: true,
      get: function get() {
        return _schema.mediaSingleFull;
      }
    });
    Object.defineProperty(exports2, "mediaSingleFullWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.mediaSingleFullWithLocalId;
      }
    });
    Object.defineProperty(exports2, "mediaSingleSpec", {
      enumerable: true,
      get: function get() {
        return _schema.mediaSingleSpec;
      }
    });
    Object.defineProperty(exports2, "mediaSingleToJSON", {
      enumerable: true,
      get: function get() {
        return _schema.mediaSingleToJSON;
      }
    });
    Object.defineProperty(exports2, "mediaSingleWithCaption", {
      enumerable: true,
      get: function get() {
        return _schema.mediaSingleWithCaption;
      }
    });
    Object.defineProperty(exports2, "mediaSingleWithWidthType", {
      enumerable: true,
      get: function get() {
        return _schema.mediaSingleWithWidthType;
      }
    });
    Object.defineProperty(exports2, "mediaToJSON", {
      enumerable: true,
      get: function get() {
        return _schema.mediaToJSON;
      }
    });
    Object.defineProperty(exports2, "mention", {
      enumerable: true,
      get: function get() {
        return _schema.mention;
      }
    });
    Object.defineProperty(exports2, "mentionToJSON", {
      enumerable: true,
      get: function get() {
        return _schema.mentionToJSON;
      }
    });
    Object.defineProperty(exports2, "multiBodiedExtension", {
      enumerable: true,
      get: function get() {
        return _schema.multiBodiedExtension;
      }
    });
    Object.defineProperty(exports2, "nestedExpand", {
      enumerable: true,
      get: function get() {
        return _schema.nestedExpand;
      }
    });
    Object.defineProperty(exports2, "nestedExpandWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.nestedExpandWithLocalId;
      }
    });
    Object.defineProperty(exports2, "normalizeHexColor", {
      enumerable: true,
      get: function get() {
        return _utils.normalizeHexColor;
      }
    });
    Object.defineProperty(exports2, "normalizeUrl", {
      enumerable: true,
      get: function get() {
        return _utils.normalizeUrl;
      }
    });
    Object.defineProperty(exports2, "orderedList", {
      enumerable: true,
      get: function get() {
        return _schema.orderedList;
      }
    });
    Object.defineProperty(exports2, "orderedListSelector", {
      enumerable: true,
      get: function get() {
        return _schema.orderedListSelector;
      }
    });
    Object.defineProperty(exports2, "orderedListWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.orderedListWithLocalId;
      }
    });
    Object.defineProperty(exports2, "orderedListWithOrder", {
      enumerable: true,
      get: function get() {
        return _schema.orderedListWithOrder;
      }
    });
    Object.defineProperty(exports2, "orderedListWithOrderAndLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.orderedListWithOrderAndLocalId;
      }
    });
    Object.defineProperty(exports2, "paragraph", {
      enumerable: true,
      get: function get() {
        return _schema.paragraph;
      }
    });
    Object.defineProperty(exports2, "placeholder", {
      enumerable: true,
      get: function get() {
        return _schema.placeholder;
      }
    });
    Object.defineProperty(exports2, "placeholderWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.placeholderWithLocalId;
      }
    });
    Object.defineProperty(exports2, "rgbToHex", {
      enumerable: true,
      get: function get() {
        return _utils.rgbToHex;
      }
    });
    Object.defineProperty(exports2, "rule", {
      enumerable: true,
      get: function get() {
        return _schema.rule;
      }
    });
    Object.defineProperty(exports2, "ruleWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.ruleWithLocalId;
      }
    });
    Object.defineProperty(exports2, "sanitizeNodes", {
      enumerable: true,
      get: function get() {
        return _schema.sanitizeNodes;
      }
    });
    Object.defineProperty(exports2, "status", {
      enumerable: true,
      get: function get() {
        return _schema.status;
      }
    });
    Object.defineProperty(exports2, "strike", {
      enumerable: true,
      get: function get() {
        return _schema.strike;
      }
    });
    Object.defineProperty(exports2, "strong", {
      enumerable: true,
      get: function get() {
        return _schema.strong;
      }
    });
    Object.defineProperty(exports2, "subsup", {
      enumerable: true,
      get: function get() {
        return _schema.subsup;
      }
    });
    Object.defineProperty(exports2, "syncBlock", {
      enumerable: true,
      get: function get() {
        return _schema.syncBlock;
      }
    });
    Object.defineProperty(exports2, "table", {
      enumerable: true,
      get: function get() {
        return _schema.table;
      }
    });
    Object.defineProperty(exports2, "tableBackgroundBorderColor", {
      enumerable: true,
      get: function get() {
        return _schema.tableBackgroundBorderColor;
      }
    });
    Object.defineProperty(exports2, "tableBackgroundColorNames", {
      enumerable: true,
      get: function get() {
        return _schema.tableBackgroundColorNames;
      }
    });
    Object.defineProperty(exports2, "tableBackgroundColorPalette", {
      enumerable: true,
      get: function get() {
        return _schema.tableBackgroundColorPalette;
      }
    });
    Object.defineProperty(exports2, "tableCell", {
      enumerable: true,
      get: function get() {
        return _schema.tableCell;
      }
    });
    Object.defineProperty(exports2, "tableCellContentDomSelector", {
      enumerable: true,
      get: function get() {
        return _schema.tableCellContentDomSelector;
      }
    });
    Object.defineProperty(exports2, "tableCellContentWrapperSelector", {
      enumerable: true,
      get: function get() {
        return _schema.tableCellContentWrapperSelector;
      }
    });
    Object.defineProperty(exports2, "tableCellSelector", {
      enumerable: true,
      get: function get() {
        return _schema.tableCellSelector;
      }
    });
    Object.defineProperty(exports2, "tableCellWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.tableCellWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableCellWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _schema.tableCellWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "tableCellWithNestedTableWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.tableCellWithNestedTableWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableHeader", {
      enumerable: true,
      get: function get() {
        return _schema.tableHeader;
      }
    });
    Object.defineProperty(exports2, "tableHeaderSelector", {
      enumerable: true,
      get: function get() {
        return _schema.tableHeaderSelector;
      }
    });
    Object.defineProperty(exports2, "tableHeaderWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.tableHeaderWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableHeaderWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _schema.tableHeaderWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "tableHeaderWithNestedTableWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.tableHeaderWithNestedTableWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tablePrefixSelector", {
      enumerable: true,
      get: function get() {
        return _schema.tablePrefixSelector;
      }
    });
    Object.defineProperty(exports2, "tableRow", {
      enumerable: true,
      get: function get() {
        return _schema.tableRow;
      }
    });
    Object.defineProperty(exports2, "tableRowWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.tableRowWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableRowWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _schema.tableRowWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "tableRowWithNestedTableWithLocalId", {
      enumerable: true,
      get: function get() {
        return _schema.tableRowWithNestedTableWithLocalId;
      }
    });
    Object.defineProperty(exports2, "tableStage0", {
      enumerable: true,
      get: function get() {
        return _schema.tableStage0;
      }
    });
    Object.defineProperty(exports2, "tableToJSON", {
      enumerable: true,
      get: function get() {
        return _schema.tableToJSON;
      }
    });
    Object.defineProperty(exports2, "tableWithCustomWidth", {
      enumerable: true,
      get: function get() {
        return _schema.tableWithCustomWidth;
      }
    });
    Object.defineProperty(exports2, "tableWithNestedTable", {
      enumerable: true,
      get: function get() {
        return _schema.tableWithNestedTable;
      }
    });
    Object.defineProperty(exports2, "taskItem", {
      enumerable: true,
      get: function get() {
        return _schema.taskItem;
      }
    });
    Object.defineProperty(exports2, "taskList", {
      enumerable: true,
      get: function get() {
        return _schema.taskList;
      }
    });
    Object.defineProperty(exports2, "taskListSelector", {
      enumerable: true,
      get: function get() {
        return _schema.taskListSelector;
      }
    });
    Object.defineProperty(exports2, "text", {
      enumerable: true,
      get: function get() {
        return _schema.text;
      }
    });
    Object.defineProperty(exports2, "textColor", {
      enumerable: true,
      get: function get() {
        return _schema.textColor;
      }
    });
    Object.defineProperty(exports2, "toJSONTableCell", {
      enumerable: true,
      get: function get() {
        return _schema.toJSONTableCell;
      }
    });
    Object.defineProperty(exports2, "toJSONTableHeader", {
      enumerable: true,
      get: function get() {
        return _schema.toJSONTableHeader;
      }
    });
    Object.defineProperty(exports2, "typeAheadQuery", {
      enumerable: true,
      get: function get() {
        return _schema.typeAheadQuery;
      }
    });
    Object.defineProperty(exports2, "underline", {
      enumerable: true,
      get: function get() {
        return _schema.underline;
      }
    });
    Object.defineProperty(exports2, "unknownBlock", {
      enumerable: true,
      get: function get() {
        return _schema.unknownBlock;
      }
    });
    Object.defineProperty(exports2, "unsupportedBlock", {
      enumerable: true,
      get: function get() {
        return _schema.unsupportedBlock;
      }
    });
    Object.defineProperty(exports2, "unsupportedInline", {
      enumerable: true,
      get: function get() {
        return _schema.unsupportedInline;
      }
    });
    Object.defineProperty(exports2, "unsupportedMark", {
      enumerable: true,
      get: function get() {
        return _schema.unsupportedMark;
      }
    });
    Object.defineProperty(exports2, "unsupportedNodeAttribute", {
      enumerable: true,
      get: function get() {
        return _schema.unsupportedNodeAttribute;
      }
    });
    Object.defineProperty(exports2, "unsupportedNodeTypesForMediaCards", {
      enumerable: true,
      get: function get() {
        return _schema.unsupportedNodeTypesForMediaCards;
      }
    });
    Object.defineProperty(exports2, "uuid", {
      enumerable: true,
      get: function get() {
        return _utils.uuid;
      }
    });
    var _schema = require_schema();
    var _utils = require_utils();
  }
});

// node_modules/@atlaskit/editor-json-transformer/dist/cjs/markOverrideRules.js
var require_markOverrideRules = __commonJS({
  "node_modules/@atlaskit/editor-json-transformer/dist/cjs/markOverrideRules.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.markOverrideRuleFor = void 0;
    var defaultAllowOverrideBehaviour = {
      canOverrideUnsupportedMark: function canOverrideUnsupportedMark() {
        return true;
      }
    };
    var defaultDoNotAllowOverrideBehaviour = {
      canOverrideUnsupportedMark: function canOverrideUnsupportedMark() {
        return false;
      }
    };
    var markOverrideRuleFor = exports2.markOverrideRuleFor = function markOverrideRuleFor2(type) {
      switch (type) {
        case "link":
        case "em":
        case "strong":
        case "strike":
        case "subsup":
        case "underline":
        case "code":
        case "textColor":
        case "backgroundColor":
        case "confluenceInlineComment":
        case "breakout":
        case "alignment":
        case "indentation":
        case "border":
          return defaultAllowOverrideBehaviour;
        default:
          return defaultDoNotAllowOverrideBehaviour;
      }
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/traverse/traverse.js
var require_traverse = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/traverse/traverse.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.traverse = traverse;
    exports2.validateVisitors = validateVisitors;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    function validateVisitors(_visitors) {
      return true;
    }
    function traverse(adf, visitors) {
      if (!validateVisitors(visitors)) {
        throw new Error('Visitors are not valid: "'.concat(Object.keys(visitors).join(", "), '"'));
      }
      return traverseNode(adf, {
        node: void 0
      }, visitors, 0, 0);
    }
    function traverseNode(adfNode, parent, visitors, index, depth) {
      var visitor = visitors[adfNode.type] || visitors["any"];
      var newNode = _objectSpread({}, adfNode);
      if (visitor) {
        var processedNode = visitor(_objectSpread({}, newNode), parent, index, depth);
        if (processedNode === false) {
          return false;
        }
        newNode = processedNode || adfNode;
      }
      if (newNode.content) {
        newNode.content = newNode.content.reduce(function(acc, node, idx) {
          if (!node) {
            return acc;
          }
          var processedNode2 = traverseNode(node, {
            node: newNode,
            parent
          }, visitors, idx, depth + 1);
          if (processedNode2 !== false) {
            acc.push(processedNode2);
          }
          return acc;
        }, []);
      }
      return newNode;
    }
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/transforms/media-link-transform.js
var require_media_link_transform = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/transforms/media-link-transform.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.transformMediaLinkMarks = void 0;
    var _traverse = require_traverse();
    var transformMediaLinkMarks = exports2.transformMediaLinkMarks = function transformMediaLinkMarks2(adf) {
      var isTransformed = false;
      var transformedAdf = (0, _traverse.traverse)(adf, {
        mediaSingle: function mediaSingle(node) {
          var _node$content$;
          if (!node.marks || !node.content || ((_node$content$ = node.content[0]) === null || _node$content$ === void 0 ? void 0 : _node$content$.type) !== "media") {
            return node;
          }
          var linkMark = null;
          node.marks.forEach(function(mark, i) {
            if (mark.type === "link") {
              var _node$marks;
              linkMark = mark;
              (_node$marks = node.marks) === null || _node$marks === void 0 || _node$marks.splice(i, 1);
              isTransformed = true;
            }
          });
          if (node.marks.length === 0) {
            delete node.marks;
          }
          if (linkMark) {
            var _mediaNode$marks;
            var mediaNode = node.content[0];
            if ((_mediaNode$marks = mediaNode.marks) !== null && _mediaNode$marks !== void 0 && _mediaNode$marks.every(function(mark) {
              return mark.type !== "link";
            })) {
              mediaNode.marks.push(linkMark);
            } else if (!mediaNode.marks) {
              mediaNode.marks = [linkMark];
            }
          }
          return node;
        }
      });
      return {
        transformedAdf,
        isTransformed
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/transforms/text-link-code-transform.js
var require_text_link_code_transform = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/transforms/text-link-code-transform.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.transformTextLinkCodeMarks = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _traverse = require_traverse();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var hasLinkAndCodeMarks = function hasLinkAndCodeMarks2(node) {
      var _node$marks;
      var marks = (_node$marks = node.marks) === null || _node$marks === void 0 ? void 0 : _node$marks.map(function(mark) {
        return mark.type;
      });
      return (marks === null || marks === void 0 ? void 0 : marks.includes("link")) && (marks === null || marks === void 0 ? void 0 : marks.includes("code"));
    };
    var removeCodeMarks = function removeCodeMarks2(node) {
      if (node.marks) {
        return _objectSpread(_objectSpread({}, node), {}, {
          marks: node.marks.filter(function(mark) {
            return mark.type !== "code";
          })
        });
      }
      return node;
    };
    var transformTextLinkCodeMarks = exports2.transformTextLinkCodeMarks = function transformTextLinkCodeMarks2(adf) {
      var isTransformed = false;
      var transformedAdf = (0, _traverse.traverse)(adf, {
        text: function text(node) {
          if (hasLinkAndCodeMarks(node)) {
            isTransformed = true;
            return removeCodeMarks(node);
          }
          return;
        }
      });
      return {
        transformedAdf,
        isTransformed
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/transforms/dedupe-marks-transform.js
var require_dedupe_marks_transform = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/transforms/dedupe-marks-transform.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.transformDedupeMarks = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _traverse = require_traverse();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var markDuplicatesDisallowed = /* @__PURE__ */ new Set(["strong", "underline", "textColor", "link", "em", "subsup", "strike", "backgroundColor"]);
    var maybeHasDisallowedDuplicateMarks = function maybeHasDisallowedDuplicateMarks2(node) {
      var _node$marks;
      var markTypes = (_node$marks = node.marks) === null || _node$marks === void 0 || (_node$marks = _node$marks.map(function(mark) {
        return mark.type;
      })) === null || _node$marks === void 0 ? void 0 : _node$marks.filter(function(markType) {
        return (
          // For annotations, we are performing the same cheap check
          // for duplicates by type, without considering IDs, to quickly determine
          // whether there may be potential deduping targets.
          // In the actual deduping logic in maybeRemoveDisallowedDuplicateMarks,
          // we correctly/safely dedupe annotations by their unique IDs.
          markDuplicatesDisallowed.has(markType) || markType === "annotation"
        );
      });
      if (!(markTypes !== null && markTypes !== void 0 && markTypes.length)) {
        return false;
      }
      return new Set(markTypes).size !== markTypes.length;
    };
    var maybeRemoveDisallowedDuplicateMarks = function maybeRemoveDisallowedDuplicateMarks2(node) {
      var quota = /* @__PURE__ */ new Map();
      var annotationsQuota = /* @__PURE__ */ new Map();
      var discardedMarks = [];
      markDuplicatesDisallowed.forEach(function(mark) {
        quota.set(mark, false);
      });
      if (!node.marks) {
        return {
          discardedMarks
        };
      }
      var dedupedMarks = node.marks.filter(function(mark) {
        var markType = mark.type;
        if (markType === "annotation") {
          var _mark$attrs;
          var id = (_mark$attrs = mark.attrs) === null || _mark$attrs === void 0 ? void 0 : _mark$attrs.id;
          if (annotationsQuota.has(id)) {
            discardedMarks.push(mark);
            return false;
          } else {
            annotationsQuota.set(id, true);
            return true;
          }
        }
        if (quota.has(markType)) {
          if (!quota.get(markType)) {
            quota.set(markType, true);
            return true;
          } else {
            discardedMarks.push(mark);
            return false;
          }
        }
        return true;
      });
      return {
        node: _objectSpread(_objectSpread({}, node), {}, {
          marks: dedupedMarks
        }),
        discardedMarks
      };
    };
    var transformDedupeMarks = exports2.transformDedupeMarks = function transformDedupeMarks2(adf) {
      var isTransformed = false;
      var discardedMarks = [];
      var transformedAdf = (0, _traverse.traverse)(adf, {
        text: function text(node) {
          if (maybeHasDisallowedDuplicateMarks(node)) {
            var result = maybeRemoveDisallowedDuplicateMarks(node);
            var resultDiscardedMarks = result.discardedMarks;
            if (resultDiscardedMarks.length) {
              discardedMarks.push.apply(discardedMarks, (0, _toConsumableArray2.default)(resultDiscardedMarks));
              isTransformed = true;
              return result.node;
            }
          }
          return;
        }
      });
      return {
        transformedAdf,
        isTransformed,
        discardedMarks
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/utils/is-duplicate-mark.js
var require_is_duplicate_mark = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/utils/is-duplicate-mark.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.duplicateMarkError = duplicateMarkError;
    exports2.isDuplicateMark = isDuplicateMark;
    function isDuplicateMark(node, type) {
      if (node.marks && node.marks.some(function(mark) {
        return mark.type === type;
      })) {
        return true;
      }
      return false;
    }
    function duplicateMarkError(node, type) {
      return "Mark with the same name '".concat(type, "' already exists on a node: ").concat(JSON.stringify(node));
    }
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/text.js
var require_text3 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/text.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.text = void 0;
    var text = exports2.text = function text2(_text) {
      return {
        type: "text",
        text: _text
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/utils/apply-mark.js
var require_apply_mark = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/utils/apply-mark.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.applyMark = applyMark;
    var _isDuplicateMark = require_is_duplicate_mark();
    var _text = require_text3();
    function applyMark(mark, maybeNode) {
      var node = typeof maybeNode === "string" ? (0, _text.text)(maybeNode) : maybeNode;
      if ((0, _isDuplicateMark.isDuplicateMark)(node, mark.type)) {
        console.error((0, _isDuplicateMark.duplicateMarkError)(node, mark.type));
        return node;
      }
      node.marks = node.marks || [];
      node.marks.push(mark);
      return node;
    }
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/breakout.js
var require_breakout2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/breakout.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.breakout = void 0;
    var _applyMark = require_apply_mark();
    var breakout = exports2.breakout = function breakout2(attrs) {
      return function(maybeNode) {
        return (0, _applyMark.applyMark)({
          type: "breakout",
          attrs
        }, maybeNode);
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/code.js
var require_code3 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/code.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.code = void 0;
    var _applyMark = require_apply_mark();
    var code = exports2.code = function code2(maybeNode) {
      return (0, _applyMark.applyMark)({
        type: "code"
      }, maybeNode);
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/em.js
var require_em2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/em.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.em = void 0;
    var _applyMark = require_apply_mark();
    var em = exports2.em = function em2(maybeNode) {
      return (0, _applyMark.applyMark)({
        type: "em"
      }, maybeNode);
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/link.js
var require_link3 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/link.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.link = void 0;
    var _applyMark = require_apply_mark();
    var link = exports2.link = function link2(attrs) {
      return function(maybeNode) {
        return (0, _applyMark.applyMark)({
          type: "link",
          attrs
        }, maybeNode);
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/strike.js
var require_strike2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/strike.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.strike = void 0;
    var _applyMark = require_apply_mark();
    var strike = exports2.strike = function strike2(maybeNode) {
      return (0, _applyMark.applyMark)({
        type: "strike"
      }, maybeNode);
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/strong.js
var require_strong2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/strong.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.strong = void 0;
    var _applyMark = require_apply_mark();
    var strong = exports2.strong = function strong2(maybeNode) {
      return (0, _applyMark.applyMark)({
        type: "strong"
      }, maybeNode);
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/subsup.js
var require_subsup2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/subsup.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.subsup = void 0;
    var _applyMark = require_apply_mark();
    var subsup = exports2.subsup = function subsup2(attrs) {
      return function(maybeNode) {
        return (0, _applyMark.applyMark)({
          type: "subsup",
          attrs
        }, maybeNode);
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/text-color.js
var require_text_color2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/text-color.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.textColor = void 0;
    var _applyMark = require_apply_mark();
    var textColor = exports2.textColor = function textColor2(attrs) {
      return function(maybeNode) {
        return (0, _applyMark.applyMark)({
          type: "textColor",
          attrs
        }, maybeNode);
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/underline.js
var require_underline2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/underline.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.underline = void 0;
    var _applyMark = require_apply_mark();
    var underline = exports2.underline = function underline2(maybeNode) {
      return (0, _applyMark.applyMark)({
        type: "underline"
      }, maybeNode);
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/alignment.js
var require_alignment2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/alignment.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.alignment = void 0;
    var _applyMark = require_apply_mark();
    var alignment = exports2.alignment = function alignment2(attrs) {
      return function(maybeNode) {
        return (0, _applyMark.applyMark)({
          type: "alignment",
          attrs
        }, maybeNode);
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/indentation.js
var require_indentation2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/indentation.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.indentation = void 0;
    var _applyMark = require_apply_mark();
    var indentation = exports2.indentation = function indentation2(attrs) {
      return function(maybeNode) {
        return (0, _applyMark.applyMark)({
          type: "indentation",
          attrs
        }, maybeNode);
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/data-consumer.js
var require_data_consumer2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/data-consumer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.dataConsumer = void 0;
    var _applyMark = require_apply_mark();
    var dataConsumer = exports2.dataConsumer = function dataConsumer2(attrs) {
      return function(maybeNode) {
        return (0, _applyMark.applyMark)({
          type: "dataConsumer",
          attrs
        }, maybeNode);
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/fragment.js
var require_fragment2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/fragment.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.fragment = void 0;
    var _applyMark = require_apply_mark();
    var fragment = exports2.fragment = function fragment2(attrs) {
      return function(maybeNode) {
        return (0, _applyMark.applyMark)({
          type: "fragment",
          attrs
        }, maybeNode);
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/border.js
var require_border2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/border.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.border = void 0;
    var _applyMark = require_apply_mark();
    var border = exports2.border = function border2(attrs) {
      return function(maybeNode) {
        return (0, _applyMark.applyMark)({
          type: "border",
          attrs
        }, maybeNode);
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/background-color.js
var require_background_color2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/marks/background-color.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.backgroundColor = void 0;
    var _applyMark = require_apply_mark();
    var backgroundColor = exports2.backgroundColor = function backgroundColor2(attrs) {
      return function(maybeNode) {
        return (0, _applyMark.applyMark)({
          type: "backgroundColor",
          attrs
        }, maybeNode);
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/blockquote.js
var require_blockquote3 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/blockquote.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.blockQuote = void 0;
    var blockQuote = exports2.blockQuote = function blockQuote2() {
      for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
        content[_key] = arguments[_key];
      }
      return {
        type: "blockquote",
        content
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/bodied-extension.js
var require_bodied_extension2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/bodied-extension.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.bodiedExtension = void 0;
    var bodiedExtension = exports2.bodiedExtension = function bodiedExtension2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "bodiedExtension",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/block-card.js
var require_block_card2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/block-card.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.blockCard = void 0;
    var blockCard = exports2.blockCard = function blockCard2(attrs) {
      return {
        type: "blockCard",
        attrs
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/bullet-list.js
var require_bullet_list2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/bullet-list.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.bulletList = void 0;
    var bulletList = exports2.bulletList = function bulletList2() {
      for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
        content[_key] = arguments[_key];
      }
      return {
        type: "bulletList",
        content
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/code-block.js
var require_code_block2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/code-block.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.codeBlock = void 0;
    var codeBlock = exports2.codeBlock = function codeBlock2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "codeBlock",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/date.js
var require_date2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/date.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.date = void 0;
    var date = exports2.date = function date2() {
      var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
        timestamp: ""
      };
      return {
        type: "date",
        attrs
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/decision-item.js
var require_decision_item2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/decision-item.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.decisionItem = void 0;
    var decisionItem = exports2.decisionItem = function decisionItem2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "decisionItem",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/decision-list.js
var require_decision_list2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/decision-list.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.decisionList = void 0;
    var decisionList = exports2.decisionList = function decisionList2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "decisionList",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/doc.js
var require_doc2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/doc.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.doc = void 0;
    var doc = exports2.doc = function doc2() {
      for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
        content[_key] = arguments[_key];
      }
      return {
        type: "doc",
        version: 1,
        content
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/emoji.js
var require_emoji3 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/emoji.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.emoji = void 0;
    var emoji = exports2.emoji = function emoji2(attrs, options) {
      if (options !== null && options !== void 0 && options.marks) {
        return {
          type: "emoji",
          attrs,
          marks: options === null || options === void 0 ? void 0 : options.marks
        };
      }
      return {
        type: "emoji",
        attrs
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/extension.js
var require_extension2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/extension.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.extension = void 0;
    var extension = exports2.extension = function extension2(attrs) {
      return {
        type: "extension",
        attrs
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/expand.js
var require_expand2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/expand.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.expand = void 0;
    var expand = exports2.expand = function expand2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "expand",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/nested-expand.js
var require_nested_expand2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/nested-expand.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.nestedExpand = void 0;
    var nestedExpand = exports2.nestedExpand = function nestedExpand2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "nestedExpand",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/hard-break.js
var require_hard_break2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/hard-break.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.hardBreak = void 0;
    var hardBreak = exports2.hardBreak = function hardBreak2(attrs) {
      return {
        type: "hardBreak",
        attrs
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/heading.js
var require_heading3 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/heading.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.heading = void 0;
    var heading = exports2.heading = function heading2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "heading",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/inline-extension.js
var require_inline_extension2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/inline-extension.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.inlineExtension = void 0;
    var inlineExtension = exports2.inlineExtension = function inlineExtension2(attrs) {
      return function() {
        return {
          type: "inlineExtension",
          attrs
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/inline-card.js
var require_inline_card2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/inline-card.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.inlineCard = void 0;
    var inlineCard = exports2.inlineCard = function inlineCard2(attrs) {
      return {
        type: "inlineCard",
        attrs
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/layout-column.js
var require_layout_column2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/layout-column.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.layoutColumn = void 0;
    var layoutColumn = exports2.layoutColumn = function layoutColumn2(attrs) {
      return function(content) {
        return {
          type: "layoutColumn",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/layout-section.js
var require_layout_section2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/layout-section.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.layoutSection = void 0;
    var layoutSection = exports2.layoutSection = function layoutSection2() {
      return function(content) {
        return {
          type: "layoutSection",
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/list-item.js
var require_list_item2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/list-item.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.listItem = void 0;
    var listItem = exports2.listItem = function listItem2(content) {
      return {
        type: "listItem",
        content
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/media-group.js
var require_media_group2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/media-group.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.mediaGroup = void 0;
    var mediaGroup = exports2.mediaGroup = function mediaGroup2() {
      for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
        content[_key] = arguments[_key];
      }
      return {
        type: "mediaGroup",
        content
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/media-single.js
var require_media_single2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/media-single.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.mediaSingle = void 0;
    var mediaSingle = exports2.mediaSingle = function mediaSingle2(attrs) {
      return function(content) {
        return {
          type: "mediaSingle",
          attrs,
          content: Array.isArray(content) ? content : [content]
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/media.js
var require_media3 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/media.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.media = void 0;
    var media = exports2.media = function media2(attrs) {
      return {
        type: "media",
        attrs
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/mention.js
var require_mention2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/mention.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.mention = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var mention = exports2.mention = function mention2(attrs) {
      return {
        type: "mention",
        attrs: _objectSpread({
          accessLevel: ""
        }, attrs)
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/ordered-list.js
var require_ordered_list2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/ordered-list.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.orderedList = void 0;
    var orderedList = exports2.orderedList = function orderedList2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "orderedList",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/panel.js
var require_panel2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/panel.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.panel = void 0;
    var panel = exports2.panel = function panel2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "panel",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/utils/create-text-nodes.js
var require_create_text_nodes = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/utils/create-text-nodes.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.createTextFromString = createTextFromString;
    exports2.createTextNodes = createTextNodes;
    var _text = require_text3();
    function createTextNodes(nodes) {
      return nodes.map(createTextFromString);
    }
    function createTextFromString(str) {
      return typeof str === "string" ? (0, _text.text)(str) : str;
    }
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/paragraph.js
var require_paragraph3 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/paragraph.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.paragraph = void 0;
    var _createTextNodes = require_create_text_nodes();
    var paragraph = exports2.paragraph = function paragraph2() {
      for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
        content[_key] = arguments[_key];
      }
      return {
        type: "paragraph",
        content: (0, _createTextNodes.createTextNodes)(content)
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/placeholder.js
var require_placeholder2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/placeholder.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.placeholder = void 0;
    var placeholder = exports2.placeholder = function placeholder2(attrs) {
      return {
        type: "placeholder",
        attrs
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/rule.js
var require_rule2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/rule.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.rule = void 0;
    var rule = exports2.rule = function rule2() {
      return {
        type: "rule"
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/status.js
var require_status2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/status.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.status = void 0;
    var status = exports2.status = function status2() {
      var attrs = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
        text: "In progress",
        color: "blue"
      };
      return {
        type: "status",
        attrs
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/table-cell.js
var require_table_cell = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/table-cell.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.tableCell = void 0;
    var tableCell = exports2.tableCell = function tableCell2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "tableCell",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/table-header.js
var require_table_header = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/table-header.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.tableHeader = void 0;
    var tableHeader = exports2.tableHeader = function tableHeader2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "tableHeader",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/table-row.js
var require_table_row = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/table-row.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.tableRow = void 0;
    var tableRow = exports2.tableRow = function tableRow2(content) {
      return {
        type: "tableRow",
        content
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/table.js
var require_table3 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/table.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.table = void 0;
    var table = exports2.table = function table2() {
      for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
        content[_key] = arguments[_key];
      }
      return {
        type: "table",
        content
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/task-item.js
var require_task_item2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/task-item.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.taskItem = void 0;
    var taskItem = exports2.taskItem = function taskItem2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "taskItem",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/task-list.js
var require_task_list2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/task-list.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.taskList = void 0;
    var taskList = exports2.taskList = function taskList2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "taskList",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/embed-card.js
var require_embed_card2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/embed-card.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.embedCard = void 0;
    var embedCard = exports2.embedCard = function embedCard2(attrs) {
      return {
        type: "embedCard",
        attrs
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/block-task-item.js
var require_block_task_item = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders/nodes/block-task-item.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.blockTaskItem = void 0;
    var blockTaskItem = exports2.blockTaskItem = function blockTaskItem2(attrs) {
      return function() {
        for (var _len = arguments.length, content = new Array(_len), _key = 0; _key < _len; _key++) {
          content[_key] = arguments[_key];
        }
        return {
          type: "blockTaskItem",
          attrs,
          content
        };
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/builders.js
var require_builders = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/builders.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "a", {
      enumerable: true,
      get: function get() {
        return _link.link;
      }
    });
    Object.defineProperty(exports2, "alignment", {
      enumerable: true,
      get: function get() {
        return _alignment.alignment;
      }
    });
    Object.defineProperty(exports2, "b", {
      enumerable: true,
      get: function get() {
        return _strong.strong;
      }
    });
    Object.defineProperty(exports2, "backgroundColor", {
      enumerable: true,
      get: function get() {
        return _backgroundColor.backgroundColor;
      }
    });
    Object.defineProperty(exports2, "blockCard", {
      enumerable: true,
      get: function get() {
        return _blockCard.blockCard;
      }
    });
    Object.defineProperty(exports2, "blockQuote", {
      enumerable: true,
      get: function get() {
        return _blockquote.blockQuote;
      }
    });
    Object.defineProperty(exports2, "blockTaskItem", {
      enumerable: true,
      get: function get() {
        return _blockTaskItem.blockTaskItem;
      }
    });
    Object.defineProperty(exports2, "bodiedExtension", {
      enumerable: true,
      get: function get() {
        return _bodiedExtension.bodiedExtension;
      }
    });
    Object.defineProperty(exports2, "border", {
      enumerable: true,
      get: function get() {
        return _border.border;
      }
    });
    Object.defineProperty(exports2, "br", {
      enumerable: true,
      get: function get() {
        return _hardBreak.hardBreak;
      }
    });
    Object.defineProperty(exports2, "breakout", {
      enumerable: true,
      get: function get() {
        return _breakout.breakout;
      }
    });
    Object.defineProperty(exports2, "bulletList", {
      enumerable: true,
      get: function get() {
        return _bulletList.bulletList;
      }
    });
    Object.defineProperty(exports2, "code", {
      enumerable: true,
      get: function get() {
        return _code.code;
      }
    });
    Object.defineProperty(exports2, "codeBlock", {
      enumerable: true,
      get: function get() {
        return _codeBlock.codeBlock;
      }
    });
    Object.defineProperty(exports2, "dataConsumer", {
      enumerable: true,
      get: function get() {
        return _dataConsumer.dataConsumer;
      }
    });
    Object.defineProperty(exports2, "date", {
      enumerable: true,
      get: function get() {
        return _date.date;
      }
    });
    Object.defineProperty(exports2, "decisionItem", {
      enumerable: true,
      get: function get() {
        return _decisionItem.decisionItem;
      }
    });
    Object.defineProperty(exports2, "decisionList", {
      enumerable: true,
      get: function get() {
        return _decisionList.decisionList;
      }
    });
    Object.defineProperty(exports2, "doc", {
      enumerable: true,
      get: function get() {
        return _doc.doc;
      }
    });
    Object.defineProperty(exports2, "em", {
      enumerable: true,
      get: function get() {
        return _em.em;
      }
    });
    Object.defineProperty(exports2, "embedCard", {
      enumerable: true,
      get: function get() {
        return _embedCard.embedCard;
      }
    });
    Object.defineProperty(exports2, "emoji", {
      enumerable: true,
      get: function get() {
        return _emoji.emoji;
      }
    });
    Object.defineProperty(exports2, "expand", {
      enumerable: true,
      get: function get() {
        return _expand.expand;
      }
    });
    Object.defineProperty(exports2, "extension", {
      enumerable: true,
      get: function get() {
        return _extension.extension;
      }
    });
    Object.defineProperty(exports2, "fragment", {
      enumerable: true,
      get: function get() {
        return _fragment.fragment;
      }
    });
    Object.defineProperty(exports2, "hardBreak", {
      enumerable: true,
      get: function get() {
        return _hardBreak.hardBreak;
      }
    });
    Object.defineProperty(exports2, "heading", {
      enumerable: true,
      get: function get() {
        return _heading.heading;
      }
    });
    Object.defineProperty(exports2, "hr", {
      enumerable: true,
      get: function get() {
        return _rule.rule;
      }
    });
    Object.defineProperty(exports2, "indentation", {
      enumerable: true,
      get: function get() {
        return _indentation.indentation;
      }
    });
    Object.defineProperty(exports2, "inlineCard", {
      enumerable: true,
      get: function get() {
        return _inlineCard.inlineCard;
      }
    });
    Object.defineProperty(exports2, "inlineExtension", {
      enumerable: true,
      get: function get() {
        return _inlineExtension.inlineExtension;
      }
    });
    Object.defineProperty(exports2, "layoutColumn", {
      enumerable: true,
      get: function get() {
        return _layoutColumn.layoutColumn;
      }
    });
    Object.defineProperty(exports2, "layoutSection", {
      enumerable: true,
      get: function get() {
        return _layoutSection.layoutSection;
      }
    });
    Object.defineProperty(exports2, "li", {
      enumerable: true,
      get: function get() {
        return _listItem.listItem;
      }
    });
    Object.defineProperty(exports2, "link", {
      enumerable: true,
      get: function get() {
        return _link.link;
      }
    });
    Object.defineProperty(exports2, "listItem", {
      enumerable: true,
      get: function get() {
        return _listItem.listItem;
      }
    });
    Object.defineProperty(exports2, "media", {
      enumerable: true,
      get: function get() {
        return _media.media;
      }
    });
    Object.defineProperty(exports2, "mediaGroup", {
      enumerable: true,
      get: function get() {
        return _mediaGroup.mediaGroup;
      }
    });
    Object.defineProperty(exports2, "mediaSingle", {
      enumerable: true,
      get: function get() {
        return _mediaSingle.mediaSingle;
      }
    });
    Object.defineProperty(exports2, "mention", {
      enumerable: true,
      get: function get() {
        return _mention.mention;
      }
    });
    Object.defineProperty(exports2, "nestedExpand", {
      enumerable: true,
      get: function get() {
        return _nestedExpand.nestedExpand;
      }
    });
    Object.defineProperty(exports2, "ol", {
      enumerable: true,
      get: function get() {
        return _orderedList.orderedList;
      }
    });
    Object.defineProperty(exports2, "orderedList", {
      enumerable: true,
      get: function get() {
        return _orderedList.orderedList;
      }
    });
    Object.defineProperty(exports2, "p", {
      enumerable: true,
      get: function get() {
        return _paragraph.paragraph;
      }
    });
    Object.defineProperty(exports2, "panel", {
      enumerable: true,
      get: function get() {
        return _panel.panel;
      }
    });
    Object.defineProperty(exports2, "paragraph", {
      enumerable: true,
      get: function get() {
        return _paragraph.paragraph;
      }
    });
    Object.defineProperty(exports2, "placeholder", {
      enumerable: true,
      get: function get() {
        return _placeholder.placeholder;
      }
    });
    Object.defineProperty(exports2, "rule", {
      enumerable: true,
      get: function get() {
        return _rule.rule;
      }
    });
    Object.defineProperty(exports2, "status", {
      enumerable: true,
      get: function get() {
        return _status.status;
      }
    });
    Object.defineProperty(exports2, "strike", {
      enumerable: true,
      get: function get() {
        return _strike.strike;
      }
    });
    Object.defineProperty(exports2, "strong", {
      enumerable: true,
      get: function get() {
        return _strong.strong;
      }
    });
    Object.defineProperty(exports2, "subsup", {
      enumerable: true,
      get: function get() {
        return _subsup.subsup;
      }
    });
    Object.defineProperty(exports2, "table", {
      enumerable: true,
      get: function get() {
        return _table.table;
      }
    });
    Object.defineProperty(exports2, "tableCell", {
      enumerable: true,
      get: function get() {
        return _tableCell.tableCell;
      }
    });
    Object.defineProperty(exports2, "tableHeader", {
      enumerable: true,
      get: function get() {
        return _tableHeader.tableHeader;
      }
    });
    Object.defineProperty(exports2, "tableRow", {
      enumerable: true,
      get: function get() {
        return _tableRow.tableRow;
      }
    });
    Object.defineProperty(exports2, "taskItem", {
      enumerable: true,
      get: function get() {
        return _taskItem.taskItem;
      }
    });
    Object.defineProperty(exports2, "taskList", {
      enumerable: true,
      get: function get() {
        return _taskList.taskList;
      }
    });
    Object.defineProperty(exports2, "td", {
      enumerable: true,
      get: function get() {
        return _tableCell.tableCell;
      }
    });
    Object.defineProperty(exports2, "text", {
      enumerable: true,
      get: function get() {
        return _text.text;
      }
    });
    Object.defineProperty(exports2, "textColor", {
      enumerable: true,
      get: function get() {
        return _textColor.textColor;
      }
    });
    Object.defineProperty(exports2, "th", {
      enumerable: true,
      get: function get() {
        return _tableHeader.tableHeader;
      }
    });
    Object.defineProperty(exports2, "tr", {
      enumerable: true,
      get: function get() {
        return _tableRow.tableRow;
      }
    });
    Object.defineProperty(exports2, "u", {
      enumerable: true,
      get: function get() {
        return _underline.underline;
      }
    });
    Object.defineProperty(exports2, "ul", {
      enumerable: true,
      get: function get() {
        return _bulletList.bulletList;
      }
    });
    Object.defineProperty(exports2, "underline", {
      enumerable: true,
      get: function get() {
        return _underline.underline;
      }
    });
    var _breakout = require_breakout2();
    var _code = require_code3();
    var _em = require_em2();
    var _link = require_link3();
    var _strike = require_strike2();
    var _strong = require_strong2();
    var _subsup = require_subsup2();
    var _textColor = require_text_color2();
    var _underline = require_underline2();
    var _alignment = require_alignment2();
    var _indentation = require_indentation2();
    var _dataConsumer = require_data_consumer2();
    var _fragment = require_fragment2();
    var _border = require_border2();
    var _backgroundColor = require_background_color2();
    var _blockquote = require_blockquote3();
    var _bodiedExtension = require_bodied_extension2();
    var _blockCard = require_block_card2();
    var _bulletList = require_bullet_list2();
    var _codeBlock = require_code_block2();
    var _date = require_date2();
    var _decisionItem = require_decision_item2();
    var _decisionList = require_decision_list2();
    var _doc = require_doc2();
    var _emoji = require_emoji3();
    var _extension = require_extension2();
    var _expand = require_expand2();
    var _nestedExpand = require_nested_expand2();
    var _hardBreak = require_hard_break2();
    var _heading = require_heading3();
    var _inlineExtension = require_inline_extension2();
    var _inlineCard = require_inline_card2();
    var _layoutColumn = require_layout_column2();
    var _layoutSection = require_layout_section2();
    var _listItem = require_list_item2();
    var _mediaGroup = require_media_group2();
    var _mediaSingle = require_media_single2();
    var _media = require_media3();
    var _mention = require_mention2();
    var _orderedList = require_ordered_list2();
    var _panel = require_panel2();
    var _paragraph = require_paragraph3();
    var _placeholder = require_placeholder2();
    var _rule = require_rule2();
    var _status = require_status2();
    var _tableCell = require_table_cell();
    var _tableHeader = require_table_header();
    var _tableRow = require_table_row();
    var _table = require_table3();
    var _taskItem = require_task_item2();
    var _taskList = require_task_list2();
    var _text = require_text3();
    var _embedCard = require_embed_card2();
    var _blockTaskItem = require_block_task_item();
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/transforms/helpers.js
var require_helpers2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/transforms/helpers.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.isEmpty = void 0;
    var isEmpty = exports2.isEmpty = function isEmpty2(node) {
      var _node$content;
      return !(node !== null && node !== void 0 && (_node$content = node.content) !== null && _node$content !== void 0 && _node$content.length);
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/transforms/nodes-missing-content-transform.js
var require_nodes_missing_content_transform = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/transforms/nodes-missing-content-transform.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.transformNodesMissingContent = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _traverse = require_traverse();
    var _builders = require_builders();
    var _helpers = require_helpers2();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var getMaxColumnsCountForTable = function getMaxColumnsCountForTable2(tableNode) {
      var _tableNode$content;
      var colsInRow = 1;
      (_tableNode$content = tableNode.content) === null || _tableNode$content === void 0 || _tableNode$content.forEach(function(childNode) {
        var _childNode$content;
        if ((childNode === null || childNode === void 0 ? void 0 : childNode.type) === "tableRow" && typeof ((_childNode$content = childNode.content) === null || _childNode$content === void 0 ? void 0 : _childNode$content.length) === "number" && childNode.content.length > colsInRow) {
          colsInRow = childNode.content.length;
        }
      });
      return colsInRow;
    };
    var createValidEmptyContent = function createValidEmptyContent2(node) {
      switch (node.type) {
        case "tableCell":
          return [(0, _builders.paragraph)()];
        default:
          return [];
      }
    };
    var fixIfTableCellInvalidEmpty = function fixIfTableCellInvalidEmpty2(reportTransform) {
      return function(node) {
        if ((0, _helpers.isEmpty)(node)) {
          reportTransform();
          return _objectSpread(_objectSpread({}, node), {}, {
            content: createValidEmptyContent(node)
          });
        }
        return;
      };
    };
    var hasNonListItemChildren = function hasNonListItemChildren2(node) {
      var _node$content;
      return (_node$content = node.content) === null || _node$content === void 0 ? void 0 : _node$content.some(function(node2) {
        return (node2 === null || node2 === void 0 ? void 0 : node2.type) !== "listItem";
      });
    };
    var hasEmptyListItemChildren = function hasEmptyListItemChildren2(node) {
      var _node$content2;
      return (_node$content2 = node.content) === null || _node$content2 === void 0 ? void 0 : _node$content2.some(function(childNode) {
        var _childNode$content2;
        return (childNode === null || childNode === void 0 ? void 0 : childNode.type) === "listItem" && !((_childNode$content2 = childNode.content) !== null && _childNode$content2 !== void 0 && _childNode$content2.length);
      });
    };
    var tryCreateValidListItemWrappedChildren = function tryCreateValidListItemWrappedChildren2(parentListNode) {
      var _parentListNode$conte;
      return (_parentListNode$conte = parentListNode.content) === null || _parentListNode$conte === void 0 ? void 0 : _parentListNode$conte.map(function(childNode) {
        if (childNode) {
          switch (childNode.type) {
            case "listItem": {
              if ((0, _helpers.isEmpty)(childNode)) {
                var result = (0, _builders.listItem)([(0, _builders.paragraph)()]);
                return result;
              }
              return childNode;
            }
            case "text":
              return (0, _builders.listItem)([(0, _builders.paragraph)(childNode)]);
            default:
              return (0, _builders.listItem)([childNode]);
          }
        }
        return childNode;
      });
    };
    var fixIfListParentWithInvalidListItemChildren = function fixIfListParentWithInvalidListItemChildren2(reportTransform) {
      return function(node) {
        if (hasNonListItemChildren(node) || hasEmptyListItemChildren(node)) {
          reportTransform();
          return _objectSpread(_objectSpread({}, node), {}, {
            content: tryCreateValidListItemWrappedChildren(node)
          });
        }
        return;
      };
    };
    var hasNonTableRowChildren = function hasNonTableRowChildren2(node) {
      var _node$content3;
      return (_node$content3 = node.content) === null || _node$content3 === void 0 ? void 0 : _node$content3.some(function(node2) {
        return (node2 === null || node2 === void 0 ? void 0 : node2.type) !== "tableRow";
      });
    };
    var tryCreateValidTableRowWrappedChildren = function tryCreateValidTableRowWrappedChildren2(parentTableNode) {
      var _parentTableNode$cont;
      var maxColsCount = getMaxColumnsCountForTable(parentTableNode);
      return (_parentTableNode$cont = parentTableNode.content) === null || _parentTableNode$cont === void 0 ? void 0 : _parentTableNode$cont.map(function(childNode) {
        if (childNode) {
          switch (childNode.type) {
            case "text": {
              return (0, _builders.tableRow)([(0, _builders.tableCell)({})((0, _builders.paragraph)(childNode))].concat((0, _toConsumableArray2.default)(new Array(maxColsCount - 1).fill((0, _builders.tableCell)({})((0, _builders.paragraph)())))));
            }
            case "tableCell": {
              return (0, _builders.tableRow)([childNode]);
            }
            case "tableRow": {
              if ((0, _helpers.isEmpty)(childNode)) {
                return (0, _builders.tableRow)((0, _toConsumableArray2.default)(new Array(maxColsCount).fill((0, _builders.tableCell)({})((0, _builders.paragraph)()))));
              }
              return childNode;
            }
            default:
              return childNode;
          }
        }
        return childNode;
      });
    };
    var hasEmptyTableRowChildren = function hasEmptyTableRowChildren2(node) {
      var _node$content4;
      return (node === null || node === void 0 || (_node$content4 = node.content) === null || _node$content4 === void 0 ? void 0 : _node$content4.some(function(node2) {
        var _node$content5;
        return (node2 === null || node2 === void 0 ? void 0 : node2.type) === "tableRow" && (node2 === null || node2 === void 0 || (_node$content5 = node2.content) === null || _node$content5 === void 0 ? void 0 : _node$content5.length) === 0;
      })) || void 0;
    };
    var fixIfTableParentWithInvalidTableRowChildren = function fixIfTableParentWithInvalidTableRowChildren2(reportTransform) {
      return function(node) {
        if (hasEmptyTableRowChildren(node) || hasNonTableRowChildren(node)) {
          reportTransform();
          return _objectSpread(_objectSpread({}, node), {}, {
            content: tryCreateValidTableRowWrappedChildren(node)
          });
        }
        return;
      };
    };
    var removeMediaSingleWithNoContent = function removeMediaSingleWithNoContent2(reportTransform) {
      return function(node) {
        if ((0, _helpers.isEmpty)(node)) {
          reportTransform();
          return false;
        }
        return;
      };
    };
    var transformNodesMissingContent = exports2.transformNodesMissingContent = function transformNodesMissingContent2(adf) {
      var isTransformed = false;
      var reportTransform = function reportTransform2() {
        isTransformed = true;
      };
      var transformedAdf = (0, _traverse.traverse)(adf, {
        tableCell: fixIfTableCellInvalidEmpty(reportTransform)
      });
      transformedAdf = (0, _traverse.traverse)(transformedAdf || adf, {
        mediaSingle: removeMediaSingleWithNoContent(reportTransform)
      });
      transformedAdf = (0, _traverse.traverse)(transformedAdf || adf, {
        bulletList: fixIfListParentWithInvalidListItemChildren(reportTransform),
        orderedList: fixIfListParentWithInvalidListItemChildren(reportTransform),
        table: fixIfTableParentWithInvalidTableRowChildren(reportTransform)
      });
      return {
        transformedAdf,
        isTransformed
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/transforms/indentation-marks-transform.js
var require_indentation_marks_transform = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/transforms/indentation-marks-transform.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.transformIndentationMarks = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _traverse = require_traverse();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var hasChildHeadingWithIndentation = function hasChildHeadingWithIndentation2(node) {
      var _node$content$some, _node$content;
      return (_node$content$some = (_node$content = node.content) === null || _node$content === void 0 ? void 0 : _node$content.some(function(childNode) {
        var _childNode$marks;
        return (childNode === null || childNode === void 0 ? void 0 : childNode.type) === "heading" && (childNode === null || childNode === void 0 || (_childNode$marks = childNode.marks) === null || _childNode$marks === void 0 ? void 0 : _childNode$marks.some(function(mark) {
          return mark.type === "indentation";
        }));
      })) !== null && _node$content$some !== void 0 ? _node$content$some : false;
    };
    var removeIndentationFromHeadings = function removeIndentationFromHeadings2(node) {
      var _node$content2;
      return _objectSpread(_objectSpread({}, node), {}, {
        content: (_node$content2 = node.content) === null || _node$content2 === void 0 ? void 0 : _node$content2.map(function(childNode) {
          if ((childNode === null || childNode === void 0 ? void 0 : childNode.type) === "heading") {
            var _childNode$marks2;
            return _objectSpread(_objectSpread({}, childNode), {}, {
              marks: (_childNode$marks2 = childNode.marks) === null || _childNode$marks2 === void 0 ? void 0 : _childNode$marks2.filter(function(mark) {
                return mark.type !== "indentation";
              })
            });
          }
          return childNode;
        })
      });
    };
    var transformIndentationMarks = exports2.transformIndentationMarks = function transformIndentationMarks2(adf) {
      var isTransformed = false;
      var transformedAdf = (0, _traverse.traverse)(adf, {
        tableCell: function tableCell(node) {
          if (hasChildHeadingWithIndentation(node)) {
            isTransformed = true;
            return removeIndentationFromHeadings(node);
          }
          return;
        },
        tableHeader: function tableHeader(node) {
          if (hasChildHeadingWithIndentation(node)) {
            isTransformed = true;
            return removeIndentationFromHeadings(node);
          }
          return;
        }
      });
      return {
        transformedAdf,
        isTransformed
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/transforms/invalid-media-content-transform.js
var require_invalid_media_content_transform = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/transforms/invalid-media-content-transform.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.transformInvalidMediaContent = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _traverse = require_traverse();
    var _helpers = require_helpers2();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var getChildrenTypeCounts = function getChildrenTypeCounts2(nodeContent, allowedTypes) {
      var childrenTypes = {};
      nodeContent.forEach(function(childNode) {
        if (!(childNode !== null && childNode !== void 0 && childNode.type) || !allowedTypes.includes(childNode.type)) {
          return;
        }
        if (!childrenTypes[childNode.type]) {
          childrenTypes[childNode.type] = 1;
          return;
        }
        childrenTypes[childNode.type]++;
      });
      return childrenTypes;
    };
    var removeDuplicatedNodes = function removeDuplicatedNodes2(type, content, predicate) {
      var maxIterations = 10;
      var childrenTypeCounts = getChildrenTypeCounts(content, [type])[type];
      var firstPredicateNodeIndex = content.findIndex(predicate);
      while (childrenTypeCounts > 1 && firstPredicateNodeIndex > -1 && maxIterations-- > 0) {
        content.splice(firstPredicateNodeIndex, 1);
        firstPredicateNodeIndex = content.findIndex(predicate);
        childrenTypeCounts = getChildrenTypeCounts(content, [type])[type];
      }
    };
    var deduplicateMediaSingleChildren = function deduplicateMediaSingleChildren2(node, allowedTypes) {
      if (!node.content) {
        return;
      }
      var content = (0, _toConsumableArray2.default)(node.content);
      Object.keys(allowedTypes).forEach(function(type) {
        removeDuplicatedNodes(type, content, function(node2) {
          return (node2 === null || node2 === void 0 ? void 0 : node2.type) === type && (0, _helpers.isEmpty)(node2);
        });
        removeDuplicatedNodes(type, content, function(node2) {
          return (node2 === null || node2 === void 0 ? void 0 : node2.type) === type;
        });
      });
      return _objectSpread(_objectSpread({}, node), {}, {
        content
      });
    };
    var transformInvalidMediaContent = exports2.transformInvalidMediaContent = function transformInvalidMediaContent2(adf) {
      var isTransformed = false;
      var transformedAdf = (0, _traverse.traverse)(adf, {
        mediaSingle: function mediaSingle(node) {
          var _node$content;
          if (!(node !== null && node !== void 0 && (_node$content = node.content) !== null && _node$content !== void 0 && _node$content.length)) {
            return;
          }
          var disallowedDuplicateTypes = ["media", "caption"];
          var childrenTypes = getChildrenTypeCounts(node.content, disallowedDuplicateTypes);
          if (Object.values(childrenTypes).some(function(occurences) {
            return occurences > 1;
          })) {
            isTransformed = true;
            return deduplicateMediaSingleChildren(node, childrenTypes);
          }
          return;
        }
      });
      return {
        transformedAdf,
        isTransformed
      };
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/transforms/errors.js
var require_errors2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/transforms/errors.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.NodeNestingTransformError = void 0;
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _possibleConstructorReturn2 = _interopRequireDefault(require_possibleConstructorReturn());
    var _getPrototypeOf2 = _interopRequireDefault(require_getPrototypeOf());
    var _inherits2 = _interopRequireDefault(require_inherits());
    var _wrapNativeSuper2 = _interopRequireDefault(require_wrapNativeSuper());
    function _callSuper(t, o, e) {
      return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e));
    }
    function _isNativeReflectConstruct() {
      try {
        var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
        }));
      } catch (t2) {
      }
      return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
        return !!t;
      })();
    }
    var NodeNestingTransformError = exports2.NodeNestingTransformError = /* @__PURE__ */ (function(_Error) {
      function NodeNestingTransformError2(message) {
        var _this;
        (0, _classCallCheck2.default)(this, NodeNestingTransformError2);
        _this = _callSuper(this, NodeNestingTransformError2, [message]);
        _this.name = "NodeNestingTransformError";
        return _this;
      }
      (0, _inherits2.default)(NodeNestingTransformError2, _Error);
      return (0, _createClass2.default)(NodeNestingTransformError2);
    })(/* @__PURE__ */ (0, _wrapNativeSuper2.default)(Error));
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/transforms/nested-table-transform.js
var require_nested_table_transform = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/transforms/nested-table-transform.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.transformNestedTablesIncomingDocument = exports2.transformNestedTableNodeOutgoingDocument = exports2.isNestedTableExtension = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _traverse = require_traverse();
    var _builders = require_builders();
    var _errors = require_errors2();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var NESTED_TABLE_EXTENSION_TYPE = "com.atlassian.confluence.migration";
    var NESTED_TABLE_EXTENSION_KEY = "nested-table";
    var isNestedTableExtension = exports2.isNestedTableExtension = function isNestedTableExtension2(extensionNode) {
      var _extensionNode$attrs, _extensionNode$attrs2;
      return ((_extensionNode$attrs = extensionNode.attrs) === null || _extensionNode$attrs === void 0 ? void 0 : _extensionNode$attrs.extensionType) === NESTED_TABLE_EXTENSION_TYPE && ((_extensionNode$attrs2 = extensionNode.attrs) === null || _extensionNode$attrs2 === void 0 ? void 0 : _extensionNode$attrs2.extensionKey) === NESTED_TABLE_EXTENSION_KEY;
    };
    var transformNestedTableExtension = function transformNestedTableExtension2(nestedTableExtension) {
      var _nestedTableExtension;
      if (!((_nestedTableExtension = nestedTableExtension.attrs) !== null && _nestedTableExtension !== void 0 && (_nestedTableExtension = _nestedTableExtension.parameters) !== null && _nestedTableExtension !== void 0 && _nestedTableExtension.adf)) {
        return false;
      }
      try {
        var _nestedTableExtension2;
        var adf = JSON.parse((_nestedTableExtension2 = nestedTableExtension.attrs) === null || _nestedTableExtension2 === void 0 || (_nestedTableExtension2 = _nestedTableExtension2.parameters) === null || _nestedTableExtension2 === void 0 ? void 0 : _nestedTableExtension2.adf);
        if (!adf.content || adf.content.length === 0) {
          return false;
        }
        return adf.content[0];
      } catch (e) {
        throw new _errors.NodeNestingTransformError("Failed to parse nested table content");
      }
    };
    function isInsideBodiedExtension(parent) {
      var _parent$parent;
      if (parent.node === void 0) {
        return false;
      }
      if (parent.node.type === "bodiedExtension") {
        return true;
      }
      if (parent !== null && parent !== void 0 && (_parent$parent = parent.parent) !== null && _parent$parent !== void 0 && _parent$parent.node) {
        return isInsideBodiedExtension(parent.parent);
      }
      return false;
    }
    var transformNestedTablesIncomingDocument = exports2.transformNestedTablesIncomingDocument = function transformNestedTablesIncomingDocument2(adf) {
      var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
      var isTransformed = false;
      var transformedAdf = (0, _traverse.traverse)(adf, {
        extension: function extension(node, parent) {
          if (isNestedTableExtension(node)) {
            if (options.environment === "renderer" && isInsideBodiedExtension(parent) && !options.disableNestedRendererTreatment) {
              return void 0;
            }
            isTransformed = true;
            return transformNestedTableExtension(node);
          }
          return;
        }
      });
      return {
        transformedAdf,
        isTransformed
      };
    };
    var transformNestedTableNodeOutgoingDocument = exports2.transformNestedTableNodeOutgoingDocument = function transformNestedTableNodeOutgoingDocument2(tableCellNode) {
      try {
        var _tableCellNode$conten;
        return _objectSpread(_objectSpread({}, tableCellNode), {}, {
          content: (_tableCellNode$conten = tableCellNode.content) === null || _tableCellNode$conten === void 0 ? void 0 : _tableCellNode$conten.map(function(childNode) {
            if ((childNode === null || childNode === void 0 ? void 0 : childNode.type) === "table") {
              return (0, _builders.extension)({
                extensionType: NESTED_TABLE_EXTENSION_TYPE,
                extensionKey: NESTED_TABLE_EXTENSION_KEY,
                parameters: {
                  adf: JSON.stringify({
                    type: "doc",
                    version: 1,
                    content: [childNode]
                  })
                }
              });
            }
            return childNode;
          })
        });
      } catch (e) {
        throw new _errors.NodeNestingTransformError("Failed to encode nested table node");
      }
    };
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/transforms.js
var require_transforms = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/transforms.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "NodeNestingTransformError", {
      enumerable: true,
      get: function get() {
        return _errors.NodeNestingTransformError;
      }
    });
    Object.defineProperty(exports2, "isNestedTableExtension", {
      enumerable: true,
      get: function get() {
        return _nestedTableTransform.isNestedTableExtension;
      }
    });
    Object.defineProperty(exports2, "transformDedupeMarks", {
      enumerable: true,
      get: function get() {
        return _dedupeMarksTransform.transformDedupeMarks;
      }
    });
    Object.defineProperty(exports2, "transformIndentationMarks", {
      enumerable: true,
      get: function get() {
        return _indentationMarksTransform.transformIndentationMarks;
      }
    });
    Object.defineProperty(exports2, "transformInvalidMediaContent", {
      enumerable: true,
      get: function get() {
        return _invalidMediaContentTransform.transformInvalidMediaContent;
      }
    });
    Object.defineProperty(exports2, "transformMediaLinkMarks", {
      enumerable: true,
      get: function get() {
        return _mediaLinkTransform.transformMediaLinkMarks;
      }
    });
    Object.defineProperty(exports2, "transformNestedTableNodeOutgoingDocument", {
      enumerable: true,
      get: function get() {
        return _nestedTableTransform.transformNestedTableNodeOutgoingDocument;
      }
    });
    Object.defineProperty(exports2, "transformNestedTablesIncomingDocument", {
      enumerable: true,
      get: function get() {
        return _nestedTableTransform.transformNestedTablesIncomingDocument;
      }
    });
    Object.defineProperty(exports2, "transformNodesMissingContent", {
      enumerable: true,
      get: function get() {
        return _nodesMissingContentTransform.transformNodesMissingContent;
      }
    });
    Object.defineProperty(exports2, "transformTextLinkCodeMarks", {
      enumerable: true,
      get: function get() {
        return _textLinkCodeTransform.transformTextLinkCodeMarks;
      }
    });
    var _mediaLinkTransform = require_media_link_transform();
    var _textLinkCodeTransform = require_text_link_code_transform();
    var _dedupeMarksTransform = require_dedupe_marks_transform();
    var _nodesMissingContentTransform = require_nodes_missing_content_transform();
    var _indentationMarksTransform = require_indentation_marks_transform();
    var _invalidMediaContentTransform = require_invalid_media_content_transform();
    var _nestedTableTransform = require_nested_table_transform();
    var _errors = require_errors2();
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/traverse/map.js
var require_map = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/traverse/map.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.map = map;
    var _traverse = require_traverse();
    function map(adf, callback) {
      var result = [];
      (0, _traverse.traverse)(adf, {
        any: function any(node) {
          result.push(callback(node));
        }
      });
      return result;
    }
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/traverse/reduce.js
var require_reduce = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/traverse/reduce.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.reduce = reduce;
    var _traverse = require_traverse();
    function reduce(adf, callback, initial) {
      var result = initial;
      (0, _traverse.traverse)(adf, {
        any: function any(node) {
          result = callback(result, node);
        }
      });
      return result;
    }
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/traverse/filter.js
var require_filter = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/traverse/filter.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.filter = filter;
    var _traverse = require_traverse();
    function filter(adf, callback) {
      var result = [];
      (0, _traverse.traverse)(adf, {
        any: function any(node) {
          if (callback(node)) {
            result.push(node);
          }
        }
      });
      return result;
    }
  }
});

// node_modules/@atlaskit/adf-utils/dist/cjs/traverse.js
var require_traverse2 = __commonJS({
  "node_modules/@atlaskit/adf-utils/dist/cjs/traverse.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    Object.defineProperty(exports2, "filter", {
      enumerable: true,
      get: function get() {
        return _filter.filter;
      }
    });
    Object.defineProperty(exports2, "map", {
      enumerable: true,
      get: function get() {
        return _map.map;
      }
    });
    Object.defineProperty(exports2, "reduce", {
      enumerable: true,
      get: function get() {
        return _reduce.reduce;
      }
    });
    Object.defineProperty(exports2, "traverse", {
      enumerable: true,
      get: function get() {
        return _traverse.traverse;
      }
    });
    var _traverse = require_traverse();
    var _map = require_map();
    var _reduce = require_reduce();
    var _filter = require_filter();
  }
});

// node_modules/@atlaskit/editor-json-transformer/dist/cjs/sanitize/remove-marks.js
var require_remove_marks = __commonJS({
  "node_modules/@atlaskit/editor-json-transformer/dist/cjs/sanitize/remove-marks.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.removeMarks = removeMarks;
    exports2.removeNonAnnotationMarks = removeNonAnnotationMarks;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    function removeMarks(node) {
      var newNode = _objectSpread({}, node);
      delete newNode.marks;
      return newNode;
    }
    function removeNonAnnotationMarks(node) {
      var newNode = _objectSpread({}, node);
      if (node.marks) {
        newNode.marks = node.marks.filter(function(mark) {
          return mark.type === "annotation";
        });
      }
      return newNode;
    }
  }
});

// node_modules/@atlaskit/editor-json-transformer/dist/cjs/sanitize/sanitize-node.js
var require_sanitize_node = __commonJS({
  "node_modules/@atlaskit/editor-json-transformer/dist/cjs/sanitize/sanitize-node.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.sanitizeNode = sanitizeNode;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _transforms = require_transforms();
    var _traverse = require_traverse2();
    var _removeMarks = require_remove_marks();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var hasNestedTable = function hasNestedTable2(tableCellNode) {
      var _tableCellNode$conten;
      return (_tableCellNode$conten = tableCellNode.content) === null || _tableCellNode$conten === void 0 ? void 0 : _tableCellNode$conten.some(function(node) {
        return (node === null || node === void 0 ? void 0 : node.type) === "table";
      });
    };
    function sanitizeNode(json) {
      var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
      var _options$keepNestedTa = options.keepNestedTables, keepNestedTables = _options$keepNestedTa === void 0 ? false : _options$keepNestedTa;
      var sanitizedJSON = (0, _traverse.traverse)(json, {
        text: function text(node) {
          if (!node || !Array.isArray(node.marks)) {
            return node;
          }
          return _objectSpread(_objectSpread({}, node), {}, {
            marks: node.marks.filter(function(mark) {
              return mark.type !== "typeAheadQuery";
            })
          });
        },
        status: function status(node) {
          if (node.attrs && !!node.attrs.text) {
            return (0, _removeMarks.removeNonAnnotationMarks)(node);
          }
          return false;
        },
        caption: function caption(node) {
          if (node.content) {
            return node;
          }
          return false;
        },
        tableCell: function tableCell(node) {
          if (hasNestedTable(node)) {
            return keepNestedTables ? node : (0, _transforms.transformNestedTableNodeOutgoingDocument)(node);
          }
          return;
        },
        tableHeader: function tableHeader(node) {
          if (hasNestedTable(node)) {
            return keepNestedTables ? node : (0, _transforms.transformNestedTableNodeOutgoingDocument)(node);
          }
          return;
        },
        emoji: _removeMarks.removeNonAnnotationMarks,
        mention: _removeMarks.removeNonAnnotationMarks,
        date: _removeMarks.removeNonAnnotationMarks,
        hardBreak: _removeMarks.removeMarks,
        inlineCard: _removeMarks.removeNonAnnotationMarks
      });
      return sanitizedJSON;
    }
  }
});

// node_modules/@atlaskit/editor-json-transformer/dist/cjs/index.js
var require_cjs6 = __commonJS({
  "node_modules/@atlaskit/editor-json-transformer/dist/cjs/index.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    var _typeof3 = require_typeof();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.nodeToJSON = exports2.SchemaStage = exports2.JSONTransformer = void 0;
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _typeof2 = _interopRequireDefault(require_typeof());
    var _objectWithoutProperties2 = _interopRequireDefault(require_objectWithoutProperties());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _isEqual = _interopRequireDefault(require_isEqual());
    var _adfSchema = require_cjs5();
    var _schemaDefault = require_default_schema();
    var _markOverrideRules = require_markOverrideRules();
    var _sanitizeNode = require_sanitize_node();
    function _toPropertyKey(t) {
      var i = _toPrimitive(t, "string");
      return "symbol" == _typeof3(i) ? i : i + "";
    }
    function _toPrimitive(t, r) {
      if ("object" != _typeof3(t) || !t) return t;
      var e = t[Symbol.toPrimitive];
      if (void 0 !== e) {
        var i = e.call(t, r || "default");
        if ("object" != _typeof3(i)) return i;
        throw new TypeError("@@toPrimitive must return a primitive value.");
      }
      return ("string" === r ? String : Number)(t);
    }
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var SchemaStage = exports2.SchemaStage = /* @__PURE__ */ (function(SchemaStage2) {
      SchemaStage2["FINAL"] = "final";
      SchemaStage2["STAGE_0"] = "stage0";
      return SchemaStage2;
    })({});
    var isType = function isType2(type) {
      return function(node) {
        return node.type.name === type;
      };
    };
    var NODES_WITH_EMPTY_ATTRS_REMOVAL = /* @__PURE__ */ new Set(["paragraph", "layoutSection", "blockquote", "nestedExpand", "bulletList", "listItem", "orderedList", "rule", "caption", "tableRow", "media", "mediaSingle", "mediaInline"]);
    var isCodeBlock = isType("codeBlock");
    var isMediaNode = isType("media");
    var isMediaInline = isType("mediaInline");
    var isMediaSingleNode = isType("mediaSingle");
    var isMentionNode = isType("mention");
    var isParagraph = isType("paragraph");
    var isHeading = isType("heading");
    var isTable = isType("table");
    var isTableCell = isType("tableCell");
    var isTableHeader = isType("tableHeader");
    var isLinkMark = isType("link");
    var isUnsupportedMark = isType("unsupportedMark");
    var isUnsupportedNodeAttributeMark = isType("unsupportedNodeAttribute");
    var isExpand = isType("expand");
    var isNestedExpand = isType("nestedExpand");
    var isUnsupportedNode = function isUnsupportedNode2(node) {
      return isType("unsupportedBlock")(node) || isType("unsupportedInline")(node);
    };
    var isDataConsumer = isType("dataConsumer");
    var isFragmentMark = isType("fragment");
    var isHardBreak = isType("hardBreak");
    var _filterNull = function filterNull(subject) {
      var output = _objectSpread({}, subject);
      for (var key in output) {
        var current = output[key];
        if (current === null) {
          var _output = output, unusedKey = _output[key], filteredObj = (0, _objectWithoutProperties2.default)(_output, [key].map(_toPropertyKey));
          output = filteredObj;
        } else if ((0, _typeof2.default)(current) === "object" && !Array.isArray(current)) {
          output[key] = _filterNull(current);
        }
      }
      return output;
    };
    var createDocFromContent = function createDocFromContent2(content) {
      return {
        version: 1,
        type: "doc",
        content: content || []
      };
    };
    var emptyDoc = createDocFromContent([{
      type: "paragraph",
      content: []
    }]);
    var _toJSON = exports2.nodeToJSON = function toJSON(node, mentionMap) {
      var obj = {
        type: node.type.name
      };
      if (isUnsupportedNode(node)) {
        return node.attrs.originalValue;
      } else if (isMediaNode(node)) {
        obj.attrs = (0, _adfSchema.mediaToJSON)(node).attrs;
      } else if (isMediaSingleNode(node)) {
        obj.attrs = (0, _adfSchema.mediaSingleToJSON)(node).attrs;
      } else if (isMediaInline(node)) {
        obj.attrs = (0, _adfSchema.mediaToJSON)(node).attrs;
      } else if (isMentionNode(node)) {
        obj.attrs = (0, _adfSchema.mentionToJSON)(node).attrs;
      } else if (isCodeBlock(node)) {
        obj.attrs = (0, _adfSchema.codeBlockToJSON)(node).attrs;
      } else if (isTable(node)) {
        obj.attrs = (0, _adfSchema.tableToJSON)(node).attrs;
      } else if (isTableCell(node)) {
        obj.attrs = (0, _adfSchema.toJSONTableCell)(node).attrs;
      } else if (isTableHeader(node)) {
        obj.attrs = (0, _adfSchema.toJSONTableHeader)(node).attrs;
      } else if (isExpand(node) || isNestedExpand(node)) {
        obj.attrs = (0, _adfSchema.expandToJSON)(node).attrs;
      } else if (node.attrs && Object.keys(node.attrs).length) {
        obj.attrs = node.attrs;
      }
      if (obj.attrs) {
        obj.attrs = _filterNull(obj.attrs);
      }
      if (isMentionNode(node) && mentionMap) {
        var _text, _obj$attrs;
        var name = !!(mentionMap !== null && mentionMap !== void 0 && mentionMap[node.attrs.id]) ? "@".concat(mentionMap[node.attrs.id]) : "";
        var text = (_text = (_obj$attrs = obj.attrs) === null || _obj$attrs === void 0 ? void 0 : _obj$attrs.text) !== null && _text !== void 0 ? _text : "";
        obj.attrs = _objectSpread(_objectSpread({}, obj.attrs), {}, {
          // If an explicit text value is set on the mention then that should take priority over the mentionMap value.
          text: !!text ? text : name
        });
      }
      if (NODES_WITH_EMPTY_ATTRS_REMOVAL.has(node.type.name) && obj.attrs && !Object.keys(obj.attrs).length || isHardBreak(node)) {
        delete obj.attrs;
      }
      if (node.isText) {
        obj.text = node.textContent;
      } else {
        node.content.forEach(function(child) {
          obj.content = obj.content || [];
          obj.content.push(_toJSON(child, mentionMap));
        });
      }
      if (isParagraph(node) || isHeading(node)) {
        obj.content = obj.content || [];
      }
      if (node.marks.length) {
        var parsedMarks = node.marks.map(function(mark) {
          if (isUnsupportedMark(mark)) {
            return canOverrideMark(mark, node.marks) ? null : mark.attrs.originalValue;
          } else if (isUnsupportedNodeAttributeMark(mark)) {
            return null;
          } else if (isLinkMark(mark)) {
            return (0, _adfSchema.linkToJSON)(mark);
          } else if (isDataConsumer(mark)) {
            var _serialised$attrs$sou;
            var serialised = (0, _adfSchema.dataConsumerToJSON)(mark);
            return !serialised.attrs.sources || ((_serialised$attrs$sou = serialised.attrs.sources) === null || _serialised$attrs$sou === void 0 ? void 0 : _serialised$attrs$sou.length) === 0 ? null : serialised;
          } else if (isFragmentMark(mark)) {
            var fragmentMark = (0, _adfSchema.fragmentToJSON)(mark);
            if (!fragmentMark.attrs.localId) {
              return null;
            }
            return fragmentMark;
          } else {
            return mark.toJSON();
          }
        }).filter(function(maybeMark) {
          return maybeMark !== null;
        });
        obj.marks = (parsedMarks === null || parsedMarks === void 0 ? void 0 : parsedMarks.length) > 0 ? parsedMarks : void 0;
        var nodeAttributeMark = node.marks.find(isUnsupportedNodeAttributeMark);
        if (nodeAttributeMark && nodeAttributeMark.attrs.type.nodeType === obj.type) {
          obj.attrs = _objectSpread({}, getUnwrappedNodeAttributes(node, nodeAttributeMark, obj));
        }
      }
      return obj;
    };
    var canOverrideMark = function canOverrideMark2(mark, existingMarks) {
      if (existingMarks.some(function(e) {
        return mark.attrs.originalValue.type === e.type.name;
      })) {
        return (0, _markOverrideRules.markOverrideRuleFor)(mark.attrs.originalValue.type).canOverrideUnsupportedMark();
      }
      return false;
    };
    var getUnwrappedNodeAttributes = function getUnwrappedNodeAttributes2(node, mark, obj) {
      var nodeAttributes = node.type.spec.attrs;
      var attributes = _objectSpread(_objectSpread({}, mark.attrs.unsupported), obj.attrs);
      for (var key in obj.attrs) {
        if (obj.attrs.hasOwnProperty(key)) {
          var attribute = nodeAttributes ? nodeAttributes[key] : null;
          if (attribute) {
            if (attribute.default === node.attrs[key] && mark.attrs.unsupported[key]) {
              return _objectSpread(_objectSpread({}, attributes), {}, (0, _defineProperty2.default)({}, key, mark.attrs.unsupported[key]));
            }
          }
        }
      }
      return attributes;
    };
    var JSONTransformer2 = exports2.JSONTransformer = /* @__PURE__ */ (function() {
      function JSONTransformer3() {
        var schema = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : _schemaDefault.defaultSchema;
        var mentionMap = arguments.length > 1 ? arguments[1] : void 0;
        (0, _classCallCheck2.default)(this, JSONTransformer3);
        this.schema = schema;
        this.mentionMap = mentionMap;
      }
      return (0, _createClass2.default)(JSONTransformer3, [{
        key: "encode",
        value: function encode(node) {
          var _this = this;
          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          var content = [];
          node.content.forEach(function(child) {
            content.push((0, _sanitizeNode.sanitizeNode)(_toJSON(child, _this.mentionMap), options));
          });
          if (!content || (0, _isEqual.default)(content, emptyDoc.content)) {
            return createDocFromContent([]);
          }
          return createDocFromContent(content);
        }
      }, {
        key: "internalParse",
        value: function internalParse(content, schema) {
          var doc = schema.nodeFromJSON(content);
          doc.check();
          return doc;
        }
      }, {
        key: "parse",
        value: function parse(content, stage) {
          if (content.type !== "doc") {
            throw new Error("Expected content format to be ADF");
          }
          var schema = !!stage ? (0, _schemaDefault.getSchemaBasedOnStage)(stage) : this.schema;
          if (!content.content || content.content.length === 0) {
            return this.internalParse(emptyDoc, schema);
          }
          return this.internalParse(content, schema);
        }
        /**
         * This method is used to encode a single node
         */
      }, {
        key: "encodeNode",
        value: function encodeNode(node) {
          return (0, _sanitizeNode.sanitizeNode)(_toJSON(node, this.mentionMap));
        }
      }]);
    })();
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/blockquote.js
var require_blockquote4 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/blockquote.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.blockquote = void 0;
    var _ = require_encoder();
    var blockquote = exports2.blockquote = function blockquote2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      var result = [];
      node.forEach(function(n) {
        result.push((0, _.encode)(n, context));
      });
      return "{quote}".concat(result.join("\n\n"), "{quote}");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/emoji-unicode-mapping.js
var require_emoji_unicode_mapping = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/emoji-unicode-mapping.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.mapping = void 0;
    var mapping = exports2.mapping = {
      "1f600": "\u{1F600}",
      "1f603": "\u{1F603}",
      "1f604": "\u{1F604}",
      "1f601": "\u{1F601}",
      "1f606": "\u{1F606}",
      "1f605": "\u{1F605}",
      "1f602": "\u{1F602}",
      "1f923": "\u{1F923}",
      "263a": "\u263A\uFE0F",
      "1f60a": "\u{1F60A}",
      "1f607": "\u{1F607}",
      "1f642": "\u{1F642}",
      "1f643": "\u{1F643}",
      "1f609": "\u{1F609}",
      "1f60c": "\u{1F60C}",
      "1f60d": "\u{1F60D}",
      "1f618": "\u{1F618}",
      "1f617": "\u{1F617}",
      "1f619": "\u{1F619}",
      "1f61a": "\u{1F61A}",
      "1f60b": "\u{1F60B}",
      "1f61c": "\u{1F61C}",
      "1f61d": "\u{1F61D}",
      "1f61b": "\u{1F61B}",
      "1f911": "\u{1F911}",
      "1f917": "\u{1F917}",
      "1f913": "\u{1F913}",
      "1f60e": "\u{1F60E}",
      "1f921": "\u{1F921}",
      "1f920": "\u{1F920}",
      "1f60f": "\u{1F60F}",
      "1f612": "\u{1F612}",
      "1f61e": "\u{1F61E}",
      "1f614": "\u{1F614}",
      "1f61f": "\u{1F61F}",
      "1f615": "\u{1F615}",
      "1f641": "\u{1F641}",
      "2639": "\u2639\uFE0F",
      "1f623": "\u{1F623}",
      "1f616": "\u{1F616}",
      "1f62b": "\u{1F62B}",
      "1f629": "\u{1F629}",
      "1f624": "\u{1F624}",
      "1f620": "\u{1F620}",
      "1f621": "\u{1F621}",
      "1f636": "\u{1F636}",
      "1f610": "\u{1F610}",
      "1f611": "\u{1F611}",
      "1f62f": "\u{1F62F}",
      "1f626": "\u{1F626}",
      "1f627": "\u{1F627}",
      "1f62e": "\u{1F62E}",
      "1f632": "\u{1F632}",
      "1f635": "\u{1F635}",
      "1f633": "\u{1F633}",
      "1f631": "\u{1F631}",
      "1f628": "\u{1F628}",
      "1f630": "\u{1F630}",
      "1f622": "\u{1F622}",
      "1f625": "\u{1F625}",
      "1f924": "\u{1F924}",
      "1f62d": "\u{1F62D}",
      "1f613": "\u{1F613}",
      "1f62a": "\u{1F62A}",
      "1f634": "\u{1F634}",
      "1f644": "\u{1F644}",
      "1f914": "\u{1F914}",
      "1f925": "\u{1F925}",
      "1f62c": "\u{1F62C}",
      "1f910": "\u{1F910}",
      "1f922": "\u{1F922}",
      "1f927": "\u{1F927}",
      "1f637": "\u{1F637}",
      "1f912": "\u{1F912}",
      "1f915": "\u{1F915}",
      "1f608": "\u{1F608}",
      "1f47f": "\u{1F47F}",
      "1f479": "\u{1F479}",
      "1f47a": "\u{1F47A}",
      "1f4a9": "\u{1F4A9}",
      "1f47b": "\u{1F47B}",
      "1f480": "\u{1F480}",
      "2620": "\u2620\uFE0F",
      "1f47d": "\u{1F47D}",
      "1f47e": "\u{1F47E}",
      "1f916": "\u{1F916}",
      "1f383": "\u{1F383}",
      "1f63a": "\u{1F63A}",
      "1f638": "\u{1F638}",
      "1f639": "\u{1F639}",
      "1f63b": "\u{1F63B}",
      "1f63c": "\u{1F63C}",
      "1f63d": "\u{1F63D}",
      "1f640": "\u{1F640}",
      "1f63f": "\u{1F63F}",
      "1f63e": "\u{1F63E}",
      "1f450": "\u{1F450}",
      "1f64c": "\u{1F64C}",
      "1f44f": "\u{1F44F}",
      "1f64f": "\u{1F64F}",
      "1f91d": "\u{1F91D}",
      "1f44d": "\u{1F44D}",
      "1f44e": "\u{1F44E}",
      "1f44a": "\u{1F44A}",
      "270a": "\u270A",
      "1f91b": "\u{1F91B}",
      "1f91c": "\u{1F91C}",
      "1f91e": "\u{1F91E}",
      "270c": "\u270C\uFE0F",
      "1f918": "\u{1F918}",
      "1f44c": "\u{1F44C}",
      "1f448": "\u{1F448}",
      "1f449": "\u{1F449}",
      "1f446": "\u{1F446}",
      "1f447": "\u{1F447}",
      "261d": "\u261D\uFE0F",
      "270b": "\u270B",
      "1f91a": "\u{1F91A}",
      "1f590": "\u{1F590}\uFE0F",
      "1f596": "\u{1F596}",
      "1f44b": "\u{1F44B}",
      "1f919": "\u{1F919}",
      "1f4aa": "\u{1F4AA}",
      "1f595": "\u{1F595}",
      "270d": "\u270D\uFE0F",
      "1f933": "\u{1F933}",
      "1f485": "\u{1F485}",
      "1f48d": "\u{1F48D}",
      "1f484": "\u{1F484}",
      "1f48b": "\u{1F48B}",
      "1f444": "\u{1F444}",
      "1f445": "\u{1F445}",
      "1f442": "\u{1F442}",
      "1f443": "\u{1F443}",
      "1f463": "\u{1F463}",
      "1f441": "\u{1F441}\uFE0F",
      "1f440": "\u{1F440}",
      "1f5e3": "\u{1F5E3}\uFE0F",
      "1f464": "\u{1F464}",
      "1f465": "\u{1F465}",
      "1f476": "\u{1F476}",
      "1f466": "\u{1F466}",
      "1f467": "\u{1F467}",
      "1f468": "\u{1F468}",
      "1f469": "\u{1F469}",
      "1f471-200d-2640-fe0f": "\u{1F471}\u200D\u2640\uFE0F",
      "1f471": "\u{1F471}",
      "1f471-200d-2642-fe0f": "\u{1F471}\u200D\u2642\uFE0F",
      "1f474": "\u{1F474}",
      "1f475": "\u{1F475}",
      "1f472": "\u{1F472}",
      "1f473-200d-2640-fe0f": "\u{1F473}\u200D\u2640\uFE0F",
      "1f473": "\u{1F473}",
      "1f473-200d-2642-fe0f": "\u{1F473}\u200D\u2642\uFE0F",
      "1f46e-200d-2640-fe0f": "\u{1F46E}\u200D\u2640\uFE0F",
      "1f46e": "\u{1F46E}",
      "1f46e-200d-2642-fe0f": "\u{1F46E}\u200D\u2642\uFE0F",
      "1f477-200d-2640-fe0f": "\u{1F477}\u200D\u2640\uFE0F",
      "1f477": "\u{1F477}",
      "1f477-200d-2642-fe0f": "\u{1F477}\u200D\u2642\uFE0F",
      "1f482-200d-2640-fe0f": "\u{1F482}\u200D\u2640\uFE0F",
      "1f482": "\u{1F482}",
      "1f482-200d-2642-fe0f": "\u{1F482}\u200D\u2642\uFE0F",
      "1f575-fe0f-200d-2640-fe0f": "\u{1F575}\uFE0F\u200D\u2640\uFE0F",
      "1f575": "\u{1F575}\uFE0F",
      "1f575-fe0f-200d-2642-fe0f": "\u{1F575}\uFE0F\u200D\u2642\uFE0F",
      "1f469-200d-2695-fe0f": "\u{1F469}\u200D\u2695\uFE0F",
      "1f468-200d-2695-fe0f": "\u{1F468}\u200D\u2695\uFE0F",
      "1f469-200d-1f33e": "\u{1F469}\u200D\u{1F33E}",
      "1f468-200d-1f33e": "\u{1F468}\u200D\u{1F33E}",
      "1f469-200d-1f373": "\u{1F469}\u200D\u{1F373}",
      "1f468-200d-1f373": "\u{1F468}\u200D\u{1F373}",
      "1f469-200d-1f393": "\u{1F469}\u200D\u{1F393}",
      "1f468-200d-1f393": "\u{1F468}\u200D\u{1F393}",
      "1f469-200d-1f3a4": "\u{1F469}\u200D\u{1F3A4}",
      "1f468-200d-1f3a4": "\u{1F468}\u200D\u{1F3A4}",
      "1f469-200d-1f3eb": "\u{1F469}\u200D\u{1F3EB}",
      "1f468-200d-1f3eb": "\u{1F468}\u200D\u{1F3EB}",
      "1f469-200d-1f3ed": "\u{1F469}\u200D\u{1F3ED}",
      "1f468-200d-1f3ed": "\u{1F468}\u200D\u{1F3ED}",
      "1f469-200d-1f4bb": "\u{1F469}\u200D\u{1F4BB}",
      "1f468-200d-1f4bb": "\u{1F468}\u200D\u{1F4BB}",
      "1f469-200d-1f4bc": "\u{1F469}\u200D\u{1F4BC}",
      "1f468-200d-1f4bc": "\u{1F468}\u200D\u{1F4BC}",
      "1f469-200d-1f527": "\u{1F469}\u200D\u{1F527}",
      "1f468-200d-1f527": "\u{1F468}\u200D\u{1F527}",
      "1f469-200d-1f52c": "\u{1F469}\u200D\u{1F52C}",
      "1f468-200d-1f52c": "\u{1F468}\u200D\u{1F52C}",
      "1f469-200d-1f3a8": "\u{1F469}\u200D\u{1F3A8}",
      "1f468-200d-1f3a8": "\u{1F468}\u200D\u{1F3A8}",
      "1f469-200d-1f692": "\u{1F469}\u200D\u{1F692}",
      "1f468-200d-1f692": "\u{1F468}\u200D\u{1F692}",
      "1f469-200d-2708-fe0f": "\u{1F469}\u200D\u2708\uFE0F",
      "1f468-200d-2708-fe0f": "\u{1F468}\u200D\u2708\uFE0F",
      "1f469-200d-1f680": "\u{1F469}\u200D\u{1F680}",
      "1f468-200d-1f680": "\u{1F468}\u200D\u{1F680}",
      "1f469-200d-2696-fe0f": "\u{1F469}\u200D\u2696\uFE0F",
      "1f468-200d-2696-fe0f": "\u{1F468}\u200D\u2696\uFE0F",
      "1f936": "\u{1F936}",
      "1f385": "\u{1F385}",
      "1f478": "\u{1F478}",
      "1f934": "\u{1F934}",
      "1f470": "\u{1F470}",
      "1f935": "\u{1F935}",
      "1f47c": "\u{1F47C}",
      "1f930": "\u{1F930}",
      "1f647-200d-2640-fe0f": "\u{1F647}\u200D\u2640\uFE0F",
      "1f647": "\u{1F647}",
      "1f647-200d-2642-fe0f": "\u{1F647}\u200D\u2642\uFE0F",
      "1f481": "\u{1F481}",
      "1f481-200d-2642-fe0f": "\u{1F481}\u200D\u2642\uFE0F",
      "1f481-200d-2640-fe0f": "\u{1F481}\u200D\u2640\uFE0F",
      "1f645": "\u{1F645}",
      "1f645-200d-2642-fe0f": "\u{1F645}\u200D\u2642\uFE0F",
      "1f645-200d-2640-fe0f": "\u{1F645}\u200D\u2640\uFE0F",
      "1f646": "\u{1F646}",
      "1f646-200d-2642-fe0f": "\u{1F646}\u200D\u2642\uFE0F",
      "1f646-200d-2640-fe0f": "\u{1F646}\u200D\u2640\uFE0F",
      "1f64b": "\u{1F64B}",
      "1f64b-200d-2642-fe0f": "\u{1F64B}\u200D\u2642\uFE0F",
      "1f64b-200d-2640-fe0f": "\u{1F64B}\u200D\u2640\uFE0F",
      "1f926-200d-2640-fe0f": "\u{1F926}\u200D\u2640\uFE0F",
      "1f926-200d-2642-fe0f": "\u{1F926}\u200D\u2642\uFE0F",
      "1f926": "\u{1F926}",
      "1f937-200d-2640-fe0f": "\u{1F937}\u200D\u2640\uFE0F",
      "1f937-200d-2642-fe0f": "\u{1F937}\u200D\u2642\uFE0F",
      "1f937": "\u{1F937}",
      "1f64e": "\u{1F64E}",
      "1f64e-200d-2642-fe0f": "\u{1F64E}\u200D\u2642\uFE0F",
      "1f64e-200d-2640-fe0f": "\u{1F64E}\u200D\u2640\uFE0F",
      "1f64d": "\u{1F64D}",
      "1f64d-200d-2642-fe0f": "\u{1F64D}\u200D\u2642\uFE0F",
      "1f64d-200d-2640-fe0f": "\u{1F64D}\u200D\u2640\uFE0F",
      "1f487": "\u{1F487}",
      "1f487-200d-2642-fe0f": "\u{1F487}\u200D\u2642\uFE0F",
      "1f487-200d-2640-fe0f": "\u{1F487}\u200D\u2640\uFE0F",
      "1f486": "\u{1F486}",
      "1f486-200d-2642-fe0f": "\u{1F486}\u200D\u2642\uFE0F",
      "1f486-200d-2640-fe0f": "\u{1F486}\u200D\u2640\uFE0F",
      "1f574": "\u{1F574}\uFE0F",
      "1f483": "\u{1F483}",
      "1f57a": "\u{1F57A}",
      "1f46f": "\u{1F46F}",
      "1f46f-200d-2642-fe0f": "\u{1F46F}\u200D\u2642\uFE0F",
      "1f46f-200d-2640-fe0f": "\u{1F46F}\u200D\u2640\uFE0F",
      "1f6b6-200d-2640-fe0f": "\u{1F6B6}\u200D\u2640\uFE0F",
      "1f6b6": "\u{1F6B6}",
      "1f6b6-200d-2642-fe0f": "\u{1F6B6}\u200D\u2642\uFE0F",
      "1f3c3-200d-2640-fe0f": "\u{1F3C3}\u200D\u2640\uFE0F",
      "1f3c3": "\u{1F3C3}",
      "1f3c3-200d-2642-fe0f": "\u{1F3C3}\u200D\u2642\uFE0F",
      "1f46b": "\u{1F46B}",
      "1f46d": "\u{1F46D}",
      "1f46c": "\u{1F46C}",
      "1f491": "\u{1F491}",
      "1f469-200d-2764-fe0f-200d-1f469": "\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F469}",
      "1f468-200d-2764-fe0f-200d-1f468": "\u{1F468}\u200D\u2764\uFE0F\u200D\u{1F468}",
      "1f48f": "\u{1F48F}",
      "1f469-200d-2764-fe0f-200d-1f48b-200d-1f469": "\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}",
      "1f468-200d-2764-fe0f-200d-1f48b-200d-1f468": "\u{1F468}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}",
      "1f46a": "\u{1F46A}",
      "1f468-200d-1f469-200d-1f467": "\u{1F468}\u200D\u{1F469}\u200D\u{1F467}",
      "1f468-200d-1f469-200d-1f467-200d-1f466": "\u{1F468}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F466}",
      "1f468-200d-1f469-200d-1f466-200d-1f466": "\u{1F468}\u200D\u{1F469}\u200D\u{1F466}\u200D\u{1F466}",
      "1f468-200d-1f469-200d-1f467-200d-1f467": "\u{1F468}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F467}",
      "1f469-200d-1f469-200d-1f466": "\u{1F469}\u200D\u{1F469}\u200D\u{1F466}",
      "1f469-200d-1f469-200d-1f467": "\u{1F469}\u200D\u{1F469}\u200D\u{1F467}",
      "1f469-200d-1f469-200d-1f467-200d-1f466": "\u{1F469}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F466}",
      "1f469-200d-1f469-200d-1f466-200d-1f466": "\u{1F469}\u200D\u{1F469}\u200D\u{1F466}\u200D\u{1F466}",
      "1f469-200d-1f469-200d-1f467-200d-1f467": "\u{1F469}\u200D\u{1F469}\u200D\u{1F467}\u200D\u{1F467}",
      "1f468-200d-1f468-200d-1f466": "\u{1F468}\u200D\u{1F468}\u200D\u{1F466}",
      "1f468-200d-1f468-200d-1f467": "\u{1F468}\u200D\u{1F468}\u200D\u{1F467}",
      "1f468-200d-1f468-200d-1f467-200d-1f466": "\u{1F468}\u200D\u{1F468}\u200D\u{1F467}\u200D\u{1F466}",
      "1f468-200d-1f468-200d-1f466-200d-1f466": "\u{1F468}\u200D\u{1F468}\u200D\u{1F466}\u200D\u{1F466}",
      "1f468-200d-1f468-200d-1f467-200d-1f467": "\u{1F468}\u200D\u{1F468}\u200D\u{1F467}\u200D\u{1F467}",
      "1f469-200d-1f466": "\u{1F469}\u200D\u{1F466}",
      "1f469-200d-1f467": "\u{1F469}\u200D\u{1F467}",
      "1f469-200d-1f467-200d-1f466": "\u{1F469}\u200D\u{1F467}\u200D\u{1F466}",
      "1f469-200d-1f466-200d-1f466": "\u{1F469}\u200D\u{1F466}\u200D\u{1F466}",
      "1f469-200d-1f467-200d-1f467": "\u{1F469}\u200D\u{1F467}\u200D\u{1F467}",
      "1f468-200d-1f466": "\u{1F468}\u200D\u{1F466}",
      "1f468-200d-1f467": "\u{1F468}\u200D\u{1F467}",
      "1f468-200d-1f467-200d-1f466": "\u{1F468}\u200D\u{1F467}\u200D\u{1F466}",
      "1f468-200d-1f466-200d-1f466": "\u{1F468}\u200D\u{1F466}\u200D\u{1F466}",
      "1f468-200d-1f467-200d-1f467": "\u{1F468}\u200D\u{1F467}\u200D\u{1F467}",
      "1f45a": "\u{1F45A}",
      "1f455": "\u{1F455}",
      "1f456": "\u{1F456}",
      "1f454": "\u{1F454}",
      "1f457": "\u{1F457}",
      "1f459": "\u{1F459}",
      "1f458": "\u{1F458}",
      "1f460": "\u{1F460}",
      "1f461": "\u{1F461}",
      "1f462": "\u{1F462}",
      "1f45e": "\u{1F45E}",
      "1f45f": "\u{1F45F}",
      "1f452": "\u{1F452}",
      "1f3a9": "\u{1F3A9}",
      "1f393": "\u{1F393}",
      "1f451": "\u{1F451}",
      "26d1": "\u26D1\uFE0F",
      "1f392": "\u{1F392}",
      "1f45d": "\u{1F45D}",
      "1f45b": "\u{1F45B}",
      "1f45c": "\u{1F45C}",
      "1f4bc": "\u{1F4BC}",
      "1f453": "\u{1F453}",
      "1f576": "\u{1F576}\uFE0F",
      "1f302": "\u{1F302}",
      "2602": "\u2602\uFE0F",
      "1f436": "\u{1F436}",
      "1f431": "\u{1F431}",
      "1f42d": "\u{1F42D}",
      "1f439": "\u{1F439}",
      "1f430": "\u{1F430}",
      "1f98a": "\u{1F98A}",
      "1f43b": "\u{1F43B}",
      "1f43c": "\u{1F43C}",
      "1f428": "\u{1F428}",
      "1f42f": "\u{1F42F}",
      "1f981": "\u{1F981}",
      "1f42e": "\u{1F42E}",
      "1f437": "\u{1F437}",
      "1f43d": "\u{1F43D}",
      "1f438": "\u{1F438}",
      "1f435": "\u{1F435}",
      "1f648": "\u{1F648}",
      "1f649": "\u{1F649}",
      "1f64a": "\u{1F64A}",
      "1f412": "\u{1F412}",
      "1f414": "\u{1F414}",
      "1f427": "\u{1F427}",
      "1f426": "\u{1F426}",
      "1f424": "\u{1F424}",
      "1f423": "\u{1F423}",
      "1f425": "\u{1F425}",
      "1f986": "\u{1F986}",
      "1f985": "\u{1F985}",
      "1f989": "\u{1F989}",
      "1f987": "\u{1F987}",
      "1f43a": "\u{1F43A}",
      "1f417": "\u{1F417}",
      "1f434": "\u{1F434}",
      "1f984": "\u{1F984}",
      "1f41d": "\u{1F41D}",
      "1f41b": "\u{1F41B}",
      "1f98b": "\u{1F98B}",
      "1f40c": "\u{1F40C}",
      "1f41a": "\u{1F41A}",
      "1f41e": "\u{1F41E}",
      "1f41c": "\u{1F41C}",
      "1f577": "\u{1F577}\uFE0F",
      "1f578": "\u{1F578}\uFE0F",
      "1f422": "\u{1F422}",
      "1f40d": "\u{1F40D}",
      "1f98e": "\u{1F98E}",
      "1f982": "\u{1F982}",
      "1f980": "\u{1F980}",
      "1f991": "\u{1F991}",
      "1f419": "\u{1F419}",
      "1f990": "\u{1F990}",
      "1f420": "\u{1F420}",
      "1f41f": "\u{1F41F}",
      "1f421": "\u{1F421}",
      "1f42c": "\u{1F42C}",
      "1f988": "\u{1F988}",
      "1f433": "\u{1F433}",
      "1f40b": "\u{1F40B}",
      "1f40a": "\u{1F40A}",
      "1f406": "\u{1F406}",
      "1f405": "\u{1F405}",
      "1f403": "\u{1F403}",
      "1f402": "\u{1F402}",
      "1f404": "\u{1F404}",
      "1f98c": "\u{1F98C}",
      "1f42a": "\u{1F42A}",
      "1f42b": "\u{1F42B}",
      "1f418": "\u{1F418}",
      "1f98f": "\u{1F98F}",
      "1f98d": "\u{1F98D}",
      "1f40e": "\u{1F40E}",
      "1f416": "\u{1F416}",
      "1f410": "\u{1F410}",
      "1f40f": "\u{1F40F}",
      "1f411": "\u{1F411}",
      "1f415": "\u{1F415}",
      "1f429": "\u{1F429}",
      "1f408": "\u{1F408}",
      "1f413": "\u{1F413}",
      "1f983": "\u{1F983}",
      "1f54a": "\u{1F54A}\uFE0F",
      "1f407": "\u{1F407}",
      "1f401": "\u{1F401}",
      "1f400": "\u{1F400}",
      "1f43f": "\u{1F43F}\uFE0F",
      "1f43e": "\u{1F43E}",
      "1f409": "\u{1F409}",
      "1f432": "\u{1F432}",
      "1f335": "\u{1F335}",
      "1f384": "\u{1F384}",
      "1f332": "\u{1F332}",
      "1f333": "\u{1F333}",
      "1f334": "\u{1F334}",
      "1f331": "\u{1F331}",
      "1f33f": "\u{1F33F}",
      "2618": "\u2618\uFE0F",
      "1f340": "\u{1F340}",
      "1f38d": "\u{1F38D}",
      "1f38b": "\u{1F38B}",
      "1f343": "\u{1F343}",
      "1f342": "\u{1F342}",
      "1f341": "\u{1F341}",
      "1f344": "\u{1F344}",
      "1f33e": "\u{1F33E}",
      "1f490": "\u{1F490}",
      "1f337": "\u{1F337}",
      "1f339": "\u{1F339}",
      "1f940": "\u{1F940}",
      "1f33b": "\u{1F33B}",
      "1f33c": "\u{1F33C}",
      "1f338": "\u{1F338}",
      "1f33a": "\u{1F33A}",
      "1f30e": "\u{1F30E}",
      "1f30d": "\u{1F30D}",
      "1f30f": "\u{1F30F}",
      "1f315": "\u{1F315}",
      "1f316": "\u{1F316}",
      "1f317": "\u{1F317}",
      "1f318": "\u{1F318}",
      "1f311": "\u{1F311}",
      "1f312": "\u{1F312}",
      "1f313": "\u{1F313}",
      "1f314": "\u{1F314}",
      "1f31a": "\u{1F31A}",
      "1f31d": "\u{1F31D}",
      "1f31e": "\u{1F31E}",
      "1f31b": "\u{1F31B}",
      "1f31c": "\u{1F31C}",
      "1f319": "\u{1F319}",
      "1f4ab": "\u{1F4AB}",
      "2b50": "\u2B50",
      "1f31f": "\u{1F31F}",
      "2728": "\u2728",
      "26a1": "\u26A1",
      "1f525": "\u{1F525}",
      "1f4a5": "\u{1F4A5}",
      "2604": "\u2604\uFE0F",
      "2600": "\u2600\uFE0F",
      "1f324": "\u{1F324}\uFE0F",
      "26c5": "\u26C5",
      "1f325": "\u{1F325}\uFE0F",
      "1f326": "\u{1F326}\uFE0F",
      "1f308": "\u{1F308}",
      "2601": "\u2601\uFE0F",
      "1f327": "\u{1F327}\uFE0F",
      "26c8": "\u26C8\uFE0F",
      "1f329": "\u{1F329}\uFE0F",
      "1f328": "\u{1F328}\uFE0F",
      "2603": "\u2603\uFE0F",
      "26c4": "\u26C4",
      "2744": "\u2744\uFE0F",
      "1f32c": "\u{1F32C}\uFE0F",
      "1f4a8": "\u{1F4A8}",
      "1f32a": "\u{1F32A}\uFE0F",
      "1f32b": "\u{1F32B}\uFE0F",
      "1f30a": "\u{1F30A}",
      "1f4a7": "\u{1F4A7}",
      "1f4a6": "\u{1F4A6}",
      "2614": "\u2614",
      "1f992": "\u{1F992}",
      "1f993": "\u{1F993}",
      "1f994": "\u{1F994}",
      "1f995": "\u{1F995}",
      "1f996": "\u{1F996}",
      "1f997": "\u{1F997}",
      "1f34f": "\u{1F34F}",
      "1f34e": "\u{1F34E}",
      "1f350": "\u{1F350}",
      "1f34a": "\u{1F34A}",
      "1f34b": "\u{1F34B}",
      "1f34c": "\u{1F34C}",
      "1f349": "\u{1F349}",
      "1f347": "\u{1F347}",
      "1f353": "\u{1F353}",
      "1f348": "\u{1F348}",
      "1f352": "\u{1F352}",
      "1f351": "\u{1F351}",
      "1f34d": "\u{1F34D}",
      "1f95d": "\u{1F95D}",
      "1f951": "\u{1F951}",
      "1f345": "\u{1F345}",
      "1f346": "\u{1F346}",
      "1f952": "\u{1F952}",
      "1f955": "\u{1F955}",
      "1f33d": "\u{1F33D}",
      "1f336": "\u{1F336}\uFE0F",
      "1f954": "\u{1F954}",
      "1f360": "\u{1F360}",
      "1f330": "\u{1F330}",
      "1f95c": "\u{1F95C}",
      "1f36f": "\u{1F36F}",
      "1f950": "\u{1F950}",
      "1f35e": "\u{1F35E}",
      "1f956": "\u{1F956}",
      "1f9c0": "\u{1F9C0}",
      "1f95a": "\u{1F95A}",
      "1f373": "\u{1F373}",
      "1f953": "\u{1F953}",
      "1f95e": "\u{1F95E}",
      "1f364": "\u{1F364}",
      "1f357": "\u{1F357}",
      "1f356": "\u{1F356}",
      "1f355": "\u{1F355}",
      "1f32d": "\u{1F32D}",
      "1f354": "\u{1F354}",
      "1f35f": "\u{1F35F}",
      "1f959": "\u{1F959}",
      "1f32e": "\u{1F32E}",
      "1f32f": "\u{1F32F}",
      "1f957": "\u{1F957}",
      "1f958": "\u{1F958}",
      "1f35d": "\u{1F35D}",
      "1f35c": "\u{1F35C}",
      "1f372": "\u{1F372}",
      "1f365": "\u{1F365}",
      "1f363": "\u{1F363}",
      "1f371": "\u{1F371}",
      "1f35b": "\u{1F35B}",
      "1f359": "\u{1F359}",
      "1f35a": "\u{1F35A}",
      "1f358": "\u{1F358}",
      "1f362": "\u{1F362}",
      "1f361": "\u{1F361}",
      "1f367": "\u{1F367}",
      "1f368": "\u{1F368}",
      "1f366": "\u{1F366}",
      "1f370": "\u{1F370}",
      "1f382": "\u{1F382}",
      "1f36e": "\u{1F36E}",
      "1f36d": "\u{1F36D}",
      "1f36c": "\u{1F36C}",
      "1f36b": "\u{1F36B}",
      "1f37f": "\u{1F37F}",
      "1f369": "\u{1F369}",
      "1f36a": "\u{1F36A}",
      "1f95b": "\u{1F95B}",
      "1f37c": "\u{1F37C}",
      "2615": "\u2615",
      "1f375": "\u{1F375}",
      "1f376": "\u{1F376}",
      "1f37a": "\u{1F37A}",
      "1f37b": "\u{1F37B}",
      "1f942": "\u{1F942}",
      "1f377": "\u{1F377}",
      "1f943": "\u{1F943}",
      "1f378": "\u{1F378}",
      "1f379": "\u{1F379}",
      "1f37e": "\u{1F37E}",
      "1f944": "\u{1F944}",
      "1f374": "\u{1F374}",
      "1f37d": "\u{1F37D}\uFE0F",
      "1f95f": "\u{1F95F}",
      "1f960": "\u{1F960}",
      "1f961": "\u{1F961}",
      "1f962": "\u{1F962}",
      "1f963": "\u{1F963}",
      "1f964": "\u{1F964}",
      "1f965": "\u{1F965}",
      "1f966": "\u{1F966}",
      "1f967": "\u{1F967}",
      "1f968": "\u{1F968}",
      "1f969": "\u{1F969}",
      "1f96a": "\u{1F96A}",
      "1f96b": "\u{1F96B}",
      "26bd": "\u26BD",
      "1f3c0": "\u{1F3C0}",
      "1f3c8": "\u{1F3C8}",
      "26be": "\u26BE",
      "1f3be": "\u{1F3BE}",
      "1f3d0": "\u{1F3D0}",
      "1f3c9": "\u{1F3C9}",
      "1f3b1": "\u{1F3B1}",
      "1f3d3": "\u{1F3D3}",
      "1f3f8": "\u{1F3F8}",
      "1f945": "\u{1F945}",
      "1f3d2": "\u{1F3D2}",
      "1f3d1": "\u{1F3D1}",
      "1f3cf": "\u{1F3CF}",
      "26f3": "\u26F3",
      "1f3f9": "\u{1F3F9}",
      "1f3a3": "\u{1F3A3}",
      "1f94a": "\u{1F94A}",
      "1f94b": "\u{1F94B}",
      "26f8": "\u26F8\uFE0F",
      "1f3bf": "\u{1F3BF}",
      "26f7": "\u26F7\uFE0F",
      "1f3c2": "\u{1F3C2}",
      "1f3cb-fe0f-200d-2640-fe0f": "\u{1F3CB}\uFE0F\u200D\u2640\uFE0F",
      "1f3cb": "\u{1F3CB}\uFE0F",
      "1f3cb-fe0f-200d-2642-fe0f": "\u{1F3CB}\uFE0F\u200D\u2642\uFE0F",
      "1f93a": "\u{1F93A}",
      "1f93c-200d-2640-fe0f": "\u{1F93C}\u200D\u2640\uFE0F",
      "1f93c-200d-2642-fe0f": "\u{1F93C}\u200D\u2642\uFE0F",
      "1f93c": "\u{1F93C}",
      "1f938-200d-2640-fe0f": "\u{1F938}\u200D\u2640\uFE0F",
      "1f938-200d-2642-fe0f": "\u{1F938}\u200D\u2642\uFE0F",
      "1f938": "\u{1F938}",
      "26f9-fe0f-200d-2640-fe0f": "\u26F9\uFE0F\u200D\u2640\uFE0F",
      "26f9": "\u26F9\uFE0F",
      "26f9-fe0f-200d-2642-fe0f": "\u26F9\uFE0F\u200D\u2642\uFE0F",
      "1f93e-200d-2640-fe0f": "\u{1F93E}\u200D\u2640\uFE0F",
      "1f93e-200d-2642-fe0f": "\u{1F93E}\u200D\u2642\uFE0F",
      "1f93e": "\u{1F93E}",
      "1f3cc-fe0f-200d-2640-fe0f": "\u{1F3CC}\uFE0F\u200D\u2640\uFE0F",
      "1f3cc": "\u{1F3CC}\uFE0F",
      "1f3cc-fe0f-200d-2642-fe0f": "\u{1F3CC}\uFE0F\u200D\u2642\uFE0F",
      "1f3c4-200d-2640-fe0f": "\u{1F3C4}\u200D\u2640\uFE0F",
      "1f3c4": "\u{1F3C4}",
      "1f3c4-200d-2642-fe0f": "\u{1F3C4}\u200D\u2642\uFE0F",
      "1f3ca-200d-2640-fe0f": "\u{1F3CA}\u200D\u2640\uFE0F",
      "1f3ca": "\u{1F3CA}",
      "1f3ca-200d-2642-fe0f": "\u{1F3CA}\u200D\u2642\uFE0F",
      "1f93d-200d-2640-fe0f": "\u{1F93D}\u200D\u2640\uFE0F",
      "1f93d-200d-2642-fe0f": "\u{1F93D}\u200D\u2642\uFE0F",
      "1f93d": "\u{1F93D}",
      "1f6a3-200d-2640-fe0f": "\u{1F6A3}\u200D\u2640\uFE0F",
      "1f6a3": "\u{1F6A3}",
      "1f6a3-200d-2642-fe0f": "\u{1F6A3}\u200D\u2642\uFE0F",
      "1f3c7": "\u{1F3C7}",
      "1f6b4-200d-2640-fe0f": "\u{1F6B4}\u200D\u2640\uFE0F",
      "1f6b4": "\u{1F6B4}",
      "1f6b4-200d-2642-fe0f": "\u{1F6B4}\u200D\u2642\uFE0F",
      "1f6b5-200d-2640-fe0f": "\u{1F6B5}\u200D\u2640\uFE0F",
      "1f6b5": "\u{1F6B5}",
      "1f6b5-200d-2642-fe0f": "\u{1F6B5}\u200D\u2642\uFE0F",
      "1f3bd": "\u{1F3BD}",
      "1f3c5": "\u{1F3C5}",
      "1f396": "\u{1F396}\uFE0F",
      "1f947": "\u{1F947}",
      "1f948": "\u{1F948}",
      "1f949": "\u{1F949}",
      "1f3c6": "\u{1F3C6}",
      "1f3f5": "\u{1F3F5}\uFE0F",
      "1f397": "\u{1F397}\uFE0F",
      "1f3ab": "\u{1F3AB}",
      "1f39f": "\u{1F39F}\uFE0F",
      "1f3aa": "\u{1F3AA}",
      "1f939-200d-2640-fe0f": "\u{1F939}\u200D\u2640\uFE0F",
      "1f939-200d-2642-fe0f": "\u{1F939}\u200D\u2642\uFE0F",
      "1f939": "\u{1F939}",
      "1f3ad": "\u{1F3AD}",
      "1f3a8": "\u{1F3A8}",
      "1f3ac": "\u{1F3AC}",
      "1f3a4": "\u{1F3A4}",
      "1f3a7": "\u{1F3A7}",
      "1f3bc": "\u{1F3BC}",
      "1f3b9": "\u{1F3B9}",
      "1f941": "\u{1F941}",
      "1f3b7": "\u{1F3B7}",
      "1f3ba": "\u{1F3BA}",
      "1f3b8": "\u{1F3B8}",
      "1f3bb": "\u{1F3BB}",
      "1f3b2": "\u{1F3B2}",
      "1f3af": "\u{1F3AF}",
      "1f3b3": "\u{1F3B3}",
      "1f3ae": "\u{1F3AE}",
      "1f3b0": "\u{1F3B0}",
      "1f6f7": "\u{1F6F7}",
      "1f931": "\u{1F931}",
      "1f94c": "\u{1F94C}",
      "1f9d6": "\u{1F9D6}",
      "1f9d7": "\u{1F9D7}",
      "1f9d8": "\u{1F9D8}",
      "1f9d6-200d-2640-fe0f": "\u{1F9D6}\u200D\u2640\uFE0F",
      "1f9d6-200d-2642-fe0f": "\u{1F9D6}\u200D\u2642\uFE0F",
      "1f9d7-200d-2640-fe0f": "\u{1F9D7}\u200D\u2640\uFE0F",
      "1f9d7-200d-2642-fe0f": "\u{1F9D7}\u200D\u2642\uFE0F",
      "1f9d8-200d-2640-fe0f": "\u{1F9D8}\u200D\u2640\uFE0F",
      "1f9d8-200d-2642-fe0f": "\u{1F9D8}\u200D\u2642\uFE0F",
      "1f697": "\u{1F697}",
      "1f695": "\u{1F695}",
      "1f699": "\u{1F699}",
      "1f68c": "\u{1F68C}",
      "1f68e": "\u{1F68E}",
      "1f3ce": "\u{1F3CE}\uFE0F",
      "1f693": "\u{1F693}",
      "1f691": "\u{1F691}",
      "1f692": "\u{1F692}",
      "1f690": "\u{1F690}",
      "1f69a": "\u{1F69A}",
      "1f69b": "\u{1F69B}",
      "1f69c": "\u{1F69C}",
      "1f6f4": "\u{1F6F4}",
      "1f6b2": "\u{1F6B2}",
      "1f6f5": "\u{1F6F5}",
      "1f3cd": "\u{1F3CD}\uFE0F",
      "1f6a8": "\u{1F6A8}",
      "1f694": "\u{1F694}",
      "1f68d": "\u{1F68D}",
      "1f698": "\u{1F698}",
      "1f696": "\u{1F696}",
      "1f6a1": "\u{1F6A1}",
      "1f6a0": "\u{1F6A0}",
      "1f69f": "\u{1F69F}",
      "1f683": "\u{1F683}",
      "1f68b": "\u{1F68B}",
      "1f69e": "\u{1F69E}",
      "1f69d": "\u{1F69D}",
      "1f684": "\u{1F684}",
      "1f685": "\u{1F685}",
      "1f688": "\u{1F688}",
      "1f682": "\u{1F682}",
      "1f686": "\u{1F686}",
      "1f687": "\u{1F687}",
      "1f68a": "\u{1F68A}",
      "1f689": "\u{1F689}",
      "1f681": "\u{1F681}",
      "1f6e9": "\u{1F6E9}\uFE0F",
      "2708": "\u2708\uFE0F",
      "1f6eb": "\u{1F6EB}",
      "1f6ec": "\u{1F6EC}",
      "1f680": "\u{1F680}",
      "1f6f0": "\u{1F6F0}\uFE0F",
      "1f4ba": "\u{1F4BA}",
      "1f6f6": "\u{1F6F6}",
      "26f5": "\u26F5",
      "1f6e5": "\u{1F6E5}\uFE0F",
      "1f6a4": "\u{1F6A4}",
      "1f6f3": "\u{1F6F3}\uFE0F",
      "26f4": "\u26F4\uFE0F",
      "1f6a2": "\u{1F6A2}",
      "2693": "\u2693",
      "1f6a7": "\u{1F6A7}",
      "26fd": "\u26FD",
      "1f68f": "\u{1F68F}",
      "1f6a6": "\u{1F6A6}",
      "1f6a5": "\u{1F6A5}",
      "1f5fa": "\u{1F5FA}\uFE0F",
      "1f5ff": "\u{1F5FF}",
      "1f5fd": "\u{1F5FD}",
      "26f2": "\u26F2",
      "1f5fc": "\u{1F5FC}",
      "1f3f0": "\u{1F3F0}",
      "1f3ef": "\u{1F3EF}",
      "1f3df": "\u{1F3DF}\uFE0F",
      "1f3a1": "\u{1F3A1}",
      "1f3a2": "\u{1F3A2}",
      "1f3a0": "\u{1F3A0}",
      "26f1": "\u26F1\uFE0F",
      "1f3d6": "\u{1F3D6}\uFE0F",
      "1f3dd": "\u{1F3DD}\uFE0F",
      "26f0": "\u26F0\uFE0F",
      "1f3d4": "\u{1F3D4}\uFE0F",
      "1f5fb": "\u{1F5FB}",
      "1f30b": "\u{1F30B}",
      "1f3dc": "\u{1F3DC}\uFE0F",
      "1f3d5": "\u{1F3D5}\uFE0F",
      "26fa": "\u26FA",
      "1f6e4": "\u{1F6E4}\uFE0F",
      "1f6e3": "\u{1F6E3}\uFE0F",
      "1f3d7": "\u{1F3D7}\uFE0F",
      "1f3ed": "\u{1F3ED}",
      "1f3e0": "\u{1F3E0}",
      "1f3e1": "\u{1F3E1}",
      "1f3d8": "\u{1F3D8}\uFE0F",
      "1f3da": "\u{1F3DA}\uFE0F",
      "1f3e2": "\u{1F3E2}",
      "1f3ec": "\u{1F3EC}",
      "1f3e3": "\u{1F3E3}",
      "1f3e4": "\u{1F3E4}",
      "1f3e5": "\u{1F3E5}",
      "1f3e6": "\u{1F3E6}",
      "1f3e8": "\u{1F3E8}",
      "1f3ea": "\u{1F3EA}",
      "1f3eb": "\u{1F3EB}",
      "1f3e9": "\u{1F3E9}",
      "1f492": "\u{1F492}",
      "1f3db": "\u{1F3DB}\uFE0F",
      "26ea": "\u26EA",
      "1f54c": "\u{1F54C}",
      "1f54d": "\u{1F54D}",
      "1f54b": "\u{1F54B}",
      "26e9": "\u26E9\uFE0F",
      "1f5fe": "\u{1F5FE}",
      "1f391": "\u{1F391}",
      "1f3de": "\u{1F3DE}\uFE0F",
      "1f305": "\u{1F305}",
      "1f304": "\u{1F304}",
      "1f320": "\u{1F320}",
      "1f387": "\u{1F387}",
      "1f386": "\u{1F386}",
      "1f307": "\u{1F307}",
      "1f306": "\u{1F306}",
      "1f3d9": "\u{1F3D9}\uFE0F",
      "1f303": "\u{1F303}",
      "1f30c": "\u{1F30C}",
      "1f309": "\u{1F309}",
      "1f301": "\u{1F301}",
      "1f6f8": "\u{1F6F8}",
      "231a": "\u231A",
      "1f4f1": "\u{1F4F1}",
      "1f4f2": "\u{1F4F2}",
      "1f4bb": "\u{1F4BB}",
      "2328": "\u2328\uFE0F",
      "1f5a5": "\u{1F5A5}\uFE0F",
      "1f5a8": "\u{1F5A8}\uFE0F",
      "1f5b1": "\u{1F5B1}\uFE0F",
      "1f5b2": "\u{1F5B2}\uFE0F",
      "1f579": "\u{1F579}\uFE0F",
      "1f5dc": "\u{1F5DC}\uFE0F",
      "1f4bd": "\u{1F4BD}",
      "1f4be": "\u{1F4BE}",
      "1f4bf": "\u{1F4BF}",
      "1f4c0": "\u{1F4C0}",
      "1f4fc": "\u{1F4FC}",
      "1f4f7": "\u{1F4F7}",
      "1f4f8": "\u{1F4F8}",
      "1f4f9": "\u{1F4F9}",
      "1f3a5": "\u{1F3A5}",
      "1f4fd": "\u{1F4FD}\uFE0F",
      "1f39e": "\u{1F39E}\uFE0F",
      "1f4de": "\u{1F4DE}",
      "260e": "\u260E\uFE0F",
      "1f4df": "\u{1F4DF}",
      "1f4e0": "\u{1F4E0}",
      "1f4fa": "\u{1F4FA}",
      "1f4fb": "\u{1F4FB}",
      "1f399": "\u{1F399}\uFE0F",
      "1f39a": "\u{1F39A}\uFE0F",
      "1f39b": "\u{1F39B}\uFE0F",
      "23f1": "\u23F1\uFE0F",
      "23f2": "\u23F2\uFE0F",
      "23f0": "\u23F0",
      "1f570": "\u{1F570}\uFE0F",
      "231b": "\u231B",
      "23f3": "\u23F3",
      "1f4e1": "\u{1F4E1}",
      "1f50b": "\u{1F50B}",
      "1f50c": "\u{1F50C}",
      "1f4a1": "\u{1F4A1}",
      "1f526": "\u{1F526}",
      "1f56f": "\u{1F56F}\uFE0F",
      "1f5d1": "\u{1F5D1}\uFE0F",
      "1f6e2": "\u{1F6E2}\uFE0F",
      "1f4b8": "\u{1F4B8}",
      "1f4b5": "\u{1F4B5}",
      "1f4b4": "\u{1F4B4}",
      "1f4b6": "\u{1F4B6}",
      "1f4b7": "\u{1F4B7}",
      "1f4b0": "\u{1F4B0}",
      "1f4b3": "\u{1F4B3}",
      "1f48e": "\u{1F48E}",
      "2696": "\u2696\uFE0F",
      "1f527": "\u{1F527}",
      "1f528": "\u{1F528}",
      "2692": "\u2692\uFE0F",
      "1f6e0": "\u{1F6E0}\uFE0F",
      "26cf": "\u26CF\uFE0F",
      "1f529": "\u{1F529}",
      "2699": "\u2699\uFE0F",
      "26d3": "\u26D3\uFE0F",
      "1f52b": "\u{1F52B}",
      "1f4a3": "\u{1F4A3}",
      "1f52a": "\u{1F52A}",
      "1f5e1": "\u{1F5E1}\uFE0F",
      "2694": "\u2694\uFE0F",
      "1f6e1": "\u{1F6E1}\uFE0F",
      "1f6ac": "\u{1F6AC}",
      "26b0": "\u26B0\uFE0F",
      "26b1": "\u26B1\uFE0F",
      "1f3fa": "\u{1F3FA}",
      "1f52e": "\u{1F52E}",
      "1f4ff": "\u{1F4FF}",
      "1f488": "\u{1F488}",
      "2697": "\u2697\uFE0F",
      "1f52d": "\u{1F52D}",
      "1f52c": "\u{1F52C}",
      "1f573": "\u{1F573}\uFE0F",
      "1f48a": "\u{1F48A}",
      "1f489": "\u{1F489}",
      "1f321": "\u{1F321}\uFE0F",
      "1f6bd": "\u{1F6BD}",
      "1f6b0": "\u{1F6B0}",
      "1f6bf": "\u{1F6BF}",
      "1f6c1": "\u{1F6C1}",
      "1f6c0": "\u{1F6C0}",
      "1f6ce": "\u{1F6CE}\uFE0F",
      "1f511": "\u{1F511}",
      "1f5dd": "\u{1F5DD}\uFE0F",
      "1f6aa": "\u{1F6AA}",
      "1f6cb": "\u{1F6CB}\uFE0F",
      "1f6cf": "\u{1F6CF}\uFE0F",
      "1f6cc": "\u{1F6CC}",
      "1f5bc": "\u{1F5BC}\uFE0F",
      "1f6cd": "\u{1F6CD}\uFE0F",
      "1f6d2": "\u{1F6D2}",
      "1f381": "\u{1F381}",
      "1f388": "\u{1F388}",
      "1f38f": "\u{1F38F}",
      "1f380": "\u{1F380}",
      "1f38a": "\u{1F38A}",
      "1f389": "\u{1F389}",
      "1f38e": "\u{1F38E}",
      "1f3ee": "\u{1F3EE}",
      "1f390": "\u{1F390}",
      "2709": "\u2709\uFE0F",
      "1f4e9": "\u{1F4E9}",
      "1f4e8": "\u{1F4E8}",
      "1f4e7": "\u{1F4E7}",
      "1f48c": "\u{1F48C}",
      "1f4e5": "\u{1F4E5}",
      "1f4e4": "\u{1F4E4}",
      "1f4e6": "\u{1F4E6}",
      "1f3f7": "\u{1F3F7}\uFE0F",
      "1f4ea": "\u{1F4EA}",
      "1f4eb": "\u{1F4EB}",
      "1f4ec": "\u{1F4EC}",
      "1f4ed": "\u{1F4ED}",
      "1f4ee": "\u{1F4EE}",
      "1f4ef": "\u{1F4EF}",
      "1f4dc": "\u{1F4DC}",
      "1f4c3": "\u{1F4C3}",
      "1f4c4": "\u{1F4C4}",
      "1f4d1": "\u{1F4D1}",
      "1f4ca": "\u{1F4CA}",
      "1f4c8": "\u{1F4C8}",
      "1f4c9": "\u{1F4C9}",
      "1f5d2": "\u{1F5D2}\uFE0F",
      "1f5d3": "\u{1F5D3}\uFE0F",
      "1f4c6": "\u{1F4C6}",
      "1f4c5": "\u{1F4C5}",
      "1f4c7": "\u{1F4C7}",
      "1f5c3": "\u{1F5C3}\uFE0F",
      "1f5f3": "\u{1F5F3}\uFE0F",
      "1f5c4": "\u{1F5C4}\uFE0F",
      "1f4cb": "\u{1F4CB}",
      "1f4c1": "\u{1F4C1}",
      "1f4c2": "\u{1F4C2}",
      "1f5c2": "\u{1F5C2}\uFE0F",
      "1f5de": "\u{1F5DE}\uFE0F",
      "1f4f0": "\u{1F4F0}",
      "1f4d3": "\u{1F4D3}",
      "1f4d4": "\u{1F4D4}",
      "1f4d2": "\u{1F4D2}",
      "1f4d5": "\u{1F4D5}",
      "1f4d7": "\u{1F4D7}",
      "1f4d8": "\u{1F4D8}",
      "1f4d9": "\u{1F4D9}",
      "1f4da": "\u{1F4DA}",
      "1f4d6": "\u{1F4D6}",
      "1f516": "\u{1F516}",
      "1f517": "\u{1F517}",
      "1f4ce": "\u{1F4CE}",
      "1f587": "\u{1F587}\uFE0F",
      "1f4d0": "\u{1F4D0}",
      "1f4cf": "\u{1F4CF}",
      "1f4cc": "\u{1F4CC}",
      "1f4cd": "\u{1F4CD}",
      "2702": "\u2702\uFE0F",
      "1f58a": "\u{1F58A}\uFE0F",
      "1f58b": "\u{1F58B}\uFE0F",
      "2712": "\u2712\uFE0F",
      "1f58c": "\u{1F58C}\uFE0F",
      "1f58d": "\u{1F58D}\uFE0F",
      "1f4dd": "\u{1F4DD}",
      "270f": "\u270F\uFE0F",
      "1f50d": "\u{1F50D}",
      "1f50e": "\u{1F50E}",
      "1f50f": "\u{1F50F}",
      "1f510": "\u{1F510}",
      "1f512": "\u{1F512}",
      "1f513": "\u{1F513}",
      "1f9e1": "\u{1F9E1}",
      "2764": "\u2764\uFE0F",
      "1f49b": "\u{1F49B}",
      "1f49a": "\u{1F49A}",
      "1f499": "\u{1F499}",
      "1f49c": "\u{1F49C}",
      "1f5a4": "\u{1F5A4}",
      "1f494": "\u{1F494}",
      "2763": "\u2763\uFE0F",
      "1f495": "\u{1F495}",
      "1f49e": "\u{1F49E}",
      "1f493": "\u{1F493}",
      "1f497": "\u{1F497}",
      "1f496": "\u{1F496}",
      "1f498": "\u{1F498}",
      "1f49d": "\u{1F49D}",
      "1f49f": "\u{1F49F}",
      "262e": "\u262E\uFE0F",
      "271d": "\u271D\uFE0F",
      "262a": "\u262A\uFE0F",
      "1f549": "\u{1F549}\uFE0F",
      "2638": "\u2638\uFE0F",
      "2721": "\u2721\uFE0F",
      "1f52f": "\u{1F52F}",
      "1f54e": "\u{1F54E}",
      "262f": "\u262F\uFE0F",
      "2626": "\u2626\uFE0F",
      "1f6d0": "\u{1F6D0}",
      "26ce": "\u26CE",
      "2648": "\u2648",
      "2649": "\u2649",
      "264a": "\u264A",
      "264b": "\u264B",
      "264c": "\u264C",
      "264d": "\u264D",
      "264e": "\u264E",
      "264f": "\u264F",
      "2650": "\u2650",
      "2651": "\u2651",
      "2652": "\u2652",
      "2653": "\u2653",
      "1f194": "\u{1F194}",
      "269b": "\u269B\uFE0F",
      "1f251": "\u{1F251}",
      "2622": "\u2622\uFE0F",
      "2623": "\u2623\uFE0F",
      "1f4f4": "\u{1F4F4}",
      "1f4f3": "\u{1F4F3}",
      "1f236": "\u{1F236}",
      "1f21a": "\u{1F21A}",
      "1f238": "\u{1F238}",
      "1f23a": "\u{1F23A}",
      "1f237": "\u{1F237}\uFE0F",
      "2734": "\u2734\uFE0F",
      "1f19a": "\u{1F19A}",
      "1f4ae": "\u{1F4AE}",
      "1f250": "\u{1F250}",
      "3299": "\u3299\uFE0F",
      "3297": "\u3297\uFE0F",
      "1f234": "\u{1F234}",
      "1f235": "\u{1F235}",
      "1f239": "\u{1F239}",
      "1f232": "\u{1F232}",
      "1f170": "\u{1F170}\uFE0F",
      "1f171": "\u{1F171}\uFE0F",
      "1f18e": "\u{1F18E}",
      "1f191": "\u{1F191}",
      "1f17e": "\u{1F17E}\uFE0F",
      "1f198": "\u{1F198}",
      "274c": "\u274C",
      "2b55": "\u2B55",
      "1f6d1": "\u{1F6D1}",
      "26d4": "\u26D4",
      "1f4db": "\u{1F4DB}",
      "1f6ab": "\u{1F6AB}",
      "1f4af": "\u{1F4AF}",
      "1f4a2": "\u{1F4A2}",
      "2668": "\u2668\uFE0F",
      "1f6b7": "\u{1F6B7}",
      "1f6af": "\u{1F6AF}",
      "1f6b3": "\u{1F6B3}",
      "1f6b1": "\u{1F6B1}",
      "1f51e": "\u{1F51E}",
      "1f4f5": "\u{1F4F5}",
      "1f6ad": "\u{1F6AD}",
      "2757": "\u2757",
      "2755": "\u2755",
      "2753": "\u2753",
      "2754": "\u2754",
      "203c": "\u203C\uFE0F",
      "2049": "\u2049\uFE0F",
      "1f505": "\u{1F505}",
      "1f506": "\u{1F506}",
      "303d": "\u303D\uFE0F",
      "26a0": "\u26A0\uFE0F",
      "1f6b8": "\u{1F6B8}",
      "1f531": "\u{1F531}",
      "269c": "\u269C\uFE0F",
      "1f530": "\u{1F530}",
      "267b": "\u267B\uFE0F",
      "2705": "\u2705",
      "1f22f": "\u{1F22F}",
      "1f4b9": "\u{1F4B9}",
      "2747": "\u2747\uFE0F",
      "2733": "\u2733\uFE0F",
      "274e": "\u274E",
      "1f310": "\u{1F310}",
      "1f4a0": "\u{1F4A0}",
      "24c2": "\u24C2\uFE0F",
      "1f300": "\u{1F300}",
      "1f4a4": "\u{1F4A4}",
      "1f3e7": "\u{1F3E7}",
      "1f6be": "\u{1F6BE}",
      "267f": "\u267F",
      "1f17f": "\u{1F17F}\uFE0F",
      "1f233": "\u{1F233}",
      "1f202": "\u{1F202}\uFE0F",
      "1f6c2": "\u{1F6C2}",
      "1f6c3": "\u{1F6C3}",
      "1f6c4": "\u{1F6C4}",
      "1f6c5": "\u{1F6C5}",
      "1f6b9": "\u{1F6B9}",
      "1f6ba": "\u{1F6BA}",
      "1f6bc": "\u{1F6BC}",
      "1f6bb": "\u{1F6BB}",
      "1f6ae": "\u{1F6AE}",
      "1f3a6": "\u{1F3A6}",
      "1f4f6": "\u{1F4F6}",
      "1f201": "\u{1F201}",
      "1f523": "\u{1F523}",
      "2139": "\u2139\uFE0F",
      "1f524": "\u{1F524}",
      "1f521": "\u{1F521}",
      "1f520": "\u{1F520}",
      "1f196": "\u{1F196}",
      "1f197": "\u{1F197}",
      "1f199": "\u{1F199}",
      "1f192": "\u{1F192}",
      "1f195": "\u{1F195}",
      "1f193": "\u{1F193}",
      "30-20e3": "0\uFE0F\u20E3",
      "31-20e3": "1\uFE0F\u20E3",
      "32-20e3": "2\uFE0F\u20E3",
      "33-20e3": "3\uFE0F\u20E3",
      "34-20e3": "4\uFE0F\u20E3",
      "35-20e3": "5\uFE0F\u20E3",
      "36-20e3": "6\uFE0F\u20E3",
      "37-20e3": "7\uFE0F\u20E3",
      "38-20e3": "8\uFE0F\u20E3",
      "39-20e3": "9\uFE0F\u20E3",
      "1f51f": "\u{1F51F}",
      "1f522": "\u{1F522}",
      "23-20e3": "#\uFE0F\u20E3",
      "2a-20e3": "*\uFE0F\u20E3",
      "25b6": "\u25B6\uFE0F",
      "23f8": "\u23F8\uFE0F",
      "23ef": "\u23EF\uFE0F",
      "23f9": "\u23F9\uFE0F",
      "23fa": "\u23FA\uFE0F",
      "23cf": "\u23CF\uFE0F",
      "23ed": "\u23ED\uFE0F",
      "23ee": "\u23EE\uFE0F",
      "23e9": "\u23E9",
      "23ea": "\u23EA",
      "23eb": "\u23EB",
      "23ec": "\u23EC",
      "25c0": "\u25C0\uFE0F",
      "1f53c": "\u{1F53C}",
      "1f53d": "\u{1F53D}",
      "27a1": "\u27A1\uFE0F",
      "2b05": "\u2B05\uFE0F",
      "2b06": "\u2B06\uFE0F",
      "2b07": "\u2B07\uFE0F",
      "2197": "\u2197\uFE0F",
      "2198": "\u2198\uFE0F",
      "2199": "\u2199\uFE0F",
      "2196": "\u2196\uFE0F",
      "2195": "\u2195\uFE0F",
      "2194": "\u2194\uFE0F",
      "21aa": "\u21AA\uFE0F",
      "21a9": "\u21A9\uFE0F",
      "2934": "\u2934\uFE0F",
      "2935": "\u2935\uFE0F",
      "1f500": "\u{1F500}",
      "1f501": "\u{1F501}",
      "1f502": "\u{1F502}",
      "1f504": "\u{1F504}",
      "1f503": "\u{1F503}",
      "1f3b5": "\u{1F3B5}",
      "1f3b6": "\u{1F3B6}",
      "2795": "\u2795",
      "2796": "\u2796",
      "2797": "\u2797",
      "2716": "\u2716\uFE0F",
      "1f4b2": "\u{1F4B2}",
      "1f4b1": "\u{1F4B1}",
      "2122": "\u2122\uFE0F",
      a9: "\xA9\uFE0F",
      ae: "\xAE\uFE0F",
      "3030": "\u3030\uFE0F",
      "27b0": "\u27B0",
      "27bf": "\u27BF",
      "1f51a": "\u{1F51A}",
      "1f519": "\u{1F519}",
      "1f51b": "\u{1F51B}",
      "1f51d": "\u{1F51D}",
      "1f51c": "\u{1F51C}",
      "2714": "\u2714\uFE0F",
      "2611": "\u2611\uFE0F",
      "1f518": "\u{1F518}",
      "26aa": "\u26AA",
      "26ab": "\u26AB",
      "1f534": "\u{1F534}",
      "1f535": "\u{1F535}",
      "1f53a": "\u{1F53A}",
      "1f53b": "\u{1F53B}",
      "1f538": "\u{1F538}",
      "1f539": "\u{1F539}",
      "1f536": "\u{1F536}",
      "1f537": "\u{1F537}",
      "1f533": "\u{1F533}",
      "1f532": "\u{1F532}",
      "25aa": "\u25AA\uFE0F",
      "25ab": "\u25AB\uFE0F",
      "25fe": "\u25FE",
      "25fd": "\u25FD",
      "25fc": "\u25FC\uFE0F",
      "25fb": "\u25FB\uFE0F",
      "2b1b": "\u2B1B",
      "2b1c": "\u2B1C",
      "1f508": "\u{1F508}",
      "1f507": "\u{1F507}",
      "1f509": "\u{1F509}",
      "1f50a": "\u{1F50A}",
      "1f514": "\u{1F514}",
      "1f515": "\u{1F515}",
      "1f4e3": "\u{1F4E3}",
      "1f4e2": "\u{1F4E2}",
      "1f5e8": "\u{1F5E8}\uFE0F",
      "1f441-fe0f-200d-1f5e8-fe0f": "\u{1F441}\uFE0F\u200D\u{1F5E8}\uFE0F",
      "1f4ac": "\u{1F4AC}",
      "1f4ad": "\u{1F4AD}",
      "1f5ef": "\u{1F5EF}\uFE0F",
      "2660": "\u2660\uFE0F",
      "2663": "\u2663\uFE0F",
      "2665": "\u2665\uFE0F",
      "2666": "\u2666\uFE0F",
      "1f0cf": "\u{1F0CF}",
      "1f3b4": "\u{1F3B4}",
      "1f004": "\u{1F004}",
      "1f550": "\u{1F550}",
      "1f551": "\u{1F551}",
      "1f552": "\u{1F552}",
      "1f553": "\u{1F553}",
      "1f554": "\u{1F554}",
      "1f555": "\u{1F555}",
      "1f556": "\u{1F556}",
      "1f557": "\u{1F557}",
      "1f558": "\u{1F558}",
      "1f559": "\u{1F559}",
      "1f55a": "\u{1F55A}",
      "1f55b": "\u{1F55B}",
      "1f55c": "\u{1F55C}",
      "1f55d": "\u{1F55D}",
      "1f55e": "\u{1F55E}",
      "1f55f": "\u{1F55F}",
      "1f560": "\u{1F560}",
      "1f561": "\u{1F561}",
      "1f562": "\u{1F562}",
      "1f563": "\u{1F563}",
      "1f564": "\u{1F564}",
      "1f565": "\u{1F565}",
      "1f566": "\u{1F566}",
      "1f567": "\u{1F567}",
      "1f3f3": "\u{1F3F3}\uFE0F",
      "1f3f4": "\u{1F3F4}",
      "1f3c1": "\u{1F3C1}",
      "1f6a9": "\u{1F6A9}",
      "1f3f3-fe0f-200d-1f308": "\u{1F3F3}\uFE0F\u200D\u{1F308}",
      "1f1e6-1f1eb": "\u{1F1E6}\u{1F1EB}",
      "1f1e6-1f1fd": "\u{1F1E6}\u{1F1FD}",
      "1f1e6-1f1f1": "\u{1F1E6}\u{1F1F1}",
      "1f1e9-1f1ff": "\u{1F1E9}\u{1F1FF}",
      "1f1e6-1f1f8": "\u{1F1E6}\u{1F1F8}",
      "1f1e6-1f1e9": "\u{1F1E6}\u{1F1E9}",
      "1f1e6-1f1f4": "\u{1F1E6}\u{1F1F4}",
      "1f1e6-1f1ee": "\u{1F1E6}\u{1F1EE}",
      "1f1e6-1f1f6": "\u{1F1E6}\u{1F1F6}",
      "1f1e6-1f1ec": "\u{1F1E6}\u{1F1EC}",
      "1f1e6-1f1f7": "\u{1F1E6}\u{1F1F7}",
      "1f1e6-1f1f2": "\u{1F1E6}\u{1F1F2}",
      "1f1e6-1f1fc": "\u{1F1E6}\u{1F1FC}",
      "1f1e6-1f1fa": "\u{1F1E6}\u{1F1FA}",
      "1f1e6-1f1f9": "\u{1F1E6}\u{1F1F9}",
      "1f1e6-1f1ff": "\u{1F1E6}\u{1F1FF}",
      "1f1e7-1f1f8": "\u{1F1E7}\u{1F1F8}",
      "1f1e7-1f1ed": "\u{1F1E7}\u{1F1ED}",
      "1f1e7-1f1e9": "\u{1F1E7}\u{1F1E9}",
      "1f1e7-1f1e7": "\u{1F1E7}\u{1F1E7}",
      "1f1e7-1f1fe": "\u{1F1E7}\u{1F1FE}",
      "1f1e7-1f1ea": "\u{1F1E7}\u{1F1EA}",
      "1f1e7-1f1ff": "\u{1F1E7}\u{1F1FF}",
      "1f1e7-1f1ef": "\u{1F1E7}\u{1F1EF}",
      "1f1e7-1f1f2": "\u{1F1E7}\u{1F1F2}",
      "1f1e7-1f1f9": "\u{1F1E7}\u{1F1F9}",
      "1f1e7-1f1f4": "\u{1F1E7}\u{1F1F4}",
      "1f1e7-1f1e6": "\u{1F1E7}\u{1F1E6}",
      "1f1e7-1f1fc": "\u{1F1E7}\u{1F1FC}",
      "1f1e7-1f1f7": "\u{1F1E7}\u{1F1F7}",
      "1f1ee-1f1f4": "\u{1F1EE}\u{1F1F4}",
      "1f1fb-1f1ec": "\u{1F1FB}\u{1F1EC}",
      "1f1e7-1f1f3": "\u{1F1E7}\u{1F1F3}",
      "1f1e7-1f1ec": "\u{1F1E7}\u{1F1EC}",
      "1f1e7-1f1eb": "\u{1F1E7}\u{1F1EB}",
      "1f1e7-1f1ee": "\u{1F1E7}\u{1F1EE}",
      "1f1f0-1f1ed": "\u{1F1F0}\u{1F1ED}",
      "1f1e8-1f1f2": "\u{1F1E8}\u{1F1F2}",
      "1f1e8-1f1e6": "\u{1F1E8}\u{1F1E6}",
      "1f1ee-1f1e8": "\u{1F1EE}\u{1F1E8}",
      "1f1e8-1f1fb": "\u{1F1E8}\u{1F1FB}",
      "1f1e7-1f1f6": "\u{1F1E7}\u{1F1F6}",
      "1f1f0-1f1fe": "\u{1F1F0}\u{1F1FE}",
      "1f1e8-1f1eb": "\u{1F1E8}\u{1F1EB}",
      "1f1f9-1f1e9": "\u{1F1F9}\u{1F1E9}",
      "1f1e8-1f1f1": "\u{1F1E8}\u{1F1F1}",
      "1f1e8-1f1f3": "\u{1F1E8}\u{1F1F3}",
      "1f1e8-1f1fd": "\u{1F1E8}\u{1F1FD}",
      "1f1e8-1f1e8": "\u{1F1E8}\u{1F1E8}",
      "1f1e8-1f1f4": "\u{1F1E8}\u{1F1F4}",
      "1f1f0-1f1f2": "\u{1F1F0}\u{1F1F2}",
      "1f1e8-1f1ec": "\u{1F1E8}\u{1F1EC}",
      "1f1e8-1f1e9": "\u{1F1E8}\u{1F1E9}",
      "1f1e8-1f1f0": "\u{1F1E8}\u{1F1F0}",
      "1f1e8-1f1f7": "\u{1F1E8}\u{1F1F7}",
      "1f1e8-1f1ee": "\u{1F1E8}\u{1F1EE}",
      "1f1ed-1f1f7": "\u{1F1ED}\u{1F1F7}",
      "1f1e8-1f1fa": "\u{1F1E8}\u{1F1FA}",
      "1f1e8-1f1fc": "\u{1F1E8}\u{1F1FC}",
      "1f1e8-1f1fe": "\u{1F1E8}\u{1F1FE}",
      "1f1e8-1f1ff": "\u{1F1E8}\u{1F1FF}",
      "1f1e9-1f1f0": "\u{1F1E9}\u{1F1F0}",
      "1f1e9-1f1ef": "\u{1F1E9}\u{1F1EF}",
      "1f1e9-1f1f2": "\u{1F1E9}\u{1F1F2}",
      "1f1e9-1f1f4": "\u{1F1E9}\u{1F1F4}",
      "1f1ea-1f1e8": "\u{1F1EA}\u{1F1E8}",
      "1f1ea-1f1ec": "\u{1F1EA}\u{1F1EC}",
      "1f1f8-1f1fb": "\u{1F1F8}\u{1F1FB}",
      "1f1ec-1f1f6": "\u{1F1EC}\u{1F1F6}",
      "1f1ea-1f1f7": "\u{1F1EA}\u{1F1F7}",
      "1f1ea-1f1ea": "\u{1F1EA}\u{1F1EA}",
      "1f1ea-1f1f9": "\u{1F1EA}\u{1F1F9}",
      "1f1ea-1f1fa": "\u{1F1EA}\u{1F1FA}",
      "1f1eb-1f1f0": "\u{1F1EB}\u{1F1F0}",
      "1f1eb-1f1f4": "\u{1F1EB}\u{1F1F4}",
      "1f1eb-1f1ef": "\u{1F1EB}\u{1F1EF}",
      "1f1eb-1f1ee": "\u{1F1EB}\u{1F1EE}",
      "1f1eb-1f1f7": "\u{1F1EB}\u{1F1F7}",
      "1f1ec-1f1eb": "\u{1F1EC}\u{1F1EB}",
      "1f1f5-1f1eb": "\u{1F1F5}\u{1F1EB}",
      "1f1f9-1f1eb": "\u{1F1F9}\u{1F1EB}",
      "1f1ec-1f1e6": "\u{1F1EC}\u{1F1E6}",
      "1f1ec-1f1f2": "\u{1F1EC}\u{1F1F2}",
      "1f1ec-1f1ea": "\u{1F1EC}\u{1F1EA}",
      "1f1e9-1f1ea": "\u{1F1E9}\u{1F1EA}",
      "1f1ec-1f1ed": "\u{1F1EC}\u{1F1ED}",
      "1f1ec-1f1ee": "\u{1F1EC}\u{1F1EE}",
      "1f1ec-1f1f7": "\u{1F1EC}\u{1F1F7}",
      "1f1ec-1f1f1": "\u{1F1EC}\u{1F1F1}",
      "1f1ec-1f1e9": "\u{1F1EC}\u{1F1E9}",
      "1f1ec-1f1f5": "\u{1F1EC}\u{1F1F5}",
      "1f1ec-1f1fa": "\u{1F1EC}\u{1F1FA}",
      "1f1ec-1f1f9": "\u{1F1EC}\u{1F1F9}",
      "1f1ec-1f1ec": "\u{1F1EC}\u{1F1EC}",
      "1f1ec-1f1f3": "\u{1F1EC}\u{1F1F3}",
      "1f1ec-1f1fc": "\u{1F1EC}\u{1F1FC}",
      "1f1ec-1f1fe": "\u{1F1EC}\u{1F1FE}",
      "1f1ed-1f1f9": "\u{1F1ED}\u{1F1F9}",
      "1f1ed-1f1f3": "\u{1F1ED}\u{1F1F3}",
      "1f1ed-1f1f0": "\u{1F1ED}\u{1F1F0}",
      "1f1ed-1f1fa": "\u{1F1ED}\u{1F1FA}",
      "1f1ee-1f1f8": "\u{1F1EE}\u{1F1F8}",
      "1f1ee-1f1f3": "\u{1F1EE}\u{1F1F3}",
      "1f1ee-1f1e9": "\u{1F1EE}\u{1F1E9}",
      "1f1ee-1f1f7": "\u{1F1EE}\u{1F1F7}",
      "1f1ee-1f1f6": "\u{1F1EE}\u{1F1F6}",
      "1f1ee-1f1ea": "\u{1F1EE}\u{1F1EA}",
      "1f1ee-1f1f2": "\u{1F1EE}\u{1F1F2}",
      "1f1ee-1f1f1": "\u{1F1EE}\u{1F1F1}",
      "1f1ee-1f1f9": "\u{1F1EE}\u{1F1F9}",
      "1f1ef-1f1f2": "\u{1F1EF}\u{1F1F2}",
      "1f1ef-1f1f5": "\u{1F1EF}\u{1F1F5}",
      "1f38c": "\u{1F38C}",
      "1f1ef-1f1ea": "\u{1F1EF}\u{1F1EA}",
      "1f1ef-1f1f4": "\u{1F1EF}\u{1F1F4}",
      "1f1f0-1f1ff": "\u{1F1F0}\u{1F1FF}",
      "1f1f0-1f1ea": "\u{1F1F0}\u{1F1EA}",
      "1f1f0-1f1ee": "\u{1F1F0}\u{1F1EE}",
      "1f1fd-1f1f0": "\u{1F1FD}\u{1F1F0}",
      "1f1f0-1f1fc": "\u{1F1F0}\u{1F1FC}",
      "1f1f0-1f1ec": "\u{1F1F0}\u{1F1EC}",
      "1f1f1-1f1e6": "\u{1F1F1}\u{1F1E6}",
      "1f1f1-1f1fb": "\u{1F1F1}\u{1F1FB}",
      "1f1f1-1f1e7": "\u{1F1F1}\u{1F1E7}",
      "1f1f1-1f1f8": "\u{1F1F1}\u{1F1F8}",
      "1f1f1-1f1f7": "\u{1F1F1}\u{1F1F7}",
      "1f1f1-1f1fe": "\u{1F1F1}\u{1F1FE}",
      "1f1f1-1f1ee": "\u{1F1F1}\u{1F1EE}",
      "1f1f1-1f1f9": "\u{1F1F1}\u{1F1F9}",
      "1f1f1-1f1fa": "\u{1F1F1}\u{1F1FA}",
      "1f1f2-1f1f4": "\u{1F1F2}\u{1F1F4}",
      "1f1f2-1f1f0": "\u{1F1F2}\u{1F1F0}",
      "1f1f2-1f1ec": "\u{1F1F2}\u{1F1EC}",
      "1f1f2-1f1fc": "\u{1F1F2}\u{1F1FC}",
      "1f1f2-1f1fe": "\u{1F1F2}\u{1F1FE}",
      "1f1f2-1f1fb": "\u{1F1F2}\u{1F1FB}",
      "1f1f2-1f1f1": "\u{1F1F2}\u{1F1F1}",
      "1f1f2-1f1f9": "\u{1F1F2}\u{1F1F9}",
      "1f1f2-1f1ed": "\u{1F1F2}\u{1F1ED}",
      "1f1f2-1f1f6": "\u{1F1F2}\u{1F1F6}",
      "1f1f2-1f1f7": "\u{1F1F2}\u{1F1F7}",
      "1f1f2-1f1fa": "\u{1F1F2}\u{1F1FA}",
      "1f1fe-1f1f9": "\u{1F1FE}\u{1F1F9}",
      "1f1f2-1f1fd": "\u{1F1F2}\u{1F1FD}",
      "1f1eb-1f1f2": "\u{1F1EB}\u{1F1F2}",
      "1f1f2-1f1e9": "\u{1F1F2}\u{1F1E9}",
      "1f1f2-1f1e8": "\u{1F1F2}\u{1F1E8}",
      "1f1f2-1f1f3": "\u{1F1F2}\u{1F1F3}",
      "1f1f2-1f1ea": "\u{1F1F2}\u{1F1EA}",
      "1f1f2-1f1f8": "\u{1F1F2}\u{1F1F8}",
      "1f1f2-1f1e6": "\u{1F1F2}\u{1F1E6}",
      "1f1f2-1f1ff": "\u{1F1F2}\u{1F1FF}",
      "1f1f2-1f1f2": "\u{1F1F2}\u{1F1F2}",
      "1f1f3-1f1e6": "\u{1F1F3}\u{1F1E6}",
      "1f1f3-1f1f7": "\u{1F1F3}\u{1F1F7}",
      "1f1f3-1f1f5": "\u{1F1F3}\u{1F1F5}",
      "1f1f3-1f1f1": "\u{1F1F3}\u{1F1F1}",
      "1f1f3-1f1e8": "\u{1F1F3}\u{1F1E8}",
      "1f1f3-1f1ff": "\u{1F1F3}\u{1F1FF}",
      "1f1f3-1f1ee": "\u{1F1F3}\u{1F1EE}",
      "1f1f3-1f1ea": "\u{1F1F3}\u{1F1EA}",
      "1f1f3-1f1ec": "\u{1F1F3}\u{1F1EC}",
      "1f1f3-1f1fa": "\u{1F1F3}\u{1F1FA}",
      "1f1f3-1f1eb": "\u{1F1F3}\u{1F1EB}",
      "1f1f0-1f1f5": "\u{1F1F0}\u{1F1F5}",
      "1f1f2-1f1f5": "\u{1F1F2}\u{1F1F5}",
      "1f1f3-1f1f4": "\u{1F1F3}\u{1F1F4}",
      "1f1f4-1f1f2": "\u{1F1F4}\u{1F1F2}",
      "1f1f5-1f1f0": "\u{1F1F5}\u{1F1F0}",
      "1f1f5-1f1fc": "\u{1F1F5}\u{1F1FC}",
      "1f1f5-1f1f8": "\u{1F1F5}\u{1F1F8}",
      "1f1f5-1f1e6": "\u{1F1F5}\u{1F1E6}",
      "1f1f5-1f1ec": "\u{1F1F5}\u{1F1EC}",
      "1f1f5-1f1fe": "\u{1F1F5}\u{1F1FE}",
      "1f1f5-1f1ea": "\u{1F1F5}\u{1F1EA}",
      "1f1f5-1f1ed": "\u{1F1F5}\u{1F1ED}",
      "1f1f5-1f1f3": "\u{1F1F5}\u{1F1F3}",
      "1f1f5-1f1f1": "\u{1F1F5}\u{1F1F1}",
      "1f1f5-1f1f9": "\u{1F1F5}\u{1F1F9}",
      "1f1f5-1f1f7": "\u{1F1F5}\u{1F1F7}",
      "1f1f6-1f1e6": "\u{1F1F6}\u{1F1E6}",
      "1f1f7-1f1ea": "\u{1F1F7}\u{1F1EA}",
      "1f1f7-1f1f4": "\u{1F1F7}\u{1F1F4}",
      "1f1f7-1f1fa": "\u{1F1F7}\u{1F1FA}",
      "1f1f7-1f1fc": "\u{1F1F7}\u{1F1FC}",
      "1f1fc-1f1f8": "\u{1F1FC}\u{1F1F8}",
      "1f1f8-1f1f2": "\u{1F1F8}\u{1F1F2}",
      "1f1f8-1f1f9": "\u{1F1F8}\u{1F1F9}",
      "1f1f8-1f1e6": "\u{1F1F8}\u{1F1E6}",
      "1f1f8-1f1f3": "\u{1F1F8}\u{1F1F3}",
      "1f1f7-1f1f8": "\u{1F1F7}\u{1F1F8}",
      "1f1f8-1f1e8": "\u{1F1F8}\u{1F1E8}",
      "1f1f8-1f1f1": "\u{1F1F8}\u{1F1F1}",
      "1f1f8-1f1ec": "\u{1F1F8}\u{1F1EC}",
      "1f1f8-1f1fd": "\u{1F1F8}\u{1F1FD}",
      "1f1f8-1f1f0": "\u{1F1F8}\u{1F1F0}",
      "1f1f8-1f1ee": "\u{1F1F8}\u{1F1EE}",
      "1f1ec-1f1f8": "\u{1F1EC}\u{1F1F8}",
      "1f1f8-1f1e7": "\u{1F1F8}\u{1F1E7}",
      "1f1f8-1f1f4": "\u{1F1F8}\u{1F1F4}",
      "1f1ff-1f1e6": "\u{1F1FF}\u{1F1E6}",
      "1f1f0-1f1f7": "\u{1F1F0}\u{1F1F7}",
      "1f1f8-1f1f8": "\u{1F1F8}\u{1F1F8}",
      "1f1ea-1f1f8": "\u{1F1EA}\u{1F1F8}",
      "1f1f1-1f1f0": "\u{1F1F1}\u{1F1F0}",
      "1f1e7-1f1f1": "\u{1F1E7}\u{1F1F1}",
      "1f1f8-1f1ed": "\u{1F1F8}\u{1F1ED}",
      "1f1f0-1f1f3": "\u{1F1F0}\u{1F1F3}",
      "1f1f1-1f1e8": "\u{1F1F1}\u{1F1E8}",
      "1f1f5-1f1f2": "\u{1F1F5}\u{1F1F2}",
      "1f1fb-1f1e8": "\u{1F1FB}\u{1F1E8}",
      "1f1f8-1f1e9": "\u{1F1F8}\u{1F1E9}",
      "1f1f8-1f1f7": "\u{1F1F8}\u{1F1F7}",
      "1f1f8-1f1ff": "\u{1F1F8}\u{1F1FF}",
      "1f1f8-1f1ea": "\u{1F1F8}\u{1F1EA}",
      "1f1e8-1f1ed": "\u{1F1E8}\u{1F1ED}",
      "1f1f8-1f1fe": "\u{1F1F8}\u{1F1FE}",
      "1f1f9-1f1fc": "\u{1F1F9}\u{1F1FC}",
      "1f1f9-1f1ef": "\u{1F1F9}\u{1F1EF}",
      "1f1f9-1f1ff": "\u{1F1F9}\u{1F1FF}",
      "1f1f9-1f1ed": "\u{1F1F9}\u{1F1ED}",
      "1f1f9-1f1f1": "\u{1F1F9}\u{1F1F1}",
      "1f1f9-1f1ec": "\u{1F1F9}\u{1F1EC}",
      "1f1f9-1f1f0": "\u{1F1F9}\u{1F1F0}",
      "1f1f9-1f1f4": "\u{1F1F9}\u{1F1F4}",
      "1f1f9-1f1f9": "\u{1F1F9}\u{1F1F9}",
      "1f1f9-1f1f3": "\u{1F1F9}\u{1F1F3}",
      "1f1f9-1f1f7": "\u{1F1F9}\u{1F1F7}",
      "1f1f9-1f1f2": "\u{1F1F9}\u{1F1F2}",
      "1f1f9-1f1e8": "\u{1F1F9}\u{1F1E8}",
      "1f1f9-1f1fb": "\u{1F1F9}\u{1F1FB}",
      "1f1fb-1f1ee": "\u{1F1FB}\u{1F1EE}",
      "1f1fa-1f1ec": "\u{1F1FA}\u{1F1EC}",
      "1f1fa-1f1e6": "\u{1F1FA}\u{1F1E6}",
      "1f1e6-1f1ea": "\u{1F1E6}\u{1F1EA}",
      "1f1ec-1f1e7": "\u{1F1EC}\u{1F1E7}",
      "1f1fa-1f1f8": "\u{1F1FA}\u{1F1F8}",
      "1f1fa-1f1fe": "\u{1F1FA}\u{1F1FE}",
      "1f1fa-1f1ff": "\u{1F1FA}\u{1F1FF}",
      "1f1fb-1f1fa": "\u{1F1FB}\u{1F1FA}",
      "1f1fb-1f1e6": "\u{1F1FB}\u{1F1E6}",
      "1f1fb-1f1ea": "\u{1F1FB}\u{1F1EA}",
      "1f1fb-1f1f3": "\u{1F1FB}\u{1F1F3}",
      "1f1fc-1f1eb": "\u{1F1FC}\u{1F1EB}",
      "1f1ea-1f1ed": "\u{1F1EA}\u{1F1ED}",
      "1f1fe-1f1ea": "\u{1F1FE}\u{1F1EA}",
      "1f1ff-1f1f2": "\u{1F1FF}\u{1F1F2}",
      "1f1ff-1f1fc": "\u{1F1FF}\u{1F1FC}",
      "1f1e6-1f1e8": "\u{1F1E6}\u{1F1E8}",
      "1f1f9-1f1e6": "\u{1F1F9}\u{1F1E6}",
      "1f1e7-1f1fb": "\u{1F1E7}\u{1F1FB}",
      "1f1ed-1f1f2": "\u{1F1ED}\u{1F1F2}",
      "1f1f8-1f1ef": "\u{1F1F8}\u{1F1EF}",
      "1f1fa-1f1f2": "\u{1F1FA}\u{1F1F2}",
      "1f1ea-1f1e6": "\u{1F1EA}\u{1F1E6}",
      "1f1e8-1f1f5": "\u{1F1E8}\u{1F1F5}",
      "1f1e9-1f1ec": "\u{1F1E9}\u{1F1EC}",
      "1f1f2-1f1eb": "\u{1F1F2}\u{1F1EB}",
      "1f1fa-1f1f3": "\u{1F1FA}\u{1F1F3}",
      "1f3f4-e0067-e0062-e0065-e006e-e0067-e007f": "\u{1F3F4}\u{E0067}\u{E0062}\u{E0065}\u{E006E}\u{E0067}\u{E007F}",
      "1f3f4-e0067-e0062-e0073-e0063-e0074-e007f": "\u{1F3F4}\u{E0067}\u{E0062}\u{E0073}\u{E0063}\u{E0074}\u{E007F}",
      "1f3f4-e0067-e0062-e0077-e006c-e0073-e007f": "\u{1F3F4}\u{E0067}\u{E0062}\u{E0077}\u{E006C}\u{E0073}\u{E007F}",
      "1f1ff": "\u{1F1FF}",
      "1f1fe": "\u{1F1FE}",
      "1f1fd": "\u{1F1FD}",
      "1f3fb": "\u{1F3FB}",
      "1f3fc": "\u{1F3FC}",
      "1f3fd": "\u{1F3FD}",
      "1f3fe": "\u{1F3FE}",
      "1f3ff": "\u{1F3FF}",
      "1f1fc": "\u{1F1FC}",
      "1f1fb": "\u{1F1FB}",
      "1f1fa": "\u{1F1FA}",
      "1f1f9": "\u{1F1F9}",
      "1f1f8": "\u{1F1F8}",
      "1f1f7": "\u{1F1F7}",
      "1f1f6": "\u{1F1F6}",
      "1f1f5": "\u{1F1F5}",
      "1f1f4": "\u{1F1F4}",
      "1f1f3": "\u{1F1F3}",
      "1f1f2": "\u{1F1F2}",
      "1f1f1": "\u{1F1F1}",
      "1f1f0": "\u{1F1F0}",
      "1f1ef": "\u{1F1EF}",
      "1f1ee": "\u{1F1EE}",
      "1f1ed": "\u{1F1ED}",
      "1f1ec": "\u{1F1EC}",
      "1f1eb": "\u{1F1EB}",
      "1f1ea": "\u{1F1EA}",
      "1f1e9": "\u{1F1E9}",
      "1f1e8": "\u{1F1E8}",
      "1f1e7": "\u{1F1E7}",
      "1f1e6": "\u{1F1E6}",
      "2640": "\u2640\uFE0F",
      "2642": "\u2642\uFE0F",
      "2695": "\u2695\uFE0F",
      "1f468-200d-1f469-200d-1f466": "\u{1F468}\u200D\u{1F469}\u200D\u{1F466}",
      "1f469-200d-2764-fe0f-200d-1f468": "\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F468}",
      "1f469-200d-2764-fe0f-200d-1f48b-200d-1f468": "\u{1F469}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F468}",
      "1f928": "\u{1F928}",
      "1f929": "\u{1F929}",
      "1f92a": "\u{1F92A}",
      "1f92b": "\u{1F92B}",
      "1f92c": "\u{1F92C}",
      "1f92d": "\u{1F92D}",
      "1f92e": "\u{1F92E}",
      "1f92f": "\u{1F92F}",
      "1f9d0": "\u{1F9D0}",
      "1f9d1": "\u{1F9D1}",
      "1f9d2": "\u{1F9D2}",
      "1f9d3": "\u{1F9D3}",
      "1f9d4": "\u{1F9D4}",
      "1f9d5": "\u{1F9D5}",
      "1f9e0": "\u{1F9E0}",
      "1f9e2": "\u{1F9E2}",
      "1f9d9": "\u{1F9D9}",
      "1f9da": "\u{1F9DA}",
      "1f9db": "\u{1F9DB}",
      "1f9dc": "\u{1F9DC}",
      "1f9dd": "\u{1F9DD}",
      "1f9de": "\u{1F9DE}",
      "1f9df": "\u{1F9DF}",
      "1f9e3": "\u{1F9E3}",
      "1f9e4": "\u{1F9E4}",
      "1f9e5": "\u{1F9E5}",
      "1f9e6": "\u{1F9E6}",
      "1f91f": "\u{1F91F}",
      "1f932": "\u{1F932}",
      "1f9d9-200d-2640-fe0f": "\u{1F9D9}\u200D\u2640\uFE0F",
      "1f9d9-200d-2642-fe0f": "\u{1F9D9}\u200D\u2642\uFE0F",
      "1f9da-200d-2640-fe0f": "\u{1F9DA}\u200D\u2640\uFE0F",
      "1f9da-200d-2642-fe0f": "\u{1F9DA}\u200D\u2642\uFE0F",
      "1f9db-200d-2640-fe0f": "\u{1F9DB}\u200D\u2640\uFE0F",
      "1f9db-200d-2642-fe0f": "\u{1F9DB}\u200D\u2642\uFE0F",
      "1f9dc-200d-2640-fe0f": "\u{1F9DC}\u200D\u2640\uFE0F",
      "1f9dc-200d-2642-fe0f": "\u{1F9DC}\u200D\u2642\uFE0F",
      "1f9dd-200d-2640-fe0f": "\u{1F9DD}\u200D\u2640\uFE0F",
      "1f9dd-200d-2642-fe0f": "\u{1F9DD}\u200D\u2642\uFE0F",
      "1f9de-200d-2640-fe0f": "\u{1F9DE}\u200D\u2640\uFE0F",
      "1f9de-200d-2642-fe0f": "\u{1F9DE}\u200D\u2642\uFE0F",
      "1f9df-200d-2640-fe0f": "\u{1F9DF}\u200D\u2640\uFE0F",
      "1f9df-200d-2642-fe0f": "\u{1F9DF}\u200D\u2642\uFE0F",
      "atlassian-check_mark": "(/)",
      "atlassian-cross_mark": "(x)",
      "atlassian-plus": "(+)",
      "atlassian-minus": "(-)",
      "atlassian-light_bulb_on": "(on)",
      "atlassian-light_bulb_off": "(off)",
      "atlassian-flag_on": "(flag)",
      "atlassian-flag_off": "(flagoff)",
      "atlassian-warning": "(!)",
      "atlassian-question_mark": "(?)",
      "atlassian-info": "(i)",
      "atlassian-yellow_star": "(*y)",
      "atlassian-blue_star": "(*b)",
      "atlassian-green_star": "(*g)",
      "atlassian-red_star": "(*r)"
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/unknown.js
var require_unknown = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/unknown.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.unknown = void 0;
    var _editorJsonTransformer = require_cjs6();
    var jsonTransformer = new _editorJsonTransformer.JSONTransformer();
    var unknown = exports2.unknown = function unknown2(node) {
      var content = JSON.stringify(jsonTransformer.encodeNode(node));
      return node.isBlock ? "{adf:display=block}\n".concat(content, "\n{adf}") : "{adf:display=inline}".concat(content, "{adf}");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/emoji.js
var require_emoji4 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/emoji.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.emoji = void 0;
    var _emojiUnicodeMapping = require_emoji_unicode_mapping();
    var _unknown = require_unknown();
    var emoji = exports2.emoji = function emoji2(node) {
      var value = _emojiUnicodeMapping.mapping[node.attrs.id];
      if (value) {
        return value;
      }
      if (node.attrs.shortName) {
        return node.attrs.shortName;
      }
      return (0, _unknown.unknown)(node);
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/hard-break.js
var require_hard_break3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/hard-break.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.hardBreak = void 0;
    var hardBreak = exports2.hardBreak = function hardBreak2(_node) {
      return "\n";
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/media-inline.js
var require_media_inline2 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/media-inline.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.mediaInline = void 0;
    var mediaInline = exports2.mediaInline = function mediaInline2(node) {
      var _context$conversion$m, _context$conversion;
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      var fileName = (_context$conversion$m = context === null || context === void 0 || (_context$conversion = context.conversion) === null || _context$conversion === void 0 || (_context$conversion = _context$conversion.mediaConversion) === null || _context$conversion === void 0 || (_context$conversion = _context$conversion[node.attrs.id]) === null || _context$conversion === void 0 ? void 0 : _context$conversion.transform) !== null && _context$conversion$m !== void 0 ? _context$conversion$m : node.attrs.id;
      return "[^".concat(fileName, "]");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/mention.js
var require_mention3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/mention.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.mention = void 0;
    var PREFIX = "accountid:";
    var UNKNOWN_USER = "UNKNOWN_USER";
    var addPrefix = function addPrefix2(content) {
      return content.toLowerCase().startsWith(PREFIX) ? content : "".concat(PREFIX).concat(content);
    };
    var mention = exports2.mention = function mention2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      if (node.attrs.id === UNKNOWN_USER) {
        return "[~".concat(node.attrs.id, "]");
      }
      var mentionKey = node.attrs.id.toLowerCase();
      var content = context && context.conversion && context.conversion.mentionConversion && context.conversion.mentionConversion[mentionKey] ? context.conversion.mentionConversion[mentionKey] : addPrefix(node.attrs.id);
      return "[~".concat(content, "]");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/url.js
var require_url2 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/url.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.decode = decode;
    function decode(raw) {
      if (typeof URL === "function") {
        var decoded = new URL(raw);
        if (decoded.href) {
          return decoded.href;
        }
      }
      var anchor = document.createElement("a");
      anchor.href = raw;
      return anchor.href;
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/link-text.js
var require_link_text = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/link-text.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.linkText = exports2.LINK_TEXT_REGEXP = void 0;
    var _adfSchema = require_cjs5();
    var _url = require_url2();
    var LINK_TEXT_REGEXP = exports2.LINK_TEXT_REGEXP = // Ignored via go/ees005
    // eslint-disable-next-line require-unicode-regexp
    /^((?:(?:https?|ftps?):\/\/)|irc:\/\/|mailto:)([\w?!~^\/\\#$%&'()*+,\-.\/:;<=@]*[\w~^\/\\#$%&'()*+,\-\/:;<=@])/i;
    var linkText = exports2.linkText = function linkText2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema;
      var matches = input2.substring(position).match(LINK_TEXT_REGEXP);
      if (!matches) {
        return fallback(input2, position);
      }
      var match = trimBadEndChar(matches);
      var textRepresentation = match[1] === "mailto:" ? match[2] : match[0];
      var url = (0, _url.decode)(unescape(match[0]));
      if (!(0, _adfSchema.isSafeUrl)(url)) {
        return fallback(input2, position);
      }
      var mark = schema.marks.link.create({
        href: url
      });
      var textNode = schema.text(textRepresentation, [mark]);
      return {
        type: "pmnode",
        nodes: [textNode],
        length: match[0].length
      };
    };
    function unescape(url) {
      var result = "";
      for (var i = 0; i < url.length; i++) {
        var char = url[i];
        if (char !== "\\") {
          result += char;
          continue;
        }
        var nextChar = url[i + 1];
        if (nextChar) {
          result += nextChar;
          i++;
        }
      }
      return result;
    }
    function fallback(input2, position) {
      return {
        type: "text",
        text: input2.substr(position, 1),
        length: 1
      };
    }
    function trimBadEndChar(input2) {
      return [
        // Ignored via go/ees005
        // eslint-disable-next-line require-unicode-regexp
        input2[0].replace(/[.,>)\];}"\'!]*$/, ""),
        input2[1],
        // Ignored via go/ees005
        // eslint-disable-next-line require-unicode-regexp
        input2[2].replace(/[.,>)\];}"\'!]*$/, "")
      ];
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/nodes/mediaSingle.js
var require_mediaSingle = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/nodes/mediaSingle.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = getMediaSingleNodeView;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _linkText = require_link_text();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var defaultWidth = 200;
    var defaultHeight = 183;
    var clamp = function clamp2(input2, lower, upper) {
      if (upper !== void 0) {
        input2 = input2 <= upper ? input2 : upper;
      }
      if (lower !== void 0) {
        input2 = input2 >= lower ? input2 : lower;
      }
      return input2;
    };
    function getMediaSingleNodeView(schema, filename, attrs) {
      var _context$defaults, _context$defaults3;
      var context = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
      var _schema$nodes = schema.nodes, media = _schema$nodes.media, mediaSingle = _schema$nodes.mediaSingle;
      var link = schema.marks.link;
      var mediaMarks = [];
      var mediaNodeAttrs = {};
      if ((context === null || context === void 0 || (_context$defaults = context.defaults) === null || _context$defaults === void 0 || (_context$defaults = _context$defaults.media) === null || _context$defaults === void 0 ? void 0 : _context$defaults.width) !== null) {
        var _context$defaults$med, _context$defaults2;
        mediaNodeAttrs.width = (_context$defaults$med = context === null || context === void 0 || (_context$defaults2 = context.defaults) === null || _context$defaults2 === void 0 || (_context$defaults2 = _context$defaults2.media) === null || _context$defaults2 === void 0 ? void 0 : _context$defaults2.width) !== null && _context$defaults$med !== void 0 ? _context$defaults$med : defaultWidth;
      }
      if ((context === null || context === void 0 || (_context$defaults3 = context.defaults) === null || _context$defaults3 === void 0 || (_context$defaults3 = _context$defaults3.media) === null || _context$defaults3 === void 0 ? void 0 : _context$defaults3.height) !== null) {
        var _context$defaults$med2, _context$defaults4;
        mediaNodeAttrs.height = (_context$defaults$med2 = context === null || context === void 0 || (_context$defaults4 = context.defaults) === null || _context$defaults4 === void 0 || (_context$defaults4 = _context$defaults4.media) === null || _context$defaults4 === void 0 ? void 0 : _context$defaults4.height) !== null && _context$defaults$med2 !== void 0 ? _context$defaults$med2 : defaultHeight;
      }
      var mediaSingleAttrs = {
        layout: "center"
      };
      if (attrs.width && attrs.width.endsWith("%")) {
        var parsed = parseInt(attrs.width, 10);
        if (!isNaN(parsed)) {
          mediaSingleAttrs.width = clamp(parsed, 0, 100);
        }
        mediaNodeAttrs = {};
      } else {
        if (attrs.width) {
          var _parsed = parseInt(attrs.width, 10);
          if (!isNaN(_parsed)) {
            mediaNodeAttrs.width = _parsed;
          }
        }
        if (attrs.height) {
          var _parsed2 = parseInt(attrs.height, 10);
          if (!isNaN(_parsed2)) {
            mediaNodeAttrs.height = _parsed2;
          }
        }
      }
      if (attrs.href) {
        var href = attrs.href.replace(/^"(.+)"$/, "$1");
        mediaMarks.push(link.create({
          href
        }));
      }
      if (attrs.alt) {
        var altText = attrs.alt.replace(/^"(.+)"$/, "$1");
        mediaNodeAttrs.alt = altText;
      }
      if (filename.match(_linkText.LINK_TEXT_REGEXP)) {
        var externalMediaNode = media.createChecked(_objectSpread({
          type: "external",
          url: filename
        }, mediaNodeAttrs), void 0, mediaMarks);
        return mediaSingle.createChecked(mediaSingleAttrs, externalMediaNode);
      } else {
        var _context$conversion$m, _context$conversion;
        var id = (_context$conversion$m = context === null || context === void 0 || (_context$conversion = context.conversion) === null || _context$conversion === void 0 || (_context$conversion = _context$conversion.mediaConversion) === null || _context$conversion === void 0 || (_context$conversion = _context$conversion[filename]) === null || _context$conversion === void 0 ? void 0 : _context$conversion.transform) !== null && _context$conversion$m !== void 0 ? _context$conversion$m : filename;
        var collection = context.hydration && context.hydration.media && context.hydration.media.targetCollectionId;
        var mediaNode = media.createChecked(_objectSpread({
          id,
          type: "file",
          collection: collection || ""
        }, mediaNodeAttrs), void 0, mediaMarks);
        return mediaSingle.createChecked(mediaSingleAttrs, mediaNode);
      }
    }
  }
});

// node_modules/@babel/runtime/helpers/toArray.js
var require_toArray = __commonJS({
  "node_modules/@babel/runtime/helpers/toArray.js"(exports2, module2) {
    var arrayWithHoles = require_arrayWithHoles();
    var iterableToArray = require_iterableToArray();
    var unsupportedIterableToArray = require_unsupportedIterableToArray();
    var nonIterableRest = require_nonIterableRest();
    function _toArray(r) {
      return arrayWithHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableRest();
    }
    module2.exports = _toArray, module2.exports.__esModule = true, module2.exports["default"] = module2.exports;
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/attrs.js
var require_attrs = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/attrs.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.parseAttrs = parseAttrs;
    var _toArray2 = _interopRequireDefault(require_toArray());
    function parseAttrs(str) {
      var sep = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "|";
      var output = {};
      if (!str) {
        return output;
      }
      var attributesStr = str.split(sep);
      attributesStr.forEach(function(attributeStr) {
        var _attributeStr$split = attributeStr.split("="), _attributeStr$split2 = (0, _toArray2.default)(_attributeStr$split), key = _attributeStr$split2[0], value = _attributeStr$split2.slice(1);
        if (!output[key]) {
          output[key] = value.join("=");
        }
      });
      return output;
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/nodes/text.js
var require_text4 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/nodes/text.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.createTextNode = createTextNode;
    function createTextNode(input2, schema, marks) {
      if (input2 === "") {
        return [];
      }
      var node = schema.text(input2, marks || []);
      return [node];
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/whitespace.js
var require_whitespace = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/whitespace.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.parseNewlineOnly = parseNewlineOnly;
    exports2.parseWhitespaceAndNewLine = parseWhitespaceAndNewLine;
    exports2.parseWhitespaceOnly = parseWhitespaceOnly;
    function parseWhitespaceAndNewLine(input2) {
      var newlineLength = parseNewlineOnly(input2);
      if (newlineLength) {
        return newlineLength;
      }
      var whitespaceLength = parseWhitespaceOnly(input2);
      if (whitespaceLength) {
        return whitespaceLength;
      }
      return 0;
    }
    function parseWhitespaceOnly(input2) {
      var index = 0;
      var char = input2.charAt(index);
      if (char === "	" || char === " ") {
        index++;
      }
      return index;
    }
    function parseNewlineOnly(input2) {
      var index = 0;
      var char = input2.charAt(index);
      if (char === "\r") {
        index++;
        if (input2.charAt(index) === "\n") {
          index++;
        }
      } else if (char === "\n") {
        index++;
      }
      return index;
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/escape.js
var require_escape3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/escape.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.escapeHandler = escapeHandler;
    var escapedChar = ["-", "#", "*", "_", "+", "?", "^", "~", "|", "%", "{", "}", "[", "]", "(", ")", "!", "@"];
    function escapeHandler(input2, position) {
      var buffer = [];
      var char = input2.charAt(position);
      var prevChar = input2.charAt(position - 1);
      var nextChar = input2.charAt(position + 1);
      if (escapedChar.indexOf(nextChar) === -1 || prevChar === "\\") {
        buffer.push(char);
      }
      buffer.push(nextChar);
      return {
        type: "text",
        text: buffer.join(""),
        length: 2
      };
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/nodes/paragraph.js
var require_paragraph4 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/nodes/paragraph.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.createEmptyParagraphNode = createEmptyParagraphNode;
    exports2.createParagraphNodeFromInlineNodes = createParagraphNodeFromInlineNodes;
    function createEmptyParagraphNode(schema) {
      var paragraph = schema.nodes.paragraph;
      return paragraph.createChecked({}, []);
    }
    function createParagraphNodeFromInlineNodes(inlineNodes, schema) {
      var paragraph = schema.nodes.paragraph;
      var result = [];
      var textNodes = inlineNodes.filter(function(node) {
        return node.type.name !== "hardBreak";
      });
      if (textNodes.length > 0) {
        result.push(paragraph.createChecked({}, inlineNodes));
      }
      return result;
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/normalize.js
var require_normalize2 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/normalize.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.isNextLineEmpty = isNextLineEmpty;
    exports2.normalizeInlineNodes = normalizeInlineNodes;
    exports2.normalizeNestedExpands = normalizeNestedExpands;
    exports2.normalizePMNodes = normalizePMNodes;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _paragraph = require_paragraph4();
    function _createForOfIteratorHelper(r, e) {
      var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
      if (!t) {
        if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
          t && (r = t);
          var _n = 0, F = function F2() {
          };
          return { s: F, n: function n() {
            return _n >= r.length ? { done: true } : { done: false, value: r[_n++] };
          }, e: function e2(r2) {
            throw r2;
          }, f: F };
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }
      var o, a = true, u = false;
      return { s: function s() {
        t = t.call(r);
      }, n: function n() {
        var r2 = t.next();
        return a = r2.done, r2;
      }, e: function e2(r2) {
        u = true, o = r2;
      }, f: function f() {
        try {
          a || null == t.return || t.return();
        } finally {
          if (u) throw o;
        }
      } };
    }
    function _unsupportedIterableToArray(r, a) {
      if (r) {
        if ("string" == typeof r) return _arrayLikeToArray(r, a);
        var t = {}.toString.call(r).slice(8, -1);
        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
      }
    }
    function _arrayLikeToArray(r, a) {
      (null == a || a > r.length) && (a = r.length);
      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
      return n;
    }
    function normalizePMNodes(nodes, schema, parentNode) {
      return [normalizeMediaGroups, normalizeNestedExpands, normalizeInlineNodes].reduce(function(currentNodes, normFunc) {
        return normFunc(currentNodes, schema, parentNode);
      }, nodes);
    }
    function normalizeNestedExpands(nodes, schema, parentNode) {
      var output = [];
      var _iterator = _createForOfIteratorHelper(nodes), _step;
      try {
        for (_iterator.s(); !(_step = _iterator.n()).done; ) {
          var _node$type;
          var node = _step.value;
          if ((node === null || node === void 0 || (_node$type = node.type) === null || _node$type === void 0 ? void 0 : _node$type.name) === "nestedExpand" && parentNode === "doc") {
            output.push(convertNodeToExpand(node, schema));
          } else {
            output.push(node);
          }
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
      return output;
    }
    function normalizeInlineNodes(nodes, schema, _parentNode) {
      var output = [];
      var inlineNodeBuffer = [];
      var _iterator2 = _createForOfIteratorHelper(nodes), _step2;
      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
          var node = _step2.value;
          if (!node.isBlock) {
            inlineNodeBuffer.push(node);
            continue;
          }
          if (inlineNodeBuffer.length > 0) {
            output.push.apply(output, (0, _toConsumableArray2.default)((0, _paragraph.createParagraphNodeFromInlineNodes)(inlineNodeBuffer, schema)));
          }
          inlineNodeBuffer = [];
          output.push(node);
        }
      } catch (err) {
        _iterator2.e(err);
      } finally {
        _iterator2.f();
      }
      if (inlineNodeBuffer.length > 0) {
        output.push.apply(output, (0, _toConsumableArray2.default)((0, _paragraph.createParagraphNodeFromInlineNodes)(inlineNodeBuffer, schema)));
      }
      if (output.length === 0) {
        return [(0, _paragraph.createEmptyParagraphNode)(schema)];
      }
      return output;
    }
    function normalizeMediaGroups(nodes, schema, _parentNode) {
      var output = [];
      var mediaGroupBuffer = [];
      var separatorBuffer = [];
      var _iterator3 = _createForOfIteratorHelper(nodes), _step3;
      try {
        for (_iterator3.s(); !(_step3 = _iterator3.n()).done; ) {
          var n = _step3.value;
          if (n.type.name === "mediaGroup" && n.childCount === 1) {
            mediaGroupBuffer.push(n);
            separatorBuffer = [];
            continue;
          }
          if (mediaGroupBuffer.length > 0) {
            if (isSignificantSeparatorNode(n, separatorBuffer)) {
              output.push(createMergedMediaGroup(mediaGroupBuffer, schema));
              output.push.apply(output, (0, _toConsumableArray2.default)(separatorBuffer));
              output.push(n);
              mediaGroupBuffer = [];
              separatorBuffer = [];
            } else {
              separatorBuffer.push(n);
            }
            continue;
          }
          output.push(n);
        }
      } catch (err) {
        _iterator3.e(err);
      } finally {
        _iterator3.f();
      }
      if (mediaGroupBuffer.length > 0) {
        output.push(createMergedMediaGroup(mediaGroupBuffer, schema));
      }
      output.push.apply(output, (0, _toConsumableArray2.default)(separatorBuffer));
      return output;
    }
    function createMergedMediaGroup(mediaGroupNodes, schema) {
      var mediaGroup = schema.nodes.mediaGroup;
      var mediaNodes = mediaGroupNodes.map(function(v) {
        return v.child(0);
      });
      return mediaGroup.createChecked({}, mediaNodes);
    }
    function isSignificantSeparatorNode(n, separatorBuffer) {
      return isHardBreak(n, separatorBuffer) || !isEmptyTextNode(n) || isMediaGroupWithMultipleChildren(n);
    }
    function isMediaGroupWithMultipleChildren(n) {
      return n.type.name === "mediaGroup" && n.childCount > 1;
    }
    function isHardBreak(n, separatorBuffer) {
      return n.type.name === "hardBreak" && separatorBuffer.map(function(v) {
        return v.type.name;
      }).indexOf("hardBreak") !== -1;
    }
    function isEmptyTextNode(n) {
      return n.textContent !== void 0 && n.textContent.trim().length === 0;
    }
    function isNextLineEmpty(input2) {
      return input2.trim().length === 0;
    }
    function convertNodeToExpand(node, schema) {
      var expand = schema.nodes.expand;
      return expand.createChecked(node.attrs, node.content);
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/text.js
var require_text5 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/text.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.parseString = parseString;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _text = require_text4();
    var _keyword = require_keyword();
    var _tokenize = require_tokenize();
    var _whitespace = require_whitespace();
    var _escape = require_escape3();
    var _normalize = require_normalize2();
    var processState = {
      NEWLINE: 0,
      BUFFER: 1,
      TOKEN: 2,
      ESCAPE: 3
    };
    function parseString(_ref) {
      var input2 = _ref.input, schema = _ref.schema, _ref$ignoreTokenTypes = _ref.ignoreTokenTypes, ignoreTokenTypes = _ref$ignoreTokenTypes === void 0 ? [] : _ref$ignoreTokenTypes, context = _ref.context, _ref$includeLeadingSp = _ref.includeLeadingSpace, includeLeadingSpace = _ref$includeLeadingSp === void 0 ? false : _ref$includeLeadingSp;
      var index = 0;
      var state = processState.NEWLINE;
      var buffer = [];
      var tokenType = _tokenize.TokenType.STRING;
      var newLines = [];
      var output = [];
      var inlineNodes = [];
      while (index < input2.length) {
        var char = input2.charAt(index);
        switch (state) {
          case processState.NEWLINE: {
            var substring = input2.substring(index);
            var length = (0, _whitespace.parseWhitespaceOnly)(substring);
            if (length) {
              index += length;
              if (includeLeadingSpace) {
                buffer.push(char);
              }
              continue;
            }
            var match = (0, _keyword.parseLeadingKeyword)(substring) || (0, _keyword.parseMacroKeyword)(substring) || (0, _keyword.parseOtherKeyword)(substring) || (0, _keyword.parseIssueKeyword)(substring, context.issueKeyRegex);
            if (match && ignoreTokenTypes.indexOf(match.type) === -1) {
              tokenType = match.type;
              state = processState.TOKEN;
              continue;
            } else {
              state = processState.BUFFER;
              continue;
            }
          }
          case processState.BUFFER: {
            var _substring = input2.substring(index);
            var _match = null;
            if (buffer.length > 0 && buffer[buffer.length - 1].endsWith("{")) {
              _match = (0, _keyword.parseOtherKeyword)(_substring);
            } else {
              _match = (0, _keyword.parseMacroKeyword)(_substring) || (0, _keyword.parseOtherKeyword)(_substring) || (0, _keyword.parseIssueKeyword)(_substring, context.issueKeyRegex);
            }
            if (_match && ignoreTokenTypes.indexOf(_match.type) === -1) {
              tokenType = _match.type;
              state = processState.TOKEN;
              continue;
            }
            if (char === "\\") {
              state = processState.ESCAPE;
              continue;
            }
            buffer.push(char);
            break;
          }
          case processState.TOKEN: {
            var token = (0, _tokenize.parseToken)(input2, tokenType, index, schema, context);
            if (token.type === "text") {
              buffer.push(token.text);
            } else if (token.type === "pmnode") {
              var _inlineNodes2;
              if (newLines.length >= 2 && (tokenType !== _tokenize.TokenType.HARD_BREAK || buffer.length > 0)) {
                output.push.apply(output, (0, _toConsumableArray2.default)((0, _normalize.normalizePMNodes)(inlineNodes, schema)));
                inlineNodes = isConsecutiveMediaGroups(inlineNodes, token.nodes) ? (0, _toConsumableArray2.default)(newLines) : [];
                newLines = [];
              }
              if (inlineNodes.length === 0) {
                newLines = [];
              }
              if (newLines.length > 0 && isNewLineRequiredBetweenNodes(inlineNodes, buffer, token.nodes)) {
                var _inlineNodes;
                (_inlineNodes = inlineNodes).push.apply(_inlineNodes, (0, _toConsumableArray2.default)(newLines));
                newLines = [];
              }
              (_inlineNodes2 = inlineNodes).push.apply(_inlineNodes2, (0, _toConsumableArray2.default)((0, _text.createTextNode)(buffer.join(""), schema)));
              if (tokenType === _tokenize.TokenType.HARD_BREAK) {
                var _newLines;
                (_newLines = newLines).push.apply(_newLines, (0, _toConsumableArray2.default)(token.nodes));
              } else {
                var _inlineNodes3;
                (_inlineNodes3 = inlineNodes).push.apply(_inlineNodes3, (0, _toConsumableArray2.default)(token.nodes));
                if (token.nodes.length > 0) {
                  newLines = [];
                }
              }
              buffer = [];
            }
            index += token.length;
            if (tokenType === _tokenize.TokenType.HARD_BREAK) {
              state = processState.NEWLINE;
            } else {
              state = processState.BUFFER;
            }
            continue;
          }
          case processState.ESCAPE: {
            var _token = (0, _escape.escapeHandler)(input2, index);
            buffer.push(_token.text);
            index += _token.length;
            state = processState.BUFFER;
            continue;
          }
          default:
        }
        index++;
      }
      var bufferedStr = buffer.join("");
      if (bufferedStr.length > 0) {
        var _inlineNodes5;
        if (newLines.length >= 2) {
          output.push.apply(output, (0, _toConsumableArray2.default)((0, _normalize.normalizePMNodes)(inlineNodes, schema)));
          inlineNodes = [];
          newLines = [];
        }
        if (newLines.length > 0 && inlineNodes.length > 0 && !inlineNodes[inlineNodes.length - 1].isBlock) {
          var _inlineNodes4;
          (_inlineNodes4 = inlineNodes).push.apply(_inlineNodes4, (0, _toConsumableArray2.default)(newLines));
        }
        (_inlineNodes5 = inlineNodes).push.apply(_inlineNodes5, (0, _toConsumableArray2.default)((0, _text.createTextNode)(bufferedStr, schema)));
      }
      return [].concat(output, (0, _toConsumableArray2.default)(inlineNodes));
    }
    function isNewLineRequiredBetweenNodes(currentNodes, buffer, nextNodes) {
      var _currentNodes;
      if (currentNodes.length === 0) {
        return false;
      }
      if (buffer.length > 0 && (_currentNodes = currentNodes[currentNodes.length - 1]) !== null && _currentNodes !== void 0 && _currentNodes.isBlock) {
        return false;
      }
      if (buffer.length === 0) {
        var _nextNodes$, _nextNodes$2, _currentNodes2;
        if (nextNodes.length === 0) {
          return false;
        }
        if (((_nextNodes$ = nextNodes[0]) === null || _nextNodes$ === void 0 ? void 0 : _nextNodes$.type.name) === "hardBreak") {
          return false;
        }
        if ((_nextNodes$2 = nextNodes[0]) !== null && _nextNodes$2 !== void 0 && _nextNodes$2.isBlock || (_currentNodes2 = currentNodes[currentNodes.length - 1]) !== null && _currentNodes2 !== void 0 && _currentNodes2.isBlock) {
          return false;
        }
      }
      return true;
    }
    function isConsecutiveMediaGroups(currentNodes, nextNodes) {
      var _currentNodes3, _nextNodes$3;
      return currentNodes.length > 0 && ((_currentNodes3 = currentNodes[currentNodes.length - 1]) === null || _currentNodes3 === void 0 ? void 0 : _currentNodes3.type.name) === "mediaGroup" && ((_nextNodes$3 = nextNodes[0]) === null || _nextNodes$3 === void 0 ? void 0 : _nextNodes$3.type.name) === "mediaGroup";
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/mention-link.js
var require_mention_link = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/mention-link.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.mentionLinkResolver = mentionLinkResolver;
    function mentionLinkResolver(link, schema, context) {
      if (link.notLinkBody.toLowerCase() === "~accountid:" || link.notLinkBody === "~") {
        return [schema.nodes.paragraph.createChecked({}, [schema.nodes.text.create({})])];
      }
      if (link.notLinkBody.startsWith("~")) {
        var mentionText = link.notLinkBody.substring(1);
        var mentionKey = mentionText.toLowerCase();
        var id = context.conversion && context.conversion.mentionConversion && context.conversion.mentionConversion[mentionKey] ? context.conversion.mentionConversion[mentionKey] : mentionText;
        return [schema.nodes.mention.createChecked({
          id
        })];
      }
      return;
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/nodes/mediaGroup.js
var require_mediaGroup = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/nodes/mediaGroup.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = getMediaGroupNodeView;
    function getMediaGroupNodeView(schema, filename) {
      var _context$conversion$m, _context$conversion;
      var context = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
      var _schema$nodes = schema.nodes, media = _schema$nodes.media, mediaGroup = _schema$nodes.mediaGroup;
      var id = (_context$conversion$m = context === null || context === void 0 || (_context$conversion = context.conversion) === null || _context$conversion === void 0 || (_context$conversion = _context$conversion.mediaConversion) === null || _context$conversion === void 0 || (_context$conversion = _context$conversion[filename]) === null || _context$conversion === void 0 ? void 0 : _context$conversion.transform) !== null && _context$conversion$m !== void 0 ? _context$conversion$m : filename;
      var collection = context.hydration && context.hydration.media && context.hydration.media.targetCollectionId;
      var mediaNode = media.createChecked({
        id,
        type: "file",
        collection: collection || ""
      });
      return mediaGroup.createChecked({}, mediaNode);
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/attachment-link.js
var require_attachment_link = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/attachment-link.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.attachmentLinkResolver = attachmentLinkResolver;
    var _mediaGroup = _interopRequireDefault(require_mediaGroup());
    function attachmentLinkResolver(link, schema, context) {
      if (link.attachmentName) {
        return [(0, _mediaGroup.default)(schema, link.attachmentName, context)];
      }
      return;
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/text.js
var require_text6 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/text.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.getSurroundingSymbols = exports2.StringBuffer = void 0;
    exports2.hasAnyOfMarks = hasAnyOfMarks;
    exports2.isBlank = isBlank;
    exports2.isDigit = isDigit;
    exports2.isNotBlank = isNotBlank;
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    function hasAnyOfMarks(node, types) {
      return node.marks.findIndex(function(m) {
        return types.findIndex(function(t) {
          return m.type.name === t;
        }) !== -1;
      }) !== -1;
    }
    function isDigit(value) {
      return !!value.match(/^\d$/);
    }
    function isBlank(value) {
      return value === null || value.trim() === "";
    }
    function isNotBlank(value) {
      return !isBlank(value);
    }
    var getSurroundingSymbols = exports2.getSurroundingSymbols = function getSurroundingSymbols2(trimmedInput, openingText, closingText) {
      var openingSymbol = trimmedInput.startsWith("{".concat(openingText, "}")) ? "{".concat(openingText, "}") : openingText;
      var endIndex = trimmedInput.indexOf(closingText, openingSymbol === "{".concat(openingText, "}") ? openingText.length + 2 : openingText.length);
      var closingSymbol = endIndex > -1 && trimmedInput.charAt(endIndex - 1) === "{" && trimmedInput.charAt(endIndex + closingText.length) === "}" ? "{".concat(closingText, "}") : closingText;
      return {
        openingSymbol,
        closingSymbol
      };
    };
    var StringBuffer = exports2.StringBuffer = /* @__PURE__ */ (function() {
      function StringBuffer2() {
        var buffer = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
        (0, _classCallCheck2.default)(this, StringBuffer2);
        this.buffer = buffer;
      }
      return (0, _createClass2.default)(StringBuffer2, [{
        key: "indexOf",
        value: function indexOf(value) {
          return this.buffer.indexOf(value);
        }
      }, {
        key: "lastIndexOf",
        value: function lastIndexOf(value) {
          return this.buffer.lastIndexOf(value);
        }
      }, {
        key: "charAt",
        value: function charAt(index) {
          return this.buffer.charAt(index);
        }
      }, {
        key: "length",
        value: function length() {
          return this.buffer.length;
        }
      }, {
        key: "delete",
        value: function _delete(start, end) {
          this.buffer = this.buffer.substring(0, start) + this.buffer.substring(end);
        }
      }, {
        key: "append",
        value: function append(value) {
          this.buffer += value;
        }
      }, {
        key: "substring",
        value: function substring(start, end) {
          return this.buffer.substring(start, end);
        }
      }, {
        key: "deleteCharAt",
        value: function deleteCharAt(index) {
          this.delete(index, index + 1);
        }
      }, {
        key: "toString",
        value: function toString() {
          return this.buffer;
        }
      }]);
    })();
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/url-link.js
var require_url_link = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/url-link.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.urlLinkResolver = urlLinkResolver;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _index = require_tokenize();
    var _adfSchema = require_cjs5();
    var _text = require_text5();
    var _text2 = require_text6();
    function urlLinkResolver(link, schema, context) {
      var output = [];
      var url = link.notLinkBody;
      var textRepresentation = link.linkBody || link.notLinkBody;
      if (!(0, _adfSchema.isSafeUrl)(url)) {
        return;
      }
      var ignoreTokenTypes = [_index.TokenType.DOUBLE_DASH_SYMBOL, _index.TokenType.TRIPLE_DASH_SYMBOL, _index.TokenType.QUADRUPLE_DASH_SYMBOL, _index.TokenType.LINK_TEXT, _index.TokenType.ISSUE_KEY];
      var rawContent = (0, _text.parseString)({
        ignoreTokenTypes,
        schema,
        context,
        // Ignored via go/ees005
        // eslint-disable-next-line require-unicode-regexp
        input: textRepresentation.replace(/^mailto:/, "")
      });
      var decoratedContent = rawContent.map(function(n) {
        var mark2 = schema.marks.link.create({
          href: url
        });
        if (n.type.name === "text" && !(0, _text2.hasAnyOfMarks)(n, ["link", "code"])) {
          return n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [mark2]));
        }
        return n;
      });
      output.push.apply(output, (0, _toConsumableArray2.default)(decoratedContent));
      if (!hasTextNode(rawContent)) {
        var mark = schema.marks.link.create({
          href: url
        });
        var linkTextNode = schema.text(textRepresentation, [mark]);
        output.push(linkTextNode);
      }
      return output;
    }
    function hasTextNode(nodes) {
      return nodes.find(function(n) {
        return n.type.name === "text";
      });
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/issue-key.js
var require_issue_key = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/issue-key.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.issueKey = exports2.getIssue = exports2.buildIssueKeyRegex = exports2.buildInlineCard = exports2.INLINE_CARD_FROM_TEXT_STAMP = void 0;
    var _text = require_text6();
    var INLINE_CARD_FROM_TEXT_STAMP = exports2.INLINE_CARD_FROM_TEXT_STAMP = /(#icft=)([A-Z][A-Z]+-[0-9]+)/;
    var issueKey = exports2.issueKey = function issueKey2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      if (!context.issueKeyRegex) {
        return fallback(input2, position);
      }
      var match = input2.substring(position).match(context.issueKeyRegex);
      if (!match) {
        return fallback(input2, position);
      }
      var issue = getIssue(context, match[0]);
      if (!issue) {
        return fallback(input2, position);
      }
      var charBefore = input2.charAt(position - 1);
      var charAfter = input2.charAt(position + issue.key.length);
      if ((0, _text.isNotBlank)(charBefore) && isNotAllowedChars(charBefore) || (0, _text.isNotBlank)(charAfter) && isNotAllowedChars(charAfter)) {
        return fallback(input2, position);
      }
      return {
        type: "pmnode",
        nodes: buildInlineCard(schema, issue),
        length: match[0].length
      };
    };
    var fallback = function fallback2(input2, position) {
      return {
        type: "text",
        text: input2.substr(position, 1),
        length: 1
      };
    };
    var getIssue = exports2.getIssue = function getIssue2(context, key) {
      return context.conversion && context.conversion.inlineCardConversion && context.conversion.inlineCardConversion[key] ? {
        key,
        url: context.conversion.inlineCardConversion[key]
      } : null;
    };
    var buildInlineCard = exports2.buildInlineCard = function buildInlineCard2(schema, issue) {
      return [schema.nodes.inlineCard.createChecked({
        url: withInlineCardFromTextStamp(issue)
      })];
    };
    var withInlineCardFromTextStamp = function withInlineCardFromTextStamp2(issue) {
      return INLINE_CARD_FROM_TEXT_STAMP.test(issue.url) ? issue.url : "".concat(issue.url, "#icft=").concat(issue.key);
    };
    var isNotAllowedChars = function isNotAllowedChars2(char) {
      return !/\s|\(|\)|!|\.|\,|\/|\:/.test(char);
    };
    var buildIssueKeyRegex = exports2.buildIssueKeyRegex = function buildIssueKeyRegex2(inlineCardConversion) {
      if (!inlineCardConversion) {
        return void 0;
      }
      var pattern = Object.keys(inlineCardConversion).join("|");
      if (!pattern) {
        return void 0;
      }
      return new RegExp("^(".concat(pattern, ")"));
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/issue-link.js
var require_issue_link = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/issue-link.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.issueLinkResolver = issueLinkResolver;
    var _issueKey = require_issue_key();
    function issueLinkResolver(link, schema, context) {
      var originalLinkText = link.originalLinkText, linkTitle = link.linkTitle, notLinkBody = link.notLinkBody;
      if (linkTitle === "smart-card" || // Ignored via go/ees007
      // eslint-disable-next-line @atlaskit/editor/enforce-todo-comment-format
      // TODO: Depricated should be removed in the next major release
      linkTitle === "block-link") {
        return [schema.nodes.blockCard.createChecked({
          url: notLinkBody
        })];
      }
      if (linkTitle === "smart-link") {
        return [schema.nodes.inlineCard.createChecked({
          url: notLinkBody
        })];
      }
      if (linkTitle === "smart-embed") {
        return [schema.nodes.embedCard.createChecked({
          url: notLinkBody
        })];
      }
      var issue = (0, _issueKey.getIssue)(context, originalLinkText);
      if (issue) {
        return (0, _issueKey.buildInlineCard)(schema, issue);
      }
      return void 0;
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/link-resolver.js
var require_link_resolver = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/link-resolver.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.resolveLink = resolveLink;
    var _mentionLink = require_mention_link();
    var _attachmentLink = require_attachment_link();
    var _urlLink = require_url_link();
    var _issueLink = require_issue_link();
    function _createForOfIteratorHelper(r, e) {
      var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
      if (!t) {
        if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
          t && (r = t);
          var _n = 0, F = function F2() {
          };
          return { s: F, n: function n() {
            return _n >= r.length ? { done: true } : { done: false, value: r[_n++] };
          }, e: function e2(r2) {
            throw r2;
          }, f: F };
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }
      var o, a = true, u = false;
      return { s: function s() {
        t = t.call(r);
      }, n: function n() {
        var r2 = t.next();
        return a = r2.done, r2;
      }, e: function e2(r2) {
        u = true, o = r2;
      }, f: function f() {
        try {
          a || null == t.return || t.return();
        } finally {
          if (u) throw o;
        }
      } };
    }
    function _unsupportedIterableToArray(r, a) {
      if (r) {
        if ("string" == typeof r) return _arrayLikeToArray(r, a);
        var t = {}.toString.call(r).slice(8, -1);
        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
      }
    }
    function _arrayLikeToArray(r, a) {
      (null == a || a > r.length) && (a = r.length);
      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
      return n;
    }
    var linkResolverStrategies = [_attachmentLink.attachmentLinkResolver, _mentionLink.mentionLinkResolver, _issueLink.issueLinkResolver, _urlLink.urlLinkResolver];
    function resolveLink(link, schema, context) {
      var length = link.originalLinkText.length + 2;
      var _iterator = _createForOfIteratorHelper(linkResolverStrategies), _step;
      try {
        for (_iterator.s(); !(_step = _iterator.n()).done; ) {
          var resolver = _step.value;
          var resolvedLink = resolver(link, schema, context);
          if (resolvedLink) {
            return {
              length,
              nodes: resolvedLink,
              type: "pmnode"
            };
          }
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
      return void 0;
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/link-parser.js
var require_link_parser = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/link-parser.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.parseContentLink = parseContentLink;
    exports2.parseLink = parseLink;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _text = require_text6();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    function trimIfPossible(s) {
      if (s === null) {
        return null;
      }
      return s.trim();
    }
    function extractLinkBody(buffer) {
      var indexOfBang = buffer.indexOf("!");
      var indexOfPipe = buffer.indexOf("|");
      var lastIndexOfBang = buffer.lastIndexOf("!");
      var notEscaped = indexOfBang === -1 || indexOfBang > indexOfPipe || indexOfBang === lastIndexOfBang;
      if (notEscaped) {
        return divideOn(buffer, "|");
      }
      var body = new _text.StringBuffer();
      var inEscape = false;
      for (var i = 0; i < buffer.length(); i++) {
        var c = buffer.charAt(i);
        if (c === "!") {
          inEscape = !inEscape;
        }
        if (c === "|" && !inEscape) {
          buffer.delete(0, i + 1);
          return body.toString();
        }
        body.append(c);
      }
      return null;
    }
    function divideAfterLast(buffer, divider) {
      if (buffer.length() === 0) {
        return null;
      }
      return divideAfter(buffer, buffer.lastIndexOf(divider));
    }
    function divideAfter(buffer, index) {
      if (typeof index === "string") {
        index = buffer.indexOf(index);
      }
      if (index < 0) {
        return null;
      } else if (index === buffer.length() - 1) {
        buffer.deleteCharAt(buffer.length() - 1);
        return null;
      } else {
        var body = buffer.substring(index + 1);
        buffer.delete(index, buffer.length());
        return body;
      }
    }
    function divideOn(buffer, divider) {
      if (buffer.length() === 0) {
        return null;
      }
      var i = buffer.indexOf(divider);
      if (i < 0) {
        return null;
      } else if (i === 0) {
        buffer.deleteCharAt(0);
        return null;
      } else {
        var body = buffer.substring(0, i);
        buffer.delete(0, i + 1);
        return body;
      }
    }
    function extractNumber(buf) {
      var digits = new _text.StringBuffer();
      var i = 0;
      for (; i < buf.length() && (0, _text.isDigit)(buf.charAt(i)); i++) {
        digits.append(buf.charAt(i));
      }
      if (i > 0) {
        buf.delete(0, i);
      }
      try {
        return parseInt(digits.toString(), 10);
      } catch (e) {
        return 0;
      }
    }
    function parseLink(linkText) {
      var originalLinkText = linkText;
      if (linkText.indexOf("&#039;") !== -1) {
        linkText = linkText.replace("&#039;", "'");
      }
      var buf = new _text.StringBuffer(linkText);
      var linkBody = extractLinkBody(buf);
      var linkTitle = trimIfPossible(divideAfter(buf, "|"));
      var notLinkBody = buf.toString().trim();
      return {
        originalLinkText,
        linkBody,
        linkTitle,
        notLinkBody
      };
    }
    function parseContentLink(link) {
      if (typeof link === "string") {
        link = parseLink(link);
      }
      var _link = link, notLinkBody = _link.notLinkBody;
      var shortcutName = null;
      var shortcutValue = null;
      var spaceKey = null;
      var attachmentName = null;
      var anchor = null;
      var destinationTitle = "";
      var contentId = 0;
      if (!notLinkBody.startsWith("~")) {
        var shortcutBuf = new _text.StringBuffer(notLinkBody);
        shortcutName = trimIfPossible(divideAfterLast(shortcutBuf, "@"));
        if ((0, _text.isNotBlank)(shortcutName)) {
          shortcutValue = shortcutBuf.toString();
        }
      }
      var buf = new _text.StringBuffer(notLinkBody);
      if ((0, _text.isBlank)(shortcutName)) {
        spaceKey = trimIfPossible(divideOn(buf, ":"));
        if (buf.indexOf("$") === 0) {
          buf.deleteCharAt(0);
          contentId = extractNumber(buf);
          if (contentId === 0) {
            return _objectSpread(_objectSpread({}, link), {}, {
              shortcutName,
              shortcutValue,
              spaceKey,
              contentId,
              attachmentName,
              anchor,
              destinationTitle
            });
          }
        }
        attachmentName = trimIfPossible(divideAfter(buf, "^"));
        anchor = trimIfPossible(divideAfter(buf, "#"));
      }
      if (contentId === 0) {
        destinationTitle = buf.toString().trim();
      }
      return _objectSpread(_objectSpread({}, link), {}, {
        shortcutName,
        shortcutValue,
        spaceKey,
        contentId,
        attachmentName,
        anchor,
        destinationTitle
      });
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/link-format.js
var require_link_format = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/links/link-format.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.linkFormat = void 0;
    var _ = require_tokenize();
    var _text = require_text5();
    var _linkResolver = require_link_resolver();
    var _linkParser = require_link_parser();
    var LINK_FORMAT_REGEXP = /^\[([^\[\]\n]+)]/;
    var linkFormat = exports2.linkFormat = function linkFormat2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var match = input2.substring(position).match(LINK_FORMAT_REGEXP);
      var ignoreTokenTypes = [
        _.TokenType.DOUBLE_DASH_SYMBOL,
        _.TokenType.TRIPLE_DASH_SYMBOL,
        _.TokenType.QUADRUPLE_DASH_SYMBOL,
        _.TokenType.TABLE,
        _.TokenType.RULER,
        // We want to avoid recursion
        _.TokenType.LINK_TEXT,
        _.TokenType.LINK_FORMAT
      ];
      if (!match) {
        return fallback();
      }
      var content = (0, _linkParser.parseContentLink)(match[1]);
      var resolvedLink = (0, _linkResolver.resolveLink)(content, schema, context);
      if (resolvedLink) {
        return resolvedLink;
      }
      var nodes = (0, _text.parseString)({
        schema,
        context,
        ignoreTokenTypes,
        input: match[0]
      });
      return {
        type: "pmnode",
        nodes,
        length: match[0].length
      };
    };
    function fallback() {
      return {
        type: "text",
        text: "[",
        length: 1
      };
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/common-formatter.js
var require_common_formatter = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/common-formatter.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.commonFormatter = commonFormatter;
    var _ = require_tokenize();
    var _linkFormat = require_link_format();
    var _whitespace = require_whitespace();
    var _keyword = require_keyword();
    var _escape = require_escape3();
    var processState = {
      START: 0,
      BUFFER: 1,
      END: 2,
      INLINE_MACRO: 3,
      LINK_FORMAT: 4,
      ESCAPE: 5
    };
    function commonFormatter(input2, position, schema, opt) {
      var index = position;
      var state = processState.START;
      var buffer = [];
      var openingSymbolLength = opt.opening.length;
      var closingSymbolLength = opt.closing.length;
      var openingWrapped = opt.opening.startsWith("{") && opt.opening.endsWith("}");
      var closingWrapped = opt.closing.startsWith("{") && opt.closing.endsWith("}");
      while (index < input2.length) {
        var char = input2.charAt(index);
        var twoChar = input2.substr(index, 2);
        var charsMatchClosingSymbol = input2.substr(index, closingSymbolLength);
        switch (state) {
          case processState.START: {
            if (position > 0) {
              var charBeforeOpening = input2.charAt(position - 1);
              if (!openingWrapped && // Ignored via go/ees005
              // eslint-disable-next-line require-unicode-regexp
              /[a-zA-Z0-9]|[^\u0000-\u007F]/.test(charBeforeOpening) && charBeforeOpening !== "\xA0") {
                return fallback(input2, index, openingSymbolLength);
              }
            }
            var charAfterOpening = input2.charAt(index + openingSymbolLength);
            if (!input2.substring(position).startsWith(opt.opening) || charAfterOpening === " ") {
              return fallback(input2, position, openingSymbolLength);
            }
            state = processState.BUFFER;
            index += openingSymbolLength;
            continue;
          }
          case processState.BUFFER: {
            var length = (0, _whitespace.parseNewlineOnly)(input2.substring(index));
            if (length) {
              return fallback(input2, position, openingSymbolLength);
            }
            if (charsMatchClosingSymbol === opt.closing) {
              state = processState.END;
              continue;
            } else if (twoChar === "{{") {
              buffer.push(twoChar);
              index += 2;
              continue;
            } else if (char === "{") {
              state = processState.INLINE_MACRO;
              continue;
            } else if (char === "[") {
              state = processState.LINK_FORMAT;
              continue;
            } else if (char === "\\") {
              state = processState.ESCAPE;
              continue;
            } else {
              buffer.push(char);
            }
            break;
          }
          case processState.END: {
            index += closingSymbolLength;
            if (buffer.length === 0) {
              return fallback(input2, position, openingSymbolLength);
            }
            if (index < input2.length) {
              var charAfterEnd = input2.charAt(index);
              if (!closingWrapped && // Ignored via go/ees005
              // eslint-disable-next-line require-unicode-regexp
              /[a-zA-Z0-9]|[^\u0000-\u007F]/.test(charAfterEnd) && charAfterEnd !== "\xA0") {
                buffer.push(charsMatchClosingSymbol);
                state = processState.BUFFER;
                continue;
              }
            }
            if (buffer.length > 0 && buffer[buffer.length - 1].endsWith(" ")) {
              return fallback(input2, position, openingSymbolLength);
            }
            return opt.rawContentProcessor(buffer.join(""), index - position);
          }
          case processState.INLINE_MACRO: {
            var match = (0, _keyword.parseMacroKeyword)(input2.substring(index));
            if (!match) {
              buffer.push(char);
              state = processState.BUFFER;
              break;
            }
            var token = (0, _.parseToken)(input2, match.type, index, schema, {});
            if (token.type === "text") {
              buffer.push(token.text);
              index += token.length;
              state = processState.BUFFER;
              continue;
            } else if (match.type === _.TokenType.COLOR_MACRO) {
              buffer.push(input2.substr(index, token.length));
              index += token.length;
              state = processState.BUFFER;
              continue;
            } else {
              return fallback(input2, position, openingSymbolLength);
            }
          }
          case processState.LINK_FORMAT: {
            var _token = (0, _linkFormat.linkFormat)({
              input: input2,
              schema,
              position: index,
              context: {}
            });
            if (_token.type === "text") {
              buffer.push(_token.text);
              index += _token.length;
              state = processState.BUFFER;
              continue;
            } else if (_token.type === "pmnode") {
              buffer.push(input2.substr(index, _token.length));
              index += _token.length;
              state = processState.BUFFER;
              continue;
            }
            return fallback(input2, position, openingSymbolLength);
          }
          case processState.ESCAPE: {
            var _token2 = (0, _escape.escapeHandler)(input2, index);
            buffer.push(_token2.text);
            index += _token2.length;
            state = processState.BUFFER;
            continue;
          }
          default:
        }
        index++;
      }
      return fallback(input2, position, openingSymbolLength);
    }
    function fallback(input2, position, length) {
      return {
        type: "text",
        text: input2.substr(position, length),
        length
      };
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/media.js
var require_media4 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/media.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.media = void 0;
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _mediaSingle = _interopRequireDefault(require_mediaSingle());
    var _attrs = require_attrs();
    var _commonFormatter = require_common_formatter();
    var media = exports2.media = function media2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var rawContentProcessor = function rawContentProcessor2(raw, length) {
        var _raw$split = raw.split("|"), _raw$split2 = (0, _slicedToArray2.default)(_raw$split, 2), rawContent = _raw$split2[0], _raw$split2$ = _raw$split2[1], rawAttrs = _raw$split2$ === void 0 ? "" : _raw$split2$;
        var node = (0, _mediaSingle.default)(schema, rawContent, (0, _attrs.parseAttrs)(rawAttrs, ","), context);
        return {
          type: "pmnode",
          nodes: [node],
          length
        };
      };
      return (0, _commonFormatter.commonFormatter)(input2, position, schema, {
        opening: "!",
        closing: "!",
        context,
        rawContentProcessor
      });
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/common-macro.js
var require_common_macro = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/common-macro.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.commonMacro = commonMacro;
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    function commonMacro(input2, schema, opt) {
      var opening = new RegExp("^{(".concat(opt.keyword, ")(?::([^{\n}]*))?}"), "i");
      var matchOpening = input2.match(opening);
      if (!matchOpening) {
        return fallback(input2);
      }
      var _matchOpening = (0, _slicedToArray2.default)(matchOpening, 3), name = _matchOpening[1], rawAttrs = _matchOpening[2];
      var openingLength = matchOpening[0].length;
      if (!opt.paired) {
        return opt.rawContentProcessor(rawAttrs, "", openingLength, schema, opt.context);
      }
      var closing = new RegExp("{".concat(name, "}"));
      var matchClosing = closing.exec(input2.substring(openingLength));
      var rawContent = "";
      if (matchClosing) {
        rawContent = input2.substring(openingLength, openingLength + matchClosing.index);
      }
      var length = matchClosing ? openingLength + matchClosing.index + matchClosing[0].length : openingLength;
      return opt.rawContentProcessor(rawAttrs, rawContent, length, schema, opt.context);
    }
    function fallback(input2) {
      return {
        type: "text",
        text: input2.substr(0, 1),
        length: 1
      };
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/quote-macro.js
var require_quote_macro = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/quote-macro.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.rawContentProcessor = exports2.quoteMacro = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _commonMacro = require_common_macro();
    var _text = require_text6();
    var _normalize = require_normalize2();
    var _text2 = require_text5();
    function _createForOfIteratorHelper(r, e) {
      var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
      if (!t) {
        if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
          t && (r = t);
          var _n = 0, F = function F2() {
          };
          return { s: F, n: function n() {
            return _n >= r.length ? { done: true } : { done: false, value: r[_n++] };
          }, e: function e2(r2) {
            throw r2;
          }, f: F };
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }
      var o, a = true, u = false;
      return { s: function s() {
        t = t.call(r);
      }, n: function n() {
        var r2 = t.next();
        return a = r2.done, r2;
      }, e: function e2(r2) {
        u = true, o = r2;
      }, f: function f() {
        try {
          a || null == t.return || t.return();
        } finally {
          if (u) throw o;
        }
      } };
    }
    function _unsupportedIterableToArray(r, a) {
      if (r) {
        if ("string" == typeof r) return _arrayLikeToArray(r, a);
        var t = {}.toString.call(r).slice(8, -1);
        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
      }
    }
    function _arrayLikeToArray(r, a) {
      (null == a || a > r.length) && (a = r.length);
      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
      return n;
    }
    var quoteMacro = exports2.quoteMacro = function quoteMacro2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      return (0, _commonMacro.commonMacro)(input2.substring(position), schema, {
        keyword: "quote",
        paired: true,
        rawContentProcessor,
        context
      });
    };
    var rawContentProcessor = exports2.rawContentProcessor = function rawContentProcessor2(_rawAttrs, rawContent, length, schema, context) {
      if (!rawContent.length) {
        var emptyQuote = emptyBlockquote(schema);
        return {
          type: "pmnode",
          nodes: [emptyQuote],
          length
        };
      }
      var parsedContent = (0, _text2.parseString)({
        schema,
        context,
        ignoreTokenTypes: [],
        input: rawContent
      });
      var normalizedContent = (0, _normalize.normalizePMNodes)(parsedContent, schema);
      return {
        type: "pmnode",
        nodes: sanitize(normalizedContent, schema),
        length
      };
    };
    function emptyBlockquote(schema) {
      var p = schema.nodes.paragraph.createChecked({}, []);
      return schema.nodes.blockquote.createChecked({}, p);
    }
    function sanitize(nodes, schema) {
      var output = [];
      var contentBuffer = [];
      var _iterator = _createForOfIteratorHelper(nodes), _step;
      try {
        for (_iterator.s(); !(_step = _iterator.n()).done; ) {
          var n = _step.value;
          switch (n.type.name) {
            case "paragraph":
            case "bulletList":
            case "orderedList":
            case "codeBlock":
            case "mediaSingle":
            case "mediaGroup": {
              contentBuffer.push(n);
              break;
            }
            case "heading": {
              contentBuffer.push(transformHeading(n, schema));
              break;
            }
            default:
              if (contentBuffer.length) {
                var _blockquote = schema.nodes.blockquote.createChecked({}, contentBuffer);
                output.push(_blockquote);
                contentBuffer = [];
              }
              output.push(n);
          }
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
      if (contentBuffer.length) {
        var blockquote = schema.nodes.blockquote.createChecked({}, contentBuffer);
        output.push(blockquote);
      }
      return output;
    }
    function transformHeading(heading, schema) {
      var contentBuffer = [];
      heading.content.forEach(function(n) {
        var strong = schema.marks.strong.create();
        var italic = schema.marks.em.create();
        var gray = schema.marks.textColor.create({
          color: "#97a0af"
        });
        if (n.type.name === "text") {
          if (n.text && heading.attrs.level === 1) {
            n.text = n.text.toUpperCase();
          }
          if (heading.attrs.level <= 4 && !(0, _text.hasAnyOfMarks)(n, ["strong", "code"])) {
            n = n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [strong]));
          }
          if ((heading.attrs.level === 5 || heading.attrs.level === 2) && !(0, _text.hasAnyOfMarks)(n, ["em", "code"])) {
            n = n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [italic]));
          }
          if (heading.attrs.level > 3 && !(0, _text.hasAnyOfMarks)(n, ["textColor", "code"])) {
            n = n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [gray]));
          }
        }
        contentBuffer.push(n);
      });
      return schema.nodes.paragraph.createChecked({}, contentBuffer);
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/blockquote.js
var require_blockquote5 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/blockquote.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.blockquote = void 0;
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _quoteMacro = require_quote_macro();
    var BLOCKQUOTE_REGEXP = /^bq\.(.*)/;
    var blockquote = exports2.blockquote = function blockquote2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var match = input2.substring(position).match(BLOCKQUOTE_REGEXP);
      if (!match) {
        return fallback(input2, position);
      }
      var _match = (0, _slicedToArray2.default)(match, 2), rawContent = _match[1];
      return (0, _quoteMacro.rawContentProcessor)("", rawContent, match[0].length, schema, context);
    };
    function fallback(input2, position) {
      return {
        type: "text",
        text: input2.substr(position, 1),
        length: 1
      };
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/char.js
var require_char = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/char.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.EM_DASH = void 0;
    var EM_DASH = exports2.EM_DASH = "\u2014";
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/citation.js
var require_citation = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/citation.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.citation = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _ = require_tokenize();
    var _text = require_text6();
    var _commonFormatter = require_common_formatter();
    var _text2 = require_text5();
    var _char = require_char();
    var citation = exports2.citation = function citation2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var ignoreTokenTypes = [_.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.ISSUE_KEY];
      var contentDecorator = function contentDecorator2(n, index) {
        var mark = schema.marks.em.create();
        if (n.type.name === "text" && !(0, _text.hasAnyOfMarks)(n, ["em", "code"])) {
          if (index === 0) {
            n.text = "".concat(_char.EM_DASH, " ").concat(n.text);
          }
          return n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [mark]));
        }
        return n;
      };
      var rawContentProcessor = function rawContentProcessor2(raw, length) {
        var content = (0, _text2.parseString)({
          ignoreTokenTypes,
          schema,
          context,
          input: raw
        });
        var decoratedContent = content.map(contentDecorator);
        return {
          type: "pmnode",
          nodes: decoratedContent,
          length
        };
      };
      var _getSurroundingSymbol = (0, _text.getSurroundingSymbols)(input2.substring(position), "??", "??"), openingSymbol = _getSurroundingSymbol.openingSymbol, closingSymbol = _getSurroundingSymbol.closingSymbol;
      return (0, _commonFormatter.commonFormatter)(input2, position, schema, {
        opening: openingSymbol,
        closing: closingSymbol,
        context,
        rawContentProcessor
      });
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/deleted.js
var require_deleted = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/deleted.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.deleted = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _ = require_tokenize();
    var _text = require_text6();
    var _commonFormatter = require_common_formatter();
    var _text2 = require_text5();
    var deleted = exports2.deleted = function deleted2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var ignoreTokenTypes = [_.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.ISSUE_KEY, _.TokenType.TABLE];
      var contentDecorator = function contentDecorator2(n) {
        var mark = schema.marks.strike.create();
        if (n.type.name === "text" && !(0, _text.hasAnyOfMarks)(n, ["strike", "code"])) {
          return n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [mark]));
        }
        return n;
      };
      var rawContentProcessor = function rawContentProcessor2(raw, length) {
        var content = (0, _text2.parseString)({
          ignoreTokenTypes,
          schema,
          context,
          input: raw
        });
        var decoratedContent = content.map(contentDecorator);
        return {
          type: "pmnode",
          nodes: decoratedContent,
          length
        };
      };
      var _getSurroundingSymbol = (0, _text.getSurroundingSymbols)(input2.substring(position), "-", "-"), openingSymbol = _getSurroundingSymbol.openingSymbol, closingSymbol = _getSurroundingSymbol.closingSymbol;
      return (0, _commonFormatter.commonFormatter)(input2, position, schema, {
        opening: openingSymbol,
        closing: closingSymbol,
        context,
        rawContentProcessor
      });
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/dash-token-creator.js
var require_dash_token_creator = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/dash-token-creator.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.createDashTokenParser = void 0;
    var createDashTokenParser = exports2.createDashTokenParser = function createDashTokenParser2(token, fallback) {
      return function(_ref) {
        var input2 = _ref.input, position = _ref.position;
        if (position > 0) {
          var charBeforeToken = input2.charAt(position - 1);
          if (!isSpace(charBeforeToken)) {
            return fallback;
          }
        }
        if (position + token.length < input2.length) {
          var charAfterToken = input2.charAt(position + token.length);
          if (!isSpace(charAfterToken)) {
            return fallback;
          }
        }
        return token;
      };
    };
    var isSpace = function isSpace2(char) {
      return /\s/.test(char);
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/double-dash-symbol.js
var require_double_dash_symbol = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/double-dash-symbol.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.doubleDashSymbol = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _dashTokenCreator = require_dash_token_creator();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var token = {
      type: "text",
      text: "\u2013",
      // EN DASH
      length: 2
    };
    var fallback = _objectSpread(_objectSpread({}, token), {}, {
      text: "--"
    });
    var doubleDashSymbol = exports2.doubleDashSymbol = (0, _dashTokenCreator.createDashTokenParser)(token, fallback);
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/emoji.js
var require_emoji5 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/emoji.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.wikiToAdfEmojiMapping = exports2.emoji = exports2.adfEmojiItems = void 0;
    var emptyOrSpecialCharRegex = new RegExp(/^$|[^A-Za-z0-9]/);
    var emoji = exports2.emoji = function emoji2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema;
      var substring = input2.substring(position);
      for (var i = 2; i <= 9 && i <= substring.length; ++i) {
        var candidateText = substring.substring(0, i);
        var emojiId = wikiToAdfEmojiMapping[candidateText];
        if (emojiId && emptyOrSpecialCharRegex.test(substring.charAt(i))) {
          return {
            type: "pmnode",
            nodes: [schema.nodes.emoji.createChecked(adfEmojiItems[emojiId])],
            length: i
          };
        }
      }
      return {
        type: "text",
        text: substring.substr(0, 1),
        length: 1
      };
    };
    var adfEmojiItems = exports2.adfEmojiItems = {
      "1f642": {
        id: "1f642",
        shortName: ":slight_smile:",
        text: "\u{1F642}"
      },
      "1f61e": {
        id: "1f61e",
        shortName: ":disappointed:",
        text: "\u{1F61E}"
      },
      "1f61b": {
        id: "1f61b",
        shortName: ":stuck_out_tongue:",
        text: "\u{1F61B}"
      },
      "1f603": {
        id: "1f603",
        shortName: ":smiley:",
        text: "\u{1F603}"
      },
      "1f609": {
        id: "1f609",
        shortName: ":wink:",
        text: "\u{1F609}"
      },
      "1f44d": {
        id: "1f44d",
        shortName: ":thumbsup:",
        text: "\u{1F44D}"
      },
      "1f44e": {
        id: "1f44e",
        shortName: ":thumbsdown:",
        text: "\u{1F44E}"
      },
      "atlassian-info": {
        id: "atlassian-info",
        shortName: ":info:",
        text: ":info:"
      },
      "atlassian-check_mark": {
        id: "atlassian-check_mark",
        shortName: ":check_mark:",
        text: ":check_mark:"
      },
      "atlassian-cross_mark": {
        id: "atlassian-cross_mark",
        shortName: ":cross_mark:",
        text: ":cross_mark:"
      },
      "atlassian-warning": {
        id: "atlassian-warning",
        shortName: ":warning:",
        text: ":warning:"
      },
      "atlassian-plus": {
        id: "atlassian-plus",
        shortName: ":plus:",
        text: ":plus:"
      },
      "atlassian-minus": {
        id: "atlassian-minus",
        shortName: ":minus:",
        text: ":minus:"
      },
      "atlassian-question_mark": {
        id: "atlassian-question_mark",
        shortName: ":question:",
        text: ":question:"
      },
      "atlassian-light_bulb_on": {
        id: "atlassian-light_bulb_on",
        shortName: ":light_bulb_on:",
        text: ":light_bulb_on:"
      },
      "atlassian-light_bulb_off": {
        id: "atlassian-light_bulb_off",
        shortName: ":light_bulb_off:",
        text: ":light_bulb_off:"
      },
      "atlassian-yellow_star": {
        id: "atlassian-yellow_star",
        shortName: ":yellow_star:",
        text: ":yellow_star:"
      },
      "atlassian-red_star": {
        id: "atlassian-red_star",
        shortName: ":red_star:",
        text: ":red_star:"
      },
      "atlassian-green_star": {
        id: "atlassian-green_star",
        shortName: ":green_star:",
        text: ":green_star:"
      },
      "atlassian-blue_star": {
        id: "atlassian-blue_star",
        shortName: ":blue_star:",
        text: ":blue_star:"
      },
      "atlassian-flag_on": {
        id: "atlassian-flag_on",
        shortName: ":flag_on:",
        text: ":flag_on:"
      },
      "atlassian-flag_off": {
        id: "atlassian-flag_off",
        shortName: ":flag_off:",
        text: ":flag_off:"
      }
    };
    var wikiToAdfEmojiMapping = exports2.wikiToAdfEmojiMapping = {
      ":)": "1f642",
      ":-)": "1f642",
      ":(": "1f61e",
      ":-(": "1f61e",
      ":P": "1f61b",
      ":-P": "1f61b",
      ":p": "1f61b",
      ":-p": "1f61b",
      ":D": "1f603",
      ":-D": "1f603",
      ";)": "1f609",
      ";-)": "1f609",
      "(y)": "1f44d",
      "(n)": "1f44e",
      "(i)": "atlassian-info",
      "(/)": "atlassian-check_mark",
      "(x)": "atlassian-cross_mark",
      "(!)": "atlassian-warning",
      "(+)": "atlassian-plus",
      "(-)": "atlassian-minus",
      "(?)": "atlassian-question_mark",
      "(on)": "atlassian-light_bulb_on",
      "(off)": "atlassian-light_bulb_off",
      "(*)": "atlassian-yellow_star",
      "(*y)": "atlassian-yellow_star",
      "(*r)": "atlassian-red_star",
      "(*g)": "atlassian-green_star",
      "(*b)": "atlassian-blue_star",
      "(flag)": "atlassian-flag_on",
      "(flagoff)": "atlassian-flag_off"
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/emphasis.js
var require_emphasis2 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/emphasis.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.emphasis = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _ = require_tokenize();
    var _text = require_text6();
    var _commonFormatter = require_common_formatter();
    var _text2 = require_text5();
    var emphasis = exports2.emphasis = function emphasis2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var ignoreTokenTypes = [_.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.ISSUE_KEY, _.TokenType.TABLE];
      var contentDecorator = function contentDecorator2(n) {
        var mark = schema.marks.em.create();
        if (n.type.name === "text" && !(0, _text.hasAnyOfMarks)(n, ["em", "code"])) {
          return n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [mark]));
        }
        return n;
      };
      var rawContentProcessor = function rawContentProcessor2(raw, length) {
        var content = (0, _text2.parseString)({
          ignoreTokenTypes,
          schema,
          context,
          input: raw
        });
        var decoratedContent = content.map(contentDecorator);
        return {
          type: "pmnode",
          nodes: decoratedContent,
          length
        };
      };
      var _getSurroundingSymbol = (0, _text.getSurroundingSymbols)(input2.substring(position), "_", "_"), openingSymbol = _getSurroundingSymbol.openingSymbol, closingSymbol = _getSurroundingSymbol.closingSymbol;
      return (0, _commonFormatter.commonFormatter)(input2, position, schema, {
        opening: openingSymbol,
        closing: closingSymbol,
        context,
        rawContentProcessor
      });
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/hardbreak.js
var require_hardbreak = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/hardbreak.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.hardbreak = void 0;
    var _whitespace = require_whitespace();
    var hardbreak = exports2.hardbreak = function hardbreak2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema;
      var length = (0, _whitespace.parseNewlineOnly)(input2.substring(position));
      if (length === 0) {
        return {
          type: "text",
          text: input2.substr(position, 1),
          length: 1
        };
      }
      return {
        type: "pmnode",
        nodes: [schema.nodes.hardBreak.createChecked()],
        length
      };
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/heading.js
var require_heading4 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/heading.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.heading = void 0;
    var _text = require_text5();
    var _ = require_tokenize();
    var HEADING_REGEXP = /^h([1-6])\.(.*)/;
    var heading = exports2.heading = function heading2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var ignoreTokenTypes = [_.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL];
      var match = input2.substring(position).match(HEADING_REGEXP);
      if (!match) {
        return fallback(input2, position);
      }
      var level = parseInt(match[1], 10);
      var content = (0, _text.parseString)({
        schema,
        ignoreTokenTypes,
        context,
        input: match[2]
      });
      try {
        var headingNode = schema.nodes.heading.createChecked({
          level
        }, content);
        return {
          type: "pmnode",
          nodes: [headingNode],
          length: match[0].length
        };
      } catch (err) {
        return {
          type: "text",
          text: "",
          length: 4
        };
      }
    };
    function fallback(input2, position) {
      return {
        type: "text",
        text: input2.substr(position, 1),
        length: 1
      };
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/inserted.js
var require_inserted = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/inserted.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.inserted = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _ = require_tokenize();
    var _text = require_text6();
    var _commonFormatter = require_common_formatter();
    var _text2 = require_text5();
    var inserted = exports2.inserted = function inserted2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var ignoreTokenTypes = [_.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.ISSUE_KEY, _.TokenType.TABLE];
      var contentDecorator = function contentDecorator2(n) {
        var mark = schema.marks.underline.create();
        if (n.type.name === "text" && !(0, _text.hasAnyOfMarks)(n, ["underline", "code"])) {
          return n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [mark]));
        }
        return n;
      };
      var rawContentProcessor = function rawContentProcessor2(raw, length) {
        var content = (0, _text2.parseString)({
          ignoreTokenTypes,
          schema,
          context,
          input: raw
        });
        var decoratedContent = content.map(contentDecorator);
        return {
          type: "pmnode",
          nodes: decoratedContent,
          length
        };
      };
      var _getSurroundingSymbol = (0, _text.getSurroundingSymbols)(input2.substring(position), "+", "+"), openingSymbol = _getSurroundingSymbol.openingSymbol, closingSymbol = _getSurroundingSymbol.closingSymbol;
      return (0, _commonFormatter.commonFormatter)(input2, position, schema, {
        opening: openingSymbol,
        closing: closingSymbol,
        context,
        rawContentProcessor
      });
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/builder/list-builder.js
var require_list_builder = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/builder/list-builder.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.ListBuilder = void 0;
    exports2.getType = getType;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    function _createForOfIteratorHelper(r, e) {
      var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
      if (!t) {
        if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
          t && (r = t);
          var _n = 0, F = function F2() {
          };
          return { s: F, n: function n() {
            return _n >= r.length ? { done: true } : { done: false, value: r[_n++] };
          }, e: function e2(r2) {
            throw r2;
          }, f: F };
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }
      var o, a = true, u = false;
      return { s: function s() {
        t = t.call(r);
      }, n: function n() {
        var r2 = t.next();
        return a = r2.done, r2;
      }, e: function e2(r2) {
        u = true, o = r2;
      }, f: function f() {
        try {
          a || null == t.return || t.return();
        } finally {
          if (u) throw o;
        }
      } };
    }
    function _unsupportedIterableToArray(r, a) {
      if (r) {
        if ("string" == typeof r) return _arrayLikeToArray(r, a);
        var t = {}.toString.call(r).slice(8, -1);
        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
      }
    }
    function _arrayLikeToArray(r, a) {
      (null == a || a > r.length) && (a = r.length);
      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
      return n;
    }
    var supportedContentType = ["paragraph", "orderedList", "bulletList", "mediaSingle", "codeBlock"];
    function getType(bullets) {
      return /#$/.test(bullets) ? "orderedList" : "bulletList";
    }
    var ListBuilder = exports2.ListBuilder = /* @__PURE__ */ (function() {
      function ListBuilder2(schema, bullets) {
        var _this = this;
        (0, _classCallCheck2.default)(this, ListBuilder2);
        (0, _defineProperty2.default)(this, "parseList", function(list) {
          var listNode = _this.schema.nodes[list.type];
          var output = [];
          var listItemsBuffer = [];
          for (var i = 0; i < list.children.length; i++) {
            var parsedContent = _this.parseListItem(list.children[i]);
            for (var j = 0; j < parsedContent.length; j++) {
              var parsedNode = parsedContent[j];
              if (parsedNode.type.name === "listItem") {
                listItemsBuffer.push(parsedNode);
                continue;
              }
              if (listItemsBuffer.length) {
                var _list = listNode.createChecked({}, listItemsBuffer);
                output.push(_list);
              }
              output.push(parsedNode);
              listItemsBuffer = [];
            }
          }
          if (listItemsBuffer.length) {
            var _list2 = listNode.createChecked({}, listItemsBuffer);
            output.push(_list2);
          }
          return output;
        });
        (0, _defineProperty2.default)(this, "parseListItem", function(item) {
          var _item$content;
          var output = [];
          if (!item.content) {
            item.content = [];
          }
          var parsedChildren = item.children.reduce(function(result, list) {
            var parsedList = _this.parseList(list);
            result.push.apply(result, (0, _toConsumableArray2.default)(parsedList));
            return result;
          }, []);
          (_item$content = item.content).push.apply(_item$content, (0, _toConsumableArray2.default)(parsedChildren));
          var contentBuffer = [];
          for (var i = 0; i < item.content.length; i++) {
            var pmNode = item.content[i];
            if (pmNode.type.name === "paragraph" && pmNode.childCount === 0) {
              continue;
            }
            if (_this.isParagraphEmptyTextNode(pmNode)) {
              continue;
            }
            if (supportedContentType.indexOf(pmNode.type.name) === -1) {
              var listItem = _this.createListItem(contentBuffer, _this.schema);
              output.push(listItem);
              output.push(pmNode);
              contentBuffer = [];
              continue;
            }
            contentBuffer.push(pmNode);
          }
          if (contentBuffer.length) {
            var _listItem = _this.createListItem(contentBuffer, _this.schema);
            output.push(_listItem);
          }
          return output;
        });
        this.schema = schema;
        this.root = {
          children: [],
          type: getType(bullets)
        };
        this.lastDepth = 1;
        this.lastList = this.root;
      }
      return (0, _createClass2.default)(ListBuilder2, [{
        key: "type",
        get: function get() {
          return this.root.type;
        }
        /**
         * Add a list item to the builder
         * @param {AddArgs[]} items
         */
      }, {
        key: "add",
        value: function add(items) {
          var _iterator = _createForOfIteratorHelper(items), _step;
          try {
            for (_iterator.s(); !(_step = _iterator.n()).done; ) {
              var item = _step.value;
              var style = item.style, content = item.content;
              if (style === null) {
                this.appendToLastItem(content);
                continue;
              }
              var depth = style.length;
              var type = getType(style);
              if (depth > this.lastDepth) {
                this.createNest(depth - this.lastDepth, type);
                this.lastDepth = depth;
                this.lastList = this.addListItem(type, content);
              } else if (depth === this.lastDepth) {
                this.lastList = this.addListItem(type, content);
              } else {
                this.lastList = this.findAncestor(this.lastDepth - depth);
                this.lastDepth = depth;
                this.lastList = this.addListItem(type, content);
              }
            }
          } catch (err) {
            _iterator.e(err);
          } finally {
            _iterator.f();
          }
        }
        /**
         * Compile a prosemirror node from the root list
         * @returns {PMNode[]}
         */
      }, {
        key: "buildPMNode",
        value: function buildPMNode() {
          return this.parseList(this.root);
        }
      }, {
        key: "isParagraphEmptyTextNode",
        value: (
          /* Check if all paragraph's children nodes are text and empty */
          function isParagraphEmptyTextNode(node) {
            if (node.type.name !== "paragraph" || !node.childCount) {
              return false;
            }
            for (var i = 0; i < node.childCount; i++) {
              var n = node.content.child(i);
              if (n.type.name !== "text") {
                return false;
              } else if (n.textContent.trim() !== "") {
                return false;
              }
            }
            return true;
          }
        )
      }, {
        key: "createListItem",
        value: function createListItem(content, schema) {
          if (content.length === 0 || ["paragraph", "mediaSingle"].indexOf(content[0].type.name) === -1) {
            content.unshift(this.schema.nodes.paragraph.createChecked());
          }
          return schema.nodes.listItem.createChecked({}, content);
        }
        /**
         * Add an item at the same level as the current list item
         * @param {ListType} type
         * @param {PMNode} content
         * @returns {PMNode}
         */
      }, {
        key: "addListItem",
        value: function addListItem(type, content) {
          var list = this.lastList;
          if (list.type !== type) {
            var parent = list.parent;
            var newList = {
              children: [],
              type,
              parent
            };
            parent.children.push(newList);
            this.lastList = list = newList;
          }
          var listItem = {
            content,
            parent: list,
            children: []
          };
          list.children = [].concat((0, _toConsumableArray2.default)(list.children), [listItem]);
          return list;
        }
        /**
         * Append the past content to the last accessed list node (multiline entries)
         * @param {PMNode[]} content
         */
      }, {
        key: "appendToLastItem",
        value: function appendToLastItem(content) {
          var _ref;
          var children = this.lastList.children;
          var lastItem = children[children.length - 1];
          (_ref = lastItem.content).push.apply(_ref, (0, _toConsumableArray2.default)(content));
        }
        /**
         * Created a nested list structure of N depth under the current node
         * @param {number} depth
         * @param {ListType} type
         */
      }, {
        key: "createNest",
        value: function createNest(depth, type) {
          while (depth-- > 0) {
            if (this.lastList.children.length === 0) {
              var listItem = {
                parent: this.lastList,
                children: []
              };
              this.lastList.children = [listItem];
            }
            var nextItem = this.lastList.children[this.lastList.children.length - 1];
            nextItem.children = [{
              children: [],
              parent: nextItem,
              type
            }];
            this.lastList = nextItem.children[0];
          }
        }
        /**
         * Find the Nth list ancestor of the current list
         * @param {number} depth
         */
      }, {
        key: "findAncestor",
        value: function findAncestor(depth) {
          var list = this.lastList;
          while (depth-- > 0 && list.parent) {
            var listItem = list.parent;
            if (listItem && listItem.parent) {
              list = listItem.parent;
            }
          }
          return list;
        }
      }]);
    })();
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/list.js
var require_list2 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/list.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.list = exports2.MAX_LIST_DEPTH = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _slicedToArray2 = _interopRequireDefault(require_slicedToArray());
    var _listBuilder = require_list_builder();
    var _text = require_text5();
    var _normalize = require_normalize2();
    var _keyword = require_keyword();
    var _ = require_tokenize();
    var _whitespace = require_whitespace();
    var _text2 = require_text6();
    var MAX_LIST_DEPTH = exports2.MAX_LIST_DEPTH = 20;
    var LIST_ITEM_REGEXP = new RegExp("^ *([*\\-#]{1,".concat(MAX_LIST_DEPTH, "}) "));
    var EMPTY_LINE_REGEXP = /^[ \t]*\r?\n/;
    var RULER_SYMBOL_REGEXP = /^-{4,5}/;
    var processState = {
      NEW_LINE: 0,
      BUFFER: 1,
      END: 2,
      MACRO: 3
    };
    var list = exports2.list = function list2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var ignoreTokenTypes = [_.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.LIST, _.TokenType.TABLE];
      var index = position;
      var state = processState.NEW_LINE;
      var buffer = [];
      var lastListSymbols = null;
      var builder = null;
      var contentBuffer = [];
      var output = [];
      while (index < input2.length) {
        var char = input2.charAt(index);
        switch (state) {
          case processState.NEW_LINE: {
            var substring = input2.substring(index);
            var listMatch = substring.match(LIST_ITEM_REGEXP);
            if (listMatch) {
              var _listMatch = (0, _slicedToArray2.default)(listMatch, 2), symbols = _listMatch[1];
              var rulerMatch = symbols.match(RULER_SYMBOL_REGEXP);
              if (rulerMatch) {
                var remainingAfterSymbol = input2.substring(index + rulerMatch[0].length);
                var _emptyLineMatch = remainingAfterSymbol.match(EMPTY_LINE_REGEXP);
                if (_emptyLineMatch) {
                  state = processState.BUFFER;
                  continue;
                }
              }
              if (!builder) {
                builder = new _listBuilder.ListBuilder(schema, symbols);
                lastListSymbols = symbols;
              } else {
                if (buffer.length > 0) {
                  var _contentBuffer;
                  var content = (0, _text.parseString)({
                    ignoreTokenTypes,
                    schema,
                    context,
                    input: buffer.join(""),
                    includeLeadingSpace: true
                  });
                  (_contentBuffer = contentBuffer).push.apply(_contentBuffer, (0, _toConsumableArray2.default)(content));
                  builder.add([{
                    style: lastListSymbols,
                    content: sanitize((0, _normalize.normalizePMNodes)(contentBuffer, schema), schema)
                  }]);
                  buffer = [];
                  contentBuffer = [];
                }
                lastListSymbols = symbols;
                var type = (0, _listBuilder.getType)(symbols);
                if (type !== builder.type && symbols.length === 1) {
                  output.push.apply(output, (0, _toConsumableArray2.default)(builder.buildPMNode()));
                  builder = new _listBuilder.ListBuilder(schema, symbols);
                }
              }
              index += listMatch[0].length;
            }
            var emptyLineMatch = substring.match(EMPTY_LINE_REGEXP);
            if (emptyLineMatch) {
              state = processState.END;
              continue;
            }
            state = processState.BUFFER;
            continue;
          }
          case processState.BUFFER: {
            var length = (0, _whitespace.parseNewlineOnly)(input2.substring(index));
            if (length) {
              buffer.push(input2.substr(index, length));
              state = processState.NEW_LINE;
              index += length;
              continue;
            }
            if (char === "{") {
              state = processState.MACRO;
              continue;
            } else {
              buffer.push(char);
            }
            break;
          }
          case processState.MACRO: {
            var match = (0, _keyword.parseMacroKeyword)(input2.substring(index));
            if (!match) {
              buffer.push(char);
              state = processState.BUFFER;
              break;
            }
            var token = (0, _.parseToken)(input2, match.type, index, schema, context);
            buffer.push(input2.substr(index, token.length));
            index += token.length;
            state = processState.BUFFER;
            continue;
          }
          case processState.END: {
            if (!builder) {
              return fallback(input2, position);
            }
            if (buffer.length > 0) {
              var _contentBuffer2;
              var _content = (0, _text.parseString)({
                ignoreTokenTypes,
                schema,
                context,
                input: buffer.join(""),
                includeLeadingSpace: true
              });
              (_contentBuffer2 = contentBuffer).push.apply(_contentBuffer2, (0, _toConsumableArray2.default)(_content));
            }
            builder.add([{
              style: lastListSymbols,
              content: sanitize((0, _normalize.normalizePMNodes)(contentBuffer, schema), schema)
            }]);
            output.push.apply(output, (0, _toConsumableArray2.default)(builder.buildPMNode()));
            return {
              type: "pmnode",
              nodes: output,
              length: index - position
            };
          }
        }
        index++;
      }
      if (buffer.length > 0) {
        var _contentBuffer3;
        var _content2 = (0, _text.parseString)({
          ignoreTokenTypes,
          schema,
          context,
          input: buffer.join(""),
          includeLeadingSpace: true
        });
        (_contentBuffer3 = contentBuffer).push.apply(_contentBuffer3, (0, _toConsumableArray2.default)(_content2));
      }
      if (builder) {
        builder.add([{
          style: lastListSymbols,
          content: sanitize((0, _normalize.normalizePMNodes)(contentBuffer, schema), schema)
        }]);
        output.push.apply(output, (0, _toConsumableArray2.default)(builder.buildPMNode()));
      }
      return {
        type: "pmnode",
        nodes: output,
        length: index - position
      };
    };
    function sanitize(nodes, schema) {
      return nodes.reduce(function(result, curr) {
        switch (curr.type.name) {
          case "blockquote": {
            curr.content.forEach(function(n) {
              result.push(n);
            });
            break;
          }
          case "heading": {
            var contentBuffer = [];
            curr.content.forEach(function(n) {
              var mark = schema.marks.strong.create();
              if (n.type.name === "text") {
                if (n.text) {
                  n.text = n.text.toUpperCase();
                }
                if (n.type.name === "text" && !(0, _text2.hasAnyOfMarks)(n, ["strong", "code"])) {
                  contentBuffer.push(n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [mark])));
                } else {
                  contentBuffer.push(n);
                }
              } else {
                contentBuffer.push(n);
              }
            });
            var p = schema.nodes.paragraph.createChecked({}, contentBuffer);
            result.push(p);
            break;
          }
          default:
            result.push(curr);
        }
        return result;
      }, []);
    }
    function fallback(input2, position) {
      return {
        type: "text",
        text: input2.substr(position, 1),
        length: 1
      };
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/monospace.js
var require_monospace = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/monospace.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.monospace = void 0;
    var _ = require_tokenize();
    var _text = require_text6();
    var _commonFormatter = require_common_formatter();
    var _text2 = require_text5();
    var monospace = exports2.monospace = function monospace2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var ignoreTokenTypes = [_.TokenType.ADF_MACRO, _.TokenType.ANCHOR_MACRO, _.TokenType.CODE_MACRO, _.TokenType.QUOTE_MACRO, _.TokenType.NOFORMAT_MACRO, _.TokenType.PANEL_MACRO, _.TokenType.COLOR_MACRO, _.TokenType.LOREM_MACRO, _.TokenType.QUOTE, _.TokenType.STRING, _.TokenType.ISSUE_KEY, _.TokenType.LINK_FORMAT, _.TokenType.LINK_TEXT, _.TokenType.MEDIA, _.TokenType.HEADING, _.TokenType.LIST, _.TokenType.TABLE, _.TokenType.RULER, _.TokenType.HARD_BREAK, _.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.STRONG, _.TokenType.MONOSPACE, _.TokenType.SUPERSCRIPT, _.TokenType.SUBSCRIPT, _.TokenType.EMPHASIS, _.TokenType.CITATION, _.TokenType.DELETED, _.TokenType.INSERTED, _.TokenType.EMOJI, _.TokenType.FORCE_LINE_BREAK];
      var contentDecorator = function contentDecorator2(n) {
        var mark = schema.marks.code.create();
        if (n.type.name === "text" && n.marks.length) {
          return n;
        }
        return n.mark([mark]);
      };
      var rawContentProcessor = function rawContentProcessor2(raw, length) {
        var content = (0, _text2.parseString)({
          ignoreTokenTypes,
          schema,
          context,
          input: raw
        });
        var decoratedContent = content.map(contentDecorator);
        return {
          type: "pmnode",
          nodes: decoratedContent,
          length
        };
      };
      var _getSurroundingSymbol = (0, _text.getSurroundingSymbols)(input2.substring(position), "{{", "}}"), openingSymbol = _getSurroundingSymbol.openingSymbol, closingSymbol = _getSurroundingSymbol.closingSymbol;
      return (0, _commonFormatter.commonFormatter)(input2, position, schema, {
        opening: openingSymbol,
        closing: closingSymbol,
        context,
        rawContentProcessor
      });
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/quadruple-dash-symbol.js
var require_quadruple_dash_symbol = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/quadruple-dash-symbol.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.quadrupleDashSymbol = void 0;
    var MULTI_DASH_REGEX = /^-{4,}(\s|$)/;
    var quadrupleDashSymbol = exports2.quadrupleDashSymbol = function quadrupleDashSymbol2(_ref) {
      var input2 = _ref.input, position = _ref.position;
      var match = input2.substring(position).match(MULTI_DASH_REGEX);
      if (!match) {
        return {
          type: "text",
          text: "----",
          length: 4
        };
      }
      return {
        type: "text",
        text: input2.substr(position, match[0].length),
        length: match[0].length
      };
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/nodes/rule.js
var require_rule3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/nodes/rule.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.createRuleNode = createRuleNode;
    exports2.default = getRuleNodeView;
    var HORIZONTAL_LINE_INSIDE_MACRO = "---";
    function getRuleNodeView(schema, containerNodeType) {
      var _schema$nodes = schema.nodes, paragraph = _schema$nodes.paragraph, rule = _schema$nodes.rule;
      if (containerNodeType) {
        var textNode = schema.text(HORIZONTAL_LINE_INSIDE_MACRO);
        return paragraph.createChecked({}, textNode);
      } else {
        return rule.createChecked();
      }
    }
    function createRuleNode(schema) {
      var rule = schema.nodes.rule;
      var ruleNode = rule.createChecked();
      return [ruleNode];
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/ruler.js
var require_ruler2 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/ruler.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.ruler = void 0;
    var _rule = require_rule3();
    var RULER_REGEX = /^-{4,5}(\s|$)/;
    var ruler = exports2.ruler = function ruler2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema;
      var match = input2.substring(position).match(RULER_REGEX);
      if (match) {
        return {
          type: "pmnode",
          nodes: (0, _rule.createRuleNode)(schema),
          length: match[0].length
        };
      }
      return {
        type: "text",
        text: input2.substring(position, 1),
        length: 1
      };
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/strong.js
var require_strong3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/strong.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.strong = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _ = require_tokenize();
    var _text = require_text6();
    var _commonFormatter = require_common_formatter();
    var _text2 = require_text5();
    var strong = exports2.strong = function strong2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var ignoreTokenTypes = [_.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.ISSUE_KEY, _.TokenType.TABLE];
      var contentDecorator = function contentDecorator2(pmNode) {
        var mark = schema.marks.strong.create();
        if (pmNode.type.name === "text" && !(0, _text.hasAnyOfMarks)(pmNode, ["strong", "code"])) {
          return pmNode.mark([].concat((0, _toConsumableArray2.default)(pmNode.marks), [mark]));
        }
        return pmNode;
      };
      var rawContentProcessor = function rawContentProcessor2(raw, length) {
        var content = (0, _text2.parseString)({
          schema,
          context,
          ignoreTokenTypes,
          input: raw
        });
        var decoratedContent = content.map(contentDecorator);
        return {
          type: "pmnode",
          nodes: decoratedContent,
          length
        };
      };
      var _getSurroundingSymbol = (0, _text.getSurroundingSymbols)(input2.substring(position), "*", "*"), openingSymbol = _getSurroundingSymbol.openingSymbol, closingSymbol = _getSurroundingSymbol.closingSymbol;
      return (0, _commonFormatter.commonFormatter)(input2, position, schema, {
        opening: openingSymbol,
        closing: closingSymbol,
        context,
        rawContentProcessor
      });
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/subscript.js
var require_subscript = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/subscript.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.subscript = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _ = require_tokenize();
    var _text = require_text6();
    var _commonFormatter = require_common_formatter();
    var _text2 = require_text5();
    var subscript = exports2.subscript = function subscript2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var ignoreTokenTypes = [_.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.ISSUE_KEY, _.TokenType.TABLE];
      var contentDecorator = function contentDecorator2(n) {
        var mark = schema.marks.subsup.create({
          type: "sub"
        });
        if (n.type.name === "text" && !(0, _text.hasAnyOfMarks)(n, ["subsup", "code"])) {
          return n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [mark]));
        }
        return n;
      };
      var rawContentProcessor = function rawContentProcessor2(raw, length) {
        var content = (0, _text2.parseString)({
          schema,
          context,
          ignoreTokenTypes,
          input: raw
        });
        var decoratedContent = content.map(contentDecorator);
        return {
          type: "pmnode",
          nodes: decoratedContent,
          length
        };
      };
      var _getSurroundingSymbol = (0, _text.getSurroundingSymbols)(input2.substring(position), "~", "~"), openingSymbol = _getSurroundingSymbol.openingSymbol, closingSymbol = _getSurroundingSymbol.closingSymbol;
      return (0, _commonFormatter.commonFormatter)(input2, position, schema, {
        opening: openingSymbol,
        closing: closingSymbol,
        context,
        rawContentProcessor
      });
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/superscript.js
var require_superscript = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/superscript.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.superscript = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _ = require_tokenize();
    var _text = require_text6();
    var _commonFormatter = require_common_formatter();
    var _text2 = require_text5();
    var superscript = exports2.superscript = function superscript2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var ignoreTokenTypes = [_.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.ISSUE_KEY, _.TokenType.TABLE];
      var contentDecorator = function contentDecorator2(n) {
        var mark = schema.marks.subsup.create({
          type: "sup"
        });
        if (n.type.name === "text" && !(0, _text.hasAnyOfMarks)(n, ["subsup", "code"])) {
          return n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [mark]));
        }
        return n;
      };
      var rawContentProcessor = function rawContentProcessor2(raw, length) {
        var content = (0, _text2.parseString)({
          schema,
          context,
          ignoreTokenTypes,
          input: raw
        });
        var decoratedContent = content.map(contentDecorator);
        return {
          type: "pmnode",
          nodes: decoratedContent,
          length
        };
      };
      var _getSurroundingSymbol = (0, _text.getSurroundingSymbols)(input2.substring(position), "^", "^"), openingSymbol = _getSurroundingSymbol.openingSymbol, closingSymbol = _getSurroundingSymbol.closingSymbol;
      return (0, _commonFormatter.commonFormatter)(input2, position, schema, {
        opening: openingSymbol,
        closing: closingSymbol,
        context,
        rawContentProcessor
      });
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/builder/table-builder.js
var require_table_builder = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/builder/table-builder.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.TableBuilder = void 0;
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    function _createForOfIteratorHelper(r, e) {
      var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
      if (!t) {
        if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
          t && (r = t);
          var _n = 0, F = function F2() {
          };
          return { s: F, n: function n() {
            return _n >= r.length ? { done: true } : { done: false, value: r[_n++] };
          }, e: function e2(r2) {
            throw r2;
          }, f: F };
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }
      var o, a = true, u = false;
      return { s: function s() {
        t = t.call(r);
      }, n: function n() {
        var r2 = t.next();
        return a = r2.done, r2;
      }, e: function e2(r2) {
        u = true, o = r2;
      }, f: function f() {
        try {
          a || null == t.return || t.return();
        } finally {
          if (u) throw o;
        }
      } };
    }
    function _unsupportedIterableToArray(r, a) {
      if (r) {
        if ("string" == typeof r) return _arrayLikeToArray(r, a);
        var t = {}.toString.call(r).slice(8, -1);
        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
      }
    }
    function _arrayLikeToArray(r, a) {
      (null == a || a > r.length) && (a = r.length);
      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
      return n;
    }
    function getType(style) {
      return /\|\|/.test(style) ? "tableHeader" : "tableCell";
    }
    var TableBuilder = exports2.TableBuilder = /* @__PURE__ */ (function() {
      function TableBuilder2(schema) {
        var _this = this;
        (0, _classCallCheck2.default)(this, TableBuilder2);
        (0, _defineProperty2.default)(this, "emptyTableCell", function() {
          var _this$schema$nodes = _this.schema.nodes, tableCell = _this$schema$nodes.tableCell, paragraph = _this$schema$nodes.paragraph;
          return tableCell.createChecked({}, paragraph.createChecked());
        });
        (0, _defineProperty2.default)(this, "emptyTableRow", function() {
          var tableRow = _this.schema.nodes.tableRow;
          return tableRow.createChecked({}, _this.emptyTableCell());
        });
        (0, _defineProperty2.default)(this, "buildTableNode", function() {
          var root = _this.root;
          var table = _this.schema.nodes.table;
          var content = root.rows.map(_this.buildTableRowNode);
          if (content.length === 0) {
            content.push(_this.emptyTableRow());
          }
          return table.createChecked({}, content);
        });
        (0, _defineProperty2.default)(this, "buildTableRowNode", function(row) {
          var tableRow = _this.schema.nodes.tableRow;
          return tableRow.createChecked({}, row.cells.map(_this.buildTableCellNode));
        });
        (0, _defineProperty2.default)(this, "buildTableCellNode", function(cell) {
          var type = cell.type, content = cell.content;
          if (content.length === 0) {
            content.push(_this.schema.nodes.paragraph.createChecked());
          }
          var cellNode = _this.schema.nodes[type];
          return cellNode.createChecked({}, content);
        });
        this.schema = schema;
        this.root = {
          rows: []
        };
      }
      return (0, _createClass2.default)(TableBuilder2, [{
        key: "type",
        get: function get() {
          return "table";
        }
        /**
         * Add new cells to the table
         * @param {AddCellArgs[]} cells
         */
      }, {
        key: "add",
        value: function add(cells) {
          if (!cells.length) {
            return;
          }
          var index = 0;
          var _iterator = _createForOfIteratorHelper(cells), _step;
          try {
            for (_iterator.s(); !(_step = _iterator.n()).done; ) {
              var cell = _step.value;
              var content = cell.content, style = cell.style;
              var cellType = getType(style);
              if (index === 0) {
                this.addRow();
              }
              var newCell = {
                type: cellType,
                content
              };
              this.lastRow.cells.push(newCell);
              index += 1;
            }
          } catch (err) {
            _iterator.e(err);
          } finally {
            _iterator.f();
          }
        }
        /**
         * Build a prosemirror table from the data
         * @returns {PMNode}
         */
      }, {
        key: "buildPMNode",
        value: function buildPMNode() {
          return this.buildTableNode();
        }
      }, {
        key: "addRow",
        value: (
          /**
           * Add a new row to the table
           */
          function addRow() {
            var rows = this.root.rows;
            var row = {
              cells: []
            };
            rows.push(row);
            this.lastRow = row;
          }
        )
      }]);
    })();
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/table.js
var require_table4 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/table.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.table = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _tableBuilder = require_table_builder();
    var _text = require_text5();
    var _normalize = require_normalize2();
    var _linkFormat = require_link_format();
    var _media = require_media4();
    var _emoji = require_emoji5();
    var _ = require_tokenize();
    var _whitespace = require_whitespace();
    var _keyword = require_keyword();
    var _text2 = require_text6();
    var CELL_REGEXP = /^([ \t]*)([|]+)([ \t]*)/;
    var EMPTY_LINE_REGEXP = /^[ \t]*\r?\n/;
    var processState = {
      END_TABLE: 2,
      BUFFER: 4,
      CLOSE_ROW: 5,
      NEW_ROW: 6,
      LINE_BREAK: 7,
      LINK: 8,
      MEDIA: 9,
      MACRO: 10,
      EMOJI: 11
    };
    var table = exports2.table = function table2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      var ignoreTokenTypes = [_.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.TABLE, _.TokenType.RULER];
      var output = [];
      var index = position;
      var currentState = processState.NEW_ROW;
      var buffer = [];
      var cellsBuffer = [];
      var cellStyle = "";
      var builder = null;
      while (index < input2.length) {
        var char = input2.charAt(index);
        var substring = input2.substring(index);
        switch (currentState) {
          case processState.NEW_ROW: {
            var tableMatch = substring.match(CELL_REGEXP);
            if (tableMatch) {
              if (!builder) {
                builder = new _tableBuilder.TableBuilder(schema);
              }
              index += tableMatch[1].length;
              cellStyle = tableMatch[2];
              index += tableMatch[2].length;
              currentState = processState.BUFFER;
              continue;
            }
            currentState = processState.END_TABLE;
            continue;
          }
          case processState.LINE_BREAK: {
            var emptyLineMatch = substring.match(EMPTY_LINE_REGEXP);
            if (emptyLineMatch) {
              bufferToCells(cellStyle, buffer.join(""), cellsBuffer, schema, ignoreTokenTypes, context);
              currentState = processState.END_TABLE;
              continue;
            }
            var cellMatch = substring.match(CELL_REGEXP);
            if (cellMatch) {
              currentState = processState.CLOSE_ROW;
            } else {
              currentState = processState.BUFFER;
            }
            continue;
          }
          case processState.BUFFER: {
            var length = (0, _whitespace.parseNewlineOnly)(substring);
            if (length) {
              var endIndex = index;
              var startIndex = input2.lastIndexOf("|", endIndex) + 1;
              var charsBefore = input2.substring(startIndex, endIndex);
              if (charsBefore === "" || charsBefore.match(EMPTY_LINE_REGEXP)) {
                currentState = processState.CLOSE_ROW;
              } else {
                currentState = processState.LINE_BREAK;
                buffer.push(input2.substr(index, length));
              }
              index += length;
              continue;
            }
            switch (char) {
              case "|": {
                bufferToCells(cellStyle, buffer.join(""), cellsBuffer, schema, ignoreTokenTypes, context);
                buffer = [];
                var _cellMatch = substring.match(CELL_REGEXP);
                if (_cellMatch) {
                  cellStyle = _cellMatch[2];
                  index += _cellMatch[2].length;
                  continue;
                }
                break;
              }
              case ":":
              case ";":
              case "(": {
                currentState = processState.EMOJI;
                continue;
              }
              case "[": {
                currentState = processState.LINK;
                continue;
              }
              case "!": {
                currentState = processState.MEDIA;
                continue;
              }
              case "{": {
                currentState = processState.MACRO;
                continue;
              }
              default: {
                buffer.push(char);
                index++;
                continue;
              }
            }
            break;
          }
          case processState.CLOSE_ROW: {
            var _bufferOutput = buffer.join("");
            if (_bufferOutput.trim().length > 0) {
              bufferToCells(cellStyle, _bufferOutput, cellsBuffer, schema, ignoreTokenTypes, context);
              buffer = [];
            }
            if (builder) {
              builder.add(cellsBuffer);
              cellsBuffer = [];
            }
            currentState = processState.NEW_ROW;
            continue;
          }
          case processState.END_TABLE: {
            if (builder) {
              if (cellsBuffer.length) {
                builder.add(cellsBuffer);
              }
              output.push(builder.buildPMNode());
            }
            return {
              type: "pmnode",
              nodes: output,
              length: index - position
            };
          }
          case processState.MEDIA: {
            var token = (0, _media.media)({
              input: input2,
              schema,
              context,
              position: index
            });
            buffer.push(input2.substr(index, token.length));
            index += token.length;
            currentState = processState.BUFFER;
            continue;
          }
          case processState.EMOJI: {
            var _token = (0, _emoji.emoji)({
              input: input2,
              schema,
              context,
              position: index
            });
            buffer.push(input2.substr(index, _token.length));
            index += _token.length;
            currentState = processState.BUFFER;
            continue;
          }
          case processState.LINK: {
            var _token2 = (0, _linkFormat.linkFormat)({
              input: input2,
              schema,
              context,
              position: index
            });
            if (_token2.type === "text") {
              buffer.push(_token2.text);
              index += _token2.length;
              currentState = processState.BUFFER;
              continue;
            } else if (_token2.type === "pmnode") {
              buffer.push(input2.substr(index, _token2.length));
              index += _token2.length;
              currentState = processState.BUFFER;
              continue;
            }
            break;
          }
          case processState.MACRO: {
            var match = (0, _keyword.parseMacroKeyword)(input2.substring(index));
            if (!match) {
              buffer.push(char);
              currentState = processState.BUFFER;
              break;
            }
            var _token3 = (0, _.parseToken)(input2, match.type, index, schema, context);
            buffer.push(input2.substr(index, _token3.length));
            index += _token3.length;
            currentState = processState.BUFFER;
            continue;
          }
        }
        index++;
      }
      var bufferOutput = buffer.join("");
      if (bufferOutput.trim().length > 0) {
        bufferToCells(cellStyle, bufferOutput, cellsBuffer, schema, ignoreTokenTypes, context);
      }
      if (builder) {
        if (cellsBuffer.length) {
          builder.add(cellsBuffer);
        }
        output.push(builder.buildPMNode());
      }
      return {
        type: "pmnode",
        nodes: output,
        length: index - position
      };
    };
    function bufferToCells(style, buffer, cellsBuffer, schema, ignoreTokenTypes, context) {
      if (buffer.length) {
        var contentNode = (0, _text.parseString)({
          schema,
          context,
          ignoreTokenTypes,
          input: buffer
        });
        if (style === "||") {
          contentNode = contentNode.map(function(e) {
            return createTableHeader(e, schema);
          });
        }
        cellsBuffer.push({
          style,
          content: (0, _normalize.normalizePMNodes)(contentNode, schema)
        });
      }
    }
    function createTableHeader(node, schema) {
      var mark = schema.marks.strong.create();
      return traverseNodeAndAddMarks(node, mark, schema);
    }
    function traverseContent(node, mark, schema) {
      if (node.content.childCount === 0 || !node.content.child(0) || !node.content.firstChild || node.type.name === "codeBlock") {
        return node;
      }
      for (var i = 0; i < node.content.childCount; i++) {
        var child = node.content.child(i);
        var markedChild = traverseNodeAndAddMarks(child, mark, schema);
        var updatedContent = node.content.replaceChild(i, markedChild);
        node = node.copy(updatedContent);
      }
      return node;
    }
    function traverseNodeAndAddMarks(node, mark, schema) {
      if (node.type.name === "text" && !(0, _text2.hasAnyOfMarks)(node, ["strong", "code"])) {
        var newNode = node.mark([].concat((0, _toConsumableArray2.default)(node.marks), [mark]));
        return newNode;
      }
      return traverseContent(node, mark, schema);
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/triple-dash-symbol.js
var require_triple_dash_symbol = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/triple-dash-symbol.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.tripleDashSymbol = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _dashTokenCreator = require_dash_token_creator();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var token = {
      type: "text",
      text: "\u2014",
      // EM DASH
      length: 3
    };
    var fallback = _objectSpread(_objectSpread({}, token), {}, {
      text: "---"
    });
    var tripleDashSymbol = exports2.tripleDashSymbol = (0, _dashTokenCreator.createDashTokenParser)(token, fallback);
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/color-name-mapping.js
var require_color_name_mapping = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/color-name-mapping.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = void 0;
    var mapping = {
      crimson: {
        r: 220,
        g: 20,
        b: 60
      },
      lightpink: {
        r: 255,
        g: 182,
        b: 193
      },
      pink: {
        r: 255,
        g: 192,
        b: 203
      },
      palevioletred: {
        r: 219,
        g: 112,
        b: 147
      },
      lavenderblush: {
        r: 255,
        g: 240,
        b: 245
      },
      hotpink: {
        r: 255,
        g: 105,
        b: 180
      },
      deeppink: {
        r: 255,
        g: 20,
        b: 147
      },
      mediumvioletred: {
        r: 199,
        g: 21,
        b: 133
      },
      orchid: {
        r: 218,
        g: 112,
        b: 214
      },
      thistle: {
        r: 216,
        g: 191,
        b: 216
      },
      plum: {
        r: 221,
        g: 160,
        b: 221
      },
      violet: {
        r: 238,
        g: 130,
        b: 238
      },
      fuchsia: {
        r: 255,
        g: 0,
        b: 255
      },
      darkmagenta: {
        r: 139,
        g: 0,
        b: 139
      },
      purple: {
        r: 128,
        g: 0,
        b: 128
      },
      mediumorchid: {
        r: 186,
        g: 85,
        b: 211
      },
      darkviolet: {
        r: 148,
        g: 0,
        b: 211
      },
      darkorchid: {
        r: 153,
        g: 50,
        b: 204
      },
      indigo: {
        r: 75,
        g: 0,
        b: 130
      },
      blueviolet: {
        r: 138,
        g: 43,
        b: 226
      },
      mediumpurple: {
        r: 147,
        g: 112,
        b: 219
      },
      darkslateblue: {
        r: 72,
        g: 61,
        b: 139
      },
      mediumslateblue: {
        r: 123,
        g: 104,
        b: 238
      },
      slateblue: {
        r: 106,
        g: 90,
        b: 205
      },
      ghostwhite: {
        r: 248,
        g: 248,
        b: 255
      },
      lavender: {
        r: 230,
        g: 230,
        b: 250
      },
      blue: {
        r: 0,
        g: 0,
        b: 255
      },
      mediumblue: {
        r: 0,
        g: 0,
        b: 205
      },
      darkblue: {
        r: 0,
        g: 0,
        b: 139
      },
      navy: {
        r: 0,
        g: 0,
        b: 128
      },
      midnightblue: {
        r: 25,
        g: 25,
        b: 112
      },
      royalblue: {
        r: 65,
        g: 105,
        b: 225
      },
      cornflowerblue: {
        r: 100,
        g: 149,
        b: 237
      },
      lightsteelblue: {
        r: 176,
        g: 196,
        b: 222
      },
      lightslategray: {
        r: 119,
        g: 136,
        b: 153
      },
      slategray: {
        r: 112,
        g: 128,
        b: 144
      },
      dodgerblue: {
        r: 30,
        g: 144,
        b: 255
      },
      aliceblue: {
        r: 240,
        g: 248,
        b: 255
      },
      steelblue: {
        r: 70,
        g: 130,
        b: 180
      },
      lightskyblue: {
        r: 135,
        g: 206,
        b: 250
      },
      skyblue: {
        r: 135,
        g: 206,
        b: 235
      },
      deepskyblue: {
        r: 0,
        g: 191,
        b: 255
      },
      lightblue: {
        r: 173,
        g: 216,
        b: 230
      },
      powderblue: {
        r: 176,
        g: 224,
        b: 230
      },
      cadetblue: {
        r: 95,
        g: 158,
        b: 160
      },
      darkturquoise: {
        r: 0,
        g: 206,
        b: 209
      },
      azure: {
        r: 240,
        g: 255,
        b: 255
      },
      lightcyan: {
        r: 224,
        g: 255,
        b: 255
      },
      paleturquoise: {
        r: 174,
        g: 238,
        b: 238
      },
      darkslategray: {
        r: 47,
        g: 79,
        b: 79
      },
      aqua: {
        r: 0,
        g: 255,
        b: 255
      },
      darkcyan: {
        r: 0,
        g: 139,
        b: 139
      },
      teal: {
        r: 0,
        g: 128,
        b: 128
      },
      mediumturquoise: {
        r: 72,
        g: 209,
        b: 204
      },
      lightseagreen: {
        r: 32,
        g: 178,
        b: 170
      },
      turquoise: {
        r: 64,
        g: 224,
        b: 208
      },
      aquamarine: {
        r: 127,
        g: 255,
        b: 212
      },
      mediumaquamarine: {
        r: 102,
        g: 205,
        b: 170
      },
      mediumspringgreen: {
        r: 0,
        g: 250,
        b: 154
      },
      mintcream: {
        r: 245,
        g: 255,
        b: 250
      },
      springgreen: {
        r: 0,
        g: 255,
        b: 127
      },
      mediumseagreen: {
        r: 60,
        g: 179,
        b: 113
      },
      seagreen: {
        r: 46,
        g: 139,
        b: 87
      },
      honeydew: {
        r: 240,
        g: 255,
        b: 240
      },
      darkseagreen: {
        r: 143,
        g: 188,
        b: 143
      },
      palegreen: {
        r: 152,
        g: 251,
        b: 152
      },
      lightgreen: {
        r: 144,
        g: 238,
        b: 144
      },
      limegreen: {
        r: 50,
        g: 205,
        b: 50
      },
      forestgreen: {
        r: 34,
        g: 139,
        b: 34
      },
      lime: {
        r: 0,
        g: 255,
        b: 0
      },
      green: {
        r: 0,
        g: 128,
        b: 0
      },
      darkgreen: {
        r: 0,
        g: 100,
        b: 0
      },
      lawngreen: {
        r: 124,
        g: 252,
        b: 0
      },
      chartreuse: {
        r: 127,
        g: 255,
        b: 0
      },
      greenyellow: {
        r: 173,
        g: 255,
        b: 47
      },
      darkolivegreen: {
        r: 85,
        g: 107,
        b: 47
      },
      olivedrab: {
        r: 107,
        g: 142,
        b: 35
      },
      yellowgreen: {
        r: 154,
        g: 205,
        b: 50
      },
      ivory: {
        r: 255,
        g: 255,
        b: 240
      },
      beige: {
        r: 245,
        g: 245,
        b: 220
      },
      lightyellow: {
        r: 255,
        g: 255,
        b: 224
      },
      lightgoldenrodyellow: {
        r: 250,
        g: 250,
        b: 210
      },
      yellow: {
        r: 255,
        g: 255,
        b: 0
      },
      olive: {
        r: 128,
        g: 128,
        b: 0
      },
      darkkhaki: {
        r: 189,
        g: 183,
        b: 107
      },
      khaki: {
        r: 240,
        g: 230,
        b: 140
      },
      palegoldenrod: {
        r: 238,
        g: 232,
        b: 170
      },
      lemonchiffon: {
        r: 255,
        g: 250,
        b: 205
      },
      gold: {
        r: 255,
        g: 215,
        b: 0
      },
      cornsilk: {
        r: 255,
        g: 248,
        b: 220
      },
      goldenrod: {
        r: 218,
        g: 165,
        b: 32
      },
      darkgoldenrod: {
        r: 184,
        g: 134,
        b: 11
      },
      orange: {
        r: 255,
        g: 128,
        b: 0
      },
      floralwhite: {
        r: 255,
        g: 250,
        b: 240
      },
      oldlace: {
        r: 253,
        g: 245,
        b: 230
      },
      wheat: {
        r: 245,
        g: 222,
        b: 179
      },
      moccasin: {
        r: 255,
        g: 228,
        b: 181
      },
      papayawhip: {
        r: 255,
        g: 239,
        b: 213
      },
      blanchedalmond: {
        r: 255,
        g: 235,
        b: 205
      },
      navajowhite: {
        r: 255,
        g: 222,
        b: 173
      },
      tan: {
        r: 210,
        g: 180,
        b: 140
      },
      antiquewhite: {
        r: 250,
        g: 235,
        b: 215
      },
      burlywood: {
        r: 222,
        g: 184,
        b: 135
      },
      bisque: {
        r: 255,
        g: 228,
        b: 196
      },
      darkorange: {
        r: 255,
        g: 140,
        b: 0
      },
      peru: {
        r: 205,
        g: 133,
        b: 63
      },
      linen: {
        r: 250,
        g: 240,
        b: 230
      },
      peachpuff: {
        r: 255,
        g: 218,
        b: 185
      },
      seashell: {
        r: 255,
        g: 245,
        b: 238
      },
      sandybrown: {
        r: 244,
        g: 164,
        b: 96
      },
      chocolate: {
        r: 210,
        g: 105,
        b: 30
      },
      saddlebrown: {
        r: 139,
        g: 69,
        b: 19
      },
      sienna: {
        r: 160,
        g: 82,
        b: 45
      },
      lightsalmon: {
        r: 255,
        g: 160,
        b: 122
      },
      coral: {
        r: 255,
        g: 127,
        b: 80
      },
      orangered: {
        r: 255,
        g: 69,
        b: 0
      },
      darksalmon: {
        r: 233,
        g: 150,
        b: 122
      },
      tomato: {
        r: 255,
        g: 99,
        b: 71
      },
      salmon: {
        r: 250,
        g: 128,
        b: 114
      },
      mistyrose: {
        r: 255,
        g: 228,
        b: 225
      },
      snow: {
        r: 255,
        g: 250,
        b: 250
      },
      rosybrown: {
        r: 188,
        g: 143,
        b: 143
      },
      lightcoral: {
        r: 240,
        g: 128,
        b: 128
      },
      indianred: {
        r: 205,
        g: 92,
        b: 92
      },
      brown: {
        r: 165,
        g: 42,
        b: 42
      },
      firebrick: {
        r: 178,
        g: 34,
        b: 34
      },
      red: {
        r: 255,
        g: 0,
        b: 0
      },
      darkred: {
        r: 139,
        g: 0,
        b: 0
      },
      maroon: {
        r: 128,
        g: 0,
        b: 0
      },
      white: {
        r: 255,
        g: 255,
        b: 255
      },
      gainsboro: {
        r: 220,
        g: 220,
        b: 220
      },
      lightgray: {
        r: 211,
        g: 211,
        b: 211
      },
      silver: {
        r: 192,
        g: 192,
        b: 192
      },
      darkgray: {
        r: 169,
        g: 169,
        b: 169
      },
      gray: {
        r: 128,
        g: 128,
        b: 128
      },
      dimgray: {
        r: 105,
        g: 105,
        b: 105
      },
      black: {
        r: 0,
        g: 0,
        b: 0
      },
      whitesmoke: {
        r: 245,
        g: 245,
        b: 245
      }
    };
    var _default = exports2.default = mapping;
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/panel-type.js
var require_panel_type = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/panel-type.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.getPanelType = getPanelType;
    var _colorNameMapping = _interopRequireDefault(require_color_name_mapping());
    var COLOR_TYPE_REGEX = {
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      hexShort: /^#?([a-f\d])([a-f\d])([a-f\d])$/i,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      hexLong: /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      rgb: /^#?rgb\((\d+),\s*(\d+),\s*(\d+)\)$/,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      prgb: /^#?rgb\((\d+)%,\s*(\d+)%,\s*(\d+)%\)$/
    };
    var PANEL_TYPE_TO_RGB = {
      info: {
        r: 222,
        g: 235,
        b: 255
      },
      note: {
        r: 234,
        g: 230,
        b: 255
      },
      success: {
        r: 227,
        g: 252,
        b: 239
      },
      warning: {
        r: 255,
        g: 250,
        b: 230
      },
      error: {
        r: 255,
        g: 235,
        b: 230
      }
    };
    function getPanelType(attrs) {
      var rgb = generateRgb(attrs.bgColor);
      if (!rgb) {
        return "info";
      }
      var mapTo = "info";
      var smallestDistance = Infinity;
      Object.keys(PANEL_TYPE_TO_RGB).forEach(function(panelType) {
        var distance = distanceOfRgb(PANEL_TYPE_TO_RGB[panelType], rgb);
        if (distance < smallestDistance) {
          smallestDistance = distance;
          mapTo = panelType;
        }
      });
      return mapTo;
    }
    function distanceOfRgb(a, b) {
      return Math.pow(a.r - b.r, 2) + Math.pow(a.g - b.g, 2) + Math.pow(a.b - b.b, 2);
    }
    function generateRgb(color) {
      switch (true) {
        case (COLOR_TYPE_REGEX.hexShort.test(color) || COLOR_TYPE_REGEX.hexLong.test(color)):
          return parseHex(color);
        case COLOR_TYPE_REGEX.rgb.test(color):
          return parseRgb(color);
        case COLOR_TYPE_REGEX.prgb.test(color):
          return parsePrgb(color);
        default:
          return parseColorName(color);
      }
    }
    function parseHex(hex) {
      hex = hex.replace(COLOR_TYPE_REGEX.hexShort, function(_m, r, g, b) {
        return r + r + g + g + b + b;
      });
      var result = COLOR_TYPE_REGEX.hexLong.exec(hex);
      return result ? {
        r: parseInt(result[1], 16),
        g: parseInt(result[2], 16),
        b: parseInt(result[3], 16)
      } : null;
    }
    function parseRgb(rgb) {
      var result = rgb.match(COLOR_TYPE_REGEX.rgb);
      return result ? {
        r: parseInt(result[1], 10),
        g: parseInt(result[2], 10),
        b: parseInt(result[3], 10)
      } : null;
    }
    function parsePrgb(prgb) {
      var result = prgb.match(COLOR_TYPE_REGEX.prgb);
      return result ? {
        r: Math.floor(255 * parseInt(result[1], 10) / 100),
        g: Math.floor(255 * parseInt(result[2], 10) / 100),
        b: Math.floor(255 * parseInt(result[4], 10) / 100)
      } : null;
    }
    function parseColorName(color) {
      return _colorNameMapping.default[color];
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/title.js
var require_title = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/utils/title.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.title = title;
    function title(text, schema) {
      var mark = schema.marks.strong.create();
      var title2 = schema.text(text, [mark]);
      return schema.nodes.paragraph.createChecked({}, [title2]);
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/panel-macro.js
var require_panel_macro = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/panel-macro.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.panelMacro = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _commonMacro = require_common_macro();
    var _text = require_text5();
    var _attrs = require_attrs();
    var _normalize = require_normalize2();
    var _panelType = require_panel_type();
    var _title = require_title();
    function _createForOfIteratorHelper(r, e) {
      var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
      if (!t) {
        if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
          t && (r = t);
          var _n = 0, F = function F2() {
          };
          return { s: F, n: function n() {
            return _n >= r.length ? { done: true } : { done: false, value: r[_n++] };
          }, e: function e2(r2) {
            throw r2;
          }, f: F };
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }
      var o, a = true, u = false;
      return { s: function s() {
        t = t.call(r);
      }, n: function n() {
        var r2 = t.next();
        return a = r2.done, r2;
      }, e: function e2(r2) {
        u = true, o = r2;
      }, f: function f() {
        try {
          a || null == t.return || t.return();
        } finally {
          if (u) throw o;
        }
      } };
    }
    function _unsupportedIterableToArray(r, a) {
      if (r) {
        if ("string" == typeof r) return _arrayLikeToArray(r, a);
        var t = {}.toString.call(r).slice(8, -1);
        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
      }
    }
    function _arrayLikeToArray(r, a) {
      (null == a || a > r.length) && (a = r.length);
      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
      return n;
    }
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var allowedNodeType = ["paragraph", "heading", "orderedList", "bulletList"];
    var panelMacro = exports2.panelMacro = function panelMacro2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      return (0, _commonMacro.commonMacro)(input2.substring(position), schema, {
        keyword: "panel",
        paired: true,
        context,
        rawContentProcessor
      });
    };
    var rawContentProcessor = function rawContentProcessor2(rawAttrs, rawContent, length, schema, context) {
      var output = [];
      var parsedAttrs = (0, _attrs.parseAttrs)(rawAttrs);
      var nodeAttrs = _objectSpread(_objectSpread({}, parsedAttrs), {}, {
        panelType: (0, _panelType.getPanelType)(parsedAttrs)
      });
      var parsedContent = (0, _text.parseString)({
        schema,
        context,
        ignoreTokenTypes: [],
        input: rawContent
      });
      var normalizedContent = (0, _normalize.normalizePMNodes)(parsedContent, schema);
      var contentBuffer = parsedAttrs.title ? [(0, _title.title)(parsedAttrs.title, schema)] : [];
      var _iterator = _createForOfIteratorHelper(normalizedContent), _step;
      try {
        for (_iterator.s(); !(_step = _iterator.n()).done; ) {
          var n = _step.value;
          if (allowedNodeType.indexOf(n.type.name) !== -1) {
            contentBuffer.push(n);
          } else {
            var _panelNode = schema.nodes.panel.createChecked(nodeAttrs, contentBuffer.length ? contentBuffer : schema.nodes.paragraph.createChecked());
            contentBuffer = [];
            output.push(_panelNode);
            output.push(n);
          }
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
      if (contentBuffer.length > 0) {
        var panelNode = schema.nodes.panel.createChecked(nodeAttrs, contentBuffer);
        output.push(panelNode);
      }
      return {
        type: "pmnode",
        nodes: output.length ? output : [emptyPanel(schema)],
        length
      };
    };
    function emptyPanel(schema) {
      var p = schema.nodes.paragraph.createChecked();
      return schema.nodes.panel.createChecked({}, p);
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/adf-macro.js
var require_adf_macro = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/adf-macro.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.adfMacro = void 0;
    var _commonMacro = require_common_macro();
    var adfMacro = exports2.adfMacro = function adfMacro2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      return (0, _commonMacro.commonMacro)(input2.substring(position), schema, {
        keyword: "adf",
        paired: true,
        context,
        rawContentProcessor
      });
    };
    var rawContentProcessor = function rawContentProcessor2(_rawAttrs, rawContent, length, schema, _context) {
      try {
        var json = JSON.parse(rawContent);
        var node = schema.nodeFromJSON(json);
        return {
          type: "pmnode",
          nodes: [node],
          length
        };
      } catch (_e) {
        var textContent = "Invalid ADF Macro: ".concat(rawContent);
        var textNode = rawContent.length ? schema.text(textContent) : void 0;
        var codeBlock = schema.nodes.codeBlock;
        var _node = codeBlock.create({
          language: void 0
        }, textNode);
        return {
          type: "pmnode",
          nodes: [_node],
          length
        };
      }
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/anchor-macro.js
var require_anchor_macro = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/anchor-macro.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.anchorMacro = void 0;
    var _commonMacro = require_common_macro();
    var anchorMacro = exports2.anchorMacro = function anchorMacro2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      return (0, _commonMacro.commonMacro)(input2.substring(position), schema, {
        keyword: "anchor",
        paired: false,
        context,
        rawContentProcessor
      });
    };
    var rawContentProcessor = function rawContentProcessor2(_rawAttrs, _rawContent, length, _schema, _context) {
      return {
        type: "text",
        text: "",
        length
      };
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/code-macro.js
var require_code_macro = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/code-macro.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.codeMacro = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _commonMacro = require_common_macro();
    var _attrs = require_attrs();
    var _title = require_title();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var SUPPORTED_CODEBOCK_LANGUAGES = ["abap", "actionscript", "ada", "arduino", "autoit", "c", "c++", "clojure", "coffeescript", "csharp", "css", "cuda", "d", "dart", "delphi", "elixir", "erlang", "fortran", "foxpro", "go", "groovy", "haskell", "haxe", "html", "java", "javascript", "json", "julia", "kotlin", "latex", "livescript", "lua", "mathematica", "matlab", "objective-c", "objective-j", "objectpascal", "ocaml", "octave", "perl", "php", "powershell", "prolog", "puppet", "python", "qml", "r", "racket", "restructuredtext", "ruby", "rust", "sass", "scala", "scheme", "shell", "smalltalk", "sql", "standardml", "swift", "tcl", "tex", "typescript", "vala", "vbnet", "verilog", "vhdl", "xml", "xquery"];
    var codeMacro = exports2.codeMacro = function codeMacro2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      return (0, _commonMacro.commonMacro)(input2.substring(position), schema, {
        keyword: "code",
        paired: true,
        context,
        rawContentProcessor
      });
    };
    var rawContentProcessor = function rawContentProcessor2(rawAttrs, rawContent, length, schema) {
      var output = [];
      var codeBlock = schema.nodes.codeBlock;
      var parsedAttrs = (0, _attrs.parseAttrs)(rawAttrs);
      var trimedContent = rawContent.replace(/^\s+|\s+$/g, "");
      var textNode = trimedContent.length ? schema.text(trimedContent) : void 0;
      if (parsedAttrs.title) {
        output.push((0, _title.title)(parsedAttrs.title, schema));
      }
      var nodeAttrs = _objectSpread(_objectSpread({}, parsedAttrs), {}, {
        language: getCodeLanguage(parsedAttrs)
      });
      output.push(codeBlock.createChecked(nodeAttrs, textNode));
      return {
        type: "pmnode",
        nodes: output,
        length
      };
    };
    function getCodeLanguage(attrs) {
      var keys = Object.keys(attrs).map(function(key) {
        return key.toLowerCase();
      });
      for (var _i = 0, _SUPPORTED_CODEBOCK_L = SUPPORTED_CODEBOCK_LANGUAGES; _i < _SUPPORTED_CODEBOCK_L.length; _i++) {
        var language = _SUPPORTED_CODEBOCK_L[_i];
        if (keys.indexOf(language) !== -1) {
          return language;
        }
      }
      if (keys.indexOf("objc") !== -1) {
        return "objective-c";
      }
      return "java";
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/color.js
var require_color = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/color.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.getEditorColor = getEditorColor;
    var _adfSchema = require_cjs5();
    function getEditorColor(attrs) {
      var keys = Object.keys(attrs);
      return (0, _adfSchema.normalizeHexColor)(keys[0]);
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/color-macro.js
var require_color_macro = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/color-macro.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.colorMacro = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _ = require_tokenize();
    var _commonMacro = require_common_macro();
    var _attrs = require_attrs();
    var _text = require_text5();
    var _color = require_color();
    var _text2 = require_text6();
    var colorMacro = exports2.colorMacro = function colorMacro2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      return (0, _commonMacro.commonMacro)(input2.substring(position), schema, {
        keyword: "color",
        paired: true,
        context,
        rawContentProcessor
      });
    };
    var rawContentProcessor = function rawContentProcessor2(rawAttrs, rawContent, length, schema, context) {
      var ignoreTokenTypes = [_.TokenType.DOUBLE_DASH_SYMBOL, _.TokenType.TRIPLE_DASH_SYMBOL, _.TokenType.QUADRUPLE_DASH_SYMBOL, _.TokenType.TABLE];
      var parsedAttrs = (0, _attrs.parseAttrs)(rawAttrs);
      var content = (0, _text.parseString)({
        ignoreTokenTypes,
        schema,
        context,
        input: rawContent
      });
      var decoratedContent = content.map(function(n) {
        var mark = schema.marks.textColor.create({
          color: (0, _color.getEditorColor)(parsedAttrs) || "#000000"
        });
        if (n.type.name === "text" && !(0, _text2.hasAnyOfMarks)(n, ["textColor", "code"])) {
          return n.mark([].concat((0, _toConsumableArray2.default)(n.marks), [mark]));
        }
        return n;
      });
      return {
        type: "pmnode",
        nodes: decoratedContent,
        length
      };
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/noformat-macro.js
var require_noformat_macro = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/noformat-macro.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.noformatMacro = void 0;
    var _commonMacro = require_common_macro();
    var _attrs = require_attrs();
    var _title = require_title();
    var noformatMacro = exports2.noformatMacro = function noformatMacro2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema, context = _ref.context;
      return (0, _commonMacro.commonMacro)(input2.substring(position), schema, {
        keyword: "noformat",
        paired: true,
        context,
        rawContentProcessor
      });
    };
    var rawContentProcessor = function rawContentProcessor2(rawAttrs, rawContent, length, schema, _context) {
      var output = [];
      var codeBlock = schema.nodes.codeBlock;
      var parsedAttrs = (0, _attrs.parseAttrs)(rawAttrs);
      var trimedContent = rawContent.replace(/^\s+|\s+$/g, "");
      var textNode = trimedContent.length ? schema.text(trimedContent) : void 0;
      if (parsedAttrs.title) {
        output.push((0, _title.title)(parsedAttrs.title, schema));
      }
      output.push(codeBlock.createChecked({}, textNode));
      return {
        type: "pmnode",
        nodes: output,
        length
      };
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/force-line-break.js
var require_force_line_break = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/force-line-break.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.forceLineBreak = void 0;
    var FORCE_LINE_BREAK_REGEX = /^\\{2}(?!\S*\\)/;
    var forceLineBreak = exports2.forceLineBreak = function forceLineBreak2(_ref) {
      var input2 = _ref.input, position = _ref.position, schema = _ref.schema;
      if (position > 0) {
        var charBefore = input2.charAt(position - 1);
        if (charBefore === "\\") {
          return fallback(input2, position);
        }
      }
      var match = input2.substring(position).match(FORCE_LINE_BREAK_REGEX);
      if (match) {
        return {
          type: "pmnode",
          nodes: [schema.nodes.hardBreak.createChecked()],
          length: 2
        };
      }
      return fallback(input2, position);
    };
    function fallback(input2, position) {
      return {
        type: "text",
        text: input2.substr(position, 2),
        length: 2
      };
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/index.js
var require_tokenize = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/index.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.TokenType = void 0;
    exports2.parseToken = parseToken;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _media = require_media4();
    var _blockquote = require_blockquote5();
    var _citation = require_citation();
    var _deleted = require_deleted();
    var _doubleDashSymbol = require_double_dash_symbol();
    var _emoji = require_emoji5();
    var _emphasis = require_emphasis2();
    var _hardbreak = require_hardbreak();
    var _heading = require_heading4();
    var _inserted = require_inserted();
    var _linkFormat = require_link_format();
    var _linkText = require_link_text();
    var _list = require_list2();
    var _monospace = require_monospace();
    var _quadrupleDashSymbol = require_quadruple_dash_symbol();
    var _ruler = require_ruler2();
    var _strong = require_strong3();
    var _subscript = require_subscript();
    var _superscript = require_superscript();
    var _table = require_table4();
    var _tripleDashSymbol = require_triple_dash_symbol();
    var _panelMacro = require_panel_macro();
    var _adfMacro = require_adf_macro();
    var _anchorMacro = require_anchor_macro();
    var _codeMacro = require_code_macro();
    var _quoteMacro = require_quote_macro();
    var _colorMacro = require_color_macro();
    var _noformatMacro = require_noformat_macro();
    var _forceLineBreak = require_force_line_break();
    var _issueKey = require_issue_key();
    var _tokenToTokenParserMa;
    var TokenType = exports2.TokenType = /* @__PURE__ */ (function(TokenType2) {
      TokenType2["ADF_MACRO"] = "ADF_MACRO";
      TokenType2["ANCHOR_MACRO"] = "ANCHOR_MACRO";
      TokenType2["CODE_MACRO"] = "CODE_MACRO";
      TokenType2["QUOTE_MACRO"] = "QUOTE_MACRO";
      TokenType2["NOFORMAT_MACRO"] = "NOFORMAT_MACRO";
      TokenType2["PANEL_MACRO"] = "PANEL_MACRO";
      TokenType2["COLOR_MACRO"] = "COLOR_MACRO";
      TokenType2["LOREM_MACRO"] = "LOREM_MACRO";
      TokenType2["QUOTE"] = "QUOTE";
      TokenType2["STRING"] = "STRING";
      TokenType2["ISSUE_KEY"] = "ISSUE_KEY";
      TokenType2["LINK_FORMAT"] = "LINK_FORMAT";
      TokenType2["LINK_TEXT"] = "LINK_TEXT";
      TokenType2["MEDIA"] = "MEDIA";
      TokenType2["HEADING"] = "HEADING";
      TokenType2["LIST"] = "LIST";
      TokenType2["TABLE"] = "TABLE";
      TokenType2["RULER"] = "RULER";
      TokenType2["HARD_BREAK"] = "HARD_BREAK";
      TokenType2["DOUBLE_DASH_SYMBOL"] = "DOUBLE_DASH_SYMBOL";
      TokenType2["TRIPLE_DASH_SYMBOL"] = "TRIPLE_DASH_SYMBOL";
      TokenType2["QUADRUPLE_DASH_SYMBOL"] = "QUADRUPLE_DASH_SYMBOL";
      TokenType2["STRONG"] = "STRONG";
      TokenType2["MONOSPACE"] = "MONOSPACE";
      TokenType2["SUPERSCRIPT"] = "SUPERSCRIPT";
      TokenType2["SUBSCRIPT"] = "SUBSCRIPT";
      TokenType2["EMPHASIS"] = "EMPHASIS";
      TokenType2["CITATION"] = "CITATION";
      TokenType2["DELETED"] = "DELETED";
      TokenType2["INSERTED"] = "INSERTED";
      TokenType2["EMOJI"] = "EMOJI";
      TokenType2["FORCE_LINE_BREAK"] = "FORCE_LINE_BREAK";
      return TokenType2;
    })({});
    var tokenToTokenParserMapping = (_tokenToTokenParserMa = {}, (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)(_tokenToTokenParserMa, TokenType.DOUBLE_DASH_SYMBOL, _doubleDashSymbol.doubleDashSymbol), TokenType.TRIPLE_DASH_SYMBOL, _tripleDashSymbol.tripleDashSymbol), TokenType.QUADRUPLE_DASH_SYMBOL, _quadrupleDashSymbol.quadrupleDashSymbol), TokenType.RULER, _ruler.ruler), TokenType.STRONG, _strong.strong), TokenType.MONOSPACE, _monospace.monospace), TokenType.SUPERSCRIPT, _superscript.superscript), TokenType.SUBSCRIPT, _subscript.subscript), TokenType.EMPHASIS, _emphasis.emphasis), TokenType.CITATION, _citation.citation), (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)(_tokenToTokenParserMa, TokenType.DELETED, _deleted.deleted), TokenType.INSERTED, _inserted.inserted), TokenType.HARD_BREAK, _hardbreak.hardbreak), TokenType.LINK_FORMAT, _linkFormat.linkFormat), TokenType.LINK_TEXT, _linkText.linkText), TokenType.HEADING, _heading.heading), TokenType.MEDIA, _media.media), TokenType.LIST, _list.list), TokenType.QUOTE, _blockquote.blockquote), TokenType.TABLE, _table.table), (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)(_tokenToTokenParserMa, TokenType.EMOJI, _emoji.emoji), TokenType.ADF_MACRO, _adfMacro.adfMacro), TokenType.ANCHOR_MACRO, _anchorMacro.anchorMacro), TokenType.CODE_MACRO, _codeMacro.codeMacro), TokenType.QUOTE_MACRO, _quoteMacro.quoteMacro), TokenType.NOFORMAT_MACRO, _noformatMacro.noformatMacro), TokenType.PANEL_MACRO, _panelMacro.panelMacro), TokenType.COLOR_MACRO, _colorMacro.colorMacro), TokenType.FORCE_LINE_BREAK, _forceLineBreak.forceLineBreak), TokenType.ISSUE_KEY, _issueKey.issueKey));
    function parseToken(input2, type, position, schema, context) {
      var tokenParser = tokenToTokenParserMapping[type];
      if (tokenParser) {
        try {
          return tokenParser({
            input: input2,
            position,
            schema,
            context
          });
        } catch (err) {
          if (context.tokenErrCallback && err instanceof Error) {
            context.tokenErrCallback(err, type);
          }
          return fallback(input2, position);
        }
      }
      return fallback(input2, position);
    }
    function fallback(input2, position) {
      return {
        type: "text",
        text: input2.substr(position, 1),
        length: 1
      };
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/keyword.js
var require_keyword = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/tokenize/keyword.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.macroKeywordTokenMap = void 0;
    exports2.parseIssueKeyword = parseIssueKeyword;
    exports2.parseLeadingKeyword = parseLeadingKeyword;
    exports2.parseMacroKeyword = parseMacroKeyword;
    exports2.parseOtherKeyword = parseOtherKeyword;
    var _ = require_tokenize();
    var _list = require_list2();
    var macroKeywordTokenMap = exports2.macroKeywordTokenMap = [{
      type: _.TokenType.ADF_MACRO,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^{adf/i
    }, {
      type: _.TokenType.ANCHOR_MACRO,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^{anchor/i
    }, {
      type: _.TokenType.CODE_MACRO,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^{code/i
    }, {
      type: _.TokenType.QUOTE_MACRO,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^{quote/i
    }, {
      type: _.TokenType.NOFORMAT_MACRO,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^{noformat/i
    }, {
      type: _.TokenType.PANEL_MACRO,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^{panel/i
    }, {
      type: _.TokenType.COLOR_MACRO,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^{color/
    }, {
      type: _.TokenType.LOREM_MACRO,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^{loremipsum/i
    }];
    var keywordTokenMap = {
      "[": _.TokenType.LINK_FORMAT,
      http: _.TokenType.LINK_TEXT,
      ftp: _.TokenType.LINK_TEXT,
      jamfselfservice: _.TokenType.LINK_TEXT,
      irc: _.TokenType.LINK_TEXT,
      mailto: _.TokenType.LINK_TEXT,
      "\\\\": _.TokenType.FORCE_LINE_BREAK,
      "\r": _.TokenType.HARD_BREAK,
      "\n": _.TokenType.HARD_BREAK,
      "\r\n": _.TokenType.HARD_BREAK,
      "!": _.TokenType.MEDIA,
      "----": _.TokenType.QUADRUPLE_DASH_SYMBOL,
      "---": _.TokenType.TRIPLE_DASH_SYMBOL,
      "--": _.TokenType.DOUBLE_DASH_SYMBOL,
      "{-}": _.TokenType.DELETED,
      "{+}": _.TokenType.INSERTED,
      "{*}": _.TokenType.STRONG,
      "{^}": _.TokenType.SUPERSCRIPT,
      "{~}": _.TokenType.SUBSCRIPT,
      "{_}": _.TokenType.EMPHASIS,
      "{{{}": _.TokenType.MONOSPACE,
      "{??}": _.TokenType.CITATION,
      "-": _.TokenType.DELETED,
      "+": _.TokenType.INSERTED,
      "*": _.TokenType.STRONG,
      "^": _.TokenType.SUPERSCRIPT,
      "~": _.TokenType.SUBSCRIPT,
      _: _.TokenType.EMPHASIS,
      "{{": _.TokenType.MONOSPACE,
      "??": _.TokenType.CITATION
    };
    var keywordTokenMapKeys = Object.keys(keywordTokenMap);
    function parseMacroKeyword(input2) {
      for (var i = 0; i < macroKeywordTokenMap.length; i++) {
        var keyword = macroKeywordTokenMap[i];
        if (keyword.regex.test(input2)) {
          return {
            type: keyword.type
          };
        }
      }
      return null;
    }
    function parseOtherKeyword(input2) {
      for (var i = 0; i < keywordTokenMapKeys.length; i++) {
        if (input2.startsWith(keywordTokenMapKeys[i])) {
          return {
            type: keywordTokenMap[keywordTokenMapKeys[i]]
          };
        }
      }
      var char = input2.charAt(0);
      if ([":", "(", ";"].indexOf(char) !== -1) {
        return {
          // This potentially can be a emoji. The emoji parser will fail out if it's not
          type: _.TokenType.EMOJI
        };
      }
      return null;
    }
    var leadingKeywordTokenMap = [{
      type: _.TokenType.QUOTE,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^bq\./
    }, {
      type: _.TokenType.HEADING,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^h[1-6]\./
    }, {
      type: _.TokenType.RULER,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^-{4,5}(\s|$)/
    }, {
      type: _.TokenType.TRIPLE_DASH_SYMBOL,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^-{3}\s/
    }, {
      type: _.TokenType.DOUBLE_DASH_SYMBOL,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^-{2}\s/
    }, {
      // Lists are limited to max 20 levels of depth
      type: _.TokenType.LIST,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: new RegExp("^([*#]{1,".concat(_list.MAX_LIST_DEPTH, "}|-) "))
    }, {
      type: _.TokenType.TABLE,
      // Ignored via go/ees005
      // eslint-disable-next-line require-unicode-regexp
      regex: /^\|{1,2}/
    }];
    function parseLeadingKeyword(input2) {
      for (var i = 0; i < leadingKeywordTokenMap.length; i++) {
        var keyword = leadingKeywordTokenMap[i];
        if (keyword.regex.test(input2)) {
          return {
            type: keyword.type
          };
        }
      }
      return null;
    }
    function parseIssueKeyword(input2, issueKeyRegex) {
      if (issueKeyRegex && issueKeyRegex.test(input2)) {
        return {
          type: _.TokenType.ISSUE_KEY
        };
      }
      return null;
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/code.js
var require_code4 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/code.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.code = void 0;
    var code = exports2.code = function code2(text) {
      return "{{".concat(text, "}}");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/color.js
var require_color2 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/color.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.textColor = void 0;
    var textColor = exports2.textColor = function textColor2(text, attrs) {
      return "{color:".concat(attrs.color, "}").concat(text, "{color}");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/__base.js
var require_base = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/__base.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.baseMarkPattern = void 0;
    var baseMarkPattern = exports2.baseMarkPattern = function baseMarkPattern2(text, token) {
      if (/^\s*$/.test(text)) {
        return text;
      }
      return text.replace(/^\s*/, "$&".concat(token)).replace(/\s*$/, "".concat(token, "$&"));
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/em.js
var require_em3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/em.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.em = void 0;
    var _base = require_base();
    var em = exports2.em = function em2(text) {
      if (text.startsWith("\u2014 ")) {
        return (0, _base.baseMarkPattern)(text.substring(2), "??");
      }
      return (0, _base.baseMarkPattern)(text, "_");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/link.js
var require_link4 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/link.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.link = void 0;
    var link = exports2.link = function link2(text, attrs) {
      return "[".concat(text, "|").concat(attrs.href, "]");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/strike.js
var require_strike3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/strike.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.strike = void 0;
    var _base = require_base();
    var strike = exports2.strike = function strike2(text) {
      return (0, _base.baseMarkPattern)(text, "-");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/strong.js
var require_strong4 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/strong.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.strong = void 0;
    var _base = require_base();
    var strong = exports2.strong = function strong2(text) {
      return (0, _base.baseMarkPattern)(text, "*");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/subsup.js
var require_subsup3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/subsup.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.subsup = void 0;
    var _base = require_base();
    var subsup = exports2.subsup = function subsup2(text, attrs) {
      if (attrs.type === "sub") {
        return (0, _base.baseMarkPattern)(text, "~");
      } else {
        return (0, _base.baseMarkPattern)(text, "^");
      }
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/underline.js
var require_underline3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/marks/underline.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.underline = void 0;
    var _base = require_base();
    var underline = exports2.underline = function underline2(text) {
      return (0, _base.baseMarkPattern)(text, "+");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/text.js
var require_text7 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/text.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.text = void 0;
    var _toConsumableArray2 = _interopRequireDefault(require_toConsumableArray());
    var _keyword = require_keyword();
    var _code = require_code4();
    var _color = require_color2();
    var _em = require_em3();
    var _link = require_link4();
    var _strike = require_strike3();
    var _strong = require_strong4();
    var _subsup = require_subsup3();
    var _underline = require_underline3();
    var markEncoderMapping = /* @__PURE__ */ new Map([["em", _em.em], ["strike", _strike.strike], ["strong", _strong.strong], ["subsup", _subsup.subsup], ["underline", _underline.underline], ["textColor", _color.textColor], ["link", _link.link], ["code", _code.code]]);
    var MENTION_ESCAPE_PATTERN = "(\\[~)";
    var MEDIA_ESCAPE_PATTERN = "(![^ !]+)(!)";
    var MEDIA_GROUP_ESCAPE_PATTERN = "(\\[\\^[^ ]+)(\\])";
    var isEscapeNeeded = function isEscapeNeeded2(node, parent) {
      return !(parent && parent.type.name === "codeBlock" || node.marks.find(function(m) {
        return m.type.name === "code";
      }) !== void 0);
    };
    function escapingWikiFormatter(text2) {
      var pattern = [MENTION_ESCAPE_PATTERN].concat((0, _toConsumableArray2.default)(_keyword.macroKeywordTokenMap.map(function(macro) {
        return "(".concat(macro.regex.source.replace("^", ""), ")");
      }))).join("|");
      return text2.replace(new RegExp(pattern, "g"), "\\$&").replace(new RegExp(MEDIA_ESCAPE_PATTERN, "g"), "\\$1\\$2").replace(new RegExp(MEDIA_GROUP_ESCAPE_PATTERN, "g"), "\\$1\\$2");
    }
    var text = exports2.text = function text2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, parent = _ref.parent;
      var result = isEscapeNeeded(node, parent) ? escapingWikiFormatter(node.text) : node.text;
      markEncoderMapping.forEach(function(encoder, markName) {
        var mark = node.marks.find(function(m) {
          return m.type.name === markName;
        });
        if (mark) {
          result = encoder(result, mark.attrs);
        }
      });
      return result;
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/inline-card.js
var require_inline_card3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/inline-card.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.inlineCard = void 0;
    var _unknown = require_unknown();
    var _issueKey = require_issue_key();
    var inlineCard = exports2.inlineCard = function inlineCard2(node) {
      if (!node.attrs.url) {
        return (0, _unknown.unknown)(node);
      }
      var match = node.attrs.url.match(_issueKey.INLINE_CARD_FROM_TEXT_STAMP);
      if (!match) {
        return "[".concat(node.attrs.url, "|").concat(node.attrs.url, "|smart-link]");
      }
      return "[".concat(match[2], "]");
    };
  }
});

// node_modules/@atlaskit/theme/dist/cjs/colors.js
var require_colors2 = __commonJS({
  "node_modules/@atlaskit/theme/dist/cjs/colors.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.R300 = exports2.R200 = exports2.R100 = exports2.P75 = exports2.P500 = exports2.P50 = exports2.P400 = exports2.P300 = exports2.P200 = exports2.P100 = exports2.N90A = exports2.N900 = exports2.N90 = exports2.N80A = exports2.N800A = exports2.N800 = exports2.N80 = exports2.N70A = exports2.N700A = exports2.N700 = exports2.N70 = exports2.N60A = exports2.N600A = exports2.N600 = exports2.N60 = exports2.N50A = exports2.N500A = exports2.N500 = exports2.N50 = exports2.N40A = exports2.N400A = exports2.N400 = exports2.N40 = exports2.N30A = exports2.N300A = exports2.N300 = exports2.N30 = exports2.N20A = exports2.N200A = exports2.N200 = exports2.N20 = exports2.N10A = exports2.N100A = exports2.N100 = exports2.N10 = exports2.N0 = exports2.L75 = exports2.L50 = exports2.G75 = exports2.G500 = exports2.G50 = exports2.G400 = exports2.G300 = exports2.G200 = exports2.G100 = exports2.DN90A = exports2.DN900 = exports2.DN90 = exports2.DN80A = exports2.DN800A = exports2.DN800 = exports2.DN80 = exports2.DN70A = exports2.DN700A = exports2.DN700 = exports2.DN70 = exports2.DN60A = exports2.DN600A = exports2.DN600 = exports2.DN60 = exports2.DN50A = exports2.DN500A = exports2.DN500 = exports2.DN50 = exports2.DN40A = exports2.DN400A = exports2.DN400 = exports2.DN40 = exports2.DN30A = exports2.DN300A = exports2.DN300 = exports2.DN30 = exports2.DN20A = exports2.DN200A = exports2.DN200 = exports2.DN20 = exports2.DN10A = exports2.DN100A = exports2.DN100 = exports2.DN10 = exports2.DN0 = exports2.B75 = exports2.B700 = exports2.B600 = exports2.B500 = exports2.B50 = exports2.B400 = exports2.B300 = exports2.B200 = exports2.B100 = void 0;
    exports2.Y75 = exports2.Y500 = exports2.Y50 = exports2.Y400 = exports2.Y300 = exports2.Y200 = exports2.Y100 = exports2.T75 = exports2.T500 = exports2.T50 = exports2.T400 = exports2.T300 = exports2.T30 = exports2.T200 = exports2.T100 = exports2.R75 = exports2.R500 = exports2.R50 = exports2.R400 = void 0;
    var R50 = exports2.R50 = "#FFEBE6";
    var R75 = exports2.R75 = "#FFBDAD";
    var R100 = exports2.R100 = "#FF8F73";
    var R200 = exports2.R200 = "#FF7452";
    var R300 = exports2.R300 = "#FF5630";
    var R400 = exports2.R400 = "#DE350B";
    var R500 = exports2.R500 = "#BF2600";
    var Y50 = exports2.Y50 = "#FFFAE6";
    var Y75 = exports2.Y75 = "#FFF0B3";
    var Y100 = exports2.Y100 = "#FFE380";
    var Y200 = exports2.Y200 = "#FFC400";
    var Y300 = exports2.Y300 = "#FFAB00";
    var Y400 = exports2.Y400 = "#FF991F";
    var Y500 = exports2.Y500 = "#FF8B00";
    var G50 = exports2.G50 = "#E3FCEF";
    var G75 = exports2.G75 = "#ABF5D1";
    var G100 = exports2.G100 = "#79F2C0";
    var G200 = exports2.G200 = "#57D9A3";
    var G300 = exports2.G300 = "#36B37E";
    var G400 = exports2.G400 = "#00875A";
    var G500 = exports2.G500 = "#006644";
    var B50 = exports2.B50 = "#DEEBFF";
    var B75 = exports2.B75 = "#B3D4FF";
    var B100 = exports2.B100 = "#4C9AFF";
    var B200 = exports2.B200 = "#2684FF";
    var B300 = exports2.B300 = "#0065FF";
    var B400 = exports2.B400 = "#0052CC";
    var B500 = exports2.B500 = "#0747A6";
    var B600 = exports2.B600 = "#669DF1";
    var B700 = exports2.B700 = "#8FB8F6";
    var P50 = exports2.P50 = "#EAE6FF";
    var P75 = exports2.P75 = "#C0B6F2";
    var P100 = exports2.P100 = "#998DD9";
    var P200 = exports2.P200 = "#8777D9";
    var P300 = exports2.P300 = "#6554C0";
    var P400 = exports2.P400 = "#5243AA";
    var P500 = exports2.P500 = "#403294";
    var T50 = exports2.T50 = "#E6FCFF";
    var T75 = exports2.T75 = "#B3F5FF";
    var T100 = exports2.T100 = "#79E2F2";
    var T200 = exports2.T200 = "#00C7E6";
    var T300 = exports2.T300 = "#00B8D9";
    var T400 = exports2.T400 = "#00A3BF";
    var T500 = exports2.T500 = "#008DA6";
    var N0 = exports2.N0 = "#FFFFFF";
    var N10 = exports2.N10 = "#FAFBFC";
    var N20 = exports2.N20 = "#F4F5F7";
    var N30 = exports2.N30 = "#EBECF0";
    var N40 = exports2.N40 = "#DFE1E6";
    var N50 = exports2.N50 = "#C1C7D0";
    var N60 = exports2.N60 = "#B3BAC5";
    var N70 = exports2.N70 = "#A5ADBA";
    var N80 = exports2.N80 = "#97A0AF";
    var N90 = exports2.N90 = "#8993A4";
    var N100 = exports2.N100 = "#7A869A";
    var N200 = exports2.N200 = "#6B778C";
    var N300 = exports2.N300 = "#5E6C84";
    var N400 = exports2.N400 = "#505F79";
    var N500 = exports2.N500 = "#42526E";
    var N600 = exports2.N600 = "#344563";
    var N700 = exports2.N700 = "#253858";
    var N800 = exports2.N800 = "#172B4D";
    var N900 = exports2.N900 = "#091E42";
    var N10A = exports2.N10A = "rgba(9, 30, 66, 0.02)";
    var N20A = exports2.N20A = "rgba(9, 30, 66, 0.04)";
    var N30A = exports2.N30A = "rgba(9, 30, 66, 0.08)";
    var N40A = exports2.N40A = "rgba(9, 30, 66, 0.13)";
    var N50A = exports2.N50A = "rgba(9, 30, 66, 0.25)";
    var N60A = exports2.N60A = "rgba(9, 30, 66, 0.31)";
    var N70A = exports2.N70A = "rgba(9, 30, 66, 0.36)";
    var N80A = exports2.N80A = "rgba(9, 30, 66, 0.42)";
    var N90A = exports2.N90A = "rgba(9, 30, 66, 0.48)";
    var N100A = exports2.N100A = "rgba(9, 30, 66, 0.54)";
    var N200A = exports2.N200A = "rgba(9, 30, 66, 0.60)";
    var N300A = exports2.N300A = "rgba(9, 30, 66, 0.66)";
    var N400A = exports2.N400A = "rgba(9, 30, 66, 0.71)";
    var N500A = exports2.N500A = "rgba(9, 30, 66, 0.77)";
    var N600A = exports2.N600A = "rgba(9, 30, 66, 0.82)";
    var N700A = exports2.N700A = "rgba(9, 30, 66, 0.89)";
    var N800A = exports2.N800A = "rgba(9, 30, 66, 0.95)";
    var DN900 = exports2.DN900 = "#E6EDFA";
    var DN800 = exports2.DN800 = "#DCE5F5";
    var DN700 = exports2.DN700 = "#CED9EB";
    var DN600 = exports2.DN600 = "#B8C7E0";
    var DN500 = exports2.DN500 = "#ABBBD6";
    var DN400 = exports2.DN400 = "#9FB0CC";
    var DN300 = exports2.DN300 = "#8C9CB8";
    var DN200 = exports2.DN200 = "#7988A3";
    var DN100 = exports2.DN100 = "#67758F";
    var DN90 = exports2.DN90 = "#56637A";
    var DN80 = exports2.DN80 = "#455166";
    var DN70 = exports2.DN70 = "#3B475C";
    var DN60 = exports2.DN60 = "#313D52";
    var DN50 = exports2.DN50 = "#283447";
    var DN40 = exports2.DN40 = "#202B3D";
    var DN30 = exports2.DN30 = "#1B2638";
    var DN20 = exports2.DN20 = "#121A29";
    var DN10 = exports2.DN10 = "#0E1624";
    var DN0 = exports2.DN0 = "#0D1424";
    var DN800A = exports2.DN800A = "rgba(13, 20, 36, 0.06)";
    var DN700A = exports2.DN700A = "rgba(13, 20, 36, 0.14)";
    var DN600A = exports2.DN600A = "rgba(13, 20, 36, 0.18)";
    var DN500A = exports2.DN500A = "rgba(13, 20, 36, 0.29)";
    var DN400A = exports2.DN400A = "rgba(13, 20, 36, 0.36)";
    var DN300A = exports2.DN300A = "rgba(13, 20, 36, 0.40)";
    var DN200A = exports2.DN200A = "rgba(13, 20, 36, 0.47)";
    var DN100A = exports2.DN100A = "rgba(13, 20, 36, 0.53)";
    var DN90A = exports2.DN90A = "rgba(13, 20, 36, 0.63)";
    var DN80A = exports2.DN80A = "rgba(13, 20, 36, 0.73)";
    var DN70A = exports2.DN70A = "rgba(13, 20, 36, 0.78)";
    var DN60A = exports2.DN60A = "rgba(13, 20, 36, 0.81)";
    var DN50A = exports2.DN50A = "rgba(13, 20, 36, 0.85)";
    var DN40A = exports2.DN40A = "rgba(13, 20, 36, 0.89)";
    var DN30A = exports2.DN30A = "rgba(13, 20, 36, 0.92)";
    var DN20A = exports2.DN20A = "rgba(13, 20, 36, 0.95)";
    var DN10A = exports2.DN10A = "rgba(13, 20, 36, 0.97)";
    var T30 = exports2.T30 = "#292A2E";
    var L50 = exports2.L50 = "#94C748";
    var L75 = exports2.L75 = "#B3DF72";
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/status.js
var require_status3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/status.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.status = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _color = require_color2();
    var _colors = require_colors2();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var color = {
      grey: _colors.N80,
      purple: _colors.P300,
      blue: _colors.T300,
      red: _colors.R300,
      yellow: _colors.Y400,
      green: _colors.G300
    };
    var status = exports2.status = function status2(node) {
      var text = "*[ ".concat(node.attrs.text.toUpperCase(), " ]*");
      var newAttrs = _objectSpread({}, node.attrs);
      if (color[node.attrs.color]) {
        newAttrs.color = color[node.attrs.color];
      } else {
        newAttrs.color = color["grey"];
      }
      return (0, _color.textColor)(text, newAttrs);
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/date.js
var require_date3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/date.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.date = void 0;
    var date = exports2.date = function date2(node) {
      var addLeadingZero = function addLeadingZero2(val) {
        if (val < 10) {
          return "0".concat(val);
        }
        return val;
      };
      var result = new Date(Number(node.attrs.timestamp));
      return "{{".concat(result.getUTCFullYear(), "-").concat(addLeadingZero(result.getUTCMonth() + 1), "-").concat(addLeadingZero(result.getUTCDate()), "}}");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/inlines.js
var require_inlines = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/inlines.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.inlines = void 0;
    var _emoji = require_emoji4();
    var _hardBreak = require_hard_break3();
    var _mediaInline = require_media_inline2();
    var _mention = require_mention3();
    var _text = require_text7();
    var _inlineCard = require_inline_card3();
    var _status = require_status3();
    var _unknown = require_unknown();
    var _date = require_date3();
    var inlinesEncoderMapping = {
      emoji: _emoji.emoji,
      hardBreak: _hardBreak.hardBreak,
      mediaInline: _mediaInline.mediaInline,
      mention: _mention.mention,
      text: _text.text,
      inlineCard: _inlineCard.inlineCard,
      status: _status.status,
      date: _date.date
    };
    var inlines = exports2.inlines = function inlines2(node, opts) {
      var encoder = inlinesEncoderMapping[node.type.name];
      if (encoder) {
        return encoder(node, opts);
      }
      return (0, _unknown.unknown)(node);
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/paragraph.js
var require_paragraph5 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/paragraph.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.paragraph = void 0;
    var _inlines = require_inlines();
    var paragraph = exports2.paragraph = function paragraph2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      var result = "";
      node.forEach(function(n) {
        result += (0, _inlines.inlines)(n, {
          context
        });
      });
      return result;
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/code-block.js
var require_code_block3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/code-block.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.codeBlock = void 0;
    var _inlines = require_inlines();
    var supportedLanguageInWiki = ["actionscript", "ada", "applescript", "bash", "c", "c#", "c++", "cpp", "css", "erlang", "go", "groovy", "haskell", "html", "java", "javascript", "js", "json", "lua", "none", "nyan", "objc", "perl", "php", "python", "r", "rainbow", "ruby", "scala", "sh", "sql", "swift", "visualbasic", "xml", "yaml"];
    var codeBlock = exports2.codeBlock = function codeBlock2(node) {
      var result = "";
      node.forEach(function(n) {
        result += (0, _inlines.inlines)(n, {
          parent: node
        });
      });
      if (supportedLanguageInWiki.indexOf(node.attrs.language) !== -1) {
        return "{code:".concat(node.attrs.language, "}").concat(result, "{code}");
      } else {
        return "{noformat}".concat(result, "{noformat}");
      }
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/caption.js
var require_caption2 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/caption.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.caption = void 0;
    var _inlines = require_inlines();
    var caption = exports2.caption = function caption2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      var result = "";
      node.forEach(function(n) {
        result += (0, _inlines.inlines)(n, {
          context
        });
      });
      return result;
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/media.js
var require_media5 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/media.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.media = void 0;
    var media = exports2.media = function media2(node) {
      var _context$conversion2;
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context, parent = _ref.parent;
      var wikiAttrs = [];
      if (parent && parent.attrs.width) {
        wikiAttrs.push("width=".concat(parent.attrs.width, "%"));
      } else {
        if (node.attrs.width) {
          wikiAttrs.push("width=".concat(node.attrs.width));
        }
        if (node.attrs.height) {
          wikiAttrs.push("height=".concat(node.attrs.height));
        }
      }
      if (node.attrs.alt) {
        wikiAttrs.push('alt="'.concat(node.attrs.alt, '"'));
      }
      if (node.marks.length) {
        var linkMark = node.marks.find(function(mark) {
          return mark.type.name === "link";
        });
        if (linkMark) {
          wikiAttrs.push('href="'.concat(linkMark === null || linkMark === void 0 ? void 0 : linkMark.attrs.href, '"'));
        }
      }
      var fileName;
      if (node.attrs.type === "external") {
        fileName = node.attrs.url;
      } else {
        var _context$conversion$m, _context$conversion;
        fileName = (_context$conversion$m = context === null || context === void 0 || (_context$conversion = context.conversion) === null || _context$conversion === void 0 || (_context$conversion = _context$conversion.mediaConversion) === null || _context$conversion === void 0 || (_context$conversion = _context$conversion[node.attrs.id]) === null || _context$conversion === void 0 ? void 0 : _context$conversion.transform) !== null && _context$conversion$m !== void 0 ? _context$conversion$m : node.attrs.id;
      }
      if ((context === null || context === void 0 || (_context$conversion2 = context.conversion) === null || _context$conversion2 === void 0 || (_context$conversion2 = _context$conversion2.mediaConversion) === null || _context$conversion2 === void 0 || (_context$conversion2 = _context$conversion2[node.attrs.id]) === null || _context$conversion2 === void 0 ? void 0 : _context$conversion2.embed) === false) {
        return "[^".concat(fileName, "]");
      }
      if (wikiAttrs.length) {
        return "!".concat(fileName, "|").concat(wikiAttrs.join(","), "!");
      }
      return "!".concat(fileName, "|thumbnail!");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/media-group.js
var require_media_group3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/media-group.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.mediaGroup = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _caption = require_caption2();
    var _media = require_media5();
    var _unknown = require_unknown();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var mediaGroup = exports2.mediaGroup = function mediaGroup2(node) {
      var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
      var result = [];
      node.forEach(function(n) {
        switch (n.type.name) {
          case "media":
            result.push((0, _media.media)(n, _objectSpread(_objectSpread({}, opts), {}, {
              parent: node
            })));
            break;
          case "caption":
            result.push((0, _caption.caption)(n, opts));
            break;
          default:
            result.push((0, _unknown.unknown)(n));
            break;
        }
      });
      return result.join("\n");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/listItem.js
var require_listItem = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/listItem.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.listItem = void 0;
    var _ = require_encoder();
    var _paragraph = require_paragraph5();
    var _unknown = require_unknown();
    var _codeBlock = require_code_block3();
    var _mediaGroup = require_media_group3();
    var _mediaInline = require_media_inline2();
    var listItem = exports2.listItem = function listItem2(node, prefix, context) {
      var result = [];
      var contentBuffer = [];
      node.forEach(function(n) {
        switch (n.type.name) {
          case "paragraph": {
            contentBuffer.push((0, _paragraph.paragraph)(n, {
              context
            }));
            break;
          }
          case "bulletList":
          case "orderedList": {
            if (contentBuffer.length) {
              result.push("".concat(prefix, " ").concat(contentBuffer.join("\n")));
              contentBuffer = [];
            }
            var nestedList = (0, _.encode)(n, context).split("\n").map(function(line) {
              if (["#", "*"].indexOf(line.substr(0, 1)) !== -1) {
                return "".concat(prefix).concat(line);
              }
              return line;
            }).join("\n");
            result.push(nestedList);
            break;
          }
          case "codeBlock": {
            contentBuffer.push((0, _codeBlock.codeBlock)(n));
            break;
          }
          case "mediaInline": {
            contentBuffer.push((0, _mediaInline.mediaInline)(n, {
              context
            }));
            break;
          }
          case "mediaSingle": {
            contentBuffer.push((0, _mediaGroup.mediaGroup)(n, {
              context
            }));
            break;
          }
          default:
            contentBuffer.push((0, _unknown.unknown)(n));
        }
      });
      if (contentBuffer.length) {
        result.push("".concat(prefix, " ").concat(contentBuffer.join("\n")));
      }
      return result.join("\n");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/bullet-list.js
var require_bullet_list3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/bullet-list.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.bulletList = void 0;
    var _listItem = require_listItem();
    var bulletList = exports2.bulletList = function bulletList2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      var result = [];
      node.forEach(function(item) {
        result.push((0, _listItem.listItem)(item, "*", context));
      });
      return result.join("\n");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/taskItem.js
var require_taskItem = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/taskItem.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.taskItem = void 0;
    var _inlines = require_inlines();
    var taskItem = exports2.taskItem = function taskItem2(node, nestedLevel) {
      var _ref = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, context = _ref.context;
      var result = "";
      node.forEach(function(n) {
        var prefix = Array(nestedLevel).fill("*").join("");
        if (node.attrs.state === "DONE") {
          result += "".concat(prefix, " -").concat((0, _inlines.inlines)(n, {
            context
          }), "-");
        } else {
          result += "".concat(prefix, " ").concat((0, _inlines.inlines)(n, {
            context
          }));
        }
      });
      return result;
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/taskList.js
var require_taskList = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/taskList.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.taskList = void 0;
    var _taskItem = require_taskItem();
    var _nestedNode = function nestedNode(node) {
      var depth = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
      var result = [];
      node.forEach(function(item) {
        if (item.type.name === "taskList") {
          result.push(_nestedNode(item, depth + 1));
        } else {
          result.push((0, _taskItem.taskItem)(item, depth));
        }
      });
      return result.join("\n");
    };
    var taskList = exports2.taskList = function taskList2(node) {
      return _nestedNode(node);
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/decisionItem.js
var require_decisionItem = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/decisionItem.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.decisionItem = void 0;
    var _inlines = require_inlines();
    var decisionItem = exports2.decisionItem = function decisionItem2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      var result = "";
      node.forEach(function(n) {
        result += "* <> ".concat((0, _inlines.inlines)(n, {
          context
        }));
      });
      return result;
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/decisionList.js
var require_decisionList = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/decisionList.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.decisionList = void 0;
    var _decisionItem = require_decisionItem();
    var decisionList = exports2.decisionList = function decisionList2(node) {
      var result = [];
      node.forEach(function(item) {
        result.push((0, _decisionItem.decisionItem)(item));
      });
      return result.join("\n");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/doc.js
var require_doc3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/doc.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.doc = void 0;
    var _ = require_encoder();
    var doc = exports2.doc = function doc2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      var result = [];
      node.forEach(function(n) {
        result.push((0, _.encode)(n, context));
      });
      return result.join("\n\n");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/expand.js
var require_expand3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/expand.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.expand = void 0;
    var _ = require_encoder();
    var expand = exports2.expand = function expand2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      var result = ["*".concat(node.attrs.title, "*"), ""];
      node.forEach(function(n) {
        result.push((0, _.encode)(n, context));
      });
      return result.join("\n");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/heading.js
var require_heading5 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/heading.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.heading = void 0;
    var _inlines = require_inlines();
    var heading = exports2.heading = function heading2(node) {
      var result = "";
      node.forEach(function(n) {
        result += (0, _inlines.inlines)(n);
      });
      return "h".concat(node.attrs.level, ". ").concat(result);
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/ordered-list.js
var require_ordered_list3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/ordered-list.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.orderedList = void 0;
    var _listItem = require_listItem();
    var orderedList = exports2.orderedList = function orderedList2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      var result = [];
      node.forEach(function(item) {
        result.push((0, _listItem.listItem)(item, "#", context));
      });
      return result.join("\n");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/panel.js
var require_panel3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/panel.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.panel = void 0;
    var _ = require_encoder();
    var panelTypeColorMapping = {
      info: "#deebff",
      note: "#eae6ff",
      success: "#e3fcef",
      warning: "#fffae6",
      error: "#ffebe6"
    };
    var panel = exports2.panel = function panel2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      var result = [];
      node.forEach(function(n) {
        result.push((0, _.encode)(n, context));
      });
      return "{panel:bgColor=".concat(panelTypeColorMapping[node.attrs.panelType] || "", "}\n").concat(result.join("\n\n"), "\n{panel}");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/rule.js
var require_rule4 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/rule.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.rule = void 0;
    var rule = exports2.rule = function rule2(_node) {
      return "----";
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/table.js
var require_table5 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/table.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.table = void 0;
    var _ = require_encoder();
    var _unknown = require_unknown();
    var table = exports2.table = function table2(node) {
      var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
      try {
        var result = [];
        node.forEach(function(n) {
          result.push(tableRow(n, opts));
        });
        return result.join("\n");
      } catch (err) {
        return (0, _unknown.unknown)(node);
      }
    };
    var tableRow = function tableRow2(node) {
      var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
      var result = "";
      var separator = "|";
      node.forEach(function(n) {
        if (n.type.name === "tableHeader") {
          separator = "||";
        } else {
          separator = "|";
        }
        result = "".concat(result).concat(separator).concat(tableCell(n, opts));
      });
      return "".concat(result).concat(separator);
    };
    var tableCell = function tableCell2(node) {
      var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, context = _ref.context;
      if (hasMergedCell(node)) {
        throw new Error("Advanced feature of table is not supported");
      }
      var result = [];
      node.forEach(function(n) {
        result.push((0, _.encode)(n, context));
      });
      var output = result.join("\n").trim();
      return output === "" ? " " : output;
    };
    var hasMergedCell = function hasMergedCell2(node) {
      if (!node.attrs) {
        return false;
      }
      if (node.attrs.colspan && node.attrs.colspan !== 1) {
        return true;
      }
      if (node.attrs.rowspan && node.attrs.rowspan !== 1) {
        return true;
      }
      return false;
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/block-card.js
var require_block_card3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/block-card.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.blockCard = void 0;
    var _unknown = require_unknown();
    var blockCard = exports2.blockCard = function blockCard2(node) {
      if (!node.attrs.url) {
        return (0, _unknown.unknown)(node);
      }
      return "[".concat(node.attrs.url, "|").concat(node.attrs.url, "|smart-card]");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/embed-card.js
var require_embed_card3 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/nodes/embed-card.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.embedCard = void 0;
    var _unknown = require_unknown();
    var embedCard = exports2.embedCard = function embedCard2(node) {
      if (!node.attrs.url) {
        return (0, _unknown.unknown)(node);
      }
      return "[".concat(node.attrs.url, "|").concat(node.attrs.url, "|smart-embed]");
    };
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/index.js
var require_encoder = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/encoder/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.encode = encode;
    var _blockquote = require_blockquote4();
    var _bulletList = require_bullet_list3();
    var _taskList = require_taskList();
    var _decisionList = require_decisionList();
    var _codeBlock = require_code_block3();
    var _doc = require_doc3();
    var _expand = require_expand3();
    var _heading = require_heading5();
    var _mediaGroup = require_media_group3();
    var _mediaInline = require_media_inline2();
    var _orderedList = require_ordered_list3();
    var _panel = require_panel3();
    var _paragraph = require_paragraph5();
    var _rule = require_rule4();
    var _table = require_table5();
    var _unknown = require_unknown();
    var _blockCard = require_block_card3();
    var _embedCard = require_embed_card3();
    var _caption = require_caption2();
    var nodeEncoderMapping = {
      blockquote: _blockquote.blockquote,
      bulletList: _bulletList.bulletList,
      taskList: _taskList.taskList,
      decisionList: _decisionList.decisionList,
      codeBlock: _codeBlock.codeBlock,
      doc: _doc.doc,
      heading: _heading.heading,
      caption: _caption.caption,
      mediaGroup: _mediaGroup.mediaGroup,
      mediaInline: _mediaInline.mediaInline,
      mediaSingle: _mediaGroup.mediaGroup,
      orderedList: _orderedList.orderedList,
      panel: _panel.panel,
      paragraph: _paragraph.paragraph,
      rule: _rule.rule,
      table: _table.table,
      blockCard: _blockCard.blockCard,
      embedCard: _embedCard.embedCard,
      expand: _expand.expand
    };
    function encode(node, context) {
      var encoder = nodeEncoderMapping[node.type.name];
      try {
        if (encoder) {
          return encoder(node, {
            context
          });
        }
        return (0, _unknown.unknown)(node);
      } catch (err) {
        return (0, _unknown.unknown)(node);
      }
    }
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/abstract-tree.js
var require_abstract_tree = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/parser/abstract-tree.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = void 0;
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _text = require_text5();
    var _normalize = require_normalize2();
    var AbstractTree = exports2.default = /* @__PURE__ */ (function() {
      function AbstractTree2(schema, wikiMarkup) {
        (0, _classCallCheck2.default)(this, AbstractTree2);
        this.schema = schema;
        this.wikiMarkup = wikiMarkup;
      }
      return (0, _createClass2.default)(AbstractTree2, [{
        key: "getProseMirrorModel",
        value: function getProseMirrorModel(context) {
          var content = (0, _text.parseString)({
            context,
            ignoreTokenTypes: [],
            input: this.wikiMarkup,
            schema: this.schema
          });
          return this.schema.nodes.doc.createChecked({}, (0, _normalize.normalizePMNodes)(content, this.schema, "doc"));
        }
      }]);
    })();
  }
});

// node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/index.js
var require_cjs7 = __commonJS({
  "node_modules/@atlaskit/editor-wikimarkup-transformer/dist/cjs/index.js"(exports2) {
    "use strict";
    var _interopRequireDefault = require_interopRequireDefault();
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.default = exports2.WikiMarkupTransformer = void 0;
    var _defineProperty2 = _interopRequireDefault(require_defineProperty());
    var _classCallCheck2 = _interopRequireDefault(require_classCallCheck());
    var _createClass2 = _interopRequireDefault(require_createClass());
    var _schemaDefault = require_default_schema();
    var _encoder = require_encoder();
    var _abstractTree = _interopRequireDefault(require_abstract_tree());
    var _issueKey = require_issue_key();
    function ownKeys(e, r) {
      var t = Object.keys(e);
      if (Object.getOwnPropertySymbols) {
        var o = Object.getOwnPropertySymbols(e);
        r && (o = o.filter(function(r2) {
          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
        })), t.push.apply(t, o);
      }
      return t;
    }
    function _objectSpread(e) {
      for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
          (0, _defineProperty2.default)(e, r2, t[r2]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
        });
      }
      return e;
    }
    var WikiMarkupTransformer2 = exports2.WikiMarkupTransformer = /* @__PURE__ */ (function() {
      function WikiMarkupTransformer3() {
        var schema = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : _schemaDefault.defaultSchema;
        (0, _classCallCheck2.default)(this, WikiMarkupTransformer3);
        this.schema = schema;
      }
      return (0, _createClass2.default)(WikiMarkupTransformer3, [{
        key: "sanitizeWikiMarkup",
        value: function sanitizeWikiMarkup(wikiMarkup) {
          return wikiMarkup.replace(/\0/g, "");
        }
      }, {
        key: "encode",
        value: function encode(node, context) {
          var wikiMarkup = (0, _encoder.encode)(node, normalizeContextObject(context));
          var sanitizedWikiMarkup = this.sanitizeWikiMarkup(wikiMarkup);
          return sanitizedWikiMarkup;
        }
      }, {
        key: "parse",
        value: function parse(wikiMarkup, context) {
          var sanitizedWikiMarkup = this.sanitizeWikiMarkup(wikiMarkup);
          var tree = new _abstractTree.default(this.schema, sanitizedWikiMarkup);
          return tree.getProseMirrorModel(this.buildContext(normalizeContextObject(context)));
        }
      }, {
        key: "buildContext",
        value: function buildContext(context) {
          return context ? _objectSpread(_objectSpread({}, context), {}, {
            issueKeyRegex: context.conversion ? (0, _issueKey.buildIssueKeyRegex)(context.conversion.inlineCardConversion) : void 0
          }) : {};
        }
      }]);
    })();
    var normalizeContextObject = function normalizeContextObject2(context) {
      if (!context || !context.conversion || !context.conversion.mentionConversion) {
        return context;
      }
      var mentionConversion = {};
      for (var key in context.conversion.mentionConversion) {
        mentionConversion[key.toLowerCase()] = context.conversion.mentionConversion[key];
      }
      context.conversion.mentionConversion = mentionConversion;
      return context;
    };
    var _default = exports2.default = WikiMarkupTransformer2;
  }
});

// atlaskit-transformer.js
var import_editor_markdown_transformer = __toESM(require_cjs4());
var import_editor_json_transformer = __toESM(require_cjs6());
var import_editor_wikimarkup_transformer = __toESM(require_cjs7());
var transformers = {
  "md": new import_editor_markdown_transformer.MarkdownTransformer(),
  "adf": new import_editor_json_transformer.JSONTransformer(),
  "wiki": new import_editor_wikimarkup_transformer.WikiMarkupTransformer()
};
var readline = require("readline");
var args = process.argv.slice(2);
var rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});
var input = "";
rl.on("line", (line) => {
  input += line + "\n";
});
rl.on("close", () => {
  let output = transformers[args[1]].encode(transformers[args[0]].parse(input));
  if (typeof output !== "string") {
    output = JSON.stringify(output);
  }
  console.log(output);
});
/*! Bundled license information:

@babel/runtime/helpers/regenerator.js:
  (*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE *)

eventemitter2/lib/eventemitter2.js:
  (*!
   * EventEmitter2
   * https://github.com/hij1nx/EventEmitter2
   *
   * Copyright (c) 2013 hij1nx
   * Licensed under the MIT license.
   *)
*/
