@bpmn-io/form-js-playground 1.11.3 → 1.12.0

package/dist/form-playground.umd.js

@@ -461,18 +461,6 @@
   ClassList.prototype.has = ClassList.prototype.contains = function (name) {
     return this.list.contains(name);
   };
-
-  /**
-   * Closest
-   *
-   * @param {Element} el
-   * @param {string} selector
-   * @param {boolean} checkYourSelf (optional)
-   */
-  function closest(element, selector, checkYourSelf) {
-    var actualElement = element ;
-    return actualElement && typeof actualElement.closest === 'function' && actualElement.closest(selector) || null;
-  }
   var componentEvent = {};
   var bind$1, unbind$1, prefix;
   function detect() {
@@ -613,16 +601,6 @@
     return fragment;
   }
   var domify$1 = domify;
-
-  /**
-   * @param { HTMLElement } element
-   * @param { String } selector
-   *
-   * @return { boolean }
-   */
-  function matches$2(element, selector) {
-    return element && typeof element.matches === 'function' && element.matches(selector) || false;
-  }
   function query(selector, el) {
     el = el || document;
     return el.querySelector(selector);
@@ -15799,7 +15777,7 @@
     null != e && "textarea" === n.type && "value" in t && t.value !== e.value && (e.value = null == t.value ? "" : t.value);
   };
 
-  /*! @license DOMPurify 3.1.6 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.1.6/LICENSE */
+  /*! @license DOMPurify 3.2.0 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.0/LICENSE */
 
   const {
     entries,
@@ -15849,12 +15827,11 @@
   const objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
   const regExpTest = unapply(RegExp.prototype.test);
   const typeErrorCreate = unconstruct(TypeError);
-
   /**
    * Creates a new function that calls the given function with a specified thisArg and arguments.
    *
-   * @param {Function} func - The function to be wrapped and called.
-   * @returns {Function} A new function that calls the given function with a specified thisArg and arguments.
+   * @param func - The function to be wrapped and called.
+   * @returns A new function that calls the given function with a specified thisArg and arguments.
    */
   function unapply(func) {
     return function (thisArg) {
@@ -15864,12 +15841,11 @@
       return apply(func, thisArg, args);
     };
   }
-
   /**
    * Creates a new function that constructs an instance of the given constructor function with the provided arguments.
    *
-   * @param {Function} func - The constructor function to be wrapped and called.
-   * @returns {Function} A new function that constructs an instance of the given constructor function with the provided arguments.
+   * @param func - The constructor function to be wrapped and called.
+   * @returns A new function that constructs an instance of the given constructor function with the provided arguments.
    */
   function unconstruct(func) {
     return function () {
@@ -15879,14 +15855,13 @@
       return construct(func, args);
     };
   }
-
   /**
    * Add properties to a lookup table
    *
-   * @param {Object} set - The set to which elements will be added.
-   * @param {Array} array - The array containing elements to be added to the set.
-   * @param {Function} transformCaseFunc - An optional function to transform the case of each element before adding to the set.
-   * @returns {Object} The modified set with added elements.
+   * @param set - The set to which elements will be added.
+   * @param array - The array containing elements to be added to the set.
+   * @param transformCaseFunc - An optional function to transform the case of each element before adding to the set.
+   * @returns The modified set with added elements.
    */
   function addToSet(set, array) {
     let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase;
@@ -15913,12 +15888,11 @@
     }
     return set;
   }
-
   /**
    * Clean up an array to harden against CSPP
    *
-   * @param {Array} array - The array to be cleaned.
-   * @returns {Array} The cleaned version of the array
+   * @param array - The array to be cleaned.
+   * @returns The cleaned version of the array
    */
   function cleanArray(array) {
     for (let index = 0; index < array.length; index++) {
@@ -15929,12 +15903,11 @@
     }
     return array;
   }
-
   /**
    * Shallow clone an object
    *
-   * @param {Object} object - The object to be cloned.
-   * @returns {Object} A new object that copies the original.
+   * @param object - The object to be cloned.
+   * @returns A new object that copies the original.
    */
   function clone$1(object) {
     const newObject = create(null);
@@ -15952,13 +15925,12 @@
     }
     return newObject;
   }
-
   /**
    * This method automatically checks if the prop is function or getter and behaves accordingly.
    *
-   * @param {Object} object - The object to look up the getter function in its prototype chain.
-   * @param {String} prop - The property name for which to find the getter function.
-   * @returns {Function} The getter function found in the prototype chain or a fallback function.
+   * @param object - The object to look up the getter function in its prototype chain.
+   * @param prop - The property name for which to find the getter function.
+   * @returns The getter function found in the prototype chain or a fallback function.
    */
   function lookupGetter(object, prop) {
     while (object !== null) {
@@ -15979,24 +15951,21 @@
     return fallbackValue;
   }
   const html$1 = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);
-
   // SVG
   const svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
   const svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);
-
   // List of SVG elements that are disallowed by default.
   // We still need to know them so that we can do namespace
   // checks properly in case one wants to add them to
   // allow-list.
   const svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);
   const mathMl$1 = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover', 'mprescripts']);
-
   // Similarly to SVG, we want to know all MathML elements,
   // even those that we disallow by default.
   const mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);
   const text = freeze(['#text']);
   const html$2 = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'popover', 'popovertarget', 'popovertargetaction', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'wrap', 'xmlns', 'slot']);
-  const svg$2 = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
+  const svg$2 = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'exponent', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'intercept', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'slope', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'tablevalues', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
   const mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
   const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);
 
@@ -16015,18 +15984,19 @@
   const CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
   var EXPRESSIONS = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    MUSTACHE_EXPR: MUSTACHE_EXPR,
-    ERB_EXPR: ERB_EXPR,
-    TMPLIT_EXPR: TMPLIT_EXPR,
-    DATA_ATTR: DATA_ATTR,
     ARIA_ATTR: ARIA_ATTR,
-    IS_ALLOWED_URI: IS_ALLOWED_URI,
-    IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA,
     ATTR_WHITESPACE: ATTR_WHITESPACE,
+    CUSTOM_ELEMENT: CUSTOM_ELEMENT,
+    DATA_ATTR: DATA_ATTR,
     DOCTYPE_NAME: DOCTYPE_NAME,
-    CUSTOM_ELEMENT: CUSTOM_ELEMENT
+    ERB_EXPR: ERB_EXPR,
+    IS_ALLOWED_URI: IS_ALLOWED_URI,
+    IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA,
+    MUSTACHE_EXPR: MUSTACHE_EXPR,
+    TMPLIT_EXPR: TMPLIT_EXPR
   });
 
+  /* eslint-disable @typescript-eslint/indent */
   // https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
   const NODE_TYPE = {
     element: 1,
@@ -16047,20 +16017,18 @@
   const getGlobal = function getGlobal() {
     return typeof window === 'undefined' ? null : window;
   };
-
   /**
    * Creates a no-op policy for internal use only.
    * Don't export this function outside this module!
-   * @param {TrustedTypePolicyFactory} trustedTypes The policy factory.
-   * @param {HTMLScriptElement} purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).
-   * @return {TrustedTypePolicy} The policy created (or null, if Trusted Types
+   * @param trustedTypes The policy factory.
+   * @param purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).
+   * @return The policy created (or null, if Trusted Types
    * are not supported or creating the policy failed).
    */
   const _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, purifyHostElement) {
     if (typeof trustedTypes !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
       return null;
     }
-
     // Allow the callers to control the unique policy name
     // by adding a data-tt-policy-suffix to the script element with the DOMPurify.
     // Policy creation with duplicate names throws in Trusted Types.
@@ -16090,17 +16058,7 @@
   function createDOMPurify() {
     let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
     const DOMPurify = root => createDOMPurify(root);
-
-    /**
-     * Version label, exposed for easier checks
-     * if DOMPurify is up to date or not
-     */
-    DOMPurify.version = '3.1.6';
-
-    /**
-     * Array of elements that DOMPurify removed during sanitation.
-     * Empty if nothing was removed.
-     */
+    DOMPurify.version = '3.2.0';
     DOMPurify.removed = [];
     if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document) {
       // Not running in a browser, provide a factory function
@@ -16130,7 +16088,6 @@
     const getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');
     const getChildNodes = lookupGetter(ElementPrototype, 'childNodes');
     const getParentNode = lookupGetter(ElementPrototype, 'parentNode');
-
     // As per issue #47, the web-components registry is inherited by a
     // new document created via createHTMLDocument. As per the spec
     // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
@@ -16155,7 +16112,6 @@
       importNode
     } = originalDocument;
     let hooks = {};
-
     /**
      * Expose whether this browser supports running the full DOMPurify.
      */
@@ -16173,22 +16129,18 @@
     let {
       IS_ALLOWED_URI: IS_ALLOWED_URI$1
     } = EXPRESSIONS;
-
     /**
      * We consider the elements and attributes below to be safe. Ideally
      * don't add any new ones but feel free to remove unwanted ones.
      */
-
     /* allowed element names */
     let ALLOWED_TAGS = null;
     const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);
-
     /* Allowed attribute names */
     let ALLOWED_ATTR = null;
     const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html$2, ...svg$2, ...mathMl, ...xml]);
-
     /*
-     * Configure how DOMPUrify should handle custom elements and their attributes as well as customized built-in elements.
+     * Configure how DOMPurify should handle custom elements and their attributes as well as customized built-in elements.
      * @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)
      * @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)
      * @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.
@@ -16213,65 +16165,49 @@
         value: false
       }
     }));
-
     /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */
     let FORBID_TAGS = null;
-
     /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
     let FORBID_ATTR = null;
-
     /* Decide if ARIA attributes are okay */
     let ALLOW_ARIA_ATTR = true;
-
     /* Decide if custom data attributes are okay */
     let ALLOW_DATA_ATTR = true;
-
     /* Decide if unknown protocols are okay */
     let ALLOW_UNKNOWN_PROTOCOLS = false;
-
     /* Decide if self-closing tags in attributes are allowed.
      * Usually removed due to a mXSS issue in jQuery 3.0 */
     let ALLOW_SELF_CLOSE_IN_ATTR = true;
-
     /* Output should be safe for common template engines.
      * This means, DOMPurify removes data attributes, mustaches and ERB
      */
     let SAFE_FOR_TEMPLATES = false;
-
     /* Output should be safe even for XML used within HTML and alike.
      * This means, DOMPurify removes comments when containing risky content.
      */
     let SAFE_FOR_XML = true;
-
     /* Decide if document with <html>... should be returned */
     let WHOLE_DOCUMENT = false;
-
     /* Track whether config is already set on this instance of DOMPurify. */
     let SET_CONFIG = false;
-
     /* Decide if all elements (e.g. style, script) must be children of
      * document.body. By default, browsers might move them to document.head */
     let FORCE_BODY = false;
-
     /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html
      * string (or a TrustedHTML object if Trusted Types are supported).
      * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead
      */
     let RETURN_DOM = false;
-
     /* Decide if a DOM `DocumentFragment` should be returned, instead of a html
      * string  (or a TrustedHTML object if Trusted Types are supported) */
     let RETURN_DOM_FRAGMENT = false;
-
     /* Try to return a Trusted Type object instead of a string, return a string in
      * case Trusted Types are not supported  */
     let RETURN_TRUSTED_TYPE = false;
-
     /* Output should be free from DOM clobbering attacks?
      * This sanitizes markups named with colliding, clobberable built-in DOM APIs.
      */
     let SANITIZE_DOM = true;
-
     /* Achieve full DOM Clobbering protection by isolating the namespace of named
      * properties and JS variables, mitigating attacks that abuse the HTML/DOM spec rules.
      *
@@ -16287,25 +16223,19 @@
      */
     let SANITIZE_NAMED_PROPS = false;
     const SANITIZE_NAMED_PROPS_PREFIX = 'user-content-';
-
     /* Keep element content when removing element? */
     let KEEP_CONTENT = true;
-
     /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
      * of importing it into a new Document and returning a sanitized copy */
     let IN_PLACE = false;
-
     /* Allow usage of profiles like html, svg and mathMl */
     let USE_PROFILES = {};
-
     /* Tags to ignore content of when KEEP_CONTENT is true */
     let FORBID_CONTENTS = null;
     const DEFAULT_FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);
-
     /* Tags that are safe for data: URIs */
     let DATA_URI_TAGS = null;
     const DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);
-
     /* Attributes safe for values like "javascript:" */
     let URI_SAFE_ATTRIBUTES = null;
     const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);
@@ -16315,32 +16245,33 @@
     /* Document namespace */
     let NAMESPACE = HTML_NAMESPACE;
     let IS_EMPTY_INPUT = false;
-
     /* Allowed XHTML+XML namespaces */
     let ALLOWED_NAMESPACES = null;
     const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
-
+    let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);
+    let HTML_INTEGRATION_POINTS = addToSet({}, ['annotation-xml']);
+    // Certain elements are allowed in both SVG and HTML
+    // namespace. We need to specify them explicitly
+    // so that they don't get erroneously deleted from
+    // HTML namespace.
+    const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ['title', 'style', 'font', 'a', 'script']);
     /* Parsing of strict XHTML documents */
     let PARSER_MEDIA_TYPE = null;
     const SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html'];
     const DEFAULT_PARSER_MEDIA_TYPE = 'text/html';
     let transformCaseFunc = null;
-
     /* Keep a reference to config to pass to hooks */
     let CONFIG = null;
-
     /* Ideally, do not touch anything below this line */
     /* ______________________________________________ */
-
     const formElement = document.createElement('form');
     const isRegexOrFunction = function isRegexOrFunction(testValue) {
       return testValue instanceof RegExp || testValue instanceof Function;
     };
-
     /**
      * _parseConfig
      *
-     * @param  {Object} cfg optional config literal
+     * @param cfg optional config literal
      */
     // eslint-disable-next-line complexity
     const _parseConfig = function _parseConfig() {
@@ -16348,39 +16279,23 @@
       if (CONFIG && CONFIG === cfg) {
         return;
       }
-
       /* Shield configuration object from tampering */
       if (!cfg || typeof cfg !== 'object') {
         cfg = {};
       }
-
       /* Shield configuration object from prototype pollution */
       cfg = clone$1(cfg);
       PARSER_MEDIA_TYPE =
       // eslint-disable-next-line unicorn/prefer-includes
       SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
-
       // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.
       transformCaseFunc = PARSER_MEDIA_TYPE === 'application/xhtml+xml' ? stringToString : stringToLowerCase;
-
       /* Set configuration parameters */
       ALLOWED_TAGS = objectHasOwnProperty(cfg, 'ALLOWED_TAGS') ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
       ALLOWED_ATTR = objectHasOwnProperty(cfg, 'ALLOWED_ATTR') ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
       ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, 'ALLOWED_NAMESPACES') ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
-      URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, 'ADD_URI_SAFE_ATTR') ? addToSet(clone$1(DEFAULT_URI_SAFE_ATTRIBUTES),
-      // eslint-disable-line indent
-      cfg.ADD_URI_SAFE_ATTR,
-      // eslint-disable-line indent
-      transformCaseFunc // eslint-disable-line indent
-      ) // eslint-disable-line indent
-      : DEFAULT_URI_SAFE_ATTRIBUTES;
-      DATA_URI_TAGS = objectHasOwnProperty(cfg, 'ADD_DATA_URI_TAGS') ? addToSet(clone$1(DEFAULT_DATA_URI_TAGS),
-      // eslint-disable-line indent
-      cfg.ADD_DATA_URI_TAGS,
-      // eslint-disable-line indent
-      transformCaseFunc // eslint-disable-line indent
-      ) // eslint-disable-line indent
-      : DEFAULT_DATA_URI_TAGS;
+      URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, 'ADD_URI_SAFE_ATTR') ? addToSet(clone$1(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
+      DATA_URI_TAGS = objectHasOwnProperty(cfg, 'ADD_DATA_URI_TAGS') ? addToSet(clone$1(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
       FORBID_CONTENTS = objectHasOwnProperty(cfg, 'FORBID_CONTENTS') ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
       FORBID_TAGS = objectHasOwnProperty(cfg, 'FORBID_TAGS') ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : {};
       FORBID_ATTR = objectHasOwnProperty(cfg, 'FORBID_ATTR') ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : {};
@@ -16402,6 +16317,8 @@
       IN_PLACE = cfg.IN_PLACE || false; // Default false
       IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;
       NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
+      MATHML_TEXT_INTEGRATION_POINTS = cfg.MATHML_TEXT_INTEGRATION_POINTS || MATHML_TEXT_INTEGRATION_POINTS;
+      HTML_INTEGRATION_POINTS = cfg.HTML_INTEGRATION_POINTS || HTML_INTEGRATION_POINTS;
       CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
       if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
         CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
@@ -16418,7 +16335,6 @@
       if (RETURN_DOM_FRAGMENT) {
         RETURN_DOM = true;
       }
-
       /* Parse profile info */
       if (USE_PROFILES) {
         ALLOWED_TAGS = addToSet({}, text);
@@ -16443,7 +16359,6 @@
           addToSet(ALLOWED_ATTR, xml);
         }
       }
-
       /* Merge configuration parameters */
       if (cfg.ADD_TAGS) {
         if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
@@ -16466,17 +16381,14 @@
         }
         addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
       }
-
       /* Add #text in case KEEP_CONTENT is set to true */
       if (KEEP_CONTENT) {
         ALLOWED_TAGS['#text'] = true;
       }
-
       /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */
       if (WHOLE_DOCUMENT) {
         addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);
       }
-
       /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */
       if (ALLOWED_TAGS.table) {
         addToSet(ALLOWED_TAGS, ['tbody']);
@@ -16489,10 +16401,8 @@
         if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== 'function') {
           throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
         }
-
         // Overwrite existing TrustedTypes policy.
         trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
-
         // Sign local variables required by `sanitize`.
         emptyHTML = trustedTypesPolicy.createHTML('');
       } else {
@@ -16500,13 +16410,11 @@
         if (trustedTypesPolicy === undefined) {
           trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
         }
-
         // If creating the internal policy succeeded sign internal variables.
         if (trustedTypesPolicy !== null && typeof emptyHTML === 'string') {
           emptyHTML = trustedTypesPolicy.createHTML('');
         }
       }
-
       // Prevent further manipulation of configuration.
       // Not available in IE8, Safari 5, etc.
       if (freeze) {
@@ -16514,30 +16422,19 @@
       }
       CONFIG = cfg;
     };
-    const MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);
-    const HTML_INTEGRATION_POINTS = addToSet({}, ['foreignobject', 'annotation-xml']);
-
-    // Certain elements are allowed in both SVG and HTML
-    // namespace. We need to specify them explicitly
-    // so that they don't get erroneously deleted from
-    // HTML namespace.
-    const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ['title', 'style', 'font', 'a', 'script']);
-
     /* Keep track of all possible SVG and MathML tags
      * so that we can perform the namespace checks
      * correctly. */
     const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
     const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
-
     /**
-     * @param  {Element} element a DOM element whose namespace is being checked
-     * @returns {boolean} Return false if the element has a
+     * @param element a DOM element whose namespace is being checked
+     * @returns Return false if the element has a
      *  namespace that a spec-compliant parser would never
      *  return. Return true otherwise.
      */
     const _checkValidNamespace = function _checkValidNamespace(element) {
       let parent = getParentNode(element);
-
       // In JSDOM, if we're inside shadow DOM, then parentNode
       // can be null. We just simulate parent in this case.
       if (!parent || !parent.tagName) {
@@ -16558,14 +16455,12 @@
         if (parent.namespaceURI === HTML_NAMESPACE) {
           return tagName === 'svg';
         }
-
         // The only way to switch from MathML to SVG is via`
         // svg if parent is either <annotation-xml> or MathML
         // text integration points.
         if (parent.namespaceURI === MATHML_NAMESPACE) {
           return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
         }
-
         // We only allow elements that are defined in SVG
         // spec. All others are disallowed in SVG namespace.
         return Boolean(ALL_SVG_TAGS[tagName]);
@@ -16577,13 +16472,11 @@
         if (parent.namespaceURI === HTML_NAMESPACE) {
           return tagName === 'math';
         }
-
         // The only way to switch from SVG to MathML is via
         // <math> and HTML integration points
         if (parent.namespaceURI === SVG_NAMESPACE) {
           return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];
         }
-
         // We only allow elements that are defined in MathML
         // spec. All others are disallowed in MathML namespace.
         return Boolean(ALL_MATHML_TAGS[tagName]);
@@ -16598,28 +16491,24 @@
         if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
           return false;
         }
-
         // We disallow tags that are specific for MathML
         // or SVG and should never appear in HTML namespace
         return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
       }
-
       // For XHTML and XML documents that support custom namespaces
       if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && ALLOWED_NAMESPACES[element.namespaceURI]) {
         return true;
       }
-
       // The code should never reach this place (this means
       // that the element somehow got namespace that is not
       // HTML, SVG, MathML or allowed via ALLOWED_NAMESPACES).
       // Return false just in case.
       return false;
     };
-
     /**
      * _forceRemove
      *
-     * @param  {Node} node a DOM node
+     * @param node a DOM node
      */
     const _forceRemove = function _forceRemove(node) {
       arrayPush(DOMPurify.removed, {
@@ -16632,46 +16521,43 @@
         remove(node);
       }
     };
-
     /**
      * _removeAttribute
      *
-     * @param  {String} name an Attribute name
-     * @param  {Node} node a DOM node
+     * @param name an Attribute name
+     * @param element a DOM node
      */
-    const _removeAttribute = function _removeAttribute(name, node) {
+    const _removeAttribute = function _removeAttribute(name, element) {
       try {
         arrayPush(DOMPurify.removed, {
-          attribute: node.getAttributeNode(name),
-          from: node
+          attribute: element.getAttributeNode(name),
+          from: element
         });
       } catch (_) {
         arrayPush(DOMPurify.removed, {
           attribute: null,
-          from: node
+          from: element
         });
       }
-      node.removeAttribute(name);
-
+      element.removeAttribute(name);
       // We void attribute values for unremovable "is"" attributes
       if (name === 'is' && !ALLOWED_ATTR[name]) {
         if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
           try {
-            _forceRemove(node);
+            _forceRemove(element);
           } catch (_) {}
         } else {
           try {
-            node.setAttribute(name, '');
+            element.setAttribute(name, '');
           } catch (_) {}
         }
       }
     };
-
     /**
      * _initDocument
      *
-     * @param  {String} dirty a string of dirty markup
-     * @return {Document} a DOM, filled with the dirty markup
+     * @param dirty - a string of dirty markup
+     * @return a DOM, filled with the dirty markup
      */
     const _initDocument = function _initDocument(dirty) {
       /* Create a HTML document */
@@ -16698,7 +16584,6 @@
           doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
         } catch (_) {}
       }
