@uiw/react-md-editor 3.20.8 → 3.20.10

package/dist/mdeditor.js

@@ -17389,6 +17389,8 @@ __webpack_require__.d(__webpack_exports__, {
   "group": () => (/* reexport */ group),
   "hr": () => (/* reexport */ hr),
   "image": () => (/* reexport */ commands_image_image),
+  "insertAtLineStart": () => (/* reexport */ insertAtLineStart),
+  "insertTextAtPosition": () => (/* reexport */ insertTextAtPosition),
   "italic": () => (/* reexport */ italic),
   "link": () => (/* reexport */ commands_link_link),
   "orderedListCommand": () => (/* reexport */ orderedListCommand),
@@ -17406,7 +17408,7 @@ __webpack_require__.d(__webpack_exports__, {
   "unorderedListCommand": () => (/* reexport */ unorderedListCommand)
 });
 
-// NAMESPACE OBJECT: ../node_modules/micromark/lib/constructs.js
+// NAMESPACE OBJECT: ../node_modules/react-markdown/node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
 __webpack_require__.d(constructs_namespaceObject, {
@@ -17659,7 +17661,7 @@ function _extends() {
 }
 // EXTERNAL MODULE: ../node_modules/is-buffer/index.js
 var is_buffer = __webpack_require__(5372);
-;// CONCATENATED MODULE: ../node_modules/unist-util-stringify-position/lib/index.js
+;// CONCATENATED MODULE: ../node_modules/vfile-message/node_modules/unist-util-stringify-position/lib/index.js
 /**
  * @typedef {import('unist').Node} Node
  * @typedef {import('unist').Point} Point
@@ -19836,7 +19838,7 @@ function looksLikeAVFileValue(value) {
   return typeof value === 'string' || is_buffer(value)
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-string/lib/index.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/mdast-util-to-string/lib/index.js
 /**
  * @typedef {import('mdast').Root|import('mdast').Content} Node
  *
@@ -20390,7 +20392,7 @@ function factorySpace(effects, ok, type, max) {
   }
 }
 
-;// CONCATENATED MODULE: ../node_modules/micromark/lib/initialize/content.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/micromark/lib/initialize/content.js
 /**
  * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
  * @typedef {import('micromark-util-types').Initializer} Initializer
@@ -20471,7 +20473,7 @@ function initializeContent(effects) {
   }
 }
 
-;// CONCATENATED MODULE: ../node_modules/micromark/lib/initialize/document.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/micromark/lib/initialize/document.js
 /**
  * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
  * @typedef {import('micromark-util-types').Initializer} Initializer
@@ -21246,7 +21248,7 @@ function tokenizeContinuation(effects, ok, nok) {
   }
 }
 
-;// CONCATENATED MODULE: ../node_modules/micromark/lib/initialize/flow.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/micromark/lib/initialize/flow.js
 /**
  * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
  * @typedef {import('micromark-util-types').Initializer} Initializer
@@ -21313,7 +21315,7 @@ function initializeFlow(effects) {
   }
 }
 
-;// CONCATENATED MODULE: ../node_modules/micromark/lib/initialize/text.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/micromark/lib/initialize/text.js
 /**
  * @typedef {import('micromark-util-types').Resolver} Resolver
  * @typedef {import('micromark-util-types').Initializer} Initializer
@@ -21565,7 +21567,7 @@ function resolveAll(constructs, events, context) {
   return events
 }
 
-;// CONCATENATED MODULE: ../node_modules/micromark/lib/create-tokenizer.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/micromark/lib/create-tokenizer.js
 /**
  * @typedef {import('micromark-util-types').Code} Code
  * @typedef {import('micromark-util-types').Chunk} Chunk
@@ -26170,7 +26172,7 @@ function tokenizeCodeText(effects, ok, nok) {
   }
 }
 
-;// CONCATENATED MODULE: ../node_modules/micromark/lib/constructs.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/micromark/lib/constructs.js
 /**
  * @typedef {import('micromark-util-types').Extension} Extension
  */
@@ -26256,7 +26258,7 @@ const disable = {
   null: []
 }
 
-;// CONCATENATED MODULE: ../node_modules/micromark/lib/parse.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/micromark/lib/parse.js
 /**
  * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
  * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension
@@ -26310,7 +26312,7 @@ function parse_parse(options = {}) {
   }
 }
 
-;// CONCATENATED MODULE: ../node_modules/micromark/lib/preprocess.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/micromark/lib/preprocess.js
 /**
  * @typedef {import('micromark-util-types').Encoding} Encoding
  * @typedef {import('micromark-util-types').Value} Value
@@ -26441,7 +26443,7 @@ function preprocess() {
   }
 }
 
-;// CONCATENATED MODULE: ../node_modules/micromark/lib/postprocess.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/micromark/lib/postprocess.js
 /**
  * @typedef {import('micromark-util-types').Event} Event
  */
@@ -26533,7 +26535,93 @@ function decode($0, $1, $2) {
   return decodeNamedCharacterReference($2) || $0
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-from-markdown/lib/index.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/unist-util-stringify-position/lib/index.js
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Point} Point
+ * @typedef {import('unist').Position} Position
+ */
+
+/**
+ * @typedef NodeLike
+ * @property {string} type
+ * @property {PositionLike | null | undefined} [position]
+ *
+ * @typedef PositionLike
+ * @property {PointLike | null | undefined} [start]
+ * @property {PointLike | null | undefined} [end]
+ *
+ * @typedef PointLike
+ * @property {number | null | undefined} [line]
+ * @property {number | null | undefined} [column]
+ * @property {number | null | undefined} [offset]
+ */
+
+/**
+ * Serialize the positional info of a point, position (start and end points),
+ * or node.
+ *
+ * @param {Node | NodeLike | Position | PositionLike | Point | PointLike | null | undefined} [value]
+ *   Node, position, or point.
+ * @returns {string}
+ *   Pretty printed positional info of a node (`string`).
+ *
+ *   In the format of a range `ls:cs-le:ce` (when given `node` or `position`)
+ *   or a point `l:c` (when given `point`), where `l` stands for line, `c` for
+ *   column, `s` for `start`, and `e` for end.
+ *   An empty string (`''`) is returned if the given value is neither `node`,
+ *   `position`, nor `point`.
+ */
+function lib_stringifyPosition(value) {
+  // Nothing.
+  if (!value || typeof value !== 'object') {
+    return ''
+  }
+
+  // Node.
+  if ('position' in value || 'type' in value) {
+    return lib_position(value.position)
+  }
+
+  // Position.
+  if ('start' in value || 'end' in value) {
+    return lib_position(value)
+  }
+
+  // Point.
+  if ('line' in value || 'column' in value) {
+    return lib_point(value)
+  }
+
+  // ?
+  return ''
+}
+
+/**
+ * @param {Point | PointLike | null | undefined} point
+ * @returns {string}
+ */
+function lib_point(point) {
+  return lib_index(point && point.line) + ':' + lib_index(point && point.column)
+}
+
+/**
+ * @param {Position | PositionLike | null | undefined} pos
+ * @returns {string}
+ */
+function lib_position(pos) {
+  return lib_point(pos && pos.start) + '-' + lib_point(pos && pos.end)
+}
+
+/**
+ * @param {number | null | undefined} value
+ * @returns {number}
+ */
+function lib_index(value) {
+  return value && typeof value === 'number' ? value : 1
+}
+
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/mdast-util-from-markdown/lib/index.js
 /**
  * @typedef {import('micromark-util-types').Encoding} Encoding
  * @typedef {import('micromark-util-types').Event} Event
@@ -26907,7 +26995,7 @@ function compiler(options) {
 
     // Figure out `root` position.
     tree.position = {
-      start: lib_point(
+      start: mdast_util_from_markdown_lib_point(
         events.length > 0
           ? events[0][1].start
           : {
@@ -26916,7 +27004,7 @@ function compiler(options) {
               offset: 0
             }
       ),
-      end: lib_point(
+      end: mdast_util_from_markdown_lib_point(
         events.length > 0
           ? events[events.length - 2][1].end
           : {
@@ -27154,7 +27242,7 @@ function compiler(options) {
     this.tokenStack.push([token, errorHandler])
     // @ts-expect-error: `end` will be patched later.
     node.position = {
-      start: lib_point(token.start)
+      start: mdast_util_from_markdown_lib_point(token.start)
     }
     return node
   }
@@ -27199,7 +27287,7 @@ function compiler(options) {
         'Cannot close `' +
           token.type +
           '` (' +
-          stringifyPosition({
+          lib_stringifyPosition({
             start: token.start,
             end: token.end
           }) +
@@ -27213,7 +27301,7 @@ function compiler(options) {
         handler.call(this, token, open[0])
       }
     }
-    node.position.end = lib_point(token.end)
+    node.position.end = mdast_util_from_markdown_lib_point(token.end)
     return node
   }
 
@@ -27384,7 +27472,7 @@ function compiler(options) {
       tail = text()
       // @ts-expect-error: we’ll add `end` later.
       tail.position = {
-        start: lib_point(token.start)
+        start: mdast_util_from_markdown_lib_point(token.start)
       }
       // @ts-expect-error: Assume `parent` accepts `text`.
       node.children.push(tail)
@@ -27400,7 +27488,7 @@ function compiler(options) {
   function onexitdata(token) {
     const tail = this.stack.pop()
     tail.value += this.sliceSerialize(token)
-    tail.position.end = lib_point(token.end)
+    tail.position.end = mdast_util_from_markdown_lib_point(token.end)
   }
 
   /**
@@ -27413,7 +27501,7 @@ function compiler(options) {
     // If we’re at a hard break, include the line ending in there.
     if (getData('atHardBreak')) {
       const tail = context.children[context.children.length - 1]
-      tail.position.end = lib_point(token.end)
+      tail.position.end = mdast_util_from_markdown_lib_point(token.end)
       setData('atHardBreak')
       return
     }
@@ -27650,7 +27738,7 @@ function compiler(options) {
     }
     const tail = this.stack.pop()
     tail.value += value
-    tail.position.end = lib_point(token.end)
+    tail.position.end = mdast_util_from_markdown_lib_point(token.end)
   }
 
   /**
@@ -27836,7 +27924,7 @@ function compiler(options) {
  * @returns {Point}
  *   unist point.
  */
-function lib_point(d) {
+function mdast_util_from_markdown_lib_point(d) {
   return {
     line: d.line,
     column: d.column,
@@ -27898,14 +27986,14 @@ function defaultOnError(left, right) {
       'Cannot close `' +
         left.type +
         '` (' +
-        stringifyPosition({
+        lib_stringifyPosition({
           start: left.start,
           end: left.end
         }) +
         '): a different token (`' +
         right.type +
         '`, ' +
-        stringifyPosition({
+        lib_stringifyPosition({
           start: right.start,
           end: right.end
         }) +
@@ -27916,7 +28004,7 @@ function defaultOnError(left, right) {
       'Cannot close document, a token (`' +
         right.type +
         '`, ' +
-        stringifyPosition({
+        lib_stringifyPosition({
           start: right.start,
           end: right.end
         }) +
@@ -27925,7 +28013,7 @@ function defaultOnError(left, right) {
   }
 }
 
-;// CONCATENATED MODULE: ../node_modules/remark-parse/lib/index.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/remark-parse/lib/index.js
 /**
  * @typedef {import('mdast').Root} Root
  * @typedef {import('mdast-util-from-markdown').Options} Options
@@ -27955,7 +28043,7 @@ function remarkParse(options) {
   Object.assign(this, {Parser: parser})
 }
 
-;// CONCATENATED MODULE: ../node_modules/remark-parse/index.js
+;// CONCATENATED MODULE: ../node_modules/react-markdown/node_modules/remark-parse/index.js
 
 
 /* harmony default export */ const remark_parse = (remarkParse);
@@ -28992,7 +29080,7 @@ const pointEnd = unist_util_position_lib_point('end')
  * @returns {Position}
  *   Position.
  */
-function lib_position(node) {
+function unist_util_position_lib_position(node) {
   return {start: pointStart(node), end: pointEnd(node)}
 }
 
@@ -30719,7 +30807,7 @@ function createState(tree, options) {
  *   Nothing.
  */
 function patch(from, to) {
-  if (from.position) to.position = lib_position(from)
+  if (from.position) to.position = unist_util_position_lib_position(from)
 }
 
 /**
@@ -33348,17 +33436,19 @@ ReactMarkdown.propTypes = {
 
 ;// CONCATENATED MODULE: ../node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js
 /**
- * @typedef {import('micromark-util-types').Extension} Extension
+ * @typedef {import('micromark-util-types').Code} Code
  * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
- * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').Extension} Extension
  * @typedef {import('micromark-util-types').Previous} Previous
  * @typedef {import('micromark-util-types').State} State
- * @typedef {import('micromark-util-types').Event} Event
- * @typedef {import('micromark-util-types').Code} Code
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
  */
 
-const www = {
-  tokenize: tokenizeWww,
+
+const wwwPrefix = {
+  tokenize: tokenizeWwwPrefix,
   partial: true
 }
 const domain = {
@@ -33369,546 +33459,886 @@ const syntax_path = {
   tokenize: tokenizePath,
   partial: true
 }
-const punctuation = {
-  tokenize: tokenizePunctuation,
+const trail = {
+  tokenize: tokenizeTrail,
   partial: true
 }
-const namedCharacterReference = {
-  tokenize: tokenizeNamedCharacterReference,
+const emailDomainDotTrail = {
+  tokenize: tokenizeEmailDomainDotTrail,
   partial: true
 }
 const wwwAutolink = {
   tokenize: tokenizeWwwAutolink,
   previous: previousWww
 }
-const httpAutolink = {
-  tokenize: tokenizeHttpAutolink,
-  previous: previousHttp
+const protocolAutolink = {
+  tokenize: tokenizeProtocolAutolink,
+  previous: previousProtocol
 }
 const emailAutolink = {
   tokenize: tokenizeEmailAutolink,
   previous: previousEmail
 }
-/** @type {ConstructRecord} */
 
+/** @type {ConstructRecord} */
 const syntax_text = {}
-/** @type {Extension} */
 
+// To do: next major: expose functions that yields extension.
+
+/**
+ * Extension for `micromark` that can be passed in `extensions` to enable GFM
+ * autolink literal syntax.
+ *
+ * @type {Extension}
+ */
 const gfmAutolinkLiteral = {
   text: syntax_text
 }
-let syntax_code = 48 // Add alphanumerics.
+let syntax_code = 48
 
+// Add alphanumerics.
 while (syntax_code < 123) {
   syntax_text[syntax_code] = emailAutolink
   syntax_code++
   if (syntax_code === 58) syntax_code = 65
   else if (syntax_code === 91) syntax_code = 97
 }
-
 syntax_text[43] = emailAutolink
 syntax_text[45] = emailAutolink
 syntax_text[46] = emailAutolink
 syntax_text[95] = emailAutolink
-syntax_text[72] = [emailAutolink, httpAutolink]
-syntax_text[104] = [emailAutolink, httpAutolink]
+syntax_text[72] = [emailAutolink, protocolAutolink]
+syntax_text[104] = [emailAutolink, protocolAutolink]
 syntax_text[87] = [emailAutolink, wwwAutolink]
 syntax_text[119] = [emailAutolink, wwwAutolink]
-/** @type {Tokenizer} */
 
+// To do: perform email autolink literals on events, afterwards.
+// That’s where `markdown-rs` and `cmark-gfm` perform it.
+// It should look for `@`, then for atext backwards, and then for a label
+// forwards.
+// To do: `mailto:`, `xmpp:` protocol as prefix.
+
+/**
+ * Email autolink literal.
+ *
+ * ```markdown
+ * > | a contact@example.org b
+ *       ^^^^^^^^^^^^^^^^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
 function tokenizeEmailAutolink(effects, ok, nok) {
   const self = this
+  /** @type {boolean | undefined} */
+  let dot
   /** @type {boolean} */
-
-  let hasDot
-  /** @type {boolean|undefined} */
-
-  let hasDigitInLastSegment
+  let data
   return start
-  /** @type {State} */
 
+  /**
+   * Start of email autolink literal.
+   *
+   * ```markdown
+   * > | a contact@example.org b
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
   function start(code) {
     if (
       !gfmAtext(code) ||
-      !previousEmail(self.previous) ||
+      !previousEmail.call(self, self.previous) ||
       previousUnbalanced(self.events)
     ) {
       return nok(code)
     }
-
     effects.enter('literalAutolink')
     effects.enter('literalAutolinkEmail')
     return atext(code)
   }
-  /** @type {State} */
 
+  /**
+   * In email atext.
+   *
+   * ```markdown
+   * > | a contact@example.org b
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
   function atext(code) {
     if (gfmAtext(code)) {
       effects.consume(code)
       return atext
     }
-
     if (code === 64) {
       effects.consume(code)
-      return label
+      return emailDomain
     }
-
     return nok(code)
   }
-  /** @type {State} */
 
-  function label(code) {
+  /**
+   * In email domain.
+   *
+   * The reference code is a bit overly complex as it handles the `@`, of which
+   * there may be just one.
+   * Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L318>
+   *
+   * ```markdown
+   * > | a contact@example.org b
+   *               ^
+   * ```
+   *
+   * @type {State}
+   */
+  function emailDomain(code) {
+    // Dot followed by alphanumerical (not `-` or `_`).
     if (code === 46) {
-      return effects.check(punctuation, done, dotContinuation)(code)
-    }
-
-    if (code === 45 || code === 95) {
-      return effects.check(punctuation, nok, dashOrUnderscoreContinuation)(code)
+      return effects.check(
+        emailDomainDotTrail,
+        emailDomainAfter,
+        emailDomainDot
+      )(code)
     }
 
-    if (asciiAlphanumeric(code)) {
-      if (!hasDigitInLastSegment && asciiDigit(code)) {
-        hasDigitInLastSegment = true
-      }
-
+    // Alphanumerical, `-`, and `_`.
+    if (code === 45 || code === 95 || asciiAlphanumeric(code)) {
+      data = true
       effects.consume(code)
-      return label
+      return emailDomain
     }
 
-    return done(code)
-  }
-  /** @type {State} */
+    // To do: `/` if xmpp.
 
-  function dotContinuation(code) {
-    effects.consume(code)
-    hasDot = true
-    hasDigitInLastSegment = undefined
-    return label
+    // Note: normally we’d truncate trailing punctuation from the link.
+    // However, email autolink literals cannot contain any of those markers,
+    // except for `.`, but that can only occur if it isn’t trailing.
+    // So we can ignore truncating!
+    return emailDomainAfter(code)
   }
-  /** @type {State} */
 
-  function dashOrUnderscoreContinuation(code) {
+  /**
+   * In email domain, on dot that is not a trail.
+   *
+   * ```markdown
+   * > | a contact@example.org b
+   *                      ^
+   * ```
+   *
+   * @type {State}
+   */
+  function emailDomainDot(code) {
     effects.consume(code)
-    return afterDashOrUnderscore
-  }
-  /** @type {State} */
-
-  function afterDashOrUnderscore(code) {
-    if (code === 46) {
-      return effects.check(punctuation, nok, dotContinuation)(code)
-    }
-
-    return label(code)
+    dot = true
+    return emailDomain
   }
-  /** @type {State} */
 
-  function done(code) {
-    if (hasDot && !hasDigitInLastSegment) {
+  /**
+   * After email domain.
+   *
+   * ```markdown
+   * > | a contact@example.org b
+   *                          ^
+   * ```
+   *
+   * @type {State}
+   */
+  function emailDomainAfter(code) {
+    // Domain must not be empty, must include a dot, and must end in alphabetical.
+    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L332>.
+    if (data && dot && asciiAlpha(self.previous)) {
       effects.exit('literalAutolinkEmail')
       effects.exit('literalAutolink')
       return ok(code)
     }
-
     return nok(code)
   }
 }
-/** @type {Tokenizer} */
 
+/**
+ * `www` autolink literal.
+ *
+ * ```markdown
+ * > | a www.example.org b
+ *       ^^^^^^^^^^^^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
 function tokenizeWwwAutolink(effects, ok, nok) {
   const self = this
-  return start
-  /** @type {State} */
+  return wwwStart
 
-  function start(code) {
+  /**
+   * Start of www autolink literal.
+   *
+   * ```markdown
+   * > | www.example.com/a?b#c
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function wwwStart(code) {
     if (
       (code !== 87 && code !== 119) ||
-      !previousWww(self.previous) ||
+      !previousWww.call(self, self.previous) ||
       previousUnbalanced(self.events)
     ) {
       return nok(code)
     }
-
     effects.enter('literalAutolink')
-    effects.enter('literalAutolinkWww') // For `www.` we check instead of attempt, because when it matches, GH
-    // treats it as part of a domain (yes, it says a valid domain must come
-    // after `www.`, but that’s not how it’s implemented by them).
-
+    effects.enter('literalAutolinkWww')
+    // Note: we *check*, so we can discard the `www.` we parsed.
+    // If it worked, we consider it as a part of the domain.
     return effects.check(
-      www,
-      effects.attempt(domain, effects.attempt(syntax_path, done), nok),
+      wwwPrefix,
+      effects.attempt(domain, effects.attempt(syntax_path, wwwAfter), nok),
       nok
     )(code)
   }
-  /** @type {State} */
 
-  function done(code) {
+  /**
+   * After a www autolink literal.
+   *
+   * ```markdown
+   * > | www.example.com/a?b#c
+   *                          ^
+   * ```
+   *
+   * @type {State}
+   */
+  function wwwAfter(code) {
     effects.exit('literalAutolinkWww')
     effects.exit('literalAutolink')
     return ok(code)
   }
 }
-/** @type {Tokenizer} */
 
-function tokenizeHttpAutolink(effects, ok, nok) {
+/**
+ * Protocol autolink literal.
+ *
+ * ```markdown
+ * > | a https://example.org b
+ *       ^^^^^^^^^^^^^^^^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeProtocolAutolink(effects, ok, nok) {
   const self = this
-  return start
-  /** @type {State} */
+  let buffer = ''
+  let seen = false
+  return protocolStart
 
-  function start(code) {
+  /**
+   * Start of protocol autolink literal.
+   *
+   * ```markdown
+   * > | https://example.com/a?b#c
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function protocolStart(code) {
     if (
-      (code !== 72 && code !== 104) ||
-      !previousHttp(self.previous) ||
-      previousUnbalanced(self.events)
+      (code === 72 || code === 104) &&
+      previousProtocol.call(self, self.previous) &&
+      !previousUnbalanced(self.events)
     ) {
-      return nok(code)
-    }
-
-    effects.enter('literalAutolink')
-    effects.enter('literalAutolinkHttp')
-    effects.consume(code)
-    return t1
-  }
-  /** @type {State} */
-
-  function t1(code) {
-    if (code === 84 || code === 116) {
+      effects.enter('literalAutolink')
+      effects.enter('literalAutolinkHttp')
+      buffer += String.fromCodePoint(code)
       effects.consume(code)
-      return t2
+      return protocolPrefixInside
     }
-
     return nok(code)
   }
-  /** @type {State} */
 
-  function t2(code) {
-    if (code === 84 || code === 116) {
-      effects.consume(code)
-      return p
-    }
-
-    return nok(code)
-  }
-  /** @type {State} */
-
-  function p(code) {
-    if (code === 80 || code === 112) {
-      effects.consume(code)
-      return s
-    }
-
-    return nok(code)
-  }
-  /** @type {State} */
-
-  function s(code) {
-    if (code === 83 || code === 115) {
+  /**
+   * In protocol.
+   *
+   * ```markdown
+   * > | https://example.com/a?b#c
+   *     ^^^^^
+   * ```
+   *
+   * @type {State}
+   */
+  function protocolPrefixInside(code) {
+    // `5` is size of `https`
+    if (asciiAlpha(code) && buffer.length < 5) {
+      buffer += String.fromCodePoint(code)
       effects.consume(code)
-      return colon
+      return protocolPrefixInside
     }
-
-    return colon(code)
-  }
-  /** @type {State} */
-
-  function colon(code) {
     if (code === 58) {
-      effects.consume(code)
-      return slash1
-    }
-
-    return nok(code)
-  }
-  /** @type {State} */
-
-  function slash1(code) {
-    if (code === 47) {
-      effects.consume(code)
-      return slash2
+      const protocol = buffer.toLowerCase()
+      if (protocol === 'http' || protocol === 'https') {
+        effects.consume(code)
+        return protocolSlashesInside
+      }
     }
-
     return nok(code)
   }
-  /** @type {State} */
 
-  function slash2(code) {
+  /**
+   * In slashes.
+   *
+   * ```markdown
+   * > | https://example.com/a?b#c
+   *           ^^
+   * ```
+   *
+   * @type {State}
+   */
+  function protocolSlashesInside(code) {
     if (code === 47) {
       effects.consume(code)
-      return after
+      if (seen) {
+        return afterProtocol
+      }
+      seen = true
+      return protocolSlashesInside
     }
-
     return nok(code)
   }
-  /** @type {State} */
 
-  function after(code) {
+  /**
+   * After protocol, before domain.
+   *
+   * ```markdown
+   * > | https://example.com/a?b#c
+   *             ^
+   * ```
+   *
+   * @type {State}
+   */
+  function afterProtocol(code) {
+    // To do: this is different from `markdown-rs`:
+    // https://github.com/wooorm/markdown-rs/blob/b3a921c761309ae00a51fe348d8a43adbc54b518/src/construct/gfm_autolink_literal.rs#L172-L182
     return code === null ||
       asciiControl(code) ||
+      markdownLineEndingOrSpace(code) ||
       unicodeWhitespace(code) ||
       unicodePunctuation(code)
       ? nok(code)
-      : effects.attempt(domain, effects.attempt(syntax_path, done), nok)(code)
+      : effects.attempt(domain, effects.attempt(syntax_path, protocolAfter), nok)(code)
   }
-  /** @type {State} */
 
-  function done(code) {
+  /**
+   * After a protocol autolink literal.
+   *
+   * ```markdown
+   * > | https://example.com/a?b#c
+   *                              ^
+   * ```
+   *
+   * @type {State}
+   */
+  function protocolAfter(code) {
     effects.exit('literalAutolinkHttp')
     effects.exit('literalAutolink')
     return ok(code)
   }
 }
-/** @type {Tokenizer} */
-
-function tokenizeWww(effects, ok, nok) {
-  return start
-  /** @type {State} */
 
-  function start(code) {
-    effects.consume(code)
-    return w2
-  }
-  /** @type {State} */
-
-  function w2(code) {
-    if (code === 87 || code === 119) {
-      effects.consume(code)
-      return w3
-    }
-
-    return nok(code)
-  }
-  /** @type {State} */
+/**
+ * `www` prefix.
+ *
+ * ```markdown
+ * > | a www.example.org b
+ *       ^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeWwwPrefix(effects, ok, nok) {
+  let size = 0
+  return wwwPrefixInside
 
-  function w3(code) {
-    if (code === 87 || code === 119) {
+  /**
+   * In www prefix.
+   *
+   * ```markdown
+   * > | www.example.com
+   *     ^^^^
+   * ```
+   *
+   * @type {State}
+   */
+  function wwwPrefixInside(code) {
+    if ((code === 87 || code === 119) && size < 3) {
+      size++
       effects.consume(code)
-      return dot
+      return wwwPrefixInside
     }
-
-    return nok(code)
-  }
-  /** @type {State} */
-
-  function dot(code) {
-    if (code === 46) {
+    if (code === 46 && size === 3) {
       effects.consume(code)
-      return after
+      return wwwPrefixAfter
     }
-
     return nok(code)
   }
-  /** @type {State} */
 
-  function after(code) {
-    return code === null || markdownLineEnding(code) ? nok(code) : ok(code)
+  /**
+   * After www prefix.
+   *
+   * ```markdown
+   * > | www.example.com
+   *         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function wwwPrefixAfter(code) {
+    // If there is *anything*, we can link.
+    return code === null ? nok(code) : ok(code)
   }
 }
-/** @type {Tokenizer} */
 
+/**
+ * Domain.
+ *
+ * ```markdown
+ * > | a https://example.org b
+ *               ^^^^^^^^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
 function tokenizeDomain(effects, ok, nok) {
-  /** @type {boolean|undefined} */
-  let hasUnderscoreInLastSegment
-  /** @type {boolean|undefined} */
-
-  let hasUnderscoreInLastLastSegment
-  return domain
-  /** @type {State} */
+  /** @type {boolean | undefined} */
+  let underscoreInLastSegment
+  /** @type {boolean | undefined} */
+  let underscoreInLastLastSegment
+  /** @type {boolean | undefined} */
+  let seen
+  return domainInside
 
-  function domain(code) {
-    if (code === 38) {
-      return effects.check(
-        namedCharacterReference,
-        done,
-        punctuationContinuation
-      )(code)
+  /**
+   * In domain.
+   *
+   * ```markdown
+   * > | https://example.com/a
+   *             ^^^^^^^^^^^
+   * ```
+   *
+   * @type {State}
+   */
+  function domainInside(code) {
+    // Check whether this marker, which is a trailing punctuation
+    // marker, optionally followed by more trailing markers, and then
+    // followed by an end.
+    if (code === 46 || code === 95) {
+      return effects.check(trail, domainAfter, domainAtPunctuation)(code)
     }
 
-    if (code === 46 || code === 95) {
-      return effects.check(punctuation, done, punctuationContinuation)(code)
-    } // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can
+    // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can
     // occur, which sounds like ASCII only, but they also support `www.點看.com`,
     // so that’s Unicode.
     // Instead of some new production for Unicode alphanumerics, markdown
     // already has that for Unicode punctuation and whitespace, so use those.
-
+    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L12>.
     if (
       code === null ||
-      asciiControl(code) ||
+      markdownLineEndingOrSpace(code) ||
       unicodeWhitespace(code) ||
       (code !== 45 && unicodePunctuation(code))
     ) {
-      return done(code)
+      return domainAfter(code)
     }
-
+    seen = true
     effects.consume(code)
-    return domain
+    return domainInside
   }
-  /** @type {State} */
 
-  function punctuationContinuation(code) {
-    if (code === 46) {
-      hasUnderscoreInLastLastSegment = hasUnderscoreInLastSegment
-      hasUnderscoreInLastSegment = undefined
-      effects.consume(code)
-      return domain
+  /**
+   * In domain, at potential trailing punctuation, that was not trailing.
+   *
+   * ```markdown
+   * > | https://example.com
+   *                    ^
+   * ```
+   *
+   * @type {State}
+   */
+  function domainAtPunctuation(code) {
+    // There is an underscore in the last segment of the domain
+    if (code === 95) {
+      underscoreInLastSegment = true
+    }
+    // Otherwise, it’s a `.`: save the last segment underscore in the
+    // penultimate segment slot.
+    else {
+      underscoreInLastLastSegment = underscoreInLastSegment
+      underscoreInLastSegment = undefined
     }
-
-    if (code === 95) hasUnderscoreInLastSegment = true
     effects.consume(code)
-    return domain
+    return domainInside
   }
-  /** @type {State} */
 
-  function done(code) {
-    if (!hasUnderscoreInLastLastSegment && !hasUnderscoreInLastSegment) {
-      return ok(code)
+  /**
+   * After domain.
+   *
+   * ```markdown
+   * > | https://example.com/a
+   *                        ^
+   * ```
+   *
+   * @type {State} */
+  function domainAfter(code) {
+    // Note: that’s GH says a dot is needed, but it’s not true:
+    // <https://github.com/github/cmark-gfm/issues/279>
+    if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) {
+      return nok(code)
     }
-
-    return nok(code)
+    return ok(code)
   }
 }
-/** @type {Tokenizer} */
 
+/**
+ * Path.
+ *
+ * ```markdown
+ * > | a https://example.org/stuff b
+ *                          ^^^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
 function tokenizePath(effects, ok) {
-  let balance = 0
-  return inPath
-  /** @type {State} */
-
-  function inPath(code) {
-    if (code === 38) {
-      return effects.check(
-        namedCharacterReference,
-        ok,
-        continuedPunctuation
-      )(code)
-    }
+  let sizeOpen = 0
+  let sizeClose = 0
+  return pathInside
 
+  /**
+   * In path.
+   *
+   * ```markdown
+   * > | https://example.com/a
+   *                        ^^
+   * ```
+   *
+   * @type {State}
+   */
+  function pathInside(code) {
     if (code === 40) {
-      balance++
+      sizeOpen++
+      effects.consume(code)
+      return pathInside
     }
 
-    if (code === 41) {
-      return effects.check(
-        punctuation,
-        parenAtPathEnd,
-        continuedPunctuation
-      )(code)
+    // To do: `markdown-rs` also needs this.
+    // If this is a paren, and there are less closings than openings,
+    // we don’t check for a trail.
+    if (code === 41 && sizeClose < sizeOpen) {
+      return pathAtPunctuation(code)
     }
 
-    if (pathEnd(code)) {
-      return ok(code)
+    // Check whether this trailing punctuation marker is optionally
+    // followed by more trailing markers, and then followed
+    // by an end.
+    if (
+      code === 33 ||
+      code === 34 ||
+      code === 38 ||
+      code === 39 ||
+      code === 41 ||
+      code === 42 ||
+      code === 44 ||
+      code === 46 ||
+      code === 58 ||
+      code === 59 ||
+      code === 60 ||
+      code === 63 ||
+      code === 93 ||
+      code === 95 ||
+      code === 126
+    ) {
+      return effects.check(trail, ok, pathAtPunctuation)(code)
     }
-
-    if (trailingPunctuation(code)) {
-      return effects.check(punctuation, ok, continuedPunctuation)(code)
+    if (
+      code === null ||
+      markdownLineEndingOrSpace(code) ||
+      unicodeWhitespace(code)
+    ) {
+      return ok(code)
     }
-
     effects.consume(code)
-    return inPath
+    return pathInside
   }
-  /** @type {State} */
 
-  function continuedPunctuation(code) {
+  /**
+   * In path, at potential trailing punctuation, that was not trailing.
+   *
+   * ```markdown
+   * > | https://example.com/a"b
+   *                          ^
+   * ```
+   *
+   * @type {State}
+   */
+  function pathAtPunctuation(code) {
+    // Count closing parens.
+    if (code === 41) {
+      sizeClose++
+    }
     effects.consume(code)
-    return inPath
-  }
-  /** @type {State} */
-
-  function parenAtPathEnd(code) {
-    balance--
-    return balance < 0 ? ok(code) : continuedPunctuation(code)
+    return pathInside
   }
 }
-/** @type {Tokenizer} */
 
-function tokenizeNamedCharacterReference(effects, ok, nok) {
-  return start
-  /** @type {State} */
-
-  function start(code) {
-    effects.consume(code)
-    return inside
-  }
-  /** @type {State} */
+/**
+ * Trail.
+ *
+ * This calls `ok` if this *is* the trail, followed by an end, which means
+ * the entire trail is not part of the link.
+ * It calls `nok` if this *is* part of the link.
+ *
+ * ```markdown
+ * > | https://example.com").
+ *                        ^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeTrail(effects, ok, nok) {
+  return trail
 
-  function inside(code) {
-    if (asciiAlpha(code)) {
+  /**
+   * In trail of domain or path.
+   *
+   * ```markdown
+   * > | https://example.com").
+   *                        ^
+   * ```
+   *
+   * @type {State}
+   */
+  function trail(code) {
+    // Regular trailing punctuation.
+    if (
+      code === 33 ||
+      code === 34 ||
+      code === 39 ||
+      code === 41 ||
+      code === 42 ||
+      code === 44 ||
+      code === 46 ||
+      code === 58 ||
+      code === 59 ||
+      code === 63 ||
+      code === 95 ||
+      code === 126
+    ) {
       effects.consume(code)
-      return inside
+      return trail
     }
 
-    if (code === 59) {
+    // `&` followed by one or more alphabeticals and then a `;`, is
+    // as a whole considered as trailing punctuation.
+    // In all other cases, it is considered as continuation of the URL.
+    if (code === 38) {
       effects.consume(code)
-      return after
+      return trailCharRefStart
     }
 
+    // Needed because we allow literals after `[`, as we fix:
+    // <https://github.com/github/cmark-gfm/issues/278>.
+    // Check that it is not followed by `(` or `[`.
+    if (code === 93) {
+      effects.consume(code)
+      return trailBracketAfter
+    }
+    if (
+      // `<` is an end.
+      code === 60 ||
+      // So is whitespace.
+      code === null ||
+      markdownLineEndingOrSpace(code) ||
+      unicodeWhitespace(code)
+    ) {
+      return ok(code)
+    }
     return nok(code)
   }
-  /** @type {State} */
 
-  function after(code) {
-    // If the named character reference is followed by the end of the path, it’s
-    // not continued punctuation.
-    return pathEnd(code) ? ok(code) : nok(code)
+  /**
+   * In trail, after `]`.
+   *
+   * > 👉 **Note**: this deviates from `cmark-gfm` to fix a bug.
+   * > See end of <https://github.com/github/cmark-gfm/issues/278> for more.
+   *
+   * ```markdown
+   * > | https://example.com](
+   *                         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function trailBracketAfter(code) {
+    // Whitespace or something that could start a resource or reference is the end.
+    // Switch back to trail otherwise.
+    if (
+      code === null ||
+      code === 40 ||
+      code === 91 ||
+      markdownLineEndingOrSpace(code) ||
+      unicodeWhitespace(code)
+    ) {
+      return ok(code)
+    }
+    return trail(code)
+  }
+
+  /**
+   * In character-reference like trail, after `&`.
+   *
+   * ```markdown
+   * > | https://example.com&amp;).
+   *                         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function trailCharRefStart(code) {
+    // When non-alpha, it’s not a trail.
+    return asciiAlpha(code) ? trailCharRefInside(code) : nok(code)
+  }
+
+  /**
+   * In character-reference like trail.
+   *
+   * ```markdown
+   * > | https://example.com&amp;).
+   *                         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function trailCharRefInside(code) {
+    // Switch back to trail if this is well-formed.
+    if (code === 59) {
+      effects.consume(code)
+      return trail
+    }
+    if (asciiAlpha(code)) {
+      effects.consume(code)
+      return trailCharRefInside
+    }
+
+    // It’s not a trail.
+    return nok(code)
   }
 }
-/** @type {Tokenizer} */
 
-function tokenizePunctuation(effects, ok, nok) {
+/**
+ * Dot in email domain trail.
+ *
+ * This calls `ok` if this *is* the trail, followed by an end, which means
+ * the trail is not part of the link.
+ * It calls `nok` if this *is* part of the link.
+ *
+ * ```markdown
+ * > | contact@example.org.
+ *                        ^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeEmailDomainDotTrail(effects, ok, nok) {
   return start
-  /** @type {State} */
 
+  /**
+   * Dot.
+   *
+   * ```markdown
+   * > | contact@example.org.
+   *                    ^   ^
+   * ```
+   *
+   * @type {State}
+   */
   function start(code) {
+    // Must be dot.
     effects.consume(code)
     return after
   }
-  /** @type {State} */
 
+  /**
+   * After dot.
+   *
+   * ```markdown
+   * > | contact@example.org.
+   *                     ^   ^
+   * ```
+   *
+   * @type {State}
+   */
   function after(code) {
-    // Check the next.
-    if (trailingPunctuation(code)) {
-      effects.consume(code)
-      return after
-    } // If the punctuation marker is followed by the end of the path, it’s not
-    // continued punctuation.
-
-    return pathEnd(code) ? ok(code) : nok(code)
+    // Not a trail if alphanumeric.
+    return asciiAlphanumeric(code) ? nok(code) : ok(code)
   }
 }
+
 /**
- * @param {Code} code
- * @returns {boolean}
+ * See:
+ * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L156>.
+ *
+ * @type {Previous}
  */
-
-function trailingPunctuation(code) {
+function previousWww(code) {
   return (
-    code === 33 ||
-    code === 34 ||
-    code === 39 ||
-    code === 41 ||
+    code === null ||
+    code === 40 ||
     code === 42 ||
-    code === 44 ||
-    code === 46 ||
-    code === 58 ||
-    code === 59 ||
-    code === 60 ||
-    code === 63 ||
     code === 95 ||
-    code === 126
+    code === 91 ||
+    code === 93 ||
+    code === 126 ||
+    markdownLineEndingOrSpace(code)
   )
 }
+
 /**
- * @param {Code} code
- * @returns {boolean}
+ * See:
+ * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L214>.
+ *
+ * @type {Previous}
  */
+function previousProtocol(code) {
+  return !asciiAlpha(code)
+}
 
-function pathEnd(code) {
-  return code === null || code === 60 || markdownLineEndingOrSpace(code)
+/**
+ * @this {TokenizeContext}
+ * @type {Previous}
+ */
+function previousEmail(code) {
+  // Do not allow a slash “inside” atext.
+  // The reference code is a bit weird, but that’s what it results in.
+  // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L307>.
+  // Other than slash, every preceding character is allowed.
+  return !(code === 47 || gfmAtext(code))
 }
+
 /**
  * @param {Code} code
  * @returns {boolean}
  */
-
 function gfmAtext(code) {
   return (
     code === 43 ||
@@ -33918,61 +34348,36 @@ function gfmAtext(code) {
     asciiAlphanumeric(code)
   )
 }
-/** @type {Previous} */
 
-function previousWww(code) {
-  return (
-    code === null ||
-    code === 40 ||
-    code === 42 ||
-    code === 95 ||
-    code === 126 ||
-    markdownLineEndingOrSpace(code)
-  )
-}
-/** @type {Previous} */
-
-function previousHttp(code) {
-  return code === null || !asciiAlpha(code)
-}
-/** @type {Previous} */
-
-function previousEmail(code) {
-  return code !== 47 && previousHttp(code)
-}
 /**
  * @param {Array<Event>} events
  * @returns {boolean}
  */
-
 function previousUnbalanced(events) {
   let index = events.length
   let result = false
-
   while (index--) {
     const token = events[index][1]
-
     if (
       (token.type === 'labelLink' || token.type === 'labelImage') &&
       !token._balanced
     ) {
       result = true
       break
-    } // @ts-expect-error If we’ve seen this token, and it was marked as not
-    // having any unbalanced bracket before it, we can exit.
+    }
 
+    // @ts-expect-error If we’ve seen this token, and it was marked as not
+    // having any unbalanced bracket before it, we can exit.
     if (token._gfmAutolinkLiteralWalkedInto) {
       result = false
       break
     }
   }
-
   if (events.length > 0 && !result) {
     // @ts-expect-error Mark the last token as “walked into” w/o finding
     // anything.
     events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true
   }
-
   return result
 }
 
@@ -36130,7 +36535,7 @@ function lib_previous(match, email) {
   )
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/util/association.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-footnote/node_modules/mdast-util-to-markdown/lib/util/association.js
 /**
  * @typedef {import('../types.js').AssociationId} AssociationId
  */
@@ -36165,7 +36570,7 @@ function association(node) {
   return decodeString(node.identifier)
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/util/container-flow.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-footnote/node_modules/mdast-util-to-markdown/lib/util/container-flow.js
 /**
  * @typedef {import('../types.js').FlowContent} FlowContent
  * @typedef {import('../types.js').Node} Node
@@ -36254,7 +36659,7 @@ function between(left, right, parent, state) {
   return '\n\n'
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/util/indent-lines.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-footnote/node_modules/mdast-util-to-markdown/lib/util/indent-lines.js
 /**
  * @typedef {import('../types.js').IndentLines} IndentLines
  */
@@ -36291,7 +36696,7 @@ function indentLines(value, map) {
   }
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-footnote/node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js
 /**
  * @typedef {import('../types.js').Unsafe} Unsafe
  */
@@ -36318,7 +36723,7 @@ function patternCompile(pattern) {
   return pattern._compiled
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-footnote/node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js
 /**
  * @typedef {import('../types.js').Unsafe} Unsafe
  * @typedef {import('../types.js').ConstructName} ConstructName
@@ -36362,7 +36767,7 @@ function listInScope(stack, list, none) {
   return false
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/util/safe.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-footnote/node_modules/mdast-util-to-markdown/lib/util/safe.js
 /**
  * @typedef {import('../types.js').State} State
  * @typedef {import('../types.js').SafeConfig} SafeConfig
@@ -36541,7 +36946,7 @@ function escapeBackslashes(value, after) {
   return results.join('')
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/util/track.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-footnote/node_modules/mdast-util-to-markdown/lib/util/track.js
 /**
  * @typedef {import('../types.js').CreateTracker} CreateTracker
  * @typedef {import('../types.js').TrackCurrent} TrackCurrent
@@ -36810,7 +37215,7 @@ function map(line, index, blank) {
   return (blank ? '' : '    ') + line
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-strikethrough/node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js
 /**
  * @typedef {import('../types.js').Handle} Handle
  * @typedef {import('../types.js').Info} Info
@@ -36909,113 +37314,299 @@ function containerPhrasing(parent, state, info) {
   return results.join('')
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-strikethrough/lib/index.js
-/**
- * @typedef {import('mdast').Delete} Delete
- *
- * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
- * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
- * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
- *
- * @typedef {import('mdast-util-to-markdown').ConstructName} ConstructName
- * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
- * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
- */
-
-
-
-
-// To do: next major: expose functions.
-// To do: next major: use `state`, state utilities.
-
-/**
- * List of constructs that occur in phrasing (paragraphs, headings), but cannot
- * contain strikethrough.
- * So they sort of cancel each other out.
- * Note: could use a better name.
- *
- * Note: keep in sync with: <https://github.com/syntax-tree/mdast-util-to-markdown/blob/8ce8dbf/lib/unsafe.js#L14>
- *
- * @type {Array<ConstructName>}
- */
-const constructsWithoutStrikethrough = [
-  'autolink',
-  'destinationLiteral',
-  'destinationRaw',
-  'reference',
-  'titleQuote',
-  'titleApostrophe'
-]
-
-handleDelete.peek = peekDelete
-
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-strikethrough/node_modules/mdast-util-to-markdown/lib/util/track.js
+/**
+ * @typedef {import('../types.js').CreateTracker} CreateTracker
+ * @typedef {import('../types.js').TrackCurrent} TrackCurrent
+ * @typedef {import('../types.js').TrackMove} TrackMove
+ * @typedef {import('../types.js').TrackShift} TrackShift
+ */
+
+/**
+ * Track positional info in the output.
+ *
+ * @type {CreateTracker}
+ */
+function track_track(config) {
+  // Defaults are used to prevent crashes when older utilities somehow activate
+  // this code.
+  /* c8 ignore next 5 */
+  const options = config || {}
+  const now = options.now || {}
+  let lineShift = options.lineShift || 0
+  let line = now.line || 1
+  let column = now.column || 1
+
+  return {move, current, shift}
+
+  /**
+   * Get the current tracked info.
+   *
+   * @type {TrackCurrent}
+   */
+  function current() {
+    return {now: {line, column}, lineShift}
+  }
+
+  /**
+   * Define an increased line shift (the typical indent for lines).
+   *
+   * @type {TrackShift}
+   */
+  function shift(value) {
+    lineShift += value
+  }
+
+  /**
+   * Move past some generated markdown.
+   *
+   * @type {TrackMove}
+   */
+  function move(input) {
+    // eslint-disable-next-line unicorn/prefer-default-parameters
+    const value = input || ''
+    const chunks = value.split(/\r?\n|\r/g)
+    const tail = chunks[chunks.length - 1]
+    line += chunks.length - 1
+    column =
+      chunks.length === 1 ? column + tail.length : 1 + tail.length + lineShift
+    return value
+  }
+}
+
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-strikethrough/lib/index.js
+/**
+ * @typedef {import('mdast').Delete} Delete
+ *
+ * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
+ * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+ * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+ *
+ * @typedef {import('mdast-util-to-markdown').ConstructName} ConstructName
+ * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+ * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+ */
+
+
+
+
+// To do: next major: expose functions.
+// To do: next major: use `state`, state utilities.
+
+/**
+ * List of constructs that occur in phrasing (paragraphs, headings), but cannot
+ * contain strikethrough.
+ * So they sort of cancel each other out.
+ * Note: could use a better name.
+ *
+ * Note: keep in sync with: <https://github.com/syntax-tree/mdast-util-to-markdown/blob/8ce8dbf/lib/unsafe.js#L14>
+ *
+ * @type {Array<ConstructName>}
+ */
+const constructsWithoutStrikethrough = [
+  'autolink',
+  'destinationLiteral',
+  'destinationRaw',
+  'reference',
+  'titleQuote',
+  'titleApostrophe'
+]
+
+handleDelete.peek = peekDelete
+
+/**
+ * Extension for `mdast-util-from-markdown` to enable GFM strikethrough.
+ *
+ * @type {FromMarkdownExtension}
+ */
+const gfmStrikethroughFromMarkdown = {
+  canContainEols: ['delete'],
+  enter: {strikethrough: enterStrikethrough},
+  exit: {strikethrough: exitStrikethrough}
+}
+
+/**
+ * Extension for `mdast-util-to-markdown` to enable GFM strikethrough.
+ *
+ * @type {ToMarkdownExtension}
+ */
+const gfmStrikethroughToMarkdown = {
+  unsafe: [
+    {
+      character: '~',
+      inConstruct: 'phrasing',
+      notInConstruct: constructsWithoutStrikethrough
+    }
+  ],
+  handlers: {delete: handleDelete}
+}
+
+/**
+ * @this {CompileContext}
+ * @type {FromMarkdownHandle}
+ */
+function enterStrikethrough(token) {
+  this.enter({type: 'delete', children: []}, token)
+}
+
+/**
+ * @this {CompileContext}
+ * @type {FromMarkdownHandle}
+ */
+function exitStrikethrough(token) {
+  this.exit(token)
+}
+
+/**
+ * @type {ToMarkdownHandle}
+ * @param {Delete} node
+ */
+function handleDelete(node, _, context, safeOptions) {
+  const tracker = track_track(safeOptions)
+  const exit = context.enter('strikethrough')
+  let value = tracker.move('~~')
+  value += containerPhrasing(node, context, {
+    ...tracker.current(),
+    before: value,
+    after: '~'
+  })
+  value += tracker.move('~~')
+  exit()
+  return value
+}
+
+/** @type {ToMarkdownHandle} */
+function peekDelete() {
+  return '~'
+}
+
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-table/node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js
+/**
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('../types.js').Info} Info
+ * @typedef {import('../types.js').Parent} Parent
+ * @typedef {import('../types.js').PhrasingContent} PhrasingContent
+ * @typedef {import('../types.js').State} State
+ */
+
+/**
+ * Serialize the children of a parent that contains phrasing children.
+ *
+ * These children will be joined flush together.
+ *
+ * @param {Parent & {children: Array<PhrasingContent>}} parent
+ *   Parent of flow nodes.
+ * @param {State} state
+ *   Info passed around about the current state.
+ * @param {Info} info
+ *   Info on where we are in the document we are generating.
+ * @returns {string}
+ *   Serialized children, joined together.
+ */
+function container_phrasing_containerPhrasing(parent, state, info) {
+  const indexStack = state.indexStack
+  const children = parent.children || []
+  /** @type {Array<string>} */
+  const results = []
+  let index = -1
+  let before = info.before
+
+  indexStack.push(-1)
+  let tracker = state.createTracker(info)
+
+  while (++index < children.length) {
+    const child = children[index]
+    /** @type {string} */
+    let after
+
+    indexStack[indexStack.length - 1] = index
+
+    if (index + 1 < children.length) {
+      /** @type {Handle} */
+      // @ts-expect-error: hush, it’s actually a `zwitch`.
+      let handle = state.handle.handlers[children[index + 1].type]
+      /** @type {Handle} */
+      // @ts-expect-error: hush, it’s actually a `zwitch`.
+      if (handle && handle.peek) handle = handle.peek
+      after = handle
+        ? handle(children[index + 1], parent, state, {
+            before: '',
+            after: '',
+            ...tracker.current()
+          }).charAt(0)
+        : ''
+    } else {
+      after = info.after
+    }
+
+    // In some cases, html (text) can be found in phrasing right after an eol.
+    // When we’d serialize that, in most cases that would be seen as html
+    // (flow).
+    // As we can’t escape or so to prevent it from happening, we take a somewhat
+    // reasonable approach: replace that eol with a space.
+    // See: <https://github.com/syntax-tree/mdast-util-to-markdown/issues/15>
+    if (
+      results.length > 0 &&
+      (before === '\r' || before === '\n') &&
+      child.type === 'html'
+    ) {
+      results[results.length - 1] = results[results.length - 1].replace(
+        /(\r?\n|\r)$/,
+        ' '
+      )
+      before = ' '
+
+      // To do: does this work to reset tracker?
+      tracker = state.createTracker(info)
+      tracker.move(results.join(''))
+    }
+
+    results.push(
+      tracker.move(
+        state.handle(child, parent, state, {
+          ...tracker.current(),
+          before,
+          after
+        })
+      )
+    )
+
+    before = results[results.length - 1].slice(-1)
+  }
+
+  indexStack.pop()
+
+  return results.join('')
+}
+
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-table/node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js
 /**
- * Extension for `mdast-util-from-markdown` to enable GFM strikethrough.
- *
- * @type {FromMarkdownExtension}
- */
-const gfmStrikethroughFromMarkdown = {
-  canContainEols: ['delete'],
-  enter: {strikethrough: enterStrikethrough},
-  exit: {strikethrough: exitStrikethrough}
-}
-
-/**
- * Extension for `mdast-util-to-markdown` to enable GFM strikethrough.
- *
- * @type {ToMarkdownExtension}
- */
-const gfmStrikethroughToMarkdown = {
-  unsafe: [
-    {
-      character: '~',
-      inConstruct: 'phrasing',
-      notInConstruct: constructsWithoutStrikethrough
-    }
-  ],
-  handlers: {delete: handleDelete}
-}
-
-/**
- * @this {CompileContext}
- * @type {FromMarkdownHandle}
+ * @typedef {import('../types.js').Unsafe} Unsafe
  */
-function enterStrikethrough(token) {
-  this.enter({type: 'delete', children: []}, token)
-}
 
 /**
- * @this {CompileContext}
- * @type {FromMarkdownHandle}
+ * @param {Unsafe} pattern
+ * @returns {RegExp}
  */
-function exitStrikethrough(token) {
-  this.exit(token)
-}
+function pattern_compile_patternCompile(pattern) {
+  if (!pattern._compiled) {
+    const before =
+      (pattern.atBreak ? '[\\r\\n][\\t ]*' : '') +
+      (pattern.before ? '(?:' + pattern.before + ')' : '')
 
-/**
- * @type {ToMarkdownHandle}
- * @param {Delete} node
- */
-function handleDelete(node, _, context, safeOptions) {
-  const tracker = track(safeOptions)
-  const exit = context.enter('strikethrough')
-  let value = tracker.move('~~')
-  value += containerPhrasing(node, context, {
-    ...tracker.current(),
-    before: value,
-    after: '~'
-  })
-  value += tracker.move('~~')
-  exit()
-  return value
-}
+    pattern._compiled = new RegExp(
+      (before ? '(' + before + ')' : '') +
+        (/[|\\{}()[\]^$+*?.-]/.test(pattern.character) ? '\\' : '') +
+        pattern.character +
+        (pattern.after ? '(?:' + pattern.after + ')' : ''),
+      'g'
+    )
+  }
 
-/** @type {ToMarkdownHandle} */
-function peekDelete() {
-  return '~'
+  return pattern._compiled
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/handle/inline-code.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-table/node_modules/mdast-util-to-markdown/lib/handle/inline-code.js
 /**
  * @typedef {import('mdast').InlineCode} InlineCode
  * @typedef {import('../types.js').Parent} Parent
@@ -37062,7 +37653,7 @@ function inline_code_inlineCode(node, _, state) {
   // them out.
   while (++index < state.unsafe.length) {
     const pattern = state.unsafe[index]
-    const expression = patternCompile(pattern)
+    const expression = pattern_compile_patternCompile(pattern)
     /** @type {RegExpExecArray | null} */
     let match
 
@@ -37694,7 +38285,7 @@ function gfmTableToMarkdown(options) {
   function handleTableCell(node, _, context, safeOptions) {
     const exit = context.enter('tableCell')
     const subexit = context.enter('phrasing')
-    const value = containerPhrasing(node, context, {
+    const value = container_phrasing_containerPhrasing(node, context, {
       ...safeOptions,
       before: around,
       after: around
@@ -37789,7 +38380,7 @@ function gfmTableToMarkdown(options) {
   }
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/util/check-bullet.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-task-list-item/node_modules/mdast-util-to-markdown/lib/util/check-bullet.js
 /**
  * @typedef {import('../types.js').State} State
  * @typedef {import('../types.js').Options} Options
@@ -37813,7 +38404,7 @@ function checkBullet(state) {
   return marker
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-task-list-item/node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js
 /**
  * @typedef {import('../types.js').State} State
  * @typedef {import('../types.js').Options} Options
@@ -37843,7 +38434,7 @@ function checkListItemIndent(state) {
   return style
 }
 
-;// CONCATENATED MODULE: ../node_modules/mdast-util-to-markdown/lib/handle/list-item.js
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-task-list-item/node_modules/mdast-util-to-markdown/lib/handle/list-item.js
 /**
  * @typedef {import('mdast').ListItem} ListItem
  * @typedef {import('../types.js').Map} Map
@@ -37910,6 +38501,66 @@ function list_item_listItem(node, parent, state, info) {
   }
 }
 
+;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-task-list-item/node_modules/mdast-util-to-markdown/lib/util/track.js
+/**
+ * @typedef {import('../types.js').CreateTracker} CreateTracker
+ * @typedef {import('../types.js').TrackCurrent} TrackCurrent
+ * @typedef {import('../types.js').TrackMove} TrackMove
+ * @typedef {import('../types.js').TrackShift} TrackShift
+ */
+
+/**
+ * Track positional info in the output.
+ *
+ * @type {CreateTracker}
+ */
+function util_track_track(config) {
+  // Defaults are used to prevent crashes when older utilities somehow activate
+  // this code.
+  /* c8 ignore next 5 */
+  const options = config || {}
+  const now = options.now || {}
+  let lineShift = options.lineShift || 0
+  let line = now.line || 1
+  let column = now.column || 1
+
+  return {move, current, shift}
+
+  /**
+   * Get the current tracked info.
+   *
+   * @type {TrackCurrent}
+   */
+  function current() {
+    return {now: {line, column}, lineShift}
+  }
+
+  /**
+   * Define an increased line shift (the typical indent for lines).
+   *
+   * @type {TrackShift}
+   */
+  function shift(value) {
+    lineShift += value
+  }
+
+  /**
+   * Move past some generated markdown.
+   *
+   * @type {TrackMove}
+   */
+  function move(input) {
+    // eslint-disable-next-line unicorn/prefer-default-parameters
+    const value = input || ''
+    const chunks = value.split(/\r?\n|\r/g)
+    const tail = chunks[chunks.length - 1]
+    line += chunks.length - 1
+    column =
+      chunks.length === 1 ? column + tail.length : 1 + tail.length + lineShift
+    return value
+  }
+}
+
 ;// CONCATENATED MODULE: ../node_modules/mdast-util-gfm-task-list-item/lib/index.js
 /**
  * @typedef {import('mdast').Content} Content
@@ -38029,7 +38680,7 @@ function listItemWithTaskListItem(node, parent, context, safeOptions) {
   const checkable =
     typeof node.checked === 'boolean' && head && head.type === 'paragraph'
   const checkbox = '[' + (node.checked ? 'x' : ' ') + '] '
-  const tracker = track(safeOptions)
+  const tracker = util_track_track(safeOptions)
 
   if (checkable) {
     tracker.move(checkbox)
@@ -45602,7 +46253,7 @@ function vbnet(Prism) {
   })
 }
 
-;// CONCATENATED MODULE: ../node_modules/character-entities-legacy/index.js
+;// CONCATENATED MODULE: ../node_modules/refractor/node_modules/character-entities-legacy/index.js
 /**
  * List of legacy HTML named character references that don’t need a trailing semicolon.
  *
@@ -45717,7 +46368,7 @@ const characterEntitiesLegacy = [
   'yuml'
 ]
 
-;// CONCATENATED MODULE: ../node_modules/character-reference-invalid/index.js
+;// CONCATENATED MODULE: ../node_modules/refractor/node_modules/character-reference-invalid/index.js
 /**
  * Map of invalid numeric character references to their replacements, according to HTML.
  *
@@ -45754,7 +46405,7 @@ const characterReferenceInvalid = {
   159: 'Ÿ'
 }
 
-;// CONCATENATED MODULE: ../node_modules/is-decimal/index.js
+;// CONCATENATED MODULE: ../node_modules/refractor/node_modules/is-decimal/index.js
 /**
  * Check if the given character code, or the character code at the first
  * character, is decimal.
@@ -45769,7 +46420,7 @@ function isDecimal(character) {
   return code >= 48 && code <= 57 /* 0-9 */
 }
 
-;// CONCATENATED MODULE: ../node_modules/is-hexadecimal/index.js
+;// CONCATENATED MODULE: ../node_modules/refractor/node_modules/is-hexadecimal/index.js
 /**
  * Check if the given character code, or the character code at the first
  * character, is hexadecimal.
@@ -45788,7 +46439,7 @@ function isHexadecimal(character) {
   )
 }
 
-;// CONCATENATED MODULE: ../node_modules/is-alphabetical/index.js
+;// CONCATENATED MODULE: ../node_modules/refractor/node_modules/is-alphabetical/index.js
 /**
  * Check if the given character code, or the character code at the first
  * character, is alphabetical.
@@ -45806,7 +46457,7 @@ function isAlphabetical(character) {
   )
 }
 
-;// CONCATENATED MODULE: ../node_modules/is-alphanumerical/index.js
+;// CONCATENATED MODULE: ../node_modules/refractor/node_modules/is-alphanumerical/index.js
 
 
 
@@ -45821,7 +46472,7 @@ function isAlphanumerical(character) {
   return isAlphabetical(character) || isDecimal(character)
 }
 
-;// CONCATENATED MODULE: ../node_modules/parse-entities/lib/index.js
+;// CONCATENATED MODULE: ../node_modules/refractor/node_modules/parse-entities/lib/index.js
 /**
  * @typedef {import('unist').Point} Point
  * @typedef {import('unist').Position} Position
@@ -70245,7 +70896,6 @@ var octiconLink = {
     }
   }]
 };
-
 ;// CONCATENATED MODULE: ../node_modules/@uiw/react-markdown-preview/esm/nodes/copy.js
 function copyElement(str) {
   if (str === void 0) {
@@ -70309,34 +70959,45 @@ function copyElement(str) {
     }]
   };
 }
-
 // EXTERNAL MODULE: ../node_modules/@uiw/copy-to-clipboard/dist/copy-to-clipboard.umd.js
 var copy_to_clipboard_umd = __webpack_require__(7071);
 var copy_to_clipboard_umd_default = /*#__PURE__*/__webpack_require__.n(copy_to_clipboard_umd);
 ;// CONCATENATED MODULE: ../node_modules/@uiw/react-markdown-preview/esm/plugins/useCopied.js
 
 
+function getParentElement(target) {
+  if (!target) return null;
+  var dom = target;
+  if (dom.dataset.code && dom.classList.contains('copied')) {
+    return dom;
+  }
+  if (dom.parentElement) {
+    return getParentElement(dom.parentElement);
+  }
+  return null;
+}
 function useCopied(container) {
-  var handle = (0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useCallback)(event => {
-    var target = event.currentTarget || event.target;
+  var handle = event => {
+    var target = getParentElement(event.target);
+    if (!target) return;
     target.classList.add('active');
     copy_to_clipboard_umd_default()(target.dataset.code, function () {
       setTimeout(() => {
         target.classList.remove('active');
       }, 2000);
     });
-  }, []);
+  };
   (0,external_root_React_commonjs2_react_commonjs_react_amd_react_.useEffect)(() => {
-    var _container$current;
-    var btns = (_container$current = container.current) == null ? void 0 : _container$current.querySelectorAll('pre code + div.copied');
-    btns && Array.from(btns).forEach(elm => elm.addEventListener('click', handle, false));
+    var _container$current, _container$current2;
+    (_container$current = container.current) == null ? void 0 : _container$current.removeEventListener('click', handle, false);
+    (_container$current2 = container.current) == null ? void 0 : _container$current2.addEventListener('click', handle, false);
     return () => {
-      btns && Array.from(btns).forEach(elm => elm.removeEventListener('click', handle, false));
+      var _container$current3;
+      (_container$current3 = container.current) == null ? void 0 : _container$current3.removeEventListener('click', handle, false);
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [container]);
 }
-
 ;// CONCATENATED MODULE: ../node_modules/@uiw/react-markdown-preview/esm/styles/markdown.css
 // extracted by mini-css-extract-plugin
 /* harmony default export */ const styles_markdown = ({});
@@ -70357,7 +71018,6 @@ var reservedMeta = function reservedMeta(options) {
     });
   };
 };
-
 // EXTERNAL MODULE: ../node_modules/react/jsx-runtime.js
 var jsx_runtime = __webpack_require__(3605);
 ;// CONCATENATED MODULE: ../node_modules/@uiw/react-markdown-preview/esm/index.js
@@ -70453,7 +71113,6 @@ var _excluded = ["prefixCls", "className", "source", "style", "disableCopy", "sk
     }))
   }));
 }));
-
 ;// CONCATENATED MODULE: ./src/Context.tsx
 function reducer(state,action){return _objectSpread2(_objectSpread2({},state),action);}var EditorContext=/*#__PURE__*/external_root_React_commonjs2_react_commonjs_react_amd_react_default().createContext({markdown:''});
 ;// CONCATENATED MODULE: ./src/components/TextArea/shortcuts.ts
@@ -71000,6 +71659,121 @@ function toDecimal(code, next, omit) {
     : value + ';'
 }
 
+;// CONCATENATED MODULE: ../node_modules/stringify-entities/node_modules/character-entities-legacy/index.js
+/**
+ * List of legacy HTML named character references that don’t need a trailing semicolon.
+ *
+ * @type {Array<string>}
+ */
+const character_entities_legacy_characterEntitiesLegacy = [
+  'AElig',
+  'AMP',
+  'Aacute',
+  'Acirc',
+  'Agrave',
+  'Aring',
+  'Atilde',
+  'Auml',
+  'COPY',
+  'Ccedil',
+  'ETH',
+  'Eacute',
+  'Ecirc',
+  'Egrave',
+  'Euml',
+  'GT',
+  'Iacute',
+  'Icirc',
+  'Igrave',
+  'Iuml',
+  'LT',
+  'Ntilde',
+  'Oacute',
+  'Ocirc',
+  'Ograve',
+  'Oslash',
+  'Otilde',
+  'Ouml',
+  'QUOT',
+  'REG',
+  'THORN',
+  'Uacute',
+  'Ucirc',
+  'Ugrave',
+  'Uuml',
+  'Yacute',
+  'aacute',
+  'acirc',
+  'acute',
+  'aelig',
+  'agrave',
+  'amp',
+  'aring',
+  'atilde',
+  'auml',
+  'brvbar',
+  'ccedil',
+  'cedil',
+  'cent',
+  'copy',
+  'curren',
+  'deg',
+  'divide',
+  'eacute',
+  'ecirc',
+  'egrave',
+  'eth',
+  'euml',
+  'frac12',
+  'frac14',
+  'frac34',
+  'gt',
+  'iacute',
+  'icirc',
+  'iexcl',
+  'igrave',
+  'iquest',
+  'iuml',
+  'laquo',
+  'lt',
+  'macr',
+  'micro',
+  'middot',
+  'nbsp',
+  'not',
+  'ntilde',
+  'oacute',
+  'ocirc',
+  'ograve',
+  'ordf',
+  'ordm',
+  'oslash',
+  'otilde',
+  'ouml',
+  'para',
+  'plusmn',
+  'pound',
+  'quot',
+  'raquo',
+  'reg',
+  'sect',
+  'shy',
+  'sup1',
+  'sup2',
+  'sup3',
+  'szlig',
+  'thorn',
+  'times',
+  'uacute',
+  'ucirc',
+  'ugrave',
+  'uml',
+  'uuml',
+  'yacute',
+  'yen',
+  'yuml'
+]
+
 ;// CONCATENATED MODULE: ../node_modules/character-entities-html4/index.js
 /**
  * Map of named character references from HTML 4.
@@ -71320,7 +72094,7 @@ function toNamed(code, next, omit, attribute) {
 
     if (
       omit &&
-      characterEntitiesLegacy.includes(name) &&
+      character_entities_legacy_characterEntitiesLegacy.includes(name) &&
       !dangerous.includes(name) &&
       (!attribute ||
         (next &&