@uiw/react-md-editor 3.20.9 → 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),
@@ -33434,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 = {
@@ -33455,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} */
+/**
+ * `www` prefix.
+ *
+ * ```markdown
+ * > | a www.example.org b
+ *       ^^^^
+ * ```
+ *
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+function tokenizeWwwPrefix(effects, ok, nok) {
+  let size = 0
+  return wwwPrefixInside
 
-  function w2(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 w3
+      return wwwPrefixInside
+    }
+    if (code === 46 && size === 3) {
+      effects.consume(code)
+      return wwwPrefixAfter
     }
-
     return nok(code)
   }
-  /** @type {State} */
-
-  function w3(code) {
-    if (code === 87 || code === 119) {
-      effects.consume(code)
-      return dot
-    }
-
-    return nok(code)
-  }
-  /** @type {State} */
-
-  function dot(code) {
-    if (code === 46) {
-      effects.consume(code)
-      return after
-    }
-
-    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 ||
@@ -34004,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
 }