-
       /* Use createHTMLDocument in case DOMParser is not available */
       if (!doc || !doc.documentElement) {
         doc = implementation.createDocument(NAMESPACE, 'template', null);
@@ -16712,112 +16597,89 @@
       if (dirty && leadingWhitespace) {
         body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);
       }
-
       /* Work on whole document or just its body */
       if (NAMESPACE === HTML_NAMESPACE) {
         return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];
       }
       return WHOLE_DOCUMENT ? doc.documentElement : body;
     };
-
     /**
      * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
      *
-     * @param  {Node} root The root element or node to start traversing on.
-     * @return {NodeIterator} The created NodeIterator
+     * @param root The root element or node to start traversing on.
+     * @return The created NodeIterator
      */
     const _createNodeIterator = function _createNodeIterator(root) {
       return createNodeIterator.call(root.ownerDocument || root, root,
       // eslint-disable-next-line no-bitwise
       NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION, null);
     };
-
     /**
      * _isClobbered
      *
-     * @param  {Node} elm element to check for clobbering attacks
-     * @return {Boolean} true if clobbered, false if safe
+     * @param element element to check for clobbering attacks
+     * @return true if clobbered, false if safe
      */
-    const _isClobbered = function _isClobbered(elm) {
-      return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function');
+    const _isClobbered = function _isClobbered(element) {
+      return element instanceof HTMLFormElement && (typeof element.nodeName !== 'string' || typeof element.textContent !== 'string' || typeof element.removeChild !== 'function' || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== 'function' || typeof element.setAttribute !== 'function' || typeof element.namespaceURI !== 'string' || typeof element.insertBefore !== 'function' || typeof element.hasChildNodes !== 'function');
     };
-
     /**
      * Checks whether the given object is a DOM node.
      *
-     * @param  {Node} object object to check whether it's a DOM node
-     * @return {Boolean} true is object is a DOM node
+     * @param value object to check whether it's a DOM node
+     * @return true is object is a DOM node
      */
-    const _isNode = function _isNode(object) {
-      return typeof Node === 'function' && object instanceof Node;
+    const _isNode = function _isNode(value) {
+      return typeof Node === 'function' && value instanceof Node;
     };
-
-    /**
-     * _executeHook
-     * Execute user configurable hooks
-     *
-     * @param  {String} entryPoint  Name of the hook's entry point
-     * @param  {Node} currentNode node to work on with the hook
-     * @param  {Object} data additional hook parameters
-     */
-    const _executeHook = function _executeHook(entryPoint, currentNode, data) {
+    function _executeHook(entryPoint, currentNode, data) {
       if (!hooks[entryPoint]) {
         return;
       }
       arrayForEach(hooks[entryPoint], hook => {
         hook.call(DOMPurify, currentNode, data, CONFIG);
       });
-    };
-
+    }
     /**
      * _sanitizeElements
      *
      * @protect nodeName
      * @protect textContent
      * @protect removeChild
-     *
-     * @param   {Node} currentNode to check for permission to exist
-     * @return  {Boolean} true if node was killed, false if left alive
+     * @param currentNode to check for permission to exist
+     * @return true if node was killed, false if left alive
      */
     const _sanitizeElements = function _sanitizeElements(currentNode) {
       let content = null;
-
       /* Execute a hook if present */
       _executeHook('beforeSanitizeElements', currentNode, null);
-
       /* Check if element is clobbered or can clobber */
       if (_isClobbered(currentNode)) {
         _forceRemove(currentNode);
         return true;
       }
-
       /* Now let's check the element's type and name */
       const tagName = transformCaseFunc(currentNode.nodeName);
-
       /* Execute a hook if present */
       _executeHook('uponSanitizeElement', currentNode, {
         tagName,
         allowedTags: ALLOWED_TAGS
       });
-
       /* Detect mXSS attempts abusing namespace confusion */
       if (currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) {
         _forceRemove(currentNode);
         return true;
       }
-
       /* Remove any occurrence of processing instructions */
       if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
         _forceRemove(currentNode);
         return true;
       }
-
       /* Remove any kind of possibly harmful comments */
       if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
         _forceRemove(currentNode);
         return true;
       }
-
       /* Remove element if anything forbids its presence */
       if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
         /* Check if we have a custom element to handle */
@@ -16829,7 +16691,6 @@
             return false;
           }
         }
-
         /* Keep content except for bad-listed elements */
         if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
           const parentNode = getParentNode(currentNode) || currentNode.parentNode;
@@ -16846,19 +16707,16 @@
         _forceRemove(currentNode);
         return true;
       }
-
       /* Check whether element has a valid namespace */
       if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
         _forceRemove(currentNode);
         return true;
       }
-
       /* Make sure that older browsers don't get fallback-tag mXSS */
       if ((tagName === 'noscript' || tagName === 'noembed' || tagName === 'noframes') && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
         _forceRemove(currentNode);
         return true;
       }
-
       /* Sanitize element content to be template-safe */
       if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
         /* Get the element's text content */
@@ -16873,19 +16731,17 @@
           currentNode.textContent = content;
         }
       }
-
       /* Execute a hook if present */
       _executeHook('afterSanitizeElements', currentNode, null);
       return false;
     };
-
     /**
      * _isValidAttribute
      *
-     * @param  {string} lcTag Lowercase tag name of containing element.
-     * @param  {string} lcName Lowercase attribute name.
-     * @param  {string} value Attribute value.
-     * @return {Boolean} Returns true if `value` is valid, otherwise false.
+     * @param lcTag Lowercase tag name of containing element.
+     * @param lcName Lowercase attribute name.
+     * @param value Attribute value.
+     * @return Returns true if `value` is valid, otherwise false.
      */
     // eslint-disable-next-line complexity
     const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
@@ -16893,7 +16749,6 @@
       if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
         return false;
       }
-
       /* Allow valid data-* attributes: At least one character after "-"
           (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
           XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
@@ -16915,19 +16770,17 @@
       } else ;
       return true;
     };
-
     /**
      * _isBasicCustomElement
      * checks if at least one dash is included in tagName, and it's not the first char
      * for more sophisticated checking see https://github.com/sindresorhus/validate-element-name
      *
-     * @param {string} tagName name of the tag of the node to sanitize
-     * @returns {boolean} Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
+     * @param tagName name of the tag of the node to sanitize
+     * @returns Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
      */
     const _isBasicCustomElement = function _isBasicCustomElement(tagName) {
       return tagName !== 'annotation-xml' && stringMatch(tagName, CUSTOM_ELEMENT);
     };
-
     /**
      * _sanitizeAttributes
      *
@@ -16936,7 +16789,7 @@
      * @protect removeAttribute
      * @protect setAttribute
      *
-     * @param  {Node} currentNode to sanitize
+     * @param currentNode to sanitize
      */
     const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
       /* Execute a hook if present */
@@ -16944,7 +16797,6 @@
       const {
         attributes
       } = currentNode;
-
       /* Check if we have attributes; if not we might have a text node */
       if (!attributes) {
         return;
@@ -16953,10 +16805,10 @@
         attrName: '',
         attrValue: '',
         keepAttr: true,
-        allowedAttributes: ALLOWED_ATTR
+        allowedAttributes: ALLOWED_ATTR,
+        forceKeepAttr: undefined
       };
       let l = attributes.length;
-
       /* Go backwards over all attributes; safely remove bad ones */
       while (l--) {
         const attr = attributes[l];
@@ -16967,7 +16819,6 @@
         } = attr;
         const lcName = transformCaseFunc(name);
         let value = name === 'value' ? attrValue : stringTrim(attrValue);
-
         /* Execute a hook if present */
         hookEvent.attrName = lcName;
         hookEvent.attrValue = value;
@@ -16975,56 +16826,46 @@
         hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set
         _executeHook('uponSanitizeAttribute', currentNode, hookEvent);
         value = hookEvent.attrValue;
-
+        /* Full DOM Clobbering protection via namespace isolation,
+         * Prefix id and name attributes with `user-content-`
+         */
+        if (SANITIZE_NAMED_PROPS && (lcName === 'id' || lcName === 'name')) {
+          // Remove the attribute with this value
+          _removeAttribute(name, currentNode);
+          // Prefix the value and later re-create the attribute with the sanitized value
+          value = SANITIZE_NAMED_PROPS_PREFIX + value;
+        }
         /* Work around a security issue with comments inside attributes */
         if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|title)/i, value)) {
           _removeAttribute(name, currentNode);
           continue;
         }
-
         /* Did the hooks approve of the attribute? */
         if (hookEvent.forceKeepAttr) {
           continue;
         }
-
         /* Remove attribute */
         _removeAttribute(name, currentNode);
-
         /* Did the hooks approve of the attribute? */
         if (!hookEvent.keepAttr) {
           continue;
         }
-
         /* Work around a security issue in jQuery 3.0 */
         if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
           _removeAttribute(name, currentNode);
           continue;
         }
-
         /* Sanitize attribute content to be template-safe */
         if (SAFE_FOR_TEMPLATES) {
           arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
             value = stringReplace(value, expr, ' ');
           });
         }
-
         /* Is `value` valid for this attribute? */
         const lcTag = transformCaseFunc(currentNode.nodeName);
         if (!_isValidAttribute(lcTag, lcName, value)) {
           continue;
         }
-
-        /* Full DOM Clobbering protection via namespace isolation,
-         * Prefix id and name attributes with `user-content-`
-         */
-        if (SANITIZE_NAMED_PROPS && (lcName === 'id' || lcName === 'name')) {
-          // Remove the attribute with this value
-          _removeAttribute(name, currentNode);
-
-          // Prefix the value and later re-create the attribute with the sanitized value
-          value = SANITIZE_NAMED_PROPS_PREFIX + value;
-        }
-
         /* Handle attributes that require Trusted Types */
         if (trustedTypesPolicy && typeof trustedTypes === 'object' && typeof trustedTypes.getAttributeType === 'function') {
           if (namespaceURI) ;else {
@@ -17042,7 +16883,6 @@
             }
           }
         }
-
         /* Handle invalid data-* attribute set by try-catching it */
         try {
           if (namespaceURI) {
@@ -17058,51 +16898,36 @@
           }
         } catch (_) {}
       }
-
       /* Execute a hook if present */
       _executeHook('afterSanitizeAttributes', currentNode, null);
     };
-
     /**
      * _sanitizeShadowDOM
      *
-     * @param  {DocumentFragment} fragment to iterate over recursively
+     * @param fragment to iterate over recursively
      */
     const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
       let shadowNode = null;
       const shadowIterator = _createNodeIterator(fragment);
-
       /* Execute a hook if present */
       _executeHook('beforeSanitizeShadowDOM', fragment, null);
       while (shadowNode = shadowIterator.nextNode()) {
         /* Execute a hook if present */
         _executeHook('uponSanitizeShadowNode', shadowNode, null);
-
         /* Sanitize tags and elements */
         if (_sanitizeElements(shadowNode)) {
           continue;
         }
-
         /* Deep shadow DOM detected */
         if (shadowNode.content instanceof DocumentFragment) {
           _sanitizeShadowDOM(shadowNode.content);
         }
-
         /* Check attributes, sanitize if necessary */
         _sanitizeAttributes(shadowNode);
       }
-
       /* Execute a hook if present */
       _executeHook('afterSanitizeShadowDOM', fragment, null);
     };
-
-    /**
-     * Sanitize
-     * Public method providing core sanitation functionality
-     *
-     * @param {String|Node} dirty string or DOM node
-     * @param {Object} cfg object
-     */
     // eslint-disable-next-line complexity
     DOMPurify.sanitize = function (dirty) {
       let cfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -17117,7 +16942,6 @@
       if (IS_EMPTY_INPUT) {
         dirty = '<!-->';
       }
-
       /* Stringify, in case dirty is an object */
       if (typeof dirty !== 'string' && !_isNode(dirty)) {
         if (typeof dirty.toString === 'function') {
@@ -17129,20 +16953,16 @@
           throw typeErrorCreate('toString is not a function');
         }
       }
-
       /* Return dirty HTML if DOMPurify cannot run */
       if (!DOMPurify.isSupported) {
         return dirty;
       }
-
       /* Assign config vars */
       if (!SET_CONFIG) {
         _parseConfig(cfg);
       }
-
       /* Clean up removed elements */
       DOMPurify.removed = [];
-
       /* Check if dirty is correctly typed for IN_PLACE */
       if (typeof dirty === 'string') {
         IN_PLACE = false;
@@ -17176,45 +16996,36 @@
         dirty.indexOf('<') === -1) {
           return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
         }
-
         /* Initialize the document to work on */
         body = _initDocument(dirty);
-
         /* Check we have a DOM node from the data */
         if (!body) {
           return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : '';
         }
       }
-
       /* Remove first element node (ours) if FORCE_BODY is set */
       if (body && FORCE_BODY) {
         _forceRemove(body.firstChild);
       }
-
       /* Get node iterator */
       const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
-
       /* Now start iterating over the created document */
       while (currentNode = nodeIterator.nextNode()) {
         /* Sanitize tags and elements */
         if (_sanitizeElements(currentNode)) {
           continue;
         }
-
         /* Shadow DOM detected, sanitize it */
         if (currentNode.content instanceof DocumentFragment) {
           _sanitizeShadowDOM(currentNode.content);
         }
-
         /* Check attributes, sanitize if necessary */
         _sanitizeAttributes(currentNode);
       }
-
       /* If we sanitized `dirty` in-place, return it. */
       if (IN_PLACE) {
         return dirty;
       }
-
       /* Return sanitized string or DOM */
       if (RETURN_DOM) {
         if (RETURN_DOM_FRAGMENT) {
@@ -17239,12 +17050,10 @@
         return returnNode;
       }
       let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
-
       /* Serialize doctype if allowed */
       if (WHOLE_DOCUMENT && ALLOWED_TAGS['!doctype'] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
         serializedHTML = '<!DOCTYPE ' + body.ownerDocument.doctype.name + '>\n' + serializedHTML;
       }
-
       /* Sanitize final string template-safe */
       if (SAFE_FOR_TEMPLATES) {
         arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
@@ -17253,39 +17062,15 @@
       }
       return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
     };
-
-    /**
-     * Public method to set the configuration once
-     * setConfig
-     *
-     * @param {Object} cfg configuration object
-     */
     DOMPurify.setConfig = function () {
       let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
       _parseConfig(cfg);
       SET_CONFIG = true;
     };
-
-    /**
-     * Public method to remove the configuration
-     * clearConfig
-     *
-     */
     DOMPurify.clearConfig = function () {
       CONFIG = null;
       SET_CONFIG = false;
     };
-
-    /**
-     * Public method to check if an attribute value is valid.
-     * Uses last set config, if any. Otherwise, uses config defaults.
-     * isValidAttribute
-     *
-     * @param  {String} tag Tag name of containing element.
-     * @param  {String} attr Attribute name.
-     * @param  {String} value Attribute value.
-     * @return {Boolean} Returns true if `value` is valid. Otherwise, returns false.
-     */
     DOMPurify.isValidAttribute = function (tag, attr, value) {
       /* Initialize shared config vars if necessary. */
       if (!CONFIG) {
@@ -17295,14 +17080,6 @@
       const lcName = transformCaseFunc(attr);
       return _isValidAttribute(lcTag, lcName, value);
     };
-
-    /**
-     * AddHook
-     * Public method to add DOMPurify hooks
-     *
-     * @param {String} entryPoint entry point for the hook to add
-     * @param {Function} hookFunction function to execute
-     */
     DOMPurify.addHook = function (entryPoint, hookFunction) {
       if (typeof hookFunction !== 'function') {
         return;
@@ -17310,37 +17087,16 @@
       hooks[entryPoint] = hooks[entryPoint] || [];
       arrayPush(hooks[entryPoint], hookFunction);
     };
-
-    /**
-     * RemoveHook
-     * Public method to remove a DOMPurify hook at a given entryPoint
-     * (pops it from the stack of hooks if more are present)
-     *
-     * @param {String} entryPoint entry point for the hook to remove
-     * @return {Function} removed(popped) hook
-     */
     DOMPurify.removeHook = function (entryPoint) {
       if (hooks[entryPoint]) {
         return arrayPop(hooks[entryPoint]);
       }
     };
-
-    /**
-     * RemoveHooks
-     * Public method to remove all DOMPurify hooks at a given entryPoint
-     *
-     * @param  {String} entryPoint entry point for the hooks to remove
-     */
     DOMPurify.removeHooks = function (entryPoint) {
       if (hooks[entryPoint]) {
         hooks[entryPoint] = [];
       }
     };
-
-    /**
-     * RemoveAllHooks
-     * Public method to remove all DOMPurify hooks
-     */
     DOMPurify.removeAllHooks = function () {
       hooks = {};
     };
@@ -31199,6 +30955,10 @@
     */
     constructor(
     /**
+    The optional name of the base tag @internal
+    */
+    name,
+    /**
     The set of this tag and all its parent tags, starting with
     this one itself and sorted in order of decreasing specificity.
     */
@@ -31212,6 +30972,7 @@
     The modifiers applied to this.base @internal
     */
     modified) {
+      this.name = name;
       this.set = set;
       this.base = base;
       this.modified = modified;
@@ -31220,16 +30981,18 @@
       */
       this.id = nextTagID++;
     }
-    /**
-    Define a new tag. If `parent` is given, the tag is treated as a
-    sub-tag of that parent, and
-    [highlighters](#highlight.tagHighlighter) that don't mention
-    this tag will try to fall back to the parent tag (or grandparent
-    tag, etc).
-    */
-    static define(parent) {
+    toString() {
+      let {
+        name
+      } = this;
+      for (let mod of this.modified) if (mod.name) name = `${mod.name}(${name})`;
+      return name;
+    }
+    static define(nameOrParent, parent) {
+      let name = typeof nameOrParent == "string" ? nameOrParent : "?";
+      if (nameOrParent instanceof Tag) parent = nameOrParent;
       if (parent === null || parent === void 0 ? void 0 : parent.base) throw new Error("Can not derive from a modified tag");
-      let tag = new Tag([], null, []);
+      let tag = new Tag(name, [], null, []);
       tag.set.push(tag);
       if (parent) for (let t of parent.set) tag.set.push(t);
       return tag;
@@ -31246,8 +31009,8 @@
     example `m1(m2(m3(t1)))` is a subtype of `m1(m2(t1))`,
     `m1(m3(t1)`, and so on.
     */
-    static defineModifier() {
-      let mod = new Modifier();
+    static defineModifier(name) {
+      let mod = new Modifier(name);
       return tag => {
         if (tag.modified.indexOf(mod) > -1) return tag;
         return Modifier.get(tag.base || tag, tag.modified.concat(mod).sort((a, b) => a.id - b.id));
@@ -31256,7 +31019,8 @@
   }
   let nextModifierID = 0;
   class Modifier {
-    constructor() {
+    constructor(name) {
+      this.name = name;
       this.instances = [];
       this.id = nextModifierID++;
     }
@@ -31265,7 +31029,7 @@
       let exists = mods[0].instances.find(t => t.base == base && sameArray$1(mods, t.modified));
       if (exists) return exists;
       let set = [],
-        tag = new Tag(set, base, mods);
+        tag = new Tag(base.name, set, base, mods);
       for (let m of mods) m.instances.push(tag);
       let configs = powerSet(mods);
       for (let parent of base.set) if (!parent.modified.length) for (let config of configs) set.push(Modifier.get(parent, config));
@@ -31837,7 +31601,7 @@
     */
     heading6: t(heading$1),
     /**
-    A prose separator (such as a horizontal rule).
+    A prose [content](#highlight.tags.content) separator (such as a horizontal rule).
     */
     contentSeparator: t(content),
     /**
@@ -31910,31 +31674,31 @@
     given element is being defined. Expected to be used with the
     various [name](#highlight.tags.name) tags.
     */
-    definition: Tag.defineModifier(),
+    definition: Tag.defineModifier("definition"),
     /**
     [Modifier](#highlight.Tag^defineModifier) that indicates that
     something is constant. Mostly expected to be used with
     [variable names](#highlight.tags.variableName).
     */
-    constant: Tag.defineModifier(),
+    constant: Tag.defineModifier("constant"),
     /**
     [Modifier](#highlight.Tag^defineModifier) used to indicate that
     a [variable](#highlight.tags.variableName) or [property
     name](#highlight.tags.propertyName) is being called or defined
     as a function.
     */
-    function: Tag.defineModifier(),
+    function: Tag.defineModifier("function"),
     /**
     [Modifier](#highlight.Tag^defineModifier) that can be applied to
     [names](#highlight.tags.name) to indicate that they belong to
     the language's standard environment.
     */
-    standard: Tag.defineModifier(),
+    standard: Tag.defineModifier("standard"),
     /**
     [Modifier](#highlight.Tag^defineModifier) that indicates a given
     [names](#highlight.tags.name) is local to some scope.
     */
-    local: Tag.defineModifier(),
+    local: Tag.defineModifier("local"),
     /**
     A generic variant [modifier](#highlight.Tag^defineModifier) that
     can be used to tag language-specific alternative variants of
@@ -31943,8 +31707,12 @@
     [variable name](#highlight.tags.variableName) tags, since those
     come up a lot.
     */
-    special: Tag.defineModifier()
+    special: Tag.defineModifier("special")
   };
+  for (let name in tags) {
+    let val = tags[name];
+    if (val instanceof Tag) val.name = name;
+  }
   /**
   This is a highlighter that adds stable, predictable classes to
   tokens, for styling with external CSS.
@@ -32196,8 +31964,6 @@
   function isSpace(ch) {
     return spaceChars.includes(ch);
   }
-
-  // eslint-disable-next-line
   function indent(str, spaces) {
     return spaces.concat(str.split(/\n/g).join('\n' + spaces));
   }
@@ -32413,6 +32179,11 @@
     [FilterExpression]: 'FilterExpression',
     [ArithmeticExpression]: 'ArithmeticExpression'
   };
+
+  /**
+   * A simple producer that retrievs a value from
+   * a given context. Used to lazily take things.
+   */
   class ValueProducer {
     /**
      * @param { Function } fn
@@ -32448,7 +32219,7 @@
     /**
      * Creates a new context from a JavaScript object.
      *
-     * @param {any} value
+     * @param {any} [value]
      */
     constructor(value = {}) {
       /**
@@ -32500,6 +32271,19 @@
       });
     }
 
+    /**
+     * Non-destructively merge another context into this one,
+     * and return the result.
+     *
+     * @param {ContextValue} other
+     *
+     * @return {VariableContext}
+     */
+    merge(other) {
+      const constructor = /** @type { typeof VariableContext } */this.constructor;
+      return new constructor(constructor.__merge(this.value, other));
+    }
+
     /**
      * Wether the given value is atomic. Non-atomic values need to be wrapped in a
      * context Class.
@@ -32512,42 +32296,89 @@
     }
 
     /**
-     * Takes any number of Contexts and merges them into a single Context.
+     * Takes any number of Contexts and merges them into a single context.
      *
-     * @param  {...Context} contexts
-     * @returns {VariableContext}
+     * @param { ...VariableContext } contexts
+     * @returns { VariableContext }
      */
     static of(...contexts) {
-      const unwrap = context => {
-        if (!context || typeof context !== 'object') {
-          return {};
+      return contexts.reduce((context, otherContext) => {
+        return context.merge(otherContext);
+      }, new this({}));
+    }
+
+    /**
+     * Returns the raw representation of the given context.
+     *
+     * @param {VariableContext | any} context
+     *
+     * @return {any}
+     */
+    static __unwrap(context) {
+      if (!context) {
+        return {};
+      }
+      if (context instanceof this) {
+        return context.value;
+      }
+      if (typeof context !== 'object') {
+        return {};
+      }
+      return {
+        ...context
+      };
+    }
+
+    /**
+     * Non-destructively merges two contexts (or their values)
+     * with each other, returning the result.
+     *
+     * @param {ContextValue} context
+     * @param {ContextValue} other
+     *
+     * @return {any}
+     */
+    static __merge(context, other) {
+      return reduce(this.__unwrap(other), (merged, value, key) => {
+        if (value instanceof ValueProducer) {
+          // keep value producers in tact
+          return {
+            ...merged,
+            [key]: value
+          };
         }
-        if (context instanceof this) {
-          return context.value;
+        value = this.__unwrap(value);
+        if (has(merged, key)) {
+          value = this.__merge(this.__unwrap(merged[key]), value);
         }
-        return {
-          ...context
-        };
-      };
-      const merged = contexts.reduce((merged, context) => {
         return {
           ...merged,
-          ...unwrap(context)
+          [key]: value
         };
-      }, {});
-      return new this(merged);
+      }, this.__unwrap(context));
     }
   }
   class Variables {
+    /**
+     * @param { {
+     *   name?: string,
+     *   tokens?: string[],
+     *   children?: Variables[],
+     *   parent: Variables | null
+     *   context: VariableContext,
+     *   value?: any,
+     *   raw?: any
+     * } } options
+     */
     constructor({
       name = 'Expressions',
       tokens = [],
       children = [],
       parent = null,
-      context = null,
-      value = null,
-      raw = null
-    } = {}) {
+      context,
+      value,
+      raw
+    }) {
       this.name = name;
       this.tokens = tokens;
       this.children = children;
@@ -32714,6 +32545,20 @@
         ...options
       });
     }
+
+    /**
+     * @param { {
+     *   name?: string,
+     *   tokens?: string[],
+     *   children?: Variables[],
+     *   parent?: Variables | null
+     *   context: VariableContext,
+     *   value?: any,
+     *   raw?: any
+     * } } options
+     *
+     * @return {Variables}
+     */
     static of(options) {
       const {
         name,
@@ -34124,16 +33969,18 @@
   function ifValid(o) {
     return o.isValid ? o : null;
   }
-  function parseExpression(expression, context = {}) {
+  function parseExpression(expression, context = {}, dialect) {
     return parser$3.configure({
       top: 'Expression',
-      contextTracker: trackVariables(context)
+      contextTracker: trackVariables(context),
+      dialect
     }).parse(expression);
   }
-  function parseUnaryTests(expression, context = {}) {
+  function parseUnaryTests(expression, context = {}, dialect) {
     return parser$3.configure({
       top: 'UnaryTests',
-      contextTracker: trackVariables(context)
+      contextTracker: trackVariables(context),
+      dialect
     }).parse(expression);
   }
   let SyntaxError$1 = class SyntaxError extends Error {
@@ -34197,16 +34044,16 @@
       });
       return root.args[root.args.length - 1];
     }
-    evaluate(expression, context = {}) {
-      const parseTree = parseExpression(expression, context);
+    evaluate(expression, context = {}, dialect) {
+      const parseTree = parseExpression(expression, context, dialect);
       const root = this._buildExecutionTree(parseTree, expression);
       return {
         parseTree,
         root
       };
     }
-    unaryTest(expression, context = {}) {
-      const parseTree = parseUnaryTests(expression, context);
+    unaryTest(expression, context = {}, dialect) {
+      const parseTree = parseUnaryTests(expression, context, dialect);
       const root = this._buildExecutionTree(parseTree, expression);
       return {
         parseTree,
@@ -34215,20 +34062,20 @@
     }
   }
   const interpreter = new Interpreter();
-  function unaryTest(expression, context = {}) {
+  function unaryTest(expression, context = {}, dialect) {
     const value = context['?'] !== undefined ? context['?'] : null;
     const {
       root
-    } = interpreter.unaryTest(expression, context);
+    } = interpreter.unaryTest(expression, context, dialect);
     // root = fn(ctx) => test(val)
     const test = root(context);
     return test(value);
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  function evaluate$1(expression, context = {}) {
+  function evaluate$1(expression, context = {}, dialect) {
     const {
       root
-    } = interpreter.evaluate(expression, context);
+    } = interpreter.evaluate(expression, context, dialect);
     // root = Expression :: fn(ctx)
     return root(context);
   }
@@ -34325,6 +34172,8 @@
               return b => a => !equals(a, b);
           }
         }, Test('boolean'));
+      case 'BacktickIdentifier':
+        return input.replace(/`/g, '');
       case 'Wildcard':
         return _context => true;
       case 'null':
@@ -34638,7 +34487,7 @@
               if (isNumber(value)) {
                 filterFn.type = 'number';
               }
-            } catch (err) {
+            } catch (_err) {
               // ignore
             }
           }
@@ -35009,7 +34858,6 @@
     if (str.endsWith('"')) {
       str = str.slice(0, -1);
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return str.replace(/(\\")|(\\\\)|(\\u[a-fA-F0-9]{5,6})|((?:\\u[a-fA-F0-9]{1,4})+)/ig, function (substring, ...groups) {
       const [quotes, escape, codePoint, charCodes] = groups;
       if (quotes) {
@@ -39683,7 +39531,7 @@
         let child = this.children[i];
         if (child.parent == this && children.indexOf(child) < 0) child.destroy();
       }
-      this.children.splice(from, to - from, ...children);
+      if (children.length < 250) this.children.splice(from, to - from, ...children);else this.children = [].concat(this.children.slice(0, from), children, this.children.slice(to));
       for (let i = 0; i < children.length; i++) children[i].setParent(this);
     }
     ignoreMutation(_rec) {
@@ -44826,10 +44674,11 @@
   // lines within the viewport, as a kludge to keep the editor
   // responsive when a ridiculously long line is loaded into it.
   class LineGap {
-    constructor(from, to, size) {
+    constructor(from, to, size, displaySize) {
       this.from = from;
       this.to = to;
       this.size = size;
+      this.displaySize = displaySize;
     }
     static same(a, b) {
       if (a.length != b.length) return false;
@@ -44842,7 +44691,7 @@
     }
     draw(viewState, wrapping) {
       return Decoration.replace({
-        widget: new LineGapWidget(this.size * (wrapping ? viewState.scaleY : viewState.scaleX), wrapping)
+        widget: new LineGapWidget(this.displaySize * (wrapping ? viewState.scaleY : viewState.scaleX), wrapping)
       }).range(this.from, this.to);
     }
   }
@@ -45155,7 +45004,7 @@
     mapLineGaps(gaps, changes) {
       if (!gaps.length || changes.empty) return gaps;
       let mapped = [];
-      for (let gap of gaps) if (!changes.touchesRange(gap.from, gap.to)) mapped.push(new LineGap(changes.mapPos(gap.from), changes.mapPos(gap.to), gap.size));
+      for (let gap of gaps) if (!changes.touchesRange(gap.from, gap.to)) mapped.push(new LineGap(changes.mapPos(gap.from), changes.mapPos(gap.to), gap.size, gap.displaySize));
       return mapped;
     }
     // Computes positions in the viewport where the start or end of a
@@ -45192,7 +45041,9 @@
             let lineStart = mayMeasure.moveToLineBoundary(EditorSelection.cursor(to), false, true).head;
             if (lineStart > from) to = lineStart;
           }
-          gap = new LineGap(from, to, this.gapSize(line, from, to, structure));
+          let size = this.gapSize(line, from, to, structure);
+          let displaySize = wrapping || size < 2000000 /* VP.MaxHorizGap */ ? size : 2000000 /* VP.MaxHorizGap */;
+          gap = new LineGap(from, to, size, displaySize);
         }
         gaps.push(gap);
       };
@@ -45219,15 +45070,21 @@
         } else {
           let totalWidth = structure.total * this.heightOracle.charWidth;
           let marginWidth = margin * this.heightOracle.charWidth;
+          let horizOffset = 0;
+          if (totalWidth > 2000000 /* VP.MaxHorizGap */) for (let old of current) {
+            if (old.from >= line.from && old.from < line.to && old.size != old.displaySize && old.from * this.heightOracle.charWidth + horizOffset < this.pixelViewport.left) horizOffset = old.size - old.displaySize;
+          }
+          let pxLeft = this.pixelViewport.left + horizOffset,
+            pxRight = this.pixelViewport.right + horizOffset;
           let left, right;
           if (target != null) {
             let targetFrac = findFraction(structure, target);
-            let spaceFrac = ((this.pixelViewport.right - this.pixelViewport.left) / 2 + marginWidth) / totalWidth;
+            let spaceFrac = ((pxRight - pxLeft) / 2 + marginWidth) / totalWidth;
             left = targetFrac - spaceFrac;
             right = targetFrac + spaceFrac;
           } else {
-            left = (this.pixelViewport.left - marginWidth) / totalWidth;
-            right = (this.pixelViewport.right + marginWidth) / totalWidth;
+            left = (pxLeft - marginWidth) / totalWidth;
+            right = (pxRight + marginWidth) / totalWidth;
           }
           viewFrom = findPosition(structure, left);
           viewTo = findPosition(structure, right);
@@ -45576,7 +45433,7 @@
       display: "none"
     },
     "&dark .cm-cursor": {
-      borderLeftColor: "#444"
+      borderLeftColor: "#ddd"
     },
     ".cm-dropCursor": {
       position: "absolute"
@@ -46217,6 +46074,9 @@
       // user action on some Android keyboards)
       this.pendingContextChange = null;
       this.handlers = Object.create(null);
+      // Kludge to work around the fact that EditContext does not respond
+      // well to having its content updated during a composition (see #1472)
+      this.composing = null;
       this.resetRange(view.state);
       let context = this.editContext = new window.EditContext({
         text: view.state.doc.sliceString(this.from, this.to),
@@ -46227,9 +46087,16 @@
         let {
           anchor
         } = view.state.selection.main;
+        let from = this.toEditorPos(e.updateRangeStart),
+          to = this.toEditorPos(e.updateRangeEnd);
+        if (view.inputState.composing >= 0 && !this.composing) this.composing = {
+          contextBase: e.updateRangeStart,
+          editorBase: from,
+          drifted: false
+        };
         let change = {
-          from: this.toEditorPos(e.updateRangeStart),
-          to: this.toEditorPos(e.updateRangeEnd),
+          from,
+          to,
           insert: Text$2.of(e.text.split("\n"))
         };
         // If the window doesn't include the anchor, assume changes
@@ -46283,6 +46150,13 @@
       this.handlers.compositionend = () => {
         view.inputState.composing = -1;
         view.inputState.compositionFirstChange = null;
+        if (this.composing) {
+          let {
+            drifted
+          } = this.composing;
+          this.composing = null;
+          if (drifted) this.reset(view.state);
+        }
       };
       for (let event in this.handlers) context.addEventListener(event, this.handlers[event]);
       this.measureReq = {
@@ -46334,11 +46208,12 @@
     }
     update(update) {
       let reverted = this.pendingContextChange;
-      if (!this.applyEdits(update) || !this.rangeIsValid(update.state)) {
+      if (this.composing && (this.composing.drifted || update.transactions.some(tr => !tr.isUserEvent("input.type") && tr.changes.touchesRange(this.from, this.to)))) {
+        this.composing.drifted = true;
+        this.composing.editorBase = update.changes.mapPos(this.composing.editorBase);
+      } else if (!this.applyEdits(update) || !this.rangeIsValid(update.state)) {
         this.pendingContextChange = null;
-        this.resetRange(update.state);
-        this.editContext.updateText(0, this.editContext.text.length, update.state.doc.sliceString(this.from, this.to));
-        this.setSelection(update.state);
+        this.reset(update.state);
       } else if (update.docChanged || update.selectionSet || reverted) {
         this.setSelection(update.state);
       }
@@ -46351,6 +46226,11 @@
       this.from = Math.max(0, head - 10000 /* CxVp.Margin */);
       this.to = Math.min(state.doc.length, head + 10000 /* CxVp.Margin */);
     }
+    reset(state) {
+      this.resetRange(state);
+      this.editContext.updateText(0, this.editContext.text.length, state.doc.sliceString(this.from, this.to));
+      this.setSelection(state);
+    }
     revertPending(state) {
       let pending = this.pendingContextChange;
       this.pendingContextChange = null;
@@ -46371,10 +46251,12 @@
       return !(this.from > 0 && head - this.from < 500 /* CxVp.MinMargin */ || this.to < state.doc.length && this.to - head < 500 /* CxVp.MinMargin */ || this.to - this.from > 10000 /* CxVp.Margin */ * 3);
     }
     toEditorPos(contextPos) {
-      return contextPos + this.from;
+      let c = this.composing;
+      return c && c.drifted ? c.editorBase + (contextPos - c.contextBase) : contextPos + this.from;
     }
     toContextPos(editorPos) {
-      return editorPos - this.from;
+      let c = this.composing;
+      return c && c.drifted ? c.contextBase + (editorPos - c.editorBase) : editorPos - this.from;
     }
     destroy() {
       for (let event in this.handlers) this.editContext.removeEventListener(event, this.handlers[event]);
@@ -48859,7 +48741,6 @@
       clearTimeout(this.measureTimeout);
     }
     readMeasure() {
-      let editor = this.view.dom.getBoundingClientRect();
       let scaleX = 1,
         scaleY = 1,
         makeAbsolute = false;
@@ -48893,9 +48774,16 @@
           } = this.view.viewState);
         }
       }
+      let visible = this.view.scrollDOM.getBoundingClientRect(),
+        margins = getScrollMargins(this.view);
       return {
-        editor,
-        parent: this.parent ? this.container.getBoundingClientRect() : editor,
+        visible: {
+          left: visible.left + margins.left,
+          top: visible.top + margins.top,
+          right: visible.right - margins.right,
+          bottom: visible.bottom - margins.bottom
+        },
+        parent: this.parent ? this.container.getBoundingClientRect() : this.view.dom.getBoundingClientRect(),
         pos: this.manager.tooltips.map((t, i) => {
           let tv = this.manager.tooltipViews[i];
           return tv.getCoords ? tv.getCoords(t.pos) : this.view.coordsAtPos(t.pos);
@@ -48917,7 +48805,7 @@
         for (let t of this.manager.tooltipViews) t.dom.style.position = "absolute";
       }
       let {
-        editor,
+        visible,
         space,
         scaleX,
         scaleY
@@ -48932,7 +48820,7 @@
         let pos = measured.pos[i],
           size = measured.size[i];
         // Hide tooltips that are outside of the editor.
-        if (!pos || pos.bottom <= Math.max(editor.top, space.top) || pos.top >= Math.min(editor.bottom, space.bottom) || pos.right < Math.max(editor.left, space.left) - .1 || pos.left > Math.min(editor.right, space.right) + .1) {
+        if (!pos || pos.bottom <= Math.max(visible.top, space.top) || pos.top >= Math.min(visible.bottom, space.bottom) || pos.right < Math.max(visible.left, space.left) - .1 || pos.left > Math.min(visible.right, space.right) + .1) {
           dom.style.top = Outside;
           continue;
         }
@@ -48944,7 +48832,7 @@
           ltr = this.view.textDirection == Direction.LTR;
         let left = size.width > space.right - space.left ? ltr ? space.left : space.right - size.width : ltr ? Math.max(space.left, Math.min(pos.left - (arrow ? 14 /* Arrow.Offset */ : 0) + offset.x, space.right - width)) : Math.min(Math.max(space.left, pos.left - width + (arrow ? 14 /* Arrow.Offset */ : 0) - offset.x), space.right - width);
         let above = this.above[i];
-        if (!tooltip.strictSide && (above ? pos.top - (size.bottom - size.top) - offset.y < space.top : pos.bottom + (size.bottom - size.top) + offset.y > space.bottom) && above == space.bottom - pos.bottom > pos.top - space.top) above = this.above[i] = !above;
+        if (!tooltip.strictSide && (above ? pos.top - height - arrowHeight - offset.y < space.top : pos.bottom + height + arrowHeight + offset.y > space.bottom) && above == space.bottom - pos.bottom > pos.top - space.top) above = this.above[i] = !above;
         let spaceVert = (above ? pos.top - space.top : space.bottom - pos.bottom) - arrowHeight;
         if (spaceVert < height && tView.resize !== false) {
           if (spaceVert < this.view.defaultLineHeight) {
@@ -48999,7 +48887,7 @@
   });
   const baseTheme$6 = /*@__PURE__*/EditorView.baseTheme({
     ".cm-tooltip": {
-      zIndex: 100,
+      zIndex: 500,
       boxSizing: "border-box"
     },
     "&light .cm-tooltip": {
@@ -52779,11 +52667,10 @@
     setSelected(selected, id) {
       return selected == this.selected || selected >= this.options.length ? this : new CompletionDialog(this.options, makeAttrs(id, selected), this.tooltip, this.timestamp, selected, this.disabled);
     }
-    static build(active, state, id, prev, conf) {
+    static build(active, state, id, prev, conf, didSetActive) {
+      if (prev && !didSetActive && active.some(s => s.isPending)) return prev.setDisabled();
       let options = sortOptions(active, state);
-      if (!options.length) {
-        return prev && active.some(a => a.state == 1 /* State.Pending */) ? new CompletionDialog(prev.options, prev.attrs, prev.tooltip, prev.timestamp, prev.selected, true) : null;
-      }
+      if (!options.length) return prev && active.some(a => a.isPending) ? prev.setDisabled() : null;
       let selected = state.facet(completionConfig).selectOnOpen ? 0 : -1;
       if (prev && prev.selected != selected && prev.selected != -1) {
         let selectedValue = prev.options[prev.selected].completion;
@@ -52803,6 +52690,9 @@
         pos: changes.mapPos(this.tooltip.pos)
       }), this.timestamp, this.selected, this.disabled);
     }
+    setDisabled() {
+      return new CompletionDialog(this.options, this.attrs, this.tooltip, this.timestamp, this.selected, true);
+    }
   }
   class CompletionState {
     constructor(active, id, open) {
@@ -52824,10 +52714,11 @@
         return value.update(tr, conf);
       });
       if (active.length == this.active.length && active.every((a, i) => a == this.active[i])) active = this.active;
-      let open = this.open;
+      let open = this.open,
+        didSet = tr.effects.some(e => e.is(setActiveEffect));
       if (open && tr.docChanged) open = open.map(tr.changes);
-      if (tr.selection || active.some(a => a.hasResult() && tr.changes.touchesRange(a.from, a.to)) || !sameResults(active, this.active)) open = CompletionDialog.build(active, state, this.id, open, conf);else if (open && open.disabled && !active.some(a => a.state == 1 /* State.Pending */)) open = null;
-      if (!open && active.every(a => a.state != 1 /* State.Pending */) && active.some(a => a.hasResult())) active = active.map(a => a.hasResult() ? new ActiveSource(a.source, 0 /* State.Inactive */) : a);
+      if (tr.selection || active.some(a => a.hasResult() && tr.changes.touchesRange(a.from, a.to)) || !sameResults(active, this.active) || didSet) open = CompletionDialog.build(active, state, this.id, open, conf, didSet);else if (open && open.disabled && !active.some(a => a.isPending)) open = null;
+      if (!open && active.every(a => !a.isPending) && active.some(a => a.hasResult())) active = active.map(a => a.hasResult() ? new ActiveSource(a.source, 0 /* State.Inactive */) : a);
       for (let effect of tr.effects) if (effect.is(setSelectedEffect)) open = open && open.setSelected(effect.value, this.id);
       return active == this.active && open == this.open ? this : new CompletionState(active, this.id, open);
     }
@@ -52841,8 +52732,8 @@
   function sameResults(a, b) {
     if (a == b) return true;
     for (let iA = 0, iB = 0;;) {
-      while (iA < a.length && !a[iA].hasResult) iA++;
-      while (iB < b.length && !b[iB].hasResult) iB++;
+      while (iA < a.length && !a[iA].hasResult()) iA++;
+      while (iB < b.length && !b[iB].hasResult()) iB++;
       let endA = iA == a.length,
         endB = iB == b.length;
       if (endA || endB) return endA == endB;
@@ -52872,14 +52763,17 @@
     return typing && conf.activateOnTyping ? 4 /* UpdateType.Activate */ | 1 /* UpdateType.Typing */ : typing ? 1 /* UpdateType.Typing */ : tr.isUserEvent("delete.backward") ? 2 /* UpdateType.Backspacing */ : tr.selection ? 8 /* UpdateType.Reset */ : tr.docChanged ? 16 /* UpdateType.ResetIfTouching */ : 0 /* UpdateType.None */;
   }
   class ActiveSource {
-    constructor(source, state, explicitPos = -1) {
+    constructor(source, state, explicit = false) {
       this.source = source;
       this.state = state;
-      this.explicitPos = explicitPos;
+      this.explicit = explicit;
     }
     hasResult() {
       return false;
     }
+    get isPending() {
+      return this.state == 1 /* State.Pending */;
+    }
     update(tr, conf) {
       let type = getUpdateType(tr, conf),
         value = this;
@@ -52887,7 +52781,7 @@
       if (type & 4 /* UpdateType.Activate */ && value.state == 0 /* State.Inactive */) value = new ActiveSource(this.source, 1 /* State.Pending */);
       value = value.updateFor(tr, type);
       for (let effect of tr.effects) {
-        if (effect.is(startCompletionEffect)) value = new ActiveSource(value.source, 1 /* State.Pending */, effect.value ? cur(tr.state) : -1);else if (effect.is(closeCompletionEffect)) value = new ActiveSource(value.source, 0 /* State.Inactive */);else if (effect.is(setActiveEffect)) for (let active of effect.value) if (active.source == value.source) value = active;
+        if (effect.is(startCompletionEffect)) value = new ActiveSource(value.source, 1 /* State.Pending */, effect.value);else if (effect.is(closeCompletionEffect)) value = new ActiveSource(value.source, 0 /* State.Inactive */);else if (effect.is(setActiveEffect)) for (let active of effect.value) if (active.source == value.source) value = active;
       }
       return value;
     }
@@ -52895,15 +52789,16 @@
       return this.map(tr.changes);
     }
     map(changes) {
-      return changes.empty || this.explicitPos < 0 ? this : new ActiveSource(this.source, this.state, changes.mapPos(this.explicitPos));
+      return this;
     }
     touches(tr) {
       return tr.changes.touchesRange(cur(tr.state));
     }
   }
   class ActiveResult extends ActiveSource {
-    constructor(source, explicitPos, result, from, to) {
-      super(source, 2 /* State.Result */, explicitPos);
+    constructor(source, explicit, limit, result, from, to) {
+      super(source, 3 /* State.Result */, explicit);
+      this.limit = limit;
       this.result = result;
       this.from = from;
       this.to = to;
@@ -52919,17 +52814,17 @@
       let from = tr.changes.mapPos(this.from),
         to = tr.changes.mapPos(this.to, 1);
       let pos = cur(tr.state);
-      if ((this.explicitPos < 0 ? pos <= from : pos < this.from) || pos > to || !result || type & 2 /* UpdateType.Backspacing */ && cur(tr.startState) == this.from) return new ActiveSource(this.source, type & 4 /* UpdateType.Activate */ ? 1 /* State.Pending */ : 0 /* State.Inactive */);
-      let explicitPos = this.explicitPos < 0 ? -1 : tr.changes.mapPos(this.explicitPos);
-      if (checkValid(result.validFor, tr.state, from, to)) return new ActiveResult(this.source, explicitPos, result, from, to);
-      if (result.update && (result = result.update(result, from, to, new CompletionContext(tr.state, pos, explicitPos >= 0)))) return new ActiveResult(this.source, explicitPos, result, result.from, (_a = result.to) !== null && _a !== void 0 ? _a : cur(tr.state));
-      return new ActiveSource(this.source, 1 /* State.Pending */, explicitPos);
+      if (pos > to || !result || type & 2 /* UpdateType.Backspacing */ && (cur(tr.startState) == this.from || pos < this.limit)) return new ActiveSource(this.source, type & 4 /* UpdateType.Activate */ ? 1 /* State.Pending */ : 0 /* State.Inactive */);
+      let limit = tr.changes.mapPos(this.limit);
+      if (checkValid(result.validFor, tr.state, from, to)) return new ActiveResult(this.source, this.explicit, limit, result, from, to);
+      if (result.update && (result = result.update(result, from, to, new CompletionContext(tr.state, pos, false)))) return new ActiveResult(this.source, this.explicit, limit, result, result.from, (_a = result.to) !== null && _a !== void 0 ? _a : cur(tr.state));
+      return new ActiveSource(this.source, 1 /* State.Pending */, this.explicit);
     }
     map(mapping) {
       if (mapping.empty) return this;
       let result = this.result.map ? this.result.map(this.result, mapping) : this.result;
       if (!result) return new ActiveSource(this.source, 0 /* State.Inactive */);
-      return new ActiveResult(this.source, this.explicitPos < 0 ? -1 : mapping.mapPos(this.explicitPos), this.result, mapping.mapPos(this.from), mapping.mapPos(this.to, 1));
+      return new ActiveResult(this.source, this.explicit, mapping.mapPos(this.limit), this.result, mapping.mapPos(this.from), mapping.mapPos(this.to, 1));
     }
     touches(tr) {
       return tr.changes.touchesRange(this.from, this.to);
@@ -53039,7 +52934,7 @@
       this.debounceAccept = -1;
       this.pendingStart = false;
       this.composing = 0 /* CompositionState.None */;
-      for (let active of view.state.field(completionState).active) if (active.state == 1 /* State.Pending */) this.startQuery(active);
+      for (let active of view.state.field(completionState).active) if (active.isPending) this.startQuery(active);
     }
     update(update) {
       let cState = update.state.field(completionState);
@@ -53068,7 +52963,7 @@
       if (this.debounceUpdate > -1) clearTimeout(this.debounceUpdate);
       if (update.transactions.some(tr => tr.effects.some(e => e.is(startCompletionEffect)))) this.pendingStart = true;
       let delay = this.pendingStart ? 50 : conf.activateOnTypingDelay;
-      this.debounceUpdate = cState.active.some(a => a.state == 1 /* State.Pending */ && !this.running.some(q => q.active.source == a.source)) ? setTimeout(() => this.startUpdate(), delay) : -1;
+      this.debounceUpdate = cState.active.some(a => a.isPending && !this.running.some(q => q.active.source == a.source)) ? setTimeout(() => this.startUpdate(), delay) : -1;
       if (this.composing != 0 /* CompositionState.None */) for (let tr of update.transactions) {
         if (tr.isUserEvent("input.type")) this.composing = 2 /* CompositionState.Changed */;else if (this.composing == 2 /* CompositionState.Changed */ && tr.selection) this.composing = 3 /* CompositionState.ChangedAndMoved */;
       }
@@ -53081,15 +52976,16 @@
         } = this.view,
         cState = state.field(completionState);
       for (let active of cState.active) {
-        if (active.state == 1 /* State.Pending */ && !this.running.some(r => r.active.source == active.source)) this.startQuery(active);
+        if (active.isPending && !this.running.some(r => r.active.source == active.source)) this.startQuery(active);
       }
+      if (this.running.length && cState.open && cState.open.disabled) this.debounceAccept = setTimeout(() => this.accept(), this.view.state.facet(completionConfig).updateSyncTime);
     }
     startQuery(active) {
       let {
           state
         } = this.view,
         pos = cur(state);
-      let context = new CompletionContext(state, pos, active.explicitPos == pos, this.view);
+      let context = new CompletionContext(state, pos, active.explicit, this.view);
       let pending = new RunningQuery(active, context);
       this.running.push(pending);
       Promise.resolve(active.source(context)).then(result => {
@@ -53114,13 +53010,16 @@
       if (this.debounceAccept > -1) clearTimeout(this.debounceAccept);
       this.debounceAccept = -1;
       let updated = [];
-      let conf = this.view.state.facet(completionConfig);
+      let conf = this.view.state.facet(completionConfig),
+        cState = this.view.state.field(completionState);
       for (let i = 0; i < this.running.length; i++) {
         let query = this.running[i];
         if (query.done === undefined) continue;
         this.running.splice(i--, 1);
         if (query.done) {
-          let active = new ActiveResult(query.active.source, query.active.explicitPos, query.done, query.done.from, (_a = query.done.to) !== null && _a !== void 0 ? _a : cur(query.updates.length ? query.updates[0].startState : this.view.state));
+          let pos = cur(query.updates.length ? query.updates[0].startState : this.view.state);
+          let limit = Math.min(pos, query.done.from + (query.active.explicit ? 0 : 1));
+          let active = new ActiveResult(query.active.source, query.active.explicit, limit, query.done, query.done.from, (_a = query.done.to) !== null && _a !== void 0 ? _a : pos);
           // Replay the transactions that happened since the start of
           // the request and see if that preserves the result
           for (let tr of query.updates) active = active.update(tr, conf);
@@ -53129,21 +53028,21 @@
             continue;
           }
         }
-        let current = this.view.state.field(completionState).active.find(a => a.source == query.active.source);
-        if (current && current.state == 1 /* State.Pending */) {
+        let current = cState.active.find(a => a.source == query.active.source);
+        if (current && current.isPending) {
           if (query.done == null) {
             // Explicitly failed. Should clear the pending status if it
             // hasn't been re-set in the meantime.
             let active = new ActiveSource(query.active.source, 0 /* State.Inactive */);
             for (let tr of query.updates) active = active.update(tr, conf);
-            if (active.state != 1 /* State.Pending */) updated.push(active);
+            if (!active.isPending) updated.push(active);
           } else {
             // Cleared by subsequent transactions. Restart.
             this.startQuery(current);
           }
         }
       }
-      if (updated.length) this.view.dispatch({
+      if (updated.length || cState.open && cState.open.disabled) this.view.dispatch({
         effects: setActiveEffect.of(updated)
       });
     }
@@ -54072,6 +53971,7 @@
     for (let r of state.selection.ranges) {
       let fromLine = state.doc.lineAt(r.from);
       let toLine = r.to <= fromLine.to ? fromLine : state.doc.lineAt(r.to);
+      if (toLine.from > fromLine.from && toLine.from == r.to) toLine = r.to == fromLine.to + 1 ? fromLine : state.doc.lineAt(r.to - 1);
       let last = ranges.length - 1;
       if (last >= 0 && ranges[last].to > fromLine.from) ranges[last].to = toLine.to;else ranges.push({
         from: fromLine.from + /^\s*/.exec(fromLine.text)[0].length,
@@ -54743,13 +54643,13 @@
     state,
     dispatch
   }) => toMatchingBracket(state, dispatch);
-  function extendSel(view, how) {
-    let selection = updateSel(view.state.selection, range => {
+  function extendSel(target, how) {
+    let selection = updateSel(target.state.selection, range => {
       let head = how(range);
       return EditorSelection.range(range.anchor, head.head, head.goalColumn, head.bidiLevel || undefined);
     });
-    if (selection.eq(view.state.selection)) return false;
-    view.dispatch(setSel(view.state, selection));
+    if (selection.eq(target.state.selection)) return false;
+    target.dispatch(setSel(target.state, selection));
     return true;
   }
   function selectByChar(view, forward) {
@@ -55563,7 +55463,7 @@
    - End: [`cursorLineBoundaryForward`](https://codemirror.net/6/docs/ref/#commands.cursorLineBoundaryForward) ([`selectLineBoundaryForward`](https://codemirror.net/6/docs/ref/#commands.selectLineBoundaryForward) with Shift)
    - Ctrl-Home (Cmd-Home on macOS): [`cursorDocStart`](https://codemirror.net/6/docs/ref/#commands.cursorDocStart) ([`selectDocStart`](https://codemirror.net/6/docs/ref/#commands.selectDocStart) with Shift)
    - Ctrl-End (Cmd-Home on macOS): [`cursorDocEnd`](https://codemirror.net/6/docs/ref/#commands.cursorDocEnd) ([`selectDocEnd`](https://codemirror.net/6/docs/ref/#commands.selectDocEnd) with Shift)
-   - Enter: [`insertNewlineAndIndent`](https://codemirror.net/6/docs/ref/#commands.insertNewlineAndIndent)
+   - Enter and Shift-Enter: [`insertNewlineAndIndent`](https://codemirror.net/6/docs/ref/#commands.insertNewlineAndIndent)
    - Ctrl-a (Cmd-a on macOS): [`selectAll`](https://codemirror.net/6/docs/ref/#commands.selectAll)
    - Backspace: [`deleteCharBackward`](https://codemirror.net/6/docs/ref/#commands.deleteCharBackward)
    - Delete: [`deleteCharForward`](https://codemirror.net/6/docs/ref/#commands.deleteCharForward)
@@ -55658,7 +55558,8 @@
     shift: selectDocEnd
   }, {
     key: "Enter",
-    run: insertNewlineAndIndent
+    run: insertNewlineAndIndent,
+    shift: insertNewlineAndIndent
   }, {
     key: "Mod-a",
     run: selectAll
@@ -59575,7 +59476,7 @@
   };
 
   /**
-   * marked v14.1.2 - a markdown parser
+   * marked v15.0.1 - a markdown parser
    * Copyright (c) 2011-2024, Christopher Jeffrey. (MIT Licensed)
    * https://github.com/markedjs/marked
    */
@@ -59606,14 +59507,285 @@
   function changeDefaults(newDefaults) {
     _defaults = newDefaults;
   }
+  const noopTest = {
+    exec: () => null
+  };
+  function edit(regex, opt = '') {
+    let source = typeof regex === 'string' ? regex : regex.source;
+    const obj = {
+      replace: (name, val) => {
+        let valSource = typeof val === 'string' ? val : val.source;
+        valSource = valSource.replace(other.caret, '$1');
+        source = source.replace(name, valSource);
+        return obj;
+      },
+      getRegex: () => {
+        return new RegExp(source, opt);
+      }
+    };
+    return obj;
+  }
+  const other = {
+    codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm,
+    outputLinkReplace: /\\([\[\]])/g,
+    indentCodeCompensation: /^(\s+)(?:```)/,
+    beginningSpace: /^\s+/,
+    endingHash: /#$/,
+    startingSpaceChar: /^ /,
+    endingSpaceChar: / $/,
+    nonSpaceChar: /[^ ]/,
+    newLineCharGlobal: /\n/g,
+    tabCharGlobal: /\t/g,
+    multipleSpaceGlobal: /\s+/g,
+    blankLine: /^[ \t]*$/,
+    doubleBlankLine: /\n[ \t]*\n[ \t]*$/,
+    blockquoteStart: /^ {0,3}>/,
+    blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g,
+    blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm,
+    listReplaceTabs: /^\t+/,
+    listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g,
+    listIsTask: /^\[[ xX]\] /,
+    listReplaceTask: /^\[[ xX]\] +/,
+    anyLine: /\n.*\n/,
+    hrefBrackets: /^<(.*)>$/,
+    tableDelimiter: /[:|]/,
+    tableAlignChars: /^\||\| *$/g,
+    tableRowBlankLine: /\n[ \t]*$/,
+    tableAlignRight: /^ *-+: *$/,
+    tableAlignCenter: /^ *:-+: *$/,
+    tableAlignLeft: /^ *:-+ *$/,
+    startATag: /^<a /i,
+    endATag: /^<\/a>/i,
+    startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i,
+    endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i,
+    startAngleBracket: /^</,
+    endAngleBracket: />$/,
+    pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/,
+    unicodeAlphaNumeric: /[\p{L}\p{N}]/u,
+    escapeTest: /[&<>"']/,
+    escapeReplace: /[&<>"']/g,
+    escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,
+    escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g,
+    unescapeTest: /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig,
+    caret: /(^|[^\[])\^/g,
+    percentDecode: /%25/g,
+    findPipe: /\|/g,
+    splitPipe: / \|/,
+    slashPipe: /\\\|/g,
+    carriageReturn: /\r\n|\r/g,
+    spaceLine: /^ +$/gm,
+    notSpaceStart: /^\S*/,
+    endingNewline: /\n$/,
+    listItemRegex: bull => new RegExp(`^( {0,3}${bull})((?:[\t ][^\\n]*)?(?:\\n|$))`),
+    nextBulletRegex: indent => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ \t][^\\n]*)?(?:\\n|$))`),
+    hrRegex: indent => new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),
+    fencesBeginRegex: indent => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`),
+    headingBeginRegex: indent => new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`),
+    htmlBeginRegex: indent => new RegExp(`^ {0,${Math.min(3, indent - 1)}}<(?:[a-z].*>|!--)`, 'i')
+  };
+  /**
+   * Block-Level Grammar
+   */
+  const newline = /^(?:[ \t]*(?:\n|$))+/;
+  const blockCode = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
+  const fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+  const hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+  const heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+  const bullet = /(?:[*+-]|\d{1,9}[.)])/;
+  const lheading = edit(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/).replace(/bull/g, bullet) // lists can interrupt
+  .replace(/blockCode/g, /(?: {4}| {0,3}\t)/) // indented code blocks can interrupt
+  .replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt
+  .replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt
+  .replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt
+  .replace(/html/g, / {0,3}<[^\n>]+>\n/) // block html can interrupt
+  .getRegex();
+  const _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
+  const blockText = /^[^\n]+/;
+  const _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+  const def = edit(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace('label', _blockLabel).replace('title', /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+  const list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bullet).getRegex();
+  const _tag = '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|h[1-6]|head|header|hr|html|iframe' + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option' + '|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title' + '|tr|track|ul';
+  const _comment = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+  const html = edit('^ {0,3}(?:' // optional indentation
+  + '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
+  + '|comment[^\\n]*(\\n+|$)' // (2)
+  + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
+  + '|<![A-Z][\\s\\S]*?(?:>\\n*|$)' // (4)
+  + '|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)' // (5)
+  + '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (6)
+  + '|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (7) open tag
+  + '|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (7) closing tag
+  + ')', 'i').replace('comment', _comment).replace('tag', _tag).replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+  const paragraph = edit(_paragraph).replace('hr', hr).replace('heading', ' {0,3}#{1,6}(?:\\s|$)').replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs
+  .replace('|table', '').replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+  .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', _tag) // pars can be interrupted by type (6) html blocks
+  .getRegex();
+  const blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace('paragraph', paragraph).getRegex();
+  /**
+   * Normal Block Grammar
+   */
+  const blockNormal = {
+    blockquote,
+    code: blockCode,
+    def,
+    fences,
+    heading,
+    hr,
+    html,
+    lheading,
+    list,
+    newline,
+    paragraph,
+    table: noopTest,
+    text: blockText
+  };
+  /**
+   * GFM Block Grammar
+   */
+  const gfmTable = edit('^ *([^\\n ].*)\\n' // Header
+  + ' {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)' // Align
+  + '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)') // Cells
+  .replace('hr', hr).replace('heading', ' {0,3}#{1,6}(?:\\s|$)').replace('blockquote', ' {0,3}>').replace('code', '(?: {4}| {0,3}\t)[^\\n]').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+  .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', _tag) // tables can be interrupted by type (6) html blocks
+  .getRegex();
+  const blockGfm = {
+    ...blockNormal,
+    table: gfmTable,
+    paragraph: edit(_paragraph).replace('hr', hr).replace('heading', ' {0,3}#{1,6}(?:\\s|$)').replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs
+    .replace('table', gfmTable) // interrupt paragraphs with table
+    .replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+    .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', _tag) // pars can be interrupted by type (6) html blocks
+    .getRegex()
+  };
+  /**
+   * Pedantic grammar (original John Gruber's loose markdown specification)
+   */
+  const blockPedantic = {
+    ...blockNormal,
+    html: edit('^ *(?:comment *(?:\\n|\\s*$)' + '|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)' // closed tag
+    + '|<tag(?:"[^"]*"|\'[^\']*\'|\\s[^\'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))').replace('comment', _comment).replace(/tag/g, '(?!(?:' + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub' + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)' + '\\b)\\w+(?!:|[^\\w\\s@]*@)\\b').getRegex(),
+    def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
+    heading: /^(#{1,6})(.*)(?:\n+|$)/,
+    fences: noopTest,
+    // fences not supported
+    lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+    paragraph: edit(_paragraph).replace('hr', hr).replace('heading', ' *#{1,6} *[^\n]').replace('lheading', lheading).replace('|table', '').replace('blockquote', ' {0,3}>').replace('|fences', '').replace('|list', '').replace('|html', '').replace('|tag', '').getRegex()
+  };
+  /**
+   * Inline-Level Grammar
+   */
+  const escape$1 = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+  const inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+  const br = /^( {2,}|\\)\n(?!\s*$)/;
+  const inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+  // list of unicode punctuation marks, plus any missing characters from CommonMark spec
+  const _punctuation = '\\p{P}\\p{S}';
+  const punctuation = edit(/^((?![*_])[\spunctuation])/, 'u').replace(/punctuation/g, _punctuation).getRegex();
+  // sequences em should skip over [title](link), `code`, <html>
+  const blockSkip = /\[[^[\]]*?\]\((?:\\.|[^\\\(\)]|\((?:\\.|[^\\\(\)])*\))*\)|`[^`]*?`|<[^<>]*?>/g;
+  const emStrongLDelim = edit(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, 'u').replace(/punct/g, _punctuation).getRegex();
+  const emStrongRDelimAst = edit('^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)' // Skip orphan inside strong
+  + '|[^*]+(?=[^*])' // Consume to delim
+  + '|(?!\\*)[punct](\\*+)(?=[\\s]|$)' // (1) #*** can only be a Right Delimiter
+  + '|[^punct\\s](\\*+)(?!\\*)(?=[punct\\s]|$)' // (2) a***#, a*** can only be a Right Delimiter
+  + '|(?!\\*)[punct\\s](\\*+)(?=[^punct\\s])' // (3) #***a, ***a can only be Left Delimiter
+  + '|[\\s](\\*+)(?!\\*)(?=[punct])' // (4) ***# can only be Left Delimiter
+  + '|(?!\\*)[punct](\\*+)(?!\\*)(?=[punct])' // (5) #***# can be either Left or Right Delimiter
+  + '|[^punct\\s](\\*+)(?=[^punct\\s])', 'gu') // (6) a***a can be either Left or Right Delimiter
+  .replace(/punct/g, _punctuation).getRegex();
+  // (6) Not allowed for _
+  const emStrongRDelimUnd = edit('^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)' // Skip orphan inside strong
+  + '|[^_]+(?=[^_])' // Consume to delim
+  + '|(?!_)[punct](_+)(?=[\\s]|$)' // (1) #___ can only be a Right Delimiter
+  + '|[^punct\\s](_+)(?!_)(?=[punct\\s]|$)' // (2) a___#, a___ can only be a Right Delimiter
+  + '|(?!_)[punct\\s](_+)(?=[^punct\\s])' // (3) #___a, ___a can only be Left Delimiter
+  + '|[\\s](_+)(?!_)(?=[punct])' // (4) ___# can only be Left Delimiter
+  + '|(?!_)[punct](_+)(?!_)(?=[punct])', 'gu') // (5) #___# can be either Left or Right Delimiter
+  .replace(/punct/g, _punctuation).getRegex();
+  const anyPunctuation = edit(/\\([punct])/, 'gu').replace(/punct/g, _punctuation).getRegex();
+  const autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace('scheme', /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace('email', /[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])?)+(?![-_])/).getRegex();
+  const _inlineComment = edit(_comment).replace('(?:-->|$)', '-->').getRegex();
+  const tag = edit('^comment' + '|^</[a-zA-Z][\\w:-]*\\s*>' // self-closing tag
+  + '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
+  + '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g. <?php ?>
+  + '|^<![a-zA-Z]+\\s[\\s\\S]*?>' // declaration, e.g. <!DOCTYPE html>
+  + '|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>') // CDATA section
+  .replace('comment', _inlineComment).replace('attribute', /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+  const _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+  const link = edit(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace('label', _inlineLabel).replace('href', /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace('title', /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+  const reflink = edit(/^!?\[(label)\]\[(ref)\]/).replace('label', _inlineLabel).replace('ref', _blockLabel).getRegex();
+  const nolink = edit(/^!?\[(ref)\](?:\[\])?/).replace('ref', _blockLabel).getRegex();
+  const reflinkSearch = edit('reflink|nolink(?!\\()', 'g').replace('reflink', reflink).replace('nolink', nolink).getRegex();
+  /**
+   * Normal Inline Grammar
+   */
+  const inlineNormal = {
+    _backpedal: noopTest,
+    // only used for GFM url
+    anyPunctuation,
+    autolink,
+    blockSkip,
+    br,
+    code: inlineCode,
+    del: noopTest,
+    emStrongLDelim,
+    emStrongRDelimAst,
+    emStrongRDelimUnd,
+    escape: escape$1,
+    link,
+    nolink,
+    punctuation,
+    reflink,
+    reflinkSearch,
+    tag,
+    text: inlineText,
+    url: noopTest
+  };
+  /**
+   * Pedantic Inline Grammar
+   */
+  const inlinePedantic = {
+    ...inlineNormal,
+    link: edit(/^!?\[(label)\]\((.*?)\)/).replace('label', _inlineLabel).getRegex(),
+    reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace('label', _inlineLabel).getRegex()
+  };
+  /**
+   * GFM Inline Grammar
+   */
+  const inlineGfm = {
+    ...inlineNormal,
+    escape: edit(escape$1).replace('])', '~|])').getRegex(),
+    url: edit(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, 'i').replace('email', /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),
+    _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
+    del: /^(~~?)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/,
+    text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
+  };
+  /**
+   * GFM + Line Breaks Inline Grammar
+   */
+  const inlineBreaks = {
+    ...inlineGfm,
+    br: edit(br).replace('{2,}', '*').getRegex(),
+    text: edit(inlineGfm.text).replace('\\b_', '\\b_| {2,}\\n').replace(/\{2,\}/g, '*').getRegex()
+  };
+  /**
+   * exports
+   */
+  const block = {
+    normal: blockNormal,
+    gfm: blockGfm,
+    pedantic: blockPedantic
+  };
+  const inline = {
+    normal: inlineNormal,
+    gfm: inlineGfm,
+    breaks: inlineBreaks,
+    pedantic: inlinePedantic
+  };
 
   /**
    * Helpers
    */
-  const escapeTest = /[&<>"']/;
-  const escapeReplace = new RegExp(escapeTest.source, 'g');
-  const escapeTestNoEncode = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/;
-  const escapeReplaceNoEncode = new RegExp(escapeTestNoEncode.source, 'g');
   const escapeReplacements = {
     '&': '&amp;',
     '<': '&lt;',
@@ -59622,50 +59794,30 @@
     "'": '&#39;'
   };
   const getEscapeReplacement = ch => escapeReplacements[ch];
-  function escape$1(html, encode) {
+  function escape(html, encode) {
     if (encode) {
-      if (escapeTest.test(html)) {
-        return html.replace(escapeReplace, getEscapeReplacement);
+      if (other.escapeTest.test(html)) {
+        return html.replace(other.escapeReplace, getEscapeReplacement);
       }
     } else {
-      if (escapeTestNoEncode.test(html)) {
-        return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
+      if (other.escapeTestNoEncode.test(html)) {
+        return html.replace(other.escapeReplaceNoEncode, getEscapeReplacement);
       }
     }
     return html;
   }
-  const caret = /(^|[^\[])\^/g;
-  function edit(regex, opt) {
-    let source = typeof regex === 'string' ? regex : regex.source;
-    opt = opt || '';
-    const obj = {
-      replace: (name, val) => {
-        let valSource = typeof val === 'string' ? val : val.source;
-        valSource = valSource.replace(caret, '$1');
-        source = source.replace(name, valSource);
-        return obj;
-      },
-      getRegex: () => {
-        return new RegExp(source, opt);
-      }
-    };
-    return obj;
-  }
   function cleanUrl(href) {
     try {
-      href = encodeURI(href).replace(/%25/g, '%');
+      href = encodeURI(href).replace(other.percentDecode, '%');
     } catch {
       return null;
     }
     return href;
   }
-  const noopTest = {
-    exec: () => null
-  };
   function splitCells(tableRow, count) {
     // ensure that every cell-delimiting pipe has a space
     // before it to distinguish it from an escaped pipe
-    const row = tableRow.replace(/\|/g, (match, offset, str) => {
+    const row = tableRow.replace(other.findPipe, (match, offset, str) => {
         let escaped = false;
         let curr = offset;
         while (--curr >= 0 && str[curr] === '\\') escaped = !escaped;
@@ -59678,13 +59830,13 @@
           return ' |';
         }
       }),
-      cells = row.split(/ \|/);
+      cells = row.split(other.splitPipe);
     let i = 0;
     // First/last cell in a row cannot be empty if it has no leading/trailing pipe
     if (!cells[0].trim()) {
       cells.shift();
     }
-    if (cells.length > 0 && !cells[cells.length - 1].trim()) {
+    if (cells.length > 0 && !cells.at(-1)?.trim()) {
       cells.pop();
     }
     if (count) {
@@ -59696,7 +59848,7 @@
     }
     for (; i < cells.length; i++) {
       // leading or trailing whitespace is ignored per the gfm spec
-      cells[i] = cells[i].trim().replace(/\\\|/g, '|');
+      cells[i] = cells[i].trim().replace(other.slashPipe, '|');
     }
     return cells;
   }
@@ -59747,10 +59899,10 @@
     }
     return -1;
   }
-  function outputLink(cap, link, raw, lexer) {
+  function outputLink(cap, link, raw, lexer, rules) {
     const href = link.href;
-    const title = link.title ? escape$1(link.title) : null;
-    const text = cap[1].replace(/\\([\[\]])/g, '$1');
+    const title = link.title || null;
+    const text = cap[1].replace(rules.other.outputLinkReplace, '$1');
     if (cap[0].charAt(0) !== '!') {
       lexer.state.inLink = true;
       const token = {
@@ -59769,17 +59921,17 @@
       raw,
       href,
       title,
-      text: escape$1(text)
+      text
     };
   }
-  function indentCodeCompensation(raw, text) {
-    const matchIndentToCode = raw.match(/^(\s+)(?:```)/);
+  function indentCodeCompensation(raw, text, rules) {
+    const matchIndentToCode = raw.match(rules.other.indentCodeCompensation);
     if (matchIndentToCode === null) {
       return text;
     }
     const indentToCode = matchIndentToCode[1];
     return text.split('\n').map(node => {
-      const matchIndentInNode = node.match(/^\s+/);
+      const matchIndentInNode = node.match(rules.other.beginningSpace);
       if (matchIndentInNode === null) {
         return node;
       }
@@ -59812,7 +59964,7 @@
     code(src) {
       const cap = this.rules.block.code.exec(src);
       if (cap) {
-        const text = cap[0].replace(/^(?: {1,4}| {0,3}\t)/gm, '');
+        const text = cap[0].replace(this.rules.other.codeRemoveIndent, '');
         return {
           type: 'code',
           raw: cap[0],
@@ -59825,7 +59977,7 @@
       const cap = this.rules.block.fences.exec(src);
       if (cap) {
         const raw = cap[0];
-        const text = indentCodeCompensation(raw, cap[3] || '');
+        const text = indentCodeCompensation(raw, cap[3] || '', this.rules);
         return {
           type: 'code',
           raw,
@@ -59839,11 +59991,11 @@
       if (cap) {
         let text = cap[2].trim();
         // remove trailing #s
-        if (/#$/.test(text)) {
+        if (this.rules.other.endingHash.test(text)) {
           const trimmed = rtrim(text, '#');
           if (this.options.pedantic) {
             text = trimmed.trim();
-          } else if (!trimmed || / $/.test(trimmed)) {
+          } else if (!trimmed || this.rules.other.endingSpaceChar.test(trimmed)) {
             // CommonMark requires space before trailing #s
             text = trimmed.trim();
           }
@@ -59879,7 +60031,7 @@
           let i;
           for (i = 0; i < lines.length; i++) {
             // get lines up to a continuation
-            if (/^ {0,3}>/.test(lines[i])) {
+            if (this.rules.other.blockquoteStart.test(lines[i])) {
               currentLines.push(lines[i]);
               inBlockquote = true;
             } else if (!inBlockquote) {
@@ -59892,7 +60044,7 @@
           const currentRaw = currentLines.join('\n');
           const currentText = currentRaw
           // precede setext continuation with 4 spaces so it isn't a setext
-          .replace(/\n {0,3}((?:=+|-+) *)(?=\n|$)/g, '\n    $1').replace(/^ {0,3}>[ \t]?/gm, '');
+          .replace(this.rules.other.blockquoteSetextReplace, '\n    $1').replace(this.rules.other.blockquoteSetextReplace2, '');
           raw = raw ? `${raw}\n${currentRaw}` : currentRaw;
           text = text ? `${text}\n${currentText}` : currentText;
           // parse blockquote lines as top level tokens
@@ -59905,7 +60057,7 @@
           if (lines.length === 0) {
             break;
           }
-          const lastToken = tokens[tokens.length - 1];
+          const lastToken = tokens.at(-1);
           if (lastToken?.type === 'code') {
             // blockquote continuation cannot be preceded by a code block
             break;
@@ -59926,7 +60078,7 @@
             tokens[tokens.length - 1] = newToken;
             raw = raw.substring(0, raw.length - lastToken.raw.length) + newToken.raw;
             text = text.substring(0, text.length - oldToken.raw.length) + newToken.raw;
-            lines = newText.substring(tokens[tokens.length - 1].raw.length).split('\n');
+            lines = newText.substring(tokens.at(-1).raw.length).split('\n');
             continue;
           }
         }
@@ -59956,7 +60108,7 @@
           bull = isordered ? bull : '[*+-]';
         }
         // Get next list item
-        const itemRegex = new RegExp(`^( {0,3}${bull})((?:[\t ][^\\n]*)?(?:\\n|$))`);
+        const itemRegex = this.rules.other.listItemRegex(bull);
         let endsWithBlankLine = false;
         // Check if current bullet point can start a new List Item
         while (src) {
@@ -59972,7 +60124,7 @@
           }
           raw = cap[0];
           src = src.substring(raw.length);
-          let line = cap[2].split('\n', 1)[0].replace(/^\t+/, t => ' '.repeat(3 * t.length));
+          let line = cap[2].split('\n', 1)[0].replace(this.rules.other.listReplaceTabs, t => ' '.repeat(3 * t.length));
           let nextLine = src.split('\n', 1)[0];
           let blankLine = !line.trim();
           let indent = 0;
@@ -59982,23 +60134,23 @@
           } else if (blankLine) {
             indent = cap[1].length + 1;
           } else {
-            indent = cap[2].search(/[^ ]/); // Find first non-space char
+            indent = cap[2].search(this.rules.other.nonSpaceChar); // Find first non-space char
             indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent
             itemContents = line.slice(indent);
             indent += cap[1].length;
           }
-          if (blankLine && /^[ \t]*$/.test(nextLine)) {
+          if (blankLine && this.rules.other.blankLine.test(nextLine)) {
             // Items begin with at most one blank line
             raw += nextLine + '\n';
             src = src.substring(nextLine.length + 1);
             endEarly = true;
           }
           if (!endEarly) {
-            const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ \t][^\\n]*)?(?:\\n|$))`);
-            const hrRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`);
-            const fencesBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`);
-            const headingBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`);
-            const htmlBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}<[a-z].*>`, 'i');
+            const nextBulletRegex = this.rules.other.nextBulletRegex(indent);
+            const hrRegex = this.rules.other.hrRegex(indent);
+            const fencesBeginRegex = this.rules.other.fencesBeginRegex(indent);
+            const headingBeginRegex = this.rules.other.headingBeginRegex(indent);
+            const htmlBeginRegex = this.rules.other.htmlBeginRegex(indent);
             // Check if following lines should be included in List Item
             while (src) {
               const rawLine = src.split('\n', 1)[0];
@@ -60006,10 +60158,10 @@
               nextLine = rawLine;
               // Re-align to follow commonmark nesting rules
               if (this.options.pedantic) {
-                nextLine = nextLine.replace(/^ {1,4}(?=( {4})*[^ ])/g, '  ');
+                nextLine = nextLine.replace(this.rules.other.listReplaceNesting, '  ');
                 nextLineWithoutTabs = nextLine;
               } else {
-                nextLineWithoutTabs = nextLine.replace(/\t/g, '    ');
+                nextLineWithoutTabs = nextLine.replace(this.rules.other.tabCharGlobal, '    ');
               }
               // End list item if found code fences
               if (fencesBeginRegex.test(nextLine)) {
@@ -60031,7 +60183,7 @@
               if (hrRegex.test(nextLine)) {
                 break;
               }
-              if (nextLineWithoutTabs.search(/[^ ]/) >= indent || !nextLine.trim()) {
+              if (nextLineWithoutTabs.search(this.rules.other.nonSpaceChar) >= indent || !nextLine.trim()) {
                 // Dedent if possible
                 itemContents += '\n' + nextLineWithoutTabs.slice(indent);
               } else {
@@ -60040,7 +60192,7 @@
                   break;
                 }
                 // paragraph continuation unless last line was a different block level element
-                if (line.replace(/\t/g, '    ').search(/[^ ]/) >= 4) {
+                if (line.replace(this.rules.other.tabCharGlobal, '    ').search(this.rules.other.nonSpaceChar) >= 4) {
                   // indented code block
                   break;
                 }
@@ -60068,7 +60220,7 @@
             // If the previous item ended with a blank line, the list is loose
             if (endsWithBlankLine) {
               list.loose = true;
-            } else if (/\n[ \t]*\n[ \t]*$/.test(raw)) {
+            } else if (this.rules.other.doubleBlankLine.test(raw)) {
               endsWithBlankLine = true;
             }
           }
@@ -60076,10 +60228,10 @@
           let ischecked;
           // Check for task list items
           if (this.options.gfm) {
-            istask = /^\[[ xX]\] /.exec(itemContents);
+            istask = this.rules.other.listIsTask.exec(itemContents);
             if (istask) {
               ischecked = istask[0] !== '[ ] ';
-              itemContents = itemContents.replace(/^\[[ xX]\] +/, '');
+              itemContents = itemContents.replace(this.rules.other.listReplaceTask, '');
             }
           }
           list.items.push({
@@ -60094,8 +60246,11 @@
           list.raw += raw;
         }
         // Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic
-        list.items[list.items.length - 1].raw = list.items[list.items.length - 1].raw.trimEnd();
-        list.items[list.items.length - 1].text = list.items[list.items.length - 1].text.trimEnd();
+        const lastItem = list.items.at(-1);
+        if (lastItem) {
+          lastItem.raw = lastItem.raw.trimEnd();
+          lastItem.text = lastItem.text.trimEnd();
+        }
         list.raw = list.raw.trimEnd();
         // Item child tokens handled here at end because we needed to have the final item to trim it first
         for (let i = 0; i < list.items.length; i++) {
@@ -60104,7 +60259,7 @@
           if (!list.loose) {
             // Check if list should be loose
             const spacers = list.items[i].tokens.filter(t => t.type === 'space');
-            const hasMultipleLineBreaks = spacers.length > 0 && spacers.some(t => /\n.*\n/.test(t.raw));
+            const hasMultipleLineBreaks = spacers.length > 0 && spacers.some(t => this.rules.other.anyLine.test(t.raw));
             list.loose = hasMultipleLineBreaks;
           }
         }
@@ -60133,8 +60288,8 @@
     def(src) {
       const cap = this.rules.block.def.exec(src);
       if (cap) {
-        const tag = cap[1].toLowerCase().replace(/\s+/g, ' ');
-        const href = cap[2] ? cap[2].replace(/^<(.*)>$/, '$1').replace(this.rules.inline.anyPunctuation, '$1') : '';
+        const tag = cap[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, ' ');
+        const href = cap[2] ? cap[2].replace(this.rules.other.hrefBrackets, '$1').replace(this.rules.inline.anyPunctuation, '$1') : '';
         const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, '$1') : cap[3];
         return {
           type: 'def',
@@ -60150,13 +60305,13 @@
       if (!cap) {
         return;
       }
-      if (!/[:|]/.test(cap[2])) {
+      if (!this.rules.other.tableDelimiter.test(cap[2])) {
         // delimiter row must have a pipe (|) or colon (:) otherwise it is a setext heading
         return;
       }
       const headers = splitCells(cap[1]);
-      const aligns = cap[2].replace(/^\||\| *$/g, '').split('|');
-      const rows = cap[3] && cap[3].trim() ? cap[3].replace(/\n[ \t]*$/, '').split('\n') : [];
+      const aligns = cap[2].replace(this.rules.other.tableAlignChars, '').split('|');
+      const rows = cap[3]?.trim() ? cap[3].replace(this.rules.other.tableRowBlankLine, '').split('\n') : [];
       const item = {
         type: 'table',
         raw: cap[0],
@@ -60169,11 +60324,11 @@
         return;
       }
       for (const align of aligns) {
-        if (/^ *-+: *$/.test(align)) {
+        if (this.rules.other.tableAlignRight.test(align)) {
           item.align.push('right');
-        } else if (/^ *:-+: *$/.test(align)) {
+        } else if (this.rules.other.tableAlignCenter.test(align)) {
           item.align.push('center');
-        } else if (/^ *:-+ *$/.test(align)) {
+        } else if (this.rules.other.tableAlignLeft.test(align)) {
           item.align.push('left');
         } else {
           item.align.push(null);
@@ -60240,21 +60395,21 @@
         return {
           type: 'escape',
           raw: cap[0],
-          text: escape$1(cap[1])
+          text: cap[1]
         };
       }
     }
     tag(src) {
       const cap = this.rules.inline.tag.exec(src);
       if (cap) {
-        if (!this.lexer.state.inLink && /^<a /i.test(cap[0])) {
+        if (!this.lexer.state.inLink && this.rules.other.startATag.test(cap[0])) {
           this.lexer.state.inLink = true;
-        } else if (this.lexer.state.inLink && /^<\/a>/i.test(cap[0])) {
+        } else if (this.lexer.state.inLink && this.rules.other.endATag.test(cap[0])) {
           this.lexer.state.inLink = false;
         }
-        if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+        if (!this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(cap[0])) {
           this.lexer.state.inRawBlock = true;
-        } else if (this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+        } else if (this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(cap[0])) {
           this.lexer.state.inRawBlock = false;
         }
         return {
@@ -60271,9 +60426,9 @@
       const cap = this.rules.inline.link.exec(src);
       if (cap) {
         const trimmedUrl = cap[2].trim();
-        if (!this.options.pedantic && /^</.test(trimmedUrl)) {
+        if (!this.options.pedantic && this.rules.other.startAngleBracket.test(trimmedUrl)) {
           // commonmark requires matching angle brackets
-          if (!/>$/.test(trimmedUrl)) {
+          if (!this.rules.other.endAngleBracket.test(trimmedUrl)) {
             return;
           }
           // ending angle bracket cannot be escaped
@@ -60296,7 +60451,7 @@
         let title = '';
         if (this.options.pedantic) {
           // split pedantic href and title
-          const link = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
+          const link = this.rules.other.pedanticHrefTitle.exec(href);
           if (link) {
             href = link[1];
             title = link[3];
@@ -60305,8 +60460,8 @@
           title = cap[3] ? cap[3].slice(1, -1) : '';
         }
         href = href.trim();
-        if (/^</.test(href)) {
-          if (this.options.pedantic && !/>$/.test(trimmedUrl)) {
+        if (this.rules.other.startAngleBracket.test(href)) {
+          if (this.options.pedantic && !this.rules.other.endAngleBracket.test(trimmedUrl)) {
             // pedantic allows starting angle bracket without ending angle bracket
             href = href.slice(1);
           } else {
@@ -60316,13 +60471,13 @@
         return outputLink(cap, {
           href: href ? href.replace(this.rules.inline.anyPunctuation, '$1') : href,
           title: title ? title.replace(this.rules.inline.anyPunctuation, '$1') : title
-        }, cap[0], this.lexer);
+        }, cap[0], this.lexer, this.rules);
       }
     }
     reflink(src, links) {
       let cap;
       if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
-        const linkString = (cap[2] || cap[1]).replace(/\s+/g, ' ');
+        const linkString = (cap[2] || cap[1]).replace(this.rules.other.multipleSpaceGlobal, ' ');
         const link = links[linkString.toLowerCase()];
         if (!link) {
           const text = cap[0].charAt(0);
@@ -60332,14 +60487,14 @@
             text
           };
         }
-        return outputLink(cap, link, cap[0], this.lexer);
+        return outputLink(cap, link, cap[0], this.lexer, this.rules);
       }
     }
     emStrong(src, maskedSrc, prevChar = '') {
       let match = this.rules.inline.emStrongLDelim.exec(src);
       if (!match) return;
       // _ can't be between two alphanumerics. \p{L}\p{N} includes non-english alphabet/numbers as well
-      if (match[3] && prevChar.match(/[\p{L}\p{N}]/u)) return;
+      if (match[3] && prevChar.match(this.rules.other.unicodeAlphaNumeric)) return;
       const nextChar = match[1] || match[2] || '';
       if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
         // unicode Regex counts emoji as 1 char; spread into array for proper count (used multiple times below)
@@ -60398,13 +60553,12 @@
     codespan(src) {
       const cap = this.rules.inline.code.exec(src);
       if (cap) {
-        let text = cap[2].replace(/\n/g, ' ');
-        const hasNonSpaceChars = /[^ ]/.test(text);
-        const hasSpaceCharsOnBothEnds = /^ /.test(text) && / $/.test(text);
+        let text = cap[2].replace(this.rules.other.newLineCharGlobal, ' ');
+        const hasNonSpaceChars = this.rules.other.nonSpaceChar.test(text);
+        const hasSpaceCharsOnBothEnds = this.rules.other.startingSpaceChar.test(text) && this.rules.other.endingSpaceChar.test(text);
         if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
           text = text.substring(1, text.length - 1);
         }
-        text = escape$1(text, true);
         return {
           type: 'codespan',
           raw: cap[0],
@@ -60437,10 +60591,10 @@
       if (cap) {
         let text, href;
         if (cap[2] === '@') {
-          text = escape$1(cap[1]);
+          text = cap[1];
           href = 'mailto:' + text;
         } else {
-          text = escape$1(cap[1]);
+          text = cap[1];
           href = text;
         }
         return {
@@ -60461,7 +60615,7 @@
       if (cap = this.rules.inline.url.exec(src)) {
         let text, href;
         if (cap[2] === '@') {
-          text = escape$1(cap[0]);
+          text = cap[0];
           href = 'mailto:' + text;
         } else {
           // do extended autolink path validation
@@ -60470,7 +60624,7 @@
             prevCapZero = cap[0];
             cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? '';
           } while (prevCapZero !== cap[0]);
-          text = escape$1(cap[0]);
+          text = cap[0];
           if (cap[1] === 'www.') {
             href = 'http://' + cap[0];
           } else {
@@ -60493,221 +60647,17 @@
     inlineText(src) {
       const cap = this.rules.inline.text.exec(src);
       if (cap) {
-        let text;
-        if (this.lexer.state.inRawBlock) {
-          text = cap[0];
-        } else {
-          text = escape$1(cap[0]);
-        }
+        const escaped = this.lexer.state.inRawBlock;
         return {
           type: 'text',
           raw: cap[0],
-          text
+          text: cap[0],
+          escaped
         };
       }
     }
   }
 
-  /**
-   * Block-Level Grammar
-   */
-  const newline = /^(?:[ \t]*(?:\n|$))+/;
-  const blockCode = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
-  const fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
-  const hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
-  const heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
-  const bullet = /(?:[*+-]|\d{1,9}[.)])/;
-  const lheading = edit(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/).replace(/bull/g, bullet) // lists can interrupt
-  .replace(/blockCode/g, /(?: {4}| {0,3}\t)/) // indented code blocks can interrupt
-  .replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt
-  .replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt
-  .replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt
-  .replace(/html/g, / {0,3}<[^\n>]+>\n/) // block html can interrupt
-  .getRegex();
-  const _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
-  const blockText = /^[^\n]+/;
-  const _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
-  const def = edit(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace('label', _blockLabel).replace('title', /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
-  const list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bullet).getRegex();
-  const _tag = '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|h[1-6]|head|header|hr|html|iframe' + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option' + '|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title' + '|tr|track|ul';
-  const _comment = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
-  const html = edit('^ {0,3}(?:' // optional indentation
-  + '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
-  + '|comment[^\\n]*(\\n+|$)' // (2)
-  + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
-  + '|<![A-Z][\\s\\S]*?(?:>\\n*|$)' // (4)
-  + '|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)' // (5)
-  + '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (6)
-  + '|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (7) open tag
-  + '|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (7) closing tag
-  + ')', 'i').replace('comment', _comment).replace('tag', _tag).replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
-  const paragraph = edit(_paragraph).replace('hr', hr).replace('heading', ' {0,3}#{1,6}(?:\\s|$)').replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs
-  .replace('|table', '').replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
-  .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', _tag) // pars can be interrupted by type (6) html blocks
-  .getRegex();
-  const blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace('paragraph', paragraph).getRegex();
-  /**
-   * Normal Block Grammar
-   */
-  const blockNormal = {
-    blockquote,
-    code: blockCode,
-    def,
-    fences,
-    heading,
-    hr,
-    html,
-    lheading,
-    list,
-    newline,
-    paragraph,
-    table: noopTest,
-    text: blockText
-  };
-  /**
-   * GFM Block Grammar
-   */
-  const gfmTable = edit('^ *([^\\n ].*)\\n' // Header
-  + ' {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)' // Align
-  + '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)') // Cells
-  .replace('hr', hr).replace('heading', ' {0,3}#{1,6}(?:\\s|$)').replace('blockquote', ' {0,3}>').replace('code', '(?: {4}| {0,3}\t)[^\\n]').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
-  .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', _tag) // tables can be interrupted by type (6) html blocks
-  .getRegex();
-  const blockGfm = {
-    ...blockNormal,
-    table: gfmTable,
-    paragraph: edit(_paragraph).replace('hr', hr).replace('heading', ' {0,3}#{1,6}(?:\\s|$)').replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs
-    .replace('table', gfmTable) // interrupt paragraphs with table
-    .replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
-    .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', _tag) // pars can be interrupted by type (6) html blocks
-    .getRegex()
-  };
-  /**
-   * Pedantic grammar (original John Gruber's loose markdown specification)
-   */
-  const blockPedantic = {
-    ...blockNormal,
-    html: edit('^ *(?:comment *(?:\\n|\\s*$)' + '|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)' // closed tag
-    + '|<tag(?:"[^"]*"|\'[^\']*\'|\\s[^\'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))').replace('comment', _comment).replace(/tag/g, '(?!(?:' + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub' + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)' + '\\b)\\w+(?!:|[^\\w\\s@]*@)\\b').getRegex(),
-    def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
-    heading: /^(#{1,6})(.*)(?:\n+|$)/,
-    fences: noopTest,
-    // fences not supported
-    lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
-    paragraph: edit(_paragraph).replace('hr', hr).replace('heading', ' *#{1,6} *[^\n]').replace('lheading', lheading).replace('|table', '').replace('blockquote', ' {0,3}>').replace('|fences', '').replace('|list', '').replace('|html', '').replace('|tag', '').getRegex()
-  };
-  /**
-   * Inline-Level Grammar
-   */
-  const escape = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
-  const inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
-  const br = /^( {2,}|\\)\n(?!\s*$)/;
-  const inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
-  // list of unicode punctuation marks, plus any missing characters from CommonMark spec
-  const _punctuation = '\\p{P}\\p{S}';
-  const punctuation = edit(/^((?![*_])[\spunctuation])/, 'u').replace(/punctuation/g, _punctuation).getRegex();
-  // sequences em should skip over [title](link), `code`, <html>
-  const blockSkip = /\[[^[\]]*?\]\([^\(\)]*?\)|`[^`]*?`|<[^<>]*?>/g;
-  const emStrongLDelim = edit(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, 'u').replace(/punct/g, _punctuation).getRegex();
-  const emStrongRDelimAst = edit('^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)' // Skip orphan inside strong
-  + '|[^*]+(?=[^*])' // Consume to delim
-  + '|(?!\\*)[punct](\\*+)(?=[\\s]|$)' // (1) #*** can only be a Right Delimiter
-  + '|[^punct\\s](\\*+)(?!\\*)(?=[punct\\s]|$)' // (2) a***#, a*** can only be a Right Delimiter
-  + '|(?!\\*)[punct\\s](\\*+)(?=[^punct\\s])' // (3) #***a, ***a can only be Left Delimiter
-  + '|[\\s](\\*+)(?!\\*)(?=[punct])' // (4) ***# can only be Left Delimiter
-  + '|(?!\\*)[punct](\\*+)(?!\\*)(?=[punct])' // (5) #***# can be either Left or Right Delimiter
-  + '|[^punct\\s](\\*+)(?=[^punct\\s])', 'gu') // (6) a***a can be either Left or Right Delimiter
-  .replace(/punct/g, _punctuation).getRegex();
-  // (6) Not allowed for _
-  const emStrongRDelimUnd = edit('^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)' // Skip orphan inside strong
-  + '|[^_]+(?=[^_])' // Consume to delim
-  + '|(?!_)[punct](_+)(?=[\\s]|$)' // (1) #___ can only be a Right Delimiter
-  + '|[^punct\\s](_+)(?!_)(?=[punct\\s]|$)' // (2) a___#, a___ can only be a Right Delimiter
-  + '|(?!_)[punct\\s](_+)(?=[^punct\\s])' // (3) #___a, ___a can only be Left Delimiter
-  + '|[\\s](_+)(?!_)(?=[punct])' // (4) ___# can only be Left Delimiter
-  + '|(?!_)[punct](_+)(?!_)(?=[punct])', 'gu') // (5) #___# can be either Left or Right Delimiter
-  .replace(/punct/g, _punctuation).getRegex();
-  const anyPunctuation = edit(/\\([punct])/, 'gu').replace(/punct/g, _punctuation).getRegex();
-  const autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace('scheme', /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace('email', /[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])?)+(?![-_])/).getRegex();
-  const _inlineComment = edit(_comment).replace('(?:-->|$)', '-->').getRegex();
-  const tag = edit('^comment' + '|^</[a-zA-Z][\\w:-]*\\s*>' // self-closing tag
-  + '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
-  + '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g. <?php ?>
-  + '|^<![a-zA-Z]+\\s[\\s\\S]*?>' // declaration, e.g. <!DOCTYPE html>
-  + '|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>') // CDATA section
-  .replace('comment', _inlineComment).replace('attribute', /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
-  const _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
-  const link = edit(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace('label', _inlineLabel).replace('href', /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace('title', /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
-  const reflink = edit(/^!?\[(label)\]\[(ref)\]/).replace('label', _inlineLabel).replace('ref', _blockLabel).getRegex();
-  const nolink = edit(/^!?\[(ref)\](?:\[\])?/).replace('ref', _blockLabel).getRegex();
-  const reflinkSearch = edit('reflink|nolink(?!\\()', 'g').replace('reflink', reflink).replace('nolink', nolink).getRegex();
-  /**
-   * Normal Inline Grammar
-   */
-  const inlineNormal = {
-    _backpedal: noopTest,
-    // only used for GFM url
-    anyPunctuation,
-    autolink,
-    blockSkip,
-    br,
-    code: inlineCode,
-    del: noopTest,
-    emStrongLDelim,
-    emStrongRDelimAst,
-    emStrongRDelimUnd,
-    escape,
-    link,
-    nolink,
-    punctuation,
-    reflink,
-    reflinkSearch,
-    tag,
-    text: inlineText,
-    url: noopTest
-  };
-  /**
-   * Pedantic Inline Grammar
-   */
-  const inlinePedantic = {
-    ...inlineNormal,
-    link: edit(/^!?\[(label)\]\((.*?)\)/).replace('label', _inlineLabel).getRegex(),
-    reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace('label', _inlineLabel).getRegex()
-  };
-  /**
-   * GFM Inline Grammar
-   */
-  const inlineGfm = {
-    ...inlineNormal,
-    escape: edit(escape).replace('])', '~|])').getRegex(),
-    url: edit(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, 'i').replace('email', /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),
-    _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
-    del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
-    text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
-  };
-  /**
-   * GFM + Line Breaks Inline Grammar
-   */
-  const inlineBreaks = {
-    ...inlineGfm,
-    br: edit(br).replace('{2,}', '*').getRegex(),
-    text: edit(inlineGfm.text).replace('\\b_', '\\b_| {2,}\\n').replace(/\{2,\}/g, '*').getRegex()
-  };
-  /**
-   * exports
-   */
-  const block = {
-    normal: blockNormal,
-    gfm: blockGfm,
-    pedantic: blockPedantic
-  };
-  const inline = {
-    normal: inlineNormal,
-    gfm: inlineGfm,
-    breaks: inlineBreaks,
-    pedantic: inlinePedantic
-  };
-
   /**
    * Block Lexer
    */
@@ -60733,6 +60683,7 @@
         top: true
       };
       const rules = {
+        other,
         block: block.normal,
         inline: inline.normal
       };
@@ -60776,7 +60727,7 @@
      * Preprocessing
      */
     lex(src) {
-      src = src.replace(/\r\n|\r/g, '\n');
+      src = src.replace(other.carriageReturn, '\n');
       this.blockTokens(src, this.tokens);
       for (let i = 0; i < this.inlineQueue.length; i++) {
         const next = this.inlineQueue[i];
@@ -60787,13 +60738,11 @@
     }
     blockTokens(src, tokens = [], lastParagraphClipped = false) {
       if (this.options.pedantic) {
-        src = src.replace(/\t/g, '    ').replace(/^ +$/gm, '');
+        src = src.replace(other.tabCharGlobal, '    ').replace(other.spaceLine, '');
       }
-      let token;
-      let lastToken;
-      let cutSrc;
       while (src) {
-        if (this.options.extensions && this.options.extensions.block && this.options.extensions.block.some(extTokenizer => {
+        let token;
+        if (this.options.extensions?.block?.some(extTokenizer => {
           if (token = extTokenizer.call({
             lexer: this
           }, src, tokens)) {
@@ -60808,10 +60757,11 @@
         // newline
         if (token = this.tokenizer.space(src)) {
           src = src.substring(token.raw.length);
-          if (token.raw.length === 1 && tokens.length > 0) {
+          const lastToken = tokens.at(-1);
+          if (token.raw.length === 1 && lastToken !== undefined) {
             // if there's a single \n as a spacer, it's terminating the last line,
             // so move it there so that we don't get unnecessary paragraph tags
-            tokens[tokens.length - 1].raw += '\n';
+            lastToken.raw += '\n';
           } else {
             tokens.push(token);
           }
@@ -60820,12 +60770,12 @@
         // code
         if (token = this.tokenizer.code(src)) {
           src = src.substring(token.raw.length);
-          lastToken = tokens[tokens.length - 1];
+          const lastToken = tokens.at(-1);
           // An indented code block cannot interrupt a paragraph.
-          if (lastToken && (lastToken.type === 'paragraph' || lastToken.type === 'text')) {
+          if (lastToken?.type === 'paragraph' || lastToken?.type === 'text') {
             lastToken.raw += '\n' + token.raw;
             lastToken.text += '\n' + token.text;
-            this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+            this.inlineQueue.at(-1).src = lastToken.text;
           } else {
             tokens.push(token);
           }
@@ -60870,11 +60820,11 @@
         // def
         if (token = this.tokenizer.def(src)) {
           src = src.substring(token.raw.length);
-          lastToken = tokens[tokens.length - 1];
-          if (lastToken && (lastToken.type === 'paragraph' || lastToken.type === 'text')) {
+          const lastToken = tokens.at(-1);
+          if (lastToken?.type === 'paragraph' || lastToken?.type === 'text') {
             lastToken.raw += '\n' + token.raw;
             lastToken.text += '\n' + token.raw;
-            this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+            this.inlineQueue.at(-1).src = lastToken.text;
           } else if (!this.tokens.links[token.tag]) {
             this.tokens.links[token.tag] = {
               href: token.href,
@@ -60897,8 +60847,8 @@
         }
         // top-level paragraph
         // prevent paragraph consuming extensions by clipping 'src' to extension start
-        cutSrc = src;
-        if (this.options.extensions && this.options.extensions.startBlock) {
+        let cutSrc = src;
+        if (this.options.extensions?.startBlock) {
           let startIndex = Infinity;
           const tempSrc = src.slice(1);
           let tempStart;
@@ -60915,12 +60865,12 @@
           }
         }
         if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {
-          lastToken = tokens[tokens.length - 1];
+          const lastToken = tokens.at(-1);
           if (lastParagraphClipped && lastToken?.type === 'paragraph') {
             lastToken.raw += '\n' + token.raw;
             lastToken.text += '\n' + token.text;
             this.inlineQueue.pop();
-            this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+            this.inlineQueue.at(-1).src = lastToken.text;
           } else {
             tokens.push(token);
           }
@@ -60931,12 +60881,12 @@
         // text
         if (token = this.tokenizer.text(src)) {
           src = src.substring(token.raw.length);
-          lastToken = tokens[tokens.length - 1];
-          if (lastToken && lastToken.type === 'text') {
+          const lastToken = tokens.at(-1);
+          if (lastToken?.type === 'text') {
             lastToken.raw += '\n' + token.raw;
             lastToken.text += '\n' + token.text;
             this.inlineQueue.pop();
-            this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+            this.inlineQueue.at(-1).src = lastToken.text;
           } else {
             tokens.push(token);
           }
@@ -60966,11 +60916,9 @@
      * Lexing/Compiling
      */
     inlineTokens(src, tokens = []) {
-      let token, lastToken, cutSrc;
       // String with links masked to avoid interference with em and strong
       let maskedSrc = src;
-      let match;
-      let keepPrevChar, prevChar;
+      let match = null;
       // Mask out reflinks
       if (this.tokens.links) {
         const links = Object.keys(this.tokens.links);
@@ -60990,13 +60938,16 @@
       while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {
         maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
       }
+      let keepPrevChar = false;
+      let prevChar = '';
       while (src) {
         if (!keepPrevChar) {
           prevChar = '';
         }
         keepPrevChar = false;
+        let token;
         // extensions
-        if (this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some(extTokenizer => {
+        if (this.options.extensions?.inline?.some(extTokenizer => {
           if (token = extTokenizer.call({
             lexer: this
           }, src, tokens)) {
@@ -61017,13 +60968,7 @@
         // tag
         if (token = this.tokenizer.tag(src)) {
           src = src.substring(token.raw.length);
-          lastToken = tokens[tokens.length - 1];
-          if (lastToken && token.type === 'text' && lastToken.type === 'text') {
-            lastToken.raw += token.raw;
-            lastToken.text += token.text;
-          } else {
-            tokens.push(token);
-          }
+          tokens.push(token);
           continue;
         }
         // link
@@ -61035,8 +60980,8 @@
         // reflink, nolink
         if (token = this.tokenizer.reflink(src, this.tokens.links)) {
           src = src.substring(token.raw.length);
-          lastToken = tokens[tokens.length - 1];
-          if (lastToken && token.type === 'text' && lastToken.type === 'text') {
+          const lastToken = tokens.at(-1);
+          if (token.type === 'text' && lastToken?.type === 'text') {
             lastToken.raw += token.raw;
             lastToken.text += token.text;
           } else {
@@ -61082,8 +61027,8 @@
         }
         // text
         // prevent inlineText consuming extensions by clipping 'src' to extension start
-        cutSrc = src;
-        if (this.options.extensions && this.options.extensions.startInline) {
+        let cutSrc = src;
+        if (this.options.extensions?.startInline) {
           let startIndex = Infinity;
           const tempSrc = src.slice(1);
           let tempStart;
@@ -61106,8 +61051,8 @@
             prevChar = token.raw.slice(-1);
           }
           keepPrevChar = true;
-          lastToken = tokens[tokens.length - 1];
-          if (lastToken && lastToken.type === 'text') {
+          const lastToken = tokens.at(-1);
+          if (lastToken?.type === 'text') {
             lastToken.raw += token.raw;
             lastToken.text += token.text;
           } else {
@@ -61146,12 +61091,12 @@
       lang,
       escaped
     }) {
-      const langString = (lang || '').match(/^\S*/)?.[0];
-      const code = text.replace(/\n$/, '') + '\n';
+      const langString = (lang || '').match(other.notSpaceStart)?.[0];
+      const code = text.replace(other.endingNewline, '') + '\n';
       if (!langString) {
-        return '<pre><code>' + (escaped ? code : escape$1(code, true)) + '</code></pre>\n';
+        return '<pre><code>' + (escaped ? code : escape(code, true)) + '</code></pre>\n';
       }
-      return '<pre><code class="language-' + escape$1(langString) + '">' + (escaped ? code : escape$1(code, true)) + '</code></pre>\n';
+      return '<pre><code class="language-' + escape(langString) + '">' + (escaped ? code : escape(code, true)) + '</code></pre>\n';
     }
     blockquote({
       tokens
@@ -61192,16 +61137,18 @@
           checked: !!item.checked
         });
         if (item.loose) {
-          if (item.tokens.length > 0 && item.tokens[0].type === 'paragraph') {
+          if (item.tokens[0]?.type === 'paragraph') {
             item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;
             if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {
-              item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;
+              item.tokens[0].tokens[0].text = checkbox + ' ' + escape(item.tokens[0].tokens[0].text);
+              item.tokens[0].tokens[0].escaped = true;
             }
           } else {
             item.tokens.unshift({
               type: 'text',
               raw: checkbox + ' ',
-              text: checkbox + ' '
+              text: checkbox + ' ',
+              escaped: true
             });
           }
         } else {
@@ -61272,7 +61219,7 @@
     codespan({
       text
     }) {
-      return `<code>${text}</code>`;
+      return `<code>${escape(text, true)}</code>`;
     }
     br(token) {
       return '<br>';
@@ -61295,7 +61242,7 @@
       href = cleanHref;
       let out = '<a href="' + href + '"';
       if (title) {
-        out += ' title="' + title + '"';
+        out += ' title="' + escape(title) + '"';
       }
       out += '>' + text + '</a>';
       return out;
@@ -61307,18 +61254,18 @@
     }) {
       const cleanHref = cleanUrl(href);
       if (cleanHref === null) {
-        return text;
+        return escape(text);
       }
       href = cleanHref;
       let out = `<img src="${href}" alt="${text}"`;
       if (title) {
-        out += ` title="${title}"`;
+        out += ` title="${escape(title)}"`;
       }
       out += '>';
       return out;
     }
     text(token) {
-      return 'tokens' in token && token.tokens ? this.parser.parseInline(token.tokens) : token.text;
+      return 'tokens' in token && token.tokens ? this.parser.parseInline(token.tokens) : 'escaped' in token && token.escaped ? token.text : escape(token.text);
     }
   }
 
@@ -61410,7 +61357,7 @@
       for (let i = 0; i < tokens.length; i++) {
         const anyToken = tokens[i];
         // Run any renderer extensions
-        if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[anyToken.type]) {
+        if (this.options.extensions?.renderers?.[anyToken.type]) {
           const genericToken = anyToken;
           const ret = this.options.extensions.renderers[genericToken.type].call({
             parser: this
@@ -61483,7 +61430,8 @@
                   tokens: [{
                     type: 'text',
                     raw: body,
-                    text: body
+                    text: body,
+                    escaped: true
                   }]
                 });
               } else {
@@ -61508,13 +61456,12 @@
     /**
      * Parse Inline Tokens
      */
-    parseInline(tokens, renderer) {
-      renderer = renderer || this.renderer;
+    parseInline(tokens, renderer = this.renderer) {
       let out = '';
       for (let i = 0; i < tokens.length; i++) {
         const anyToken = tokens[i];
         // Run any renderer extensions
-        if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[anyToken.type]) {
+        if (this.options.extensions?.renderers?.[anyToken.type]) {
           const ret = this.options.extensions.renderers[anyToken.type].call({
             parser: this
           }, anyToken);
@@ -61932,7 +61879,7 @@
       return e => {
         e.message += '\nPlease report this to https://github.com/markedjs/marked.';
         if (silent) {
-          const msg = '<p>An error occurred:</p><pre>' + escape$1(e.message + '', true) + '</pre>';
+          const msg = '<p>An error occurred:</p><pre>' + escape(e.message + '', true) + '</pre>';
           if (async) {
             return Promise.resolve(msg);
           }
@@ -73389,11 +73336,11 @@
   var sortOrderedTabbables = function sortOrderedTabbables(a, b) {
     return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
   };
-  var isInput$1 = function isInput(node) {
+  var isInput = function isInput(node) {
     return node.tagName === 'INPUT';
   };
   var isHiddenInput = function isHiddenInput(node) {
-    return isInput$1(node) && node.type === 'hidden';
+    return isInput(node) && node.type === 'hidden';
   };
   var isDetailsWithSummary = function isDetailsWithSummary(node) {
     var r = node.tagName === 'DETAILS' && Array.prototype.slice.apply(node.children).some(function (child) {
@@ -73432,7 +73379,7 @@
     return !checked || checked === node;
   };
   var isRadio = function isRadio(node) {
-    return isInput$1(node) && node.type === 'radio';
+    return isInput(node) && node.type === 'radio';
   };
   var isNonTabbableRadio = function isNonTabbableRadio(node) {
     return isRadio(node) && !isTabbableRadio(node);
@@ -77805,13 +77752,17 @@
         ref.current.focus();
       }
     }, [selection, field]);
-    function onClick(event) {
-      event.stopPropagation();
-      selection.toggle(field);
-
-      // properly focus on field
-      ref.current.focus();
-    }
+    const onClick = T$2(event => {
+      // TODO(nikku): refactor this to use proper DOM delegation
+      const fieldEl = event.target.closest('[data-id]');
+      if (!fieldEl) {
+        return;
+      }
+      const id = fieldEl.dataset.id;
+      if (id === field.id) {
+        selection.toggle(field);
+      }
+    }, [field, selection]);
     const isSelected = selection.isSelected(field);
     const classString = F$1(() => {
       const classes = [];
@@ -78202,6 +78153,34 @@
         container,
         compact = false
       } = renderConfig;
+      eventBus.on('form.init', function () {
+        // emit <canvas.init> so dependent components can hook in
+        // this is required to register keyboard bindings
+        eventBus.fire('canvas.init', {
+          svg: container,
+          viewport: null
+        });
+      });
+
+      // focus container on over if no selection
+      container.addEventListener('mouseover', function () {
+        if (document.activeElement === document.body) {
+          container.focus({
+            preventScroll: true
+          });
+        }
+      });
+
+      // ensure we focus the container if the users clicks
+      // inside; this follows input focus handling closely
+      container.addEventListener('click', function (event) {
+        // force focus when clicking container
+        if (!container.contains(document.activeElement)) {
+          container.focus({
+            preventScroll: true
+          });
+        }
+      });
       const App = () => {
         const [state, setState] = h(formEditor._getState());
         const formEditorContext = {
@@ -78632,8 +78611,8 @@
 
   var KEYDOWN_EVENT = 'keyboard.keydown',
     KEYUP_EVENT = 'keyboard.keyup';
-  var HANDLE_MODIFIER_ATTRIBUTE = 'input-handle-modified-keys';
   var DEFAULT_PRIORITY$2 = 1000;
+  var compatMessage = 'Keyboard binding is now implicit; explicit binding to an element got removed. For more information, see https://github.com/bpmn-io/diagram-js/issues/661';
 
   /**
    * A keyboard abstraction that may be activated and
@@ -78653,16 +78632,16 @@
    *
    * All events contain one field which is node.
    *
-   * A default binding for the keyboard may be specified via the
-   * `keyboard.bindTo` configuration option.
+   * Specify the initial keyboard binding state via the
+   * `keyboard.bind=true|false` configuration option.
    *
    * @param {Object} config
-   * @param {EventTarget} [config.bindTo]
+   * @param {boolean} [config.bind]
    * @param {EventBus} eventBus
    */
   function Keyboard(config, eventBus) {
     var self = this;
-    this._config = config || {};
+    this._config = config = config || {};
     this._eventBus = eventBus;
     this._keydownHandler = this._keydownHandler.bind(this);
     this._keyupHandler = this._keyupHandler.bind(this);
@@ -78672,16 +78651,16 @@
       self._fire('destroy');
       self.unbind();
     });
-    eventBus.on('diagram.init', function () {
-      self._fire('init');
-    });
-    eventBus.on('attach', function () {
-      if (config && config.bindTo) {
-        self.bind(config.bindTo);
+    if (config.bindTo) {
+      console.error('unsupported configuration <keyboard.bindTo>', new Error(compatMessage));
+    }
+    var bind = config && config.bind !== false;
+    eventBus.on('canvas.init', function (event) {
+      self._target = event.svg;
+      if (bind) {
+        self.bind();
       }
-    });
-    eventBus.on('detach', function () {
-      self.unbind();
+      self._fire('init');
     });
   }
   Keyboard.$inject = ['config.keyboard', 'eventBus'];
@@ -78705,35 +78684,29 @@
     }
   };
   Keyboard.prototype._isEventIgnored = function (event) {
-    if (event.defaultPrevented) {
-      return true;
-    }
-    return (isInput(event.target) || isButton(event.target) && isKey([' ', 'Enter'], event)) && this._isModifiedKeyIgnored(event);
-  };
-  Keyboard.prototype._isModifiedKeyIgnored = function (event) {
-    if (!isCmd(event)) {
-      return true;
-    }
-    var allowedModifiers = this._getAllowedModifiers(event.target);
-    return allowedModifiers.indexOf(event.key) === -1;
-  };
-  Keyboard.prototype._getAllowedModifiers = function (element) {
-    var modifierContainer = closest(element, '[' + HANDLE_MODIFIER_ATTRIBUTE + ']');
-    if (!modifierContainer || this._node && !this._node.contains(modifierContainer)) {
-      return [];
-    }
-    return modifierContainer.getAttribute(HANDLE_MODIFIER_ATTRIBUTE).split(',');
+    return false;
   };
 
   /**
    * Bind keyboard events to the given DOM node.
    *
+   * @overlord
+   * @deprecated No longer in use since version 15.0.0.
+   *
    * @param {EventTarget} node
    */
+  /**
+   * Bind keyboard events to the canvas node.
+   */
   Keyboard.prototype.bind = function (node) {
+    // legacy <node> argument provided
+    if (node) {
+      console.error('unsupported argument <node>', new Error(compatMessage));
+    }
+
     // make sure that the keyboard is only bound once to the DOM
     this.unbind();
-    this._node = node;
+    node = this._node = this._target;
 
     // bind key events
     event.bind(node, 'keydown', this._keydownHandler);
@@ -78799,15 +78772,6 @@
   Keyboard.prototype.isCmd = isCmd;
   Keyboard.prototype.isShift = isShift;
   Keyboard.prototype.isKey = isKey;
-
-  // helpers ///////
-
-  function isInput(target) {
-    return target && (matches$2(target, 'input, textarea') || target.contentEditable === 'true');
-  }
-  function isButton(target) {
-    return target && matches$2(target, 'button, input[type=submit], input[type=button], a[href], [aria-role=button]');
-  }
   var LOW_PRIORITY$1 = 500;
 
   /**
@@ -78970,7 +78934,7 @@
         const {
           keyEvent
         } = context;
-        if (isCmd(keyEvent) && !isShift(keyEvent) && isKey(KEYS_UNDO, keyEvent)) {
+        if (isUndo(keyEvent)) {
           editorActions.trigger('undo');
           return true;
         }
@@ -78983,7 +78947,7 @@
         const {
           keyEvent
         } = context;
-        if (isCmd(keyEvent) && (isKey(KEYS_REDO, keyEvent) || isKey(KEYS_UNDO, keyEvent) && isShift(keyEvent))) {
+        if (isRedo(keyEvent)) {
           editorActions.trigger('redo');
           return true;
         }
@@ -80771,6 +80735,21 @@
     width: "16",
     height: "16"
   };
+  var CloseIcon = function CloseIcon(props) {
+    return o("svg", {
+      ...props,
+      children: o("path", {
+        fillRule: "evenodd",
+        d: "m12 4.7-.7-.7L8 7.3 4.7 4l-.7.7L7.3 8 4 11.3l.7.7L8 8.7l3.3 3.3.7-.7L8.7 8 12 4.7Z",
+        fill: "currentColor"
+      })
+    });
+  };
+  CloseIcon.defaultProps = {
+    xmlns: "http://www.w3.org/2000/svg",
+    width: "16",
+    height: "16"
+  };
   var CreateIcon = function CreateIcon(props) {
     return o("svg", {
       ...props,
@@ -80858,26 +80837,17 @@
     fill: "none",
     xmlns: "http://www.w3.org/2000/svg"
   };
-  var HelpIcon = function HelpIcon(props) {
+  var LaunchIcon = function LaunchIcon(props) {
     return o("svg", {
       ...props,
       children: [o("path", {
-        d: "M16 2a14 14 0 1 0 14 14A14 14 0 0 0 16 2Zm0 26a12 12 0 1 1 12-12 12 12 0 0 1-12 12Z"
-      }), o("circle", {
-        cx: "16",
-        cy: "23.5",
-        r: "1.5"
-      }), o("path", {
-        d: "M17 8h-1.5a4.49 4.49 0 0 0-4.5 4.5v.5h2v-.5a2.5 2.5 0 0 1 2.5-2.5H17a2.5 2.5 0 0 1 0 5h-2v4.5h2V17a4.5 4.5 0 0 0 0-9Z"
+        d: "M26 28H6a2.003 2.003 0 0 1-2-2V6a2.003 2.003 0 0 1 2-2h10v2H6v20h20V16h2v10a2.003 2.003 0 0 1-2 2Z"
       }), o("path", {
-        style: {
-          fill: "none"
-        },
-        d: "M0 0h32v32H0z"
+        d: "M20 2v2h6.586L18 12.586 19.414 14 28 5.414V12h2V2H20z"
       })]
     });
   };
-  HelpIcon.defaultProps = {
+  LaunchIcon.defaultProps = {
     xmlns: "http://www.w3.org/2000/svg",
     viewBox: "0 0 32 32"
   };
@@ -80899,21 +80869,6 @@
     height: "16",
     viewBox: "0 0 32 32"
   };
-  var CloseIcon = function CloseIcon(props) {
-    return o("svg", {
-      ...props,
-      children: o("path", {
-        fillRule: "evenodd",
-        d: "m12 4.7-.7-.7L8 7.3 4.7 4l-.7.7L7.3 8 4 11.3l.7.7L8 8.7l3.3 3.3.7-.7L8.7 8 12 4.7Z",
-        fill: "currentColor"
-      })
-    });
-  };
-  CloseIcon.defaultProps = {
-    xmlns: "http://www.w3.org/2000/svg",
-    width: "16",
-    height: "16"
-  };
   function Header(props) {
     const {
       element,
@@ -80952,7 +80907,7 @@
       }), o("div", {
         class: "bio-properties-panel-header-actions",
         children: documentationRef ? o("a", {
-          rel: "noopener",
+          rel: "noreferrer",
           class: "bio-properties-panel-header-link",
           href: documentationRef,
           title: "Open documentation",
@@ -80970,19 +80925,19 @@
     errors: {}
   });
 
-  /**
-   * @typedef {Function} <propertiesPanel.showEntry> callback
-   *
-   * @example
-   *
-   * useEvent('propertiesPanel.showEntry', ({ focus = false, ...rest }) => {
-   *   // ...
-   * });
-   *
-   * @param {Object} context
-   * @param {boolean} [context.focus]
-   *
-   * @returns void
+  /**
+   * @typedef {Function} <propertiesPanel.showEntry> callback
+   *
+   * @example
+   *
+   * useEvent('propertiesPanel.showEntry', ({ focus = false, ...rest }) => {
+   *   // ...
+   * });
+   *
+   * @param {Object} context
+   * @param {boolean} [context.focus]
+   *
+   * @returns void
    */
 
   const EventContext = G({
@@ -80999,20 +80954,20 @@
     getTooltipForId: () => {}
   });
 
-  /**
-   * Accesses the global TooltipContext and returns a tooltip for a given id and element.
-   *
-   * @example
-   * ```jsx
-   * function TextField(props) {
-   *   const tooltip = useTooltipContext('input1', element);
-   * }
-   * ```
-   *
-   * @param {string} id
-   * @param {object} element
-   *
-   * @returns {string}
+  /**
+   * Accesses the global TooltipContext and returns a tooltip for a given id and element.
+   *
+   * @example
+   * ```jsx
+   * function TextField(props) {
+   *   const tooltip = useTooltipContext('input1', element);
+   * }
+   * ```
+   *
+   * @param {string} id
+   * @param {object} element
+   *
+   * @returns {string}
    */
   function useTooltipContext(id, element) {
     const {
@@ -81164,20 +81119,20 @@
     return `bio-properties-panel-${id}`;
   }
 
-  /**
-   * Accesses the global DescriptionContext and returns a description for a given id and element.
-   *
-   * @example
-   * ```jsx
-   * function TextField(props) {
-   *   const description = useDescriptionContext('input1', element);
-   * }
-   * ```
-   *
-   * @param {string} id
-   * @param {object} element
-   *
-   * @returns {string}
+  /**
+   * Accesses the global DescriptionContext and returns a description for a given id and element.
+   *
+   * @example
+   * ```jsx
+   * function TextField(props) {
+   *   const description = useDescriptionContext('input1', element);
+   * }
+   * ```
+   *
+   * @param {string} id
+   * @param {object} element
+   *
+   * @returns {string}
    */
   function useDescriptionContext(id, element) {
     const {
@@ -81198,11 +81153,11 @@
     return errors;
   }
 
-  /**
-   * Subscribe to an event immediately. Update subscription after inputs changed.
-   *
-   * @param {string} event
-   * @param {Function} callback
+  /**
+   * Subscribe to an event immediately. Update subscription after inputs changed.
+   *
+   * @param {string} event
+   * @param {Function} callback
    */
   function useEvent(event, callback, eventBus) {
     const eventContext = q$1(EventContext);
@@ -81232,20 +81187,20 @@
     }, [callback, event, eventBus]);
   }
 
-  /**
-   * Creates a state that persists in the global LayoutContext.
-   *
-   * @example
-   * ```jsx
-   * function Group(props) {
-   *   const [ open, setOpen ] = useLayoutState([ 'groups', 'foo', 'open' ], false);
-   * }
-   * ```
-   *
-   * @param {(string|number)[]} path
-   * @param {any} [defaultValue]
-   *
-   * @returns {[ any, Function ]}
+  /**
+   * Creates a state that persists in the global LayoutContext.
+   *
+   * @example
+   * ```jsx
+   * function Group(props) {
+   *   const [ open, setOpen ] = useLayoutState([ 'groups', 'foo', 'open' ], false);
+   * }
+   * ```
+   *
+   * @param {(string|number)[]} path
+   * @param {any} [defaultValue]
+   *
+   * @returns {[ any, Function ]}
    */
   function useLayoutState(path, defaultValue) {
     const {
@@ -81259,11 +81214,11 @@
     return [layoutForKey, setState];
   }
 
-  /**
-   * @pinussilvestrus: we need to introduce our own hook to persist the previous
-   * state on updates.
-   *
-   * cf. https://reactjs.org/docs/hooks-faq.html#how-to-get-the-previous-props-or-state
+  /**
+   * @pinussilvestrus: we need to introduce our own hook to persist the previous
+   * state on updates.
+   *
+   * cf. https://reactjs.org/docs/hooks-faq.html#how-to-get-the-previous-props-or-state
    */
 
   function usePrevious(value) {
@@ -81274,12 +81229,12 @@
     return ref.current;
   }
 
-  /**
-   * Subscribe to `propertiesPanel.showEntry`.
-   *
-   * @param {string} id
-   *
-   * @returns {import('preact').Ref}
+  /**
+   * Subscribe to `propertiesPanel.showEntry`.
+   *
+   * @param {string} id
+   *
+   * @returns {import('preact').Ref}
    */
   function useShowEntryEvent(id) {
     const {
@@ -81310,20 +81265,20 @@
     return ref;
   }
 
-  /**
-   * @callback setSticky
-   * @param {boolean} value
+  /**
+   * @callback setSticky
+   * @param {boolean} value
    */
 
-  /**
-   * Use IntersectionObserver to identify when DOM element is in sticky mode.
-   * If sticky is observered setSticky(true) will be called.
-   * If sticky mode is left, setSticky(false) will be called.
-   *
-   *
-   * @param {Object} ref
-   * @param {string} scrollContainerSelector
-   * @param {setSticky} setSticky
+  /**
+   * Use IntersectionObserver to identify when DOM element is in sticky mode.
+   * If sticky is observered setSticky(true) will be called.
+   * If sticky mode is left, setSticky(false) will be called.
+   *
+   *
+   * @param {Object} ref
+   * @param {string} scrollContainerSelector
+   * @param {setSticky} setSticky
    */
   function useStickyIntersectionObserver(ref, scrollContainerSelector, setSticky) {
     const [scrollContainer, setScrollContainer] = h(query(scrollContainerSelector));
@@ -81377,19 +81332,19 @@
     }, [ref.current, scrollContainer, setSticky]);
   }
 
-  /**
-   * Creates a static function reference with changing body.
-   * This is necessary when external libraries require a callback function
-   * that has references to state variables.
-   *
-   * Usage:
-   * const callback = useStaticCallback((val) => {val === currentState});
-   *
-   * The `callback` reference is static and can be safely used in external
-   * libraries or as a prop that does not cause rerendering of children.
-   *
-   * @param {Function} callback function with changing reference
-   * @returns {Function} static function reference
+  /**
+   * Creates a static function reference with changing body.
+   * This is necessary when external libraries require a callback function
+   * that has references to state variables.
+   *
+   * Usage:
+   * const callback = useStaticCallback((val) => {val === currentState});
+   *
+   * The `callback` reference is static and can be safely used in external
+   * libraries or as a prop that does not cause rerendering of children.
+   *
+   * @param {Function} callback function with changing reference
+   * @returns {Function} static function reference
    */
   function useStaticCallback(callback) {
     const callbackRef = _$1(callback);
@@ -81530,13 +81485,13 @@
     return null;
   }
 
-  /**
-   * @typedef { {
-   *  text: (element: object) => string,
-   *  icon?: (element: Object) => import('preact').Component
-   * } } PlaceholderDefinition
-   *
-   * @param { PlaceholderDefinition } props
+  /**
+   * @typedef { {
+   *  text: (element: object) => string,
+   *  icon?: (element: Object) => import('preact').Component
+   * } } PlaceholderDefinition
+   *
+   * @param { PlaceholderDefinition } props
    */
   function Placeholder(props) {
     const {
@@ -81573,9 +81528,9 @@
   }
   const noop$6 = () => {};
 
-  /**
-   * Buffer `.focus()` calls while the editor is not initialized.
-   * Set Focus inside when the editor is ready.
+  /**
+   * Buffer `.focus()` calls while the editor is not initialized.
+   * Set Focus inside when the editor is ready.
    */
   const useBufferedFocus$1 = function (editor, ref) {
     const [buffer, setBuffer] = h(undefined);
@@ -81675,9 +81630,9 @@
   });
   const noop$5 = () => {};
 
-  /**
-   * Buffer `.focus()` calls while the editor is not initialized.
-   * Set Focus inside when the editor is ready.
+  /**
+   * Buffer `.focus()` calls while the editor is not initialized.
+   * Set Focus inside when the editor is ready.
    */
   const useBufferedFocus = function (editor, ref) {
     const [buffer, setBuffer] = h(undefined);
@@ -81726,10 +81681,10 @@
     p(() => {
       let editor;
 
-      /* Trigger FEEL toggle when
-       *
-       * - `backspace` is pressed
-       * - AND the cursor is at the beginning of the input
+      /* Trigger FEEL toggle when
+       *
+       * - `backspace` is pressed
+       * - AND the cursor is at the beginning of the input
        */
       const onKeyDown = e => {
         if (e.key !== 'Backspace' || !editor) {
@@ -81818,10 +81773,10 @@
   }
   const noop$4 = () => {};
 
-  /**
-   * @param {Object} props
-   * @param {Object} props.label
-   * @param {String} props.feel
+  /**
+   * @param {Object} props
+   * @param {Object} props.label
+   * @param {String} props.feel
    */
   function FeelIcon(props) {
     const {
@@ -81855,22 +81810,22 @@
     source: null
   });
 
-  /**
-   * Add a dragger that calls back the passed function with
-   * { event, delta } on drag.
-   *
-   * @example
-   *
-   * function dragMove(event, delta) {
-   *   // we are dragging (!!)
-   * }
-   *
-   * domElement.addEventListener('dragstart', dragger(dragMove));
-   *
-   * @param {Function} fn
-   * @param {Element} [dragPreview]
-   *
-   * @return {Function} drag start callback function
+  /**
+   * Add a dragger that calls back the passed function with
+   * { event, delta } on drag.
+   *
+   * @example
+   *
+   * function dragMove(event, delta) {
+   *   // we are dragging (!!)
+   * }
+   *
+   * domElement.addEventListener('dragstart', dragger(dragMove));
+   *
+   * @param {Function} fn
+   * @param {Element} [dragPreview]
+   *
+   * @return {Function} drag start callback function
    */
   function createDragger(fn, dragPreview) {
     let self;
@@ -81924,23 +81879,23 @@
   }
   const noop$3 = () => {};
 
-  /**
-   * A generic popup component.
-   *
-   * @param {Object} props
-   * @param {HTMLElement} [props.container]
-   * @param {string} [props.className]
-   * @param {boolean} [props.delayInitialFocus]
-   * @param {{x: number, y: number}} [props.position]
-   * @param {number} [props.width]
-   * @param {number} [props.height]
-   * @param {Function} props.onClose
-   * @param {Function} [props.onPostActivate]
-   * @param {Function} [props.onPostDeactivate]
-   * @param {boolean} [props.returnFocus]
-   * @param {boolean} [props.closeOnEscape]
-   * @param {string} props.title
-   * @param {Ref} [ref]
+  /**
+   * A generic popup component.
+   *
+   * @param {Object} props
+   * @param {HTMLElement} [props.container]
+   * @param {string} [props.className]
+   * @param {boolean} [props.delayInitialFocus]
+   * @param {{x: number, y: number}} [props.position]
+   * @param {number} [props.width]
+   * @param {number} [props.height]
+   * @param {Function} props.onClose
+   * @param {Function} [props.onPostActivate]
+   * @param {Function} [props.onPostDeactivate]
+   * @param {boolean} [props.returnFocus]
+   * @param {boolean} [props.closeOnEscape]
+   * @param {string} props.title
+   * @param {Ref} [ref]
    */
   function PopupComponent(props, globalRef) {
     const {
@@ -82158,12 +82113,12 @@
   const FEEL_POPUP_WIDTH = 700;
   const FEEL_POPUP_HEIGHT = 250;
 
-  /**
-   * FEEL popup component, built as a singleton. Emits lifecycle events as follows:
-   *  - `feelPopup.open` - fired before the popup is mounted
-   *  - `feelPopup.opened` - fired after the popup is mounted. Event context contains the DOM node of the popup
-   *  - `feelPopup.close` - fired before the popup is unmounted. Event context contains the DOM node of the popup
-   *  - `feelPopup.closed` - fired after the popup is unmounted
+  /**
+   * FEEL popup component, built as a singleton. Emits lifecycle events as follows:
+   *  - `feelPopup.open` - fired before the popup is mounted
+   *  - `feelPopup.opened` - fired after the popup is mounted. Event context contains the DOM node of the popup
+   *  - `feelPopup.close` - fired before the popup is unmounted. Event context contains the DOM node of the popup
+   *  - `feelPopup.closed` - fired after the popup is unmounted
    */
   function FEELPopupRoot(props) {
     const {
@@ -82173,7 +82128,8 @@
         on() {},
         off() {}
       },
-      popupContainer
+      popupContainer,
+      getPopupLinks = () => []
     } = props;
     const prevElement = usePrevious(element);
     const [popupConfig, setPopupConfig] = h({});
@@ -82248,6 +82204,7 @@
       children: [open && o(FeelPopupComponent, {
         onClose: handleClose,
         container: popupContainer,
+        getLinks: getPopupLinks,
         sourceElement: sourceElement,
         emit: emit,
         ...popupConfig
@@ -82257,6 +82214,7 @@
   function FeelPopupComponent(props) {
     const {
       container,
+      getLinks,
       id,
       hostLanguage,
       onInput,
@@ -82334,17 +82292,17 @@
         closeButtonTooltip: "Save and close",
         onClose: onClose,
         draggable: true,
-        children: [type === 'feel' && o("a", {
-          href: "https://docs.camunda.io/docs/components/modeler/feel/what-is-feel/",
-          target: "_blank",
-          class: "bio-properties-panel-feel-popup__title-link",
-          children: ["Learn FEEL expressions", o(HelpIcon, {})]
-        }), type === 'feelers' && o("a", {
-          href: "https://docs.camunda.io/docs/components/modeler/forms/configuration/forms-config-templating-syntax/",
-          target: "_blank",
-          class: "bio-properties-panel-feel-popup__title-link",
-          children: ["Learn templating", o(HelpIcon, {})]
-        })]
+        children: o(k$2, {
+          children: getLinks(type).map((link, index) => {
+            return o("a", {
+              rel: "noreferrer",
+              href: link.href,
+              target: "_blank",
+              class: "bio-properties-panel-feel-popup__title-link",
+              children: [link.title, o(LaunchIcon, {})]
+            }, index);
+          })
+        })
       }), o(Popup.Body, {
         children: o("div", {
           onKeyDownCapture: onKeyDownCapture,
@@ -82387,11 +82345,11 @@
     return element.closest('.cm-editor').querySelector('.cm-tooltip-autocomplete');
   }
 
-  /**
-   * This hook behaves like useEffect, but does not trigger on the first render.
-   *
-   * @param {Function} effect
-   * @param {Array} deps
+  /**
+   * This hook behaves like useEffect, but does not trigger on the first render.
+   *
+   * @param {Function} effect
+   * @param {Array} deps
    */
   function useUpdateEffect(effect, deps) {
     const isMounted = _$1(false);
@@ -82468,19 +82426,19 @@
     });
   }
 
-  /**
-   * @param {Object} props
-   * @param {Object} props.element
-   * @param {String} props.id
-   * @param {String} props.description
-   * @param {String} props.label
-   * @param {String} props.switcherLabel
-   * @param {Boolean} props.inline
-   * @param {Function} props.getValue
-   * @param {Function} props.setValue
-   * @param {Function} props.onFocus
-   * @param {Function} props.onBlur
-   * @param {string|import('preact').Component} props.tooltip
+  /**
+   * @param {Object} props
+   * @param {Object} props.element
+   * @param {String} props.id
+   * @param {String} props.description
+   * @param {String} props.label
+   * @param {String} props.switcherLabel
+   * @param {Boolean} props.inline
+   * @param {Function} props.getValue
+   * @param {Function} props.setValue
+   * @param {Function} props.onFocus
+   * @param {Function} props.onBlur
+   * @param {string|import('preact').Component} props.tooltip
    */
   function ToggleSwitchEntry(props) {
     const {
@@ -82587,22 +82545,22 @@
     });
   }
 
-  /**
-   * @param {Object} props
-   * @param {Boolean} props.debounce
-   * @param {String} props.description
-   * @param {Boolean} props.disabled
-   * @param {Object} props.element
-   * @param {Function} props.getValue
-   * @param {String} props.id
-   * @param {String} props.label
-   * @param {String} props.max
-   * @param {String} props.min
-   * @param {Function} props.setValue
-   * @param {Function} props.onFocus
-   * @param {Function} props.onBlur
-   * @param {String} props.step
-   * @param {Function} props.validate
+  /**
+   * @param {Object} props
+   * @param {Boolean} props.debounce
+   * @param {String} props.description
+   * @param {Boolean} props.disabled
+   * @param {Object} props.element
+   * @param {Function} props.getValue
+   * @param {String} props.id
+   * @param {String} props.label
+   * @param {String} props.max
+   * @param {String} props.min
+   * @param {Function} props.setValue
+   * @param {Function} props.onFocus
+   * @param {Function} props.onBlur
+   * @param {String} props.step
+   * @param {Function} props.validate
    */
   function NumberFieldEntry(props) {
     const {
@@ -83087,26 +83045,26 @@
     });
   });
 
-  /**
-   * @param {Object} props
-   * @param {Object} props.element
-   * @param {String} props.id
-   * @param {String} props.description
-   * @param {Boolean} props.debounce
-   * @param {Boolean} props.disabled
-   * @param {Boolean} props.feel
-   * @param {String} props.label
-   * @param {Function} props.getValue
-   * @param {Function} props.setValue
-   * @param {Function} props.tooltipContainer
-   * @param {Function} props.validate
-   * @param {Function} props.show
-   * @param {Function} props.example
-   * @param {Function} props.variables
-   * @param {Function} props.onFocus
-   * @param {Function} props.onBlur
-   * @param {string} [props.placeholder]
-   * @param {string|import('preact').Component} props.tooltip
+  /**
+   * @param {Object} props
+   * @param {Object} props.element
+   * @param {String} props.id
+   * @param {String} props.description
+   * @param {Boolean} props.debounce
+   * @param {Boolean} props.disabled
+   * @param {Boolean} props.feel
+   * @param {String} props.label
+   * @param {Function} props.getValue
+   * @param {Function} props.setValue
+   * @param {Function} props.tooltipContainer
+   * @param {Function} props.validate
+   * @param {Function} props.show
+   * @param {Function} props.example
+   * @param {Function} props.variables
+   * @param {Function} props.onFocus
+   * @param {Function} props.onBlur
+   * @param {string} [props.placeholder]
+   * @param {string|import('preact').Component} props.tooltip
    */
   function FeelEntry(props) {
     const {
@@ -83193,27 +83151,27 @@
     });
   }
 
-  /**
-   * @param {Object} props
-   * @param {Object} props.element
-   * @param {String} props.id
-   * @param {String} props.description
-   * @param {Boolean} props.debounce
-   * @param {Boolean} props.disabled
-   * @param {String} props.max
-   * @param {String} props.min
-   * @param {String} props.step
-   * @param {Boolean} props.feel
-   * @param {String} props.label
-   * @param {Function} props.getValue
-   * @param {Function} props.setValue
-   * @param {Function} props.tooltipContainer
-   * @param {Function} props.validate
-   * @param {Function} props.show
-   * @param {Function} props.example
-   * @param {Function} props.variables
-   * @param {Function} props.onFocus
-   * @param {Function} props.onBlur
+  /**
+   * @param {Object} props
+   * @param {Object} props.element
+   * @param {String} props.id
+   * @param {String} props.description
+   * @param {Boolean} props.debounce
+   * @param {Boolean} props.disabled
+   * @param {String} props.max
+   * @param {String} props.min
+   * @param {String} props.step
+   * @param {Boolean} props.feel
+   * @param {String} props.label
+   * @param {Function} props.getValue
+   * @param {Function} props.setValue
+   * @param {Function} props.tooltipContainer
+   * @param {Function} props.validate
+   * @param {Function} props.show
+   * @param {Function} props.example
+   * @param {Function} props.variables
+   * @param {Function} props.onFocus
+   * @param {Function} props.onBlur
    */
   function FeelNumberEntry(props) {
     return o(FeelEntry, {
@@ -83223,24 +83181,24 @@
     });
   }
 
-  /**
-   * @param {Object} props
-   * @param {Object} props.element
-   * @param {String} props.id
-   * @param {String} props.description
-   * @param {Boolean} props.debounce
-   * @param {Boolean} props.disabled
-   * @param {Boolean} props.feel
-   * @param {String} props.label
-   * @param {Function} props.getValue
-   * @param {Function} props.setValue
-   * @param {Function} props.tooltipContainer
-   * @param {Function} props.validate
-   * @param {Function} props.show
-   * @param {Function} props.example
-   * @param {Function} props.variables
-   * @param {Function} props.onFocus
-   * @param {Function} props.onBlur
+  /**
+   * @param {Object} props
+   * @param {Object} props.element
+   * @param {String} props.id
+   * @param {String} props.description
+   * @param {Boolean} props.debounce
+   * @param {Boolean} props.disabled
+   * @param {Boolean} props.feel
+   * @param {String} props.label
+   * @param {Function} props.getValue
+   * @param {Function} props.setValue
+   * @param {Function} props.tooltipContainer
+   * @param {Function} props.validate
+   * @param {Function} props.show
+   * @param {Function} props.example
+   * @param {Function} props.variables
+   * @param {Function} props.onFocus
+   * @param {Function} props.onBlur
    */
   function FeelToggleSwitchEntry(props) {
     return o(FeelEntry, {
@@ -83250,26 +83208,26 @@
     });
   }
 
-  /**
-   * @param {Object} props
-   * @param {Object} props.element
-   * @param {String} props.id
-   * @param {String} props.description
-   * @param {String} props.hostLanguage
-   * @param {Boolean} props.singleLine
-   * @param {Boolean} props.debounce
-   * @param {Boolean} props.disabled
-   * @param {Boolean} props.feel
-   * @param {String} props.label
-   * @param {Function} props.getValue
-   * @param {Function} props.setValue
-   * @param {Function} props.tooltipContainer
-   * @param {Function} props.validate
-   * @param {Function} props.show
-   * @param {Function} props.example
-   * @param {Function} props.variables
-   * @param {Function} props.onFocus
-   * @param {Function} props.onBlur
+  /**
+   * @param {Object} props
+   * @param {Object} props.element
+   * @param {String} props.id
+   * @param {String} props.description
+   * @param {String} props.hostLanguage
+   * @param {Boolean} props.singleLine
+   * @param {Boolean} props.debounce
+   * @param {Boolean} props.disabled
+   * @param {Boolean} props.feel
+   * @param {String} props.label
+   * @param {Function} props.getValue
+   * @param {Function} props.setValue
+   * @param {Function} props.tooltipContainer
+   * @param {Function} props.validate
+   * @param {Function} props.show
+   * @param {Function} props.example
+   * @param {Function} props.variables
+   * @param {Function} props.onFocus
+   * @param {Function} props.onBlur
    */
   function FeelTemplatingEntry(props) {
     return o(FeelEntry, {
@@ -83337,84 +83295,85 @@
   const DEFAULT_DESCRIPTION = {};
   const DEFAULT_TOOLTIP = {};
 
-  /**
-   * @typedef { {
-   *    component: import('preact').Component,
-   *    id: String,
-   *    isEdited?: Function
-   * } } EntryDefinition
-   *
-   * @typedef { {
-   *    autoFocusEntry: String,
-   *    autoOpen?: Boolean,
-   *    entries: Array<EntryDefinition>,
-   *    id: String,
-   *    label: String,
-   *    remove: (event: MouseEvent) => void
-   * } } ListItemDefinition
-   *
-   * @typedef { {
-   *    add: (event: MouseEvent) => void,
-   *    component: import('preact').Component,
-   *    element: Object,
-   *    id: String,
-   *    items: Array<ListItemDefinition>,
-   *    label: String,
-   *    shouldOpen?: Boolean
-   * } } ListGroupDefinition
-   *
-   * @typedef { {
-   *    component?: import('preact').Component,
-   *    entries: Array<EntryDefinition>,
-   *    id: String,
-   *    label: String,
-   *    shouldOpen?: Boolean
-   * } } GroupDefinition
-   *
-   *  @typedef { {
-   *    [id: String]: GetDescriptionFunction
-   * } } DescriptionConfig
-   *
-   *  @typedef { {
-   *    [id: String]: GetTooltipFunction
-   * } } TooltipConfig
-   *
-   * @callback { {
-   * @param {string} id
-   * @param {Object} element
-   * @returns {string}
-   * } } GetDescriptionFunction
-   *
-   * @callback { {
-   * @param {string} id
-   * @param {Object} element
-   * @returns {string}
-   * } } GetTooltipFunction
-   *
-   * @typedef { {
-   *  getEmpty: (element: object) => import('./components/Placeholder').PlaceholderDefinition,
-   *  getMultiple: (element: Object) => import('./components/Placeholder').PlaceholderDefinition
-   * } } PlaceholderProvider
-   *
+  /**
+   * @typedef { {
+   *    component: import('preact').Component,
+   *    id: String,
+   *    isEdited?: Function
+   * } } EntryDefinition
+   *
+   * @typedef { {
+   *    autoFocusEntry: String,
+   *    autoOpen?: Boolean,
+   *    entries: Array<EntryDefinition>,
+   *    id: String,
+   *    label: String,
+   *    remove: (event: MouseEvent) => void
+   * } } ListItemDefinition
+   *
+   * @typedef { {
+   *    add: (event: MouseEvent) => void,
+   *    component: import('preact').Component,
+   *    element: Object,
+   *    id: String,
+   *    items: Array<ListItemDefinition>,
+   *    label: String,
+   *    shouldOpen?: Boolean
+   * } } ListGroupDefinition
+   *
+   * @typedef { {
+   *    component?: import('preact').Component,
+   *    entries: Array<EntryDefinition>,
+   *    id: String,
+   *    label: String,
+   *    shouldOpen?: Boolean
+   * } } GroupDefinition
+   *
+   *  @typedef { {
+   *    [id: String]: GetDescriptionFunction
+   * } } DescriptionConfig
+   *
+   *  @typedef { {
+   *    [id: String]: GetTooltipFunction
+   * } } TooltipConfig
+   *
+   * @callback { {
+   * @param {string} id
+   * @param {Object} element
+   * @returns {string}
+   * } } GetDescriptionFunction
+   *
+   * @callback { {
+   * @param {string} id
+   * @param {Object} element
+   * @returns {string}
+   * } } GetTooltipFunction
+   *
+   * @typedef { {
+   *  getEmpty: (element: object) => import('./components/Placeholder').PlaceholderDefinition,
+   *  getMultiple: (element: Object) => import('./components/Placeholder').PlaceholderDefinition
+   * } } PlaceholderProvider
+   *
    */
 
-  /**
-   * A basic properties panel component. Describes *how* content will be rendered, accepts
-   * data from implementor to describe *what* will be rendered.
-   *
-   * @param {Object} props
-   * @param {Object|Array} props.element
-   * @param {import('./components/Header').HeaderProvider} props.headerProvider
-   * @param {PlaceholderProvider} [props.placeholderProvider]
-   * @param {Array<GroupDefinition|ListGroupDefinition>} props.groups
-   * @param {Object} [props.layoutConfig]
-   * @param {Function} [props.layoutChanged]
-   * @param {DescriptionConfig} [props.descriptionConfig]
-   * @param {Function} [props.descriptionLoaded]
-   * @param {TooltipConfig} [props.tooltipConfig]
-   * @param {Function} [props.tooltipLoaded]
-   * @param {HTMLElement} [props.feelPopupContainer]
-   * @param {Object} [props.eventBus]
+  /**
+   * A basic properties panel component. Describes *how* content will be rendered, accepts
+   * data from implementor to describe *what* will be rendered.
+   *
+   * @param {Object} props
+   * @param {Object|Array} props.element
+   * @param {import('./components/Header').HeaderProvider} props.headerProvider
+   * @param {PlaceholderProvider} [props.placeholderProvider]
+   * @param {Array<GroupDefinition|ListGroupDefinition>} props.groups
+   * @param {Object} [props.layoutConfig]
+   * @param {Function} [props.layoutChanged]
+   * @param {DescriptionConfig} [props.descriptionConfig]
+   * @param {Function} [props.descriptionLoaded]
+   * @param {TooltipConfig} [props.tooltipConfig]
+   * @param {Function} [props.tooltipLoaded]
+   * @param {HTMLElement} [props.feelPopupContainer]
+   * @param {Function} [props.getFeelPopupLinks]
+   * @param {Object} [props.eventBus]
    */
   function PropertiesPanel$1(props) {
     const {
@@ -83429,6 +83388,7 @@
       tooltipConfig,
       tooltipLoaded,
       feelPopupContainer,
+      getFeelPopupLinks,
       eventBus
     } = props;
 
@@ -83533,6 +83493,7 @@
                   element: element,
                   eventBus: eventBus,
                   popupContainer: feelPopupContainer,
+                  getPopupLinks: getFeelPopupLinks,
                   children: o("div", {
                     class: "bio-properties-panel",
                     children: [o(Header, {
@@ -83585,11 +83546,11 @@
 
   // hooks //////////////////
 
-  /**
-   * This hook behaves like useLayoutEffect, but does not trigger on the first render.
-   *
-   * @param {Function} effect
-   * @param {Array} deps
+  /**
+   * This hook behaves like useLayoutEffect, but does not trigger on the first render.
+   *
+   * @param {Function} effect
+   * @param {Array} deps
    */
   function useUpdateLayoutEffect(effect, deps) {
     const isMounted = _$1(false);
@@ -83602,20 +83563,20 @@
     }, deps);
   }
 
-  /**
-   * @typedef { {
-   *   [key: string]: string;
-   * } } TranslateReplacements
+  /**
+   * @typedef { {
+   *   [key: string]: string;
+   * } } TranslateReplacements
    */
 
-  /**
-   * A simple translation stub to be used for multi-language support.
-   * Can be easily replaced with a more sophisticated solution.
-   *
-   * @param {string} template to interpolate
-   * @param {TranslateReplacements} [replacements] a map with substitutes
-   *
-   * @return {string} the translated string
+  /**
+   * A simple translation stub to be used for multi-language support.
+   * Can be easily replaced with a more sophisticated solution.
+   *
+   * @param {string} template to interpolate
+   * @param {TranslateReplacements} [replacements] a map with substitutes
+   *
+   * @return {string} the translated string
    */
   function translateFallback(template, replacements) {
     replacements = replacements || {};
@@ -83724,8 +83685,8 @@
   }
   const noop$1 = () => {};
 
-  /**
-   * @param {import('../PropertiesPanel').ListGroupDefinition} props
+  /**
+   * @param {import('../PropertiesPanel').ListGroupDefinition} props
    */
   function ListGroup(props) {
     const {
@@ -83916,18 +83877,18 @@
     });
   }
 
-  /**
-   * @param {Object} props
-   * @param {Object} props.element
-   * @param {String} props.id
-   * @param {String} props.description
-   * @param {String} props.label
-   * @param {Function} props.getValue
-   * @param {Function} props.setValue
-   * @param {Function} props.onFocus
-   * @param {Function} props.onBlur
-   * @param {string|import('preact').Component} props.tooltip
-   * @param {boolean} [props.disabled]
+  /**
+   * @param {Object} props
+   * @param {Object} props.element
+   * @param {String} props.id
+   * @param {String} props.description
+   * @param {String} props.label
+   * @param {Function} props.getValue
+   * @param {Function} props.setValue
+   * @param {Function} props.onFocus
+   * @param {Function} props.onBlur
+   * @param {string|import('preact').Component} props.tooltip
+   * @param {boolean} [props.disabled]
    */
   function CheckboxEntry(props) {
     const {
@@ -84047,20 +84008,20 @@
     });
   }
 
-  /**
-   * @param {object} props
-   * @param {object} props.element
-   * @param {string} props.id
-   * @param {string} [props.description]
-   * @param {string} props.label
-   * @param {Function} props.getValue
-   * @param {Function} props.setValue
-   * @param {Function} props.onFocus
-   * @param {Function} props.onBlur
-   * @param {Function} props.getOptions
-   * @param {boolean} [props.disabled]
-   * @param {Function} [props.validate]
-   * @param {string|import('preact').Component} props.tooltip
+  /**
+   * @param {object} props
+   * @param {object} props.element
+   * @param {string} props.id
+   * @param {string} [props.description]
+   * @param {string} props.label
+   * @param {Function} props.getValue
+   * @param {Function} props.setValue
+   * @param {Function} props.onFocus
+   * @param {Function} props.onBlur
+   * @param {Function} props.getOptions
+   * @param {boolean} [props.disabled]
+   * @param {Function} [props.validate]
+   * @param {string|import('preact').Component} props.tooltip
    */
   function SelectEntry(props) {
     const {
@@ -84351,20 +84312,20 @@
     });
   }
 
-  /**
-   * @param {Object} props
-   * @param {Object} props.element
-   * @param {String} props.id
-   * @param {String} props.description
-   * @param {Boolean} props.debounce
-   * @param {Boolean} props.disabled
-   * @param {String} props.label
-   * @param {Function} props.getValue
-   * @param {Function} props.setValue
-   * @param {Function} props.onFocus
-   * @param {Function} props.onBlur
-   * @param {string|import('preact').Component} props.tooltip
-   * @param {Function} props.validate
+  /**
+   * @param {Object} props
+   * @param {Object} props.element
+   * @param {String} props.id
+   * @param {String} props.description
+   * @param {Boolean} props.debounce
+   * @param {Boolean} props.disabled
+   * @param {String} props.label
+   * @param {Function} props.getValue
+   * @param {Function} props.setValue
+   * @param {Function} props.onFocus
+   * @param {Function} props.onBlur
+   * @param {string|import('preact').Component} props.tooltip
+   * @param {Function} props.validate
    */
   function TextfieldEntry(props) {
     const {
@@ -84439,20 +84400,20 @@
       this._eventBus = eventBus;
     }
 
-    /**
-     * Check if the FEEL popup is open.
-     * @return {Boolean}
+    /**
+     * Check if the FEEL popup is open.
+     * @return {Boolean}
      */
     isOpen() {
       return this._eventBus.fire('feelPopup._isOpen');
     }
 
-    /**
-     * Open the FEEL popup.
-     *
-     * @param {String} entryId
-     * @param {Object} popupConfig
-     * @param {HTMLElement} sourceElement
+    /**
+     * Open the FEEL popup.
+     *
+     * @param {String} entryId
+     * @param {Object} popupConfig
+     * @param {HTMLElement} sourceElement
      */
     open(entryId, popupConfig, sourceElement) {
       return this._eventBus.fire('feelPopup._open', {
@@ -84462,8 +84423,8 @@
       });
     }
 
-    /**
-     * Close the FEEL popup.
+    /**
+     * Close the FEEL popup.
      */
     close() {
       return this._eventBus.fire('feelPopup._close');
@@ -88999,7 +88960,7 @@
        * @type {Element}
        */
       this._container = createFormContainer();
-      this._container.setAttribute('input-handle-modified-keys', 'z,y');
+      this._container.setAttribute('tabindex', '0');
       const {
         container,
         exporter,