markdown-flow-ui 0.1.69-beta.8 → 0.1.70-beta.0

package/dist/node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-bullet-ordered.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.js"],"sourcesContent":["/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['bulletOrdered'], null | undefined>}\n */\nexport function checkBulletOrdered(state) {\n  const marker = state.options.bulletOrdered || '.'\n\n  if (marker !== '.' && marker !== ')') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        marker +\n        '` for `options.bulletOrdered`, expected `.` or `)`'\n    )\n  }\n\n  return marker\n}\n"],"names":["checkBulletOrdered","state","marker"],"mappings":"AAQO,SAASA,EAAmBC,GAAO;AACxC,QAAMC,IAASD,EAAM,QAAQ,iBAAiB;AAE9C,MAAIC,MAAW,OAAOA,MAAW;AAC/B,UAAM,IAAI;AAAA,MACR,kCACEA,IACA;AAAA,IACR;AAGE,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-bullet-other.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.js"],"sourcesContent":["/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\nimport {checkBullet} from './check-bullet.js'\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['bullet'], null | undefined>}\n */\nexport function checkBulletOther(state) {\n  const bullet = checkBullet(state)\n  const bulletOther = state.options.bulletOther\n\n  if (!bulletOther) {\n    return bullet === '*' ? '-' : '*'\n  }\n\n  if (bulletOther !== '*' && bulletOther !== '+' && bulletOther !== '-') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        bulletOther +\n        '` for `options.bulletOther`, expected `*`, `+`, or `-`'\n    )\n  }\n\n  if (bulletOther === bullet) {\n    throw new Error(\n      'Expected `bullet` (`' +\n        bullet +\n        '`) and `bulletOther` (`' +\n        bulletOther +\n        '`) to be different'\n    )\n  }\n\n  return bulletOther\n}\n"],"names":["checkBulletOther","state","bullet","checkBullet","bulletOther"],"mappings":";AAUO,SAASA,EAAiBC,GAAO;AACtC,QAAMC,IAASC,EAAYF,CAAK,GAC1BG,IAAcH,EAAM,QAAQ;AAElC,MAAI,CAACG;AACH,WAAOF,MAAW,MAAM,MAAM;AAGhC,MAAIE,MAAgB,OAAOA,MAAgB,OAAOA,MAAgB;AAChE,UAAM,IAAI;AAAA,MACR,kCACEA,IACA;AAAA,IACR;AAGE,MAAIA,MAAgBF;AAClB,UAAM,IAAI;AAAA,MACR,yBACEA,IACA,4BACAE,IACA;AAAA,IACR;AAGE,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/check-bullet.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-bullet.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-bullet.js"],"sourcesContent":["/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['bullet'], null | undefined>}\n */\nexport function checkBullet(state) {\n  const marker = state.options.bullet || '*'\n\n  if (marker !== '*' && marker !== '+' && marker !== '-') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        marker +\n        '` for `options.bullet`, expected `*`, `+`, or `-`'\n    )\n  }\n\n  return marker\n}\n"],"names":["checkBullet","state","marker"],"mappings":"AAQO,SAASA,EAAYC,GAAO;AACjC,QAAMC,IAASD,EAAM,QAAQ,UAAU;AAEvC,MAAIC,MAAW,OAAOA,MAAW,OAAOA,MAAW;AACjD,UAAM,IAAI;AAAA,MACR,kCACEA,IACA;AAAA,IACR;AAGE,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/check-emphasis.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-emphasis.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-emphasis.js"],"sourcesContent":["/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['emphasis'], null | undefined>}\n */\nexport function checkEmphasis(state) {\n  const marker = state.options.emphasis || '*'\n\n  if (marker !== '*' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize emphasis with `' +\n        marker +\n        '` for `options.emphasis`, expected `*`, or `_`'\n    )\n  }\n\n  return marker\n}\n"],"names":["checkEmphasis","state","marker"],"mappings":"AAQO,SAASA,EAAcC,GAAO;AACnC,QAAMC,IAASD,EAAM,QAAQ,YAAY;AAEzC,MAAIC,MAAW,OAAOA,MAAW;AAC/B,UAAM,IAAI;AAAA,MACR,qCACEA,IACA;AAAA,IACR;AAGE,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/check-fence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-fence.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-fence.js"],"sourcesContent":["/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['fence'], null | undefined>}\n */\nexport function checkFence(state) {\n  const marker = state.options.fence || '`'\n\n  if (marker !== '`' && marker !== '~') {\n    throw new Error(\n      'Cannot serialize code with `' +\n        marker +\n        '` for `options.fence`, expected `` ` `` or `~`'\n    )\n  }\n\n  return marker\n}\n"],"names":["checkFence","state","marker"],"mappings":"AAQO,SAASA,EAAWC,GAAO;AAChC,QAAMC,IAASD,EAAM,QAAQ,SAAS;AAEtC,MAAIC,MAAW,OAAOA,MAAW;AAC/B,UAAM,IAAI;AAAA,MACR,iCACEA,IACA;AAAA,IACR;AAGE,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-list-item-indent.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js"],"sourcesContent":["/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['listItemIndent'], null | undefined>}\n */\nexport function checkListItemIndent(state) {\n  const style = state.options.listItemIndent || 'one'\n\n  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        style +\n        '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'\n    )\n  }\n\n  return style\n}\n"],"names":["checkListItemIndent","state","style"],"mappings":"AAQO,SAASA,EAAoBC,GAAO;AACzC,QAAMC,IAAQD,EAAM,QAAQ,kBAAkB;AAE9C,MAAIC,MAAU,SAASA,MAAU,SAASA,MAAU;AAClD,UAAM,IAAI;AAAA,MACR,kCACEA,IACA;AAAA,IACR;AAGE,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/check-quote.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-quote.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-quote.js"],"sourcesContent":["/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['quote'], null | undefined>}\n */\nexport function checkQuote(state) {\n  const marker = state.options.quote || '\"'\n\n  if (marker !== '\"' && marker !== \"'\") {\n    throw new Error(\n      'Cannot serialize title with `' +\n        marker +\n        '` for `options.quote`, expected `\"`, or `\\'`'\n    )\n  }\n\n  return marker\n}\n"],"names":["checkQuote","state","marker"],"mappings":"AAQO,SAASA,EAAWC,GAAO;AAChC,QAAMC,IAASD,EAAM,QAAQ,SAAS;AAEtC,MAAIC,MAAW,OAAOA,MAAW;AAC/B,UAAM,IAAI;AAAA,MACR,kCACEA,IACA;AAAA,IACR;AAGE,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-rule-repetition.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js"],"sourcesContent":["/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['ruleRepetition'], null | undefined>}\n */\nexport function checkRuleRepetition(state) {\n  const repetition = state.options.ruleRepetition || 3\n\n  if (repetition < 3) {\n    throw new Error(\n      'Cannot serialize rules with repetition `' +\n        repetition +\n        '` for `options.ruleRepetition`, expected `3` or more'\n    )\n  }\n\n  return repetition\n}\n"],"names":["checkRuleRepetition","state","repetition"],"mappings":"AAQO,SAASA,EAAoBC,GAAO;AACzC,QAAMC,IAAaD,EAAM,QAAQ,kBAAkB;AAEnD,MAAIC,IAAa;AACf,UAAM,IAAI;AAAA,MACR,6CACEA,IACA;AAAA,IACR;AAGE,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/check-rule.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-rule.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-rule.js"],"sourcesContent":["/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['rule'], null | undefined>}\n */\nexport function checkRule(state) {\n  const marker = state.options.rule || '*'\n\n  if (marker !== '*' && marker !== '-' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize rules with `' +\n        marker +\n        '` for `options.rule`, expected `*`, `-`, or `_`'\n    )\n  }\n\n  return marker\n}\n"],"names":["checkRule","state","marker"],"mappings":"AAQO,SAASA,EAAUC,GAAO;AAC/B,QAAMC,IAASD,EAAM,QAAQ,QAAQ;AAErC,MAAIC,MAAW,OAAOA,MAAW,OAAOA,MAAW;AACjD,UAAM,IAAI;AAAA,MACR,kCACEA,IACA;AAAA,IACR;AAGE,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/check-strong.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-strong.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-strong.js"],"sourcesContent":["/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['strong'], null | undefined>}\n */\nexport function checkStrong(state) {\n  const marker = state.options.strong || '*'\n\n  if (marker !== '*' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize strong with `' +\n        marker +\n        '` for `options.strong`, expected `*`, or `_`'\n    )\n  }\n\n  return marker\n}\n"],"names":["checkStrong","state","marker"],"mappings":"AAQO,SAASA,EAAYC,GAAO;AACjC,QAAMC,IAASD,EAAM,QAAQ,UAAU;AAEvC,MAAIC,MAAW,OAAOA,MAAW;AAC/B,UAAM,IAAI;AAAA,MACR,mCACEA,IACA;AAAA,IACR;AAGE,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"encode-character-reference.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.js"],"sourcesContent":["/**\n * Encode a code point as a character reference.\n *\n * @param {number} code\n *   Code point to encode.\n * @returns {string}\n *   Encoded character reference.\n */\nexport function encodeCharacterReference(code) {\n  return '&#x' + code.toString(16).toUpperCase() + ';'\n}\n"],"names":["encodeCharacterReference","code"],"mappings":"AAQO,SAASA,EAAyBC,GAAM;AAC7C,SAAO,QAAQA,EAAK,SAAS,EAAE,EAAE,YAAW,IAAK;AACnD;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/encode-info.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"encode-info.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/encode-info.js"],"sourcesContent":["/**\n * @import {EncodeSides} from '../types.js'\n */\n\nimport {classifyCharacter} from 'micromark-util-classify-character'\n\n/**\n * Check whether to encode (as a character reference) the characters\n * surrounding an attention run.\n *\n * Which characters are around an attention run influence whether it works or\n * not.\n *\n * See <https://github.com/orgs/syntax-tree/discussions/60> for more info.\n * See this markdown in a particular renderer to see what works:\n *\n * ```markdown\n * |                         | A (letter inside) | B (punctuation inside) | C (whitespace inside) | D (nothing inside) |\n * | ----------------------- | ----------------- | ---------------------- | --------------------- | ------------------ |\n * | 1 (letter outside)      | x*y*z             | x*.*z                  | x* *z                 | x**z               |\n * | 2 (punctuation outside) | .*y*.             | .*.*.                  | .* *.                 | .**.               |\n * | 3 (whitespace outside)  | x *y* z           | x *.* z                | x * * z               | x ** z             |\n * | 4 (nothing outside)     | *x*               | *.*                    | * *                   | **                 |\n * ```\n *\n * @param {number} outside\n *   Code point on the outer side of the run.\n * @param {number} inside\n *   Code point on the inner side of the run.\n * @param {'*' | '_'} marker\n *   Marker of the run.\n *   Underscores are handled more strictly (they form less often) than\n *   asterisks.\n * @returns {EncodeSides}\n *   Whether to encode characters.\n */\n// Important: punctuation must never be encoded.\n// Punctuation is solely used by markdown constructs.\n// And by encoding itself.\n// Encoding them will break constructs or double encode things.\nexport function encodeInfo(outside, inside, marker) {\n  const outsideKind = classifyCharacter(outside)\n  const insideKind = classifyCharacter(inside)\n\n  // Letter outside:\n  if (outsideKind === undefined) {\n    return insideKind === undefined\n      ? // Letter inside:\n        // we have to encode *both* letters for `_` as it is looser.\n        // it already forms for `*` (and GFMs `~`).\n        marker === '_'\n        ? {inside: true, outside: true}\n        : {inside: false, outside: false}\n      : insideKind === 1\n        ? // Whitespace inside: encode both (letter, whitespace).\n          {inside: true, outside: true}\n        : // Punctuation inside: encode outer (letter)\n          {inside: false, outside: true}\n  }\n\n  // Whitespace outside:\n  if (outsideKind === 1) {\n    return insideKind === undefined\n      ? // Letter inside: already forms.\n        {inside: false, outside: false}\n      : insideKind === 1\n        ? // Whitespace inside: encode both (whitespace).\n          {inside: true, outside: true}\n        : // Punctuation inside: already forms.\n          {inside: false, outside: false}\n  }\n\n  // Punctuation outside:\n  return insideKind === undefined\n    ? // Letter inside: already forms.\n      {inside: false, outside: false}\n    : insideKind === 1\n      ? // Whitespace inside: encode inner (whitespace).\n        {inside: true, outside: false}\n      : // Punctuation inside: already forms.\n        {inside: false, outside: false}\n}\n"],"names":["encodeInfo","outside","inside","marker","outsideKind","classifyCharacter","insideKind"],"mappings":";AAwCO,SAASA,EAAWC,GAASC,GAAQC,GAAQ;AAClD,QAAMC,IAAcC,EAAkBJ,CAAO,GACvCK,IAAaD,EAAkBH,CAAM;AAG3C,SAAIE,MAAgB,SACXE,MAAe;AAAA;AAAA;AAAA;AAAA,IAIlBH,MAAW,MACT,EAAC,QAAQ,IAAM,SAAS,GAAI,IAC5B,EAAC,QAAQ,IAAO,SAAS,GAAK;AAAA,MAChCG,MAAe;AAAA;AAAA,IAEb,EAAC,QAAQ,IAAM,SAAS,GAAI;AAAA;AAAA;AAAA,IAE5B,EAAC,QAAQ,IAAO,SAAS,GAAI;AAAA,MAIjCF,MAAgB,IACXE,MAAe;AAAA;AAAA,IAElB,EAAC,QAAQ,IAAO,SAAS,GAAK;AAAA,MAC9BA,MAAe;AAAA;AAAA,IAEb,EAAC,QAAQ,IAAM,SAAS,GAAI;AAAA;AAAA;AAAA,IAE5B,EAAC,QAAQ,IAAO,SAAS,GAAK;AAAA,MAI/BA,MAAe;AAAA;AAAA,IAElB,EAAC,QAAQ,IAAO,SAAS,GAAK;AAAA,MAC9BA,MAAe;AAAA;AAAA,IAEb,EAAC,QAAQ,IAAM,SAAS,GAAK;AAAA;AAAA;AAAA,IAE7B,EAAC,QAAQ,IAAO,SAAS,GAAK;AAAA;AACtC;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"format-code-as-indented.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js"],"sourcesContent":["/**\n * @import {State} from 'mdast-util-to-markdown'\n * @import {Code} from 'mdast'\n */\n\n/**\n * @param {Code} node\n * @param {State} state\n * @returns {boolean}\n */\nexport function formatCodeAsIndented(node, state) {\n  return Boolean(\n    state.options.fences === false &&\n      node.value &&\n      // If there’s no info…\n      !node.lang &&\n      // And there’s a non-whitespace character…\n      /[^ \\r\\n]/.test(node.value) &&\n      // And the value doesn’t start or end in a blank…\n      !/^[\\t ]*(?:[\\r\\n]|$)|(?:^|[\\r\\n])[\\t ]*$/.test(node.value)\n  )\n}\n"],"names":["formatCodeAsIndented","node","state"],"mappings":"AAUO,SAASA,EAAqBC,GAAMC,GAAO;AAChD,SAAO,GACLA,EAAM,QAAQ,WAAW,MACvBD,EAAK;AAAA,EAEL,CAACA,EAAK;AAAA,EAEN,WAAW,KAAKA,EAAK,KAAK;AAAA,EAE1B,CAAC,0CAA0C,KAAKA,EAAK,KAAK;AAEhE;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js

@@ -1,14 +0,0 @@
-import { visit as o } from "../../../unist-util-visit/lib/index.js";
-import { toString as a } from "../../../mdast-util-to-string/lib/index.js";
-import { EXIT as f } from "../../../unist-util-visit-parents/lib/index.js";
-function n(t, i) {
-  let e = !1;
-  return o(t, function(r) {
-    if ("value" in r && /\r?\n|\r/.test(r.value) || r.type === "break")
-      return e = !0, f;
-  }), !!((!t.depth || t.depth < 3) && a(t) && (i.options.setext || e));
-}
-export {
-  n as formatHeadingAsSetext
-};
-//# sourceMappingURL=format-heading-as-setext.js.map

package/dist/node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"format-heading-as-setext.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js"],"sourcesContent":["/**\n * @import {State} from 'mdast-util-to-markdown'\n * @import {Heading} from 'mdast'\n */\n\nimport {EXIT, visit} from 'unist-util-visit'\nimport {toString} from 'mdast-util-to-string'\n\n/**\n * @param {Heading} node\n * @param {State} state\n * @returns {boolean}\n */\nexport function formatHeadingAsSetext(node, state) {\n  let literalWithBreak = false\n\n  // Look for literals with a line break.\n  // Note that this also\n  visit(node, function (node) {\n    if (\n      ('value' in node && /\\r?\\n|\\r/.test(node.value)) ||\n      node.type === 'break'\n    ) {\n      literalWithBreak = true\n      return EXIT\n    }\n  })\n\n  return Boolean(\n    (!node.depth || node.depth < 3) &&\n      toString(node) &&\n      (state.options.setext || literalWithBreak)\n  )\n}\n"],"names":["formatHeadingAsSetext","node","state","literalWithBreak","visit","EXIT","toString"],"mappings":";;;AAaO,SAASA,EAAsBC,GAAMC,GAAO;AACjD,MAAIC,IAAmB;AAIvB,SAAAC,EAAMH,GAAM,SAAUA,GAAM;AAC1B,QACG,WAAWA,KAAQ,WAAW,KAAKA,EAAK,KAAK,KAC9CA,EAAK,SAAS;AAEd,aAAAE,IAAmB,IACZE;AAAA,EAEX,CAAC,GAEM,IACJ,CAACJ,EAAK,SAASA,EAAK,QAAQ,MAC3BK,EAASL,CAAI,MACZC,EAAM,QAAQ,UAAUC;AAE/B;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"format-link-as-autolink.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js"],"sourcesContent":["/**\n * @import {State} from 'mdast-util-to-markdown'\n * @import {Link} from 'mdast'\n */\n\nimport {toString} from 'mdast-util-to-string'\n\n/**\n * @param {Link} node\n * @param {State} state\n * @returns {boolean}\n */\nexport function formatLinkAsAutolink(node, state) {\n  const raw = toString(node)\n\n  return Boolean(\n    !state.options.resourceLink &&\n      // If there’s a url…\n      node.url &&\n      // And there’s a no title…\n      !node.title &&\n      // And the content of `node` is a single text node…\n      node.children &&\n      node.children.length === 1 &&\n      node.children[0].type === 'text' &&\n      // And if the url is the same as the content…\n      (raw === node.url || 'mailto:' + raw === node.url) &&\n      // And that starts w/ a protocol…\n      /^[a-z][a-z+.-]+:/i.test(node.url) &&\n      // And that doesn’t contain ASCII control codes (character escapes and\n      // references don’t work), space, or angle brackets…\n      !/[\\0- <>\\u007F]/.test(node.url)\n  )\n}\n"],"names":["formatLinkAsAutolink","node","state","raw","toString"],"mappings":";AAYO,SAASA,EAAqBC,GAAMC,GAAO;AAChD,QAAMC,IAAMC,EAASH,CAAI;AAEzB,SAAO,GACL,CAACC,EAAM,QAAQ;AAAA,EAEbD,EAAK;AAAA,EAEL,CAACA,EAAK;AAAA,EAENA,EAAK,YACLA,EAAK,SAAS,WAAW,KACzBA,EAAK,SAAS,CAAC,EAAE,SAAS;AAAA,GAEzBE,MAAQF,EAAK,OAAO,YAAYE,MAAQF,EAAK;AAAA,EAE9C,oBAAoB,KAAKA,EAAK,GAAG;AAAA;AAAA,EAGjC,CAAC,iBAAiB,KAAKA,EAAK,GAAG;AAErC;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pattern-in-scope.js","sources":["../../../../../../../../node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js"],"sourcesContent":["/**\n * @import {ConstructName, Unsafe} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {Array<ConstructName>} stack\n * @param {Unsafe} pattern\n * @returns {boolean}\n */\nexport function patternInScope(stack, pattern) {\n  return (\n    listInScope(stack, pattern.inConstruct, true) &&\n    !listInScope(stack, pattern.notInConstruct, false)\n  )\n}\n\n/**\n * @param {Array<ConstructName>} stack\n * @param {Unsafe['inConstruct']} list\n * @param {boolean} none\n * @returns {boolean}\n */\nfunction listInScope(stack, list, none) {\n  if (typeof list === 'string') {\n    list = [list]\n  }\n\n  if (!list || list.length === 0) {\n    return none\n  }\n\n  let index = -1\n\n  while (++index < list.length) {\n    if (stack.includes(list[index])) {\n      return true\n    }\n  }\n\n  return false\n}\n"],"names":["patternInScope","stack","pattern","listInScope","list","none","index"],"mappings":"AASO,SAASA,EAAeC,GAAOC,GAAS;AAC7C,SACEC,EAAYF,GAAOC,EAAQ,aAAa,EAAI,KAC5C,CAACC,EAAYF,GAAOC,EAAQ,gBAAgB,EAAK;AAErD;AAQA,SAASC,EAAYF,GAAOG,GAAMC,GAAM;AAKtC,MAJI,OAAOD,KAAS,aAClBA,IAAO,CAACA,CAAI,IAGV,CAACA,KAAQA,EAAK,WAAW;AAC3B,WAAOC;AAGT,MAAIC,IAAQ;AAEZ,SAAO,EAAEA,IAAQF,EAAK;AACpB,QAAIH,EAAM,SAASG,EAAKE,CAAK,CAAC;AAC5B,aAAO;AAIX,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/mdast-util-to-string/lib/index.js

@@ -1,30 +0,0 @@
-const f = {};
-function l(t, o) {
-  const n = f, i = typeof n.includeImageAlt == "boolean" ? n.includeImageAlt : !0, r = typeof n.includeHtml == "boolean" ? n.includeHtml : !0;
-  return c(t, i, r);
-}
-function c(t, o, n) {
-  if (s(t)) {
-    if ("value" in t)
-      return t.type === "html" && !n ? "" : t.value;
-    if (o && "alt" in t && t.alt)
-      return t.alt;
-    if ("children" in t)
-      return e(t.children, o, n);
-  }
-  return Array.isArray(t) ? e(t, o, n) : "";
-}
-function e(t, o, n) {
-  const i = [];
-  let r = -1;
-  for (; ++r < t.length; )
-    i[r] = c(t[r], o, n);
-  return i.join("");
-}
-function s(t) {
-  return !!(t && typeof t == "object");
-}
-export {
-  l as toString
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/mdast-util-to-string/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/mdast-util-to-string/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('mdast').Nodes} Nodes\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s (default: `true`).\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML (default: `true`).\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} [value]\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Nodes}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n"],"names":["emptyOptions","toString","value","options","settings","includeImageAlt","includeHtml","one","node","all","values","result","index"],"mappings":"AAYA,MAAMA,IAAe,CAAA;AAed,SAASC,EAASC,GAAOC,GAAS;AACvC,QAAMC,IAAsBJ,GACtBK,IACJ,OAAOD,EAAS,mBAAoB,YAChCA,EAAS,kBACT,IACAE,IACJ,OAAOF,EAAS,eAAgB,YAAYA,EAAS,cAAc;AAErE,SAAOG,EAAIL,GAAOG,GAAiBC,CAAW;AAChD;AAcA,SAASC,EAAIL,GAAOG,GAAiBC,GAAa;AAChD,MAAIE,EAAKN,CAAK,GAAG;AACf,QAAI,WAAWA;AACb,aAAOA,EAAM,SAAS,UAAU,CAACI,IAAc,KAAKJ,EAAM;AAG5D,QAAIG,KAAmB,SAASH,KAASA,EAAM;AAC7C,aAAOA,EAAM;AAGf,QAAI,cAAcA;AAChB,aAAOO,EAAIP,EAAM,UAAUG,GAAiBC,CAAW;AAAA,EAE3D;AAEA,SAAI,MAAM,QAAQJ,CAAK,IACdO,EAAIP,GAAOG,GAAiBC,CAAW,IAGzC;AACT;AAcA,SAASG,EAAIC,GAAQL,GAAiBC,GAAa;AAEjD,QAAMK,IAAS,CAAA;AACf,MAAIC,IAAQ;AAEZ,SAAO,EAAEA,IAAQF,EAAO;AACtB,IAAAC,EAAOC,CAAK,IAAIL,EAAIG,EAAOE,CAAK,GAAGP,GAAiBC,CAAW;AAGjE,SAAOK,EAAO,KAAK,EAAE;AACvB;AAUA,SAASH,EAAKN,GAAO;AACnB,SAAO,GAAQA,KAAS,OAAOA,KAAU;AAC3C;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-core-commonmark/lib/blank-line.js

@@ -1,19 +0,0 @@
-import { factorySpace as o } from "../../micromark-factory-space/index.js";
-import { markdownSpace as f, markdownLineEnding as u } from "../../micromark-util-character/index.js";
-const p = {
-  partial: !0,
-  tokenize: k
-};
-function k(t, i, e) {
-  return a;
-  function a(n) {
-    return f(n) ? o(t, r, "linePrefix")(n) : r(n);
-  }
-  function r(n) {
-    return n === null || u(n) ? i(n) : e(n);
-  }
-}
-export {
-  p as blankLine
-};
-//# sourceMappingURL=blank-line.js.map

package/dist/node_modules/micromark-core-commonmark/lib/blank-line.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"blank-line.js","sources":["../../../../../../../node_modules/micromark-core-commonmark/lib/blank-line.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blankLine = {\n  partial: true,\n  tokenize: tokenizeBlankLine\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code) ? factorySpace(effects, after, \"linePrefix\")(code) : after(code);\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}"],"names":["blankLine","tokenizeBlankLine","effects","ok","nok","start","code","markdownSpace","factorySpace","after","markdownLineEnding"],"mappings":";;AAYY,MAACA,IAAY;AAAA,EACvB,SAAS;AAAA,EACT,UAAUC;AACZ;AAOA,SAASA,EAAkBC,GAASC,GAAIC,GAAK;AAC3C,SAAOC;AAgBP,WAASA,EAAMC,GAAM;AACnB,WAAOC,EAAcD,CAAI,IAAIE,EAAaN,GAASO,GAAO,YAAY,EAAEH,CAAI,IAAIG,EAAMH,CAAI;AAAA,EAC5F;AAgBA,WAASG,EAAMH,GAAM;AACnB,WAAOA,MAAS,QAAQI,EAAmBJ,CAAI,IAAIH,EAAGG,CAAI,IAAIF,EAAIE,CAAI;AAAA,EACxE;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-extension-gfm/index.js

@@ -1,19 +0,0 @@
-import { combineExtensions as m } from "../micromark-util-combine-extensions/index.js";
-import { gfmAutolinkLiteral as r } from "../micromark-extension-gfm-autolink-literal/lib/syntax.js";
-import { gfmFootnote as t } from "../micromark-extension-gfm-footnote/lib/syntax.js";
-import { gfmStrikethrough as f } from "../micromark-extension-gfm-strikethrough/lib/syntax.js";
-import { gfmTable as i } from "../micromark-extension-gfm-table/lib/syntax.js";
-import { gfmTaskListItem as e } from "../micromark-extension-gfm-task-list-item/lib/syntax.js";
-function k(o) {
-  return m([
-    r(),
-    t(),
-    f(o),
-    i(),
-    e()
-  ]);
-}
-export {
-  k as gfm
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-extension-gfm/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-extension-gfm/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-extension-gfm-footnote').HtmlOptions} HtmlOptions\n * @typedef {import('micromark-extension-gfm-strikethrough').Options} Options\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n */\n\nimport {\n  combineExtensions,\n  combineHtmlExtensions\n} from 'micromark-util-combine-extensions'\nimport {\n  gfmAutolinkLiteral,\n  gfmAutolinkLiteralHtml\n} from 'micromark-extension-gfm-autolink-literal'\nimport {gfmFootnote, gfmFootnoteHtml} from 'micromark-extension-gfm-footnote'\nimport {\n  gfmStrikethrough,\n  gfmStrikethroughHtml\n} from 'micromark-extension-gfm-strikethrough'\nimport {gfmTable, gfmTableHtml} from 'micromark-extension-gfm-table'\nimport {gfmTagfilterHtml} from 'micromark-extension-gfm-tagfilter'\nimport {\n  gfmTaskListItem,\n  gfmTaskListItemHtml\n} from 'micromark-extension-gfm-task-list-item'\n\n/**\n * Create an extension for `micromark` to enable GFM syntax.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n *\n *   Passed to `micromark-extens-gfm-strikethrough`.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   syntax.\n */\nexport function gfm(options) {\n  return combineExtensions([\n    gfmAutolinkLiteral(),\n    gfmFootnote(),\n    gfmStrikethrough(options),\n    gfmTable(),\n    gfmTaskListItem()\n  ])\n}\n\n/**\n * Create an extension for `micromark` to support GFM when serializing to HTML.\n *\n * @param {HtmlOptions | null | undefined} [options]\n *   Configuration (optional).\n *\n *   Passed to `micromark-extens-gfm-footnote`.\n * @returns {HtmlExtension}\n *   Extension for `micromark` that can be passed in `htmlExtensions` to\n *   support GFM when serializing to HTML.\n */\nexport function gfmHtml(options) {\n  return combineHtmlExtensions([\n    gfmAutolinkLiteralHtml(),\n    gfmFootnoteHtml(options),\n    gfmStrikethroughHtml(),\n    gfmTableHtml(),\n    gfmTagfilterHtml(),\n    gfmTaskListItemHtml()\n  ])\n}\n"],"names":["gfm","options","combineExtensions","gfmAutolinkLiteral","gfmFootnote","gfmStrikethrough","gfmTable","gfmTaskListItem"],"mappings":";;;;;;AAsCO,SAASA,EAAIC,GAAS;AAC3B,SAAOC,EAAkB;AAAA,IACvBC,EAAkB;AAAA,IAClBC,EAAW;AAAA,IACXC,EAAiBJ,CAAO;AAAA,IACxBK,EAAQ;AAAA,IACRC,EAAe;AAAA,EACnB,CAAG;AACH;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.js","sources":["../../../../../../../node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js"],"sourcesContent":["/**\n * @import {Code, ConstructRecord, Event, Extension, Previous, State, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { asciiAlpha, asciiAlphanumeric, asciiControl, markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\nconst wwwPrefix = {\n  tokenize: tokenizeWwwPrefix,\n  partial: true\n};\nconst domain = {\n  tokenize: tokenizeDomain,\n  partial: true\n};\nconst path = {\n  tokenize: tokenizePath,\n  partial: true\n};\nconst trail = {\n  tokenize: tokenizeTrail,\n  partial: true\n};\nconst emailDomainDotTrail = {\n  tokenize: tokenizeEmailDomainDotTrail,\n  partial: true\n};\nconst wwwAutolink = {\n  name: 'wwwAutolink',\n  tokenize: tokenizeWwwAutolink,\n  previous: previousWww\n};\nconst protocolAutolink = {\n  name: 'protocolAutolink',\n  tokenize: tokenizeProtocolAutolink,\n  previous: previousProtocol\n};\nconst emailAutolink = {\n  name: 'emailAutolink',\n  tokenize: tokenizeEmailAutolink,\n  previous: previousEmail\n};\n\n/** @type {ConstructRecord} */\nconst text = {};\n\n/**\n * Create an extension for `micromark` to support GitHub autolink literal\n * syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   autolink literal syntax.\n */\nexport function gfmAutolinkLiteral() {\n  return {\n    text\n  };\n}\n\n/** @type {Code} */\nlet code = 48;\n\n// Add alphanumerics.\nwhile (code < 123) {\n  text[code] = emailAutolink;\n  code++;\n  if (code === 58) code = 65;else if (code === 91) code = 97;\n}\ntext[43] = emailAutolink;\ntext[45] = emailAutolink;\ntext[46] = emailAutolink;\ntext[95] = emailAutolink;\ntext[72] = [emailAutolink, protocolAutolink];\ntext[104] = [emailAutolink, protocolAutolink];\ntext[87] = [emailAutolink, wwwAutolink];\ntext[119] = [emailAutolink, wwwAutolink];\n\n// To do: perform email autolink literals on events, afterwards.\n// That’s where `markdown-rs` and `cmark-gfm` perform it.\n// It should look for `@`, then for atext backwards, and then for a label\n// forwards.\n// To do: `mailto:`, `xmpp:` protocol as prefix.\n\n/**\n * Email autolink literal.\n *\n * ```markdown\n * > | a contact@example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailAutolink(effects, ok, nok) {\n  const self = this;\n  /** @type {boolean | undefined} */\n  let dot;\n  /** @type {boolean} */\n  let data;\n  return start;\n\n  /**\n   * Start of email autolink literal.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (!gfmAtext(code) || !previousEmail.call(self, self.previous) || previousUnbalanced(self.events)) {\n      return nok(code);\n    }\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkEmail');\n    return atext(code);\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atext(code) {\n    if (gfmAtext(code)) {\n      effects.consume(code);\n      return atext;\n    }\n    if (code === 64) {\n      effects.consume(code);\n      return emailDomain;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In email domain.\n   *\n   * The reference code is a bit overly complex as it handles the `@`, of which\n   * there may be just one.\n   * Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L318>\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomain(code) {\n    // Dot followed by alphanumerical (not `-` or `_`).\n    if (code === 46) {\n      return effects.check(emailDomainDotTrail, emailDomainAfter, emailDomainDot)(code);\n    }\n\n    // Alphanumerical, `-`, and `_`.\n    if (code === 45 || code === 95 || asciiAlphanumeric(code)) {\n      data = true;\n      effects.consume(code);\n      return emailDomain;\n    }\n\n    // To do: `/` if xmpp.\n\n    // Note: normally we’d truncate trailing punctuation from the link.\n    // However, email autolink literals cannot contain any of those markers,\n    // except for `.`, but that can only occur if it isn’t trailing.\n    // So we can ignore truncating!\n    return emailDomainAfter(code);\n  }\n\n  /**\n   * In email domain, on dot that is not a trail.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainDot(code) {\n    effects.consume(code);\n    dot = true;\n    return emailDomain;\n  }\n\n  /**\n   * After email domain.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainAfter(code) {\n    // Domain must not be empty, must include a dot, and must end in alphabetical.\n    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L332>.\n    if (data && dot && asciiAlpha(self.previous)) {\n      effects.exit('literalAutolinkEmail');\n      effects.exit('literalAutolink');\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * `www` autolink literal.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwAutolink(effects, ok, nok) {\n  const self = this;\n  return wwwStart;\n\n  /**\n   * Start of www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwStart(code) {\n    if (code !== 87 && code !== 119 || !previousWww.call(self, self.previous) || previousUnbalanced(self.events)) {\n      return nok(code);\n    }\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkWww');\n    // Note: we *check*, so we can discard the `www.` we parsed.\n    // If it worked, we consider it as a part of the domain.\n    return effects.check(wwwPrefix, effects.attempt(domain, effects.attempt(path, wwwAfter), nok), nok)(code);\n  }\n\n  /**\n   * After a www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwAfter(code) {\n    effects.exit('literalAutolinkWww');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\n/**\n * Protocol autolink literal.\n *\n * ```markdown\n * > | a https://example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeProtocolAutolink(effects, ok, nok) {\n  const self = this;\n  let buffer = '';\n  let seen = false;\n  return protocolStart;\n\n  /**\n   * Start of protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolStart(code) {\n    if ((code === 72 || code === 104) && previousProtocol.call(self, self.previous) && !previousUnbalanced(self.events)) {\n      effects.enter('literalAutolink');\n      effects.enter('literalAutolinkHttp');\n      buffer += String.fromCodePoint(code);\n      effects.consume(code);\n      return protocolPrefixInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In protocol.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolPrefixInside(code) {\n    // `5` is size of `https`\n    if (asciiAlpha(code) && buffer.length < 5) {\n      // @ts-expect-error: definitely number.\n      buffer += String.fromCodePoint(code);\n      effects.consume(code);\n      return protocolPrefixInside;\n    }\n    if (code === 58) {\n      const protocol = buffer.toLowerCase();\n      if (protocol === 'http' || protocol === 'https') {\n        effects.consume(code);\n        return protocolSlashesInside;\n      }\n    }\n    return nok(code);\n  }\n\n  /**\n   * In slashes.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *           ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolSlashesInside(code) {\n    if (code === 47) {\n      effects.consume(code);\n      if (seen) {\n        return afterProtocol;\n      }\n      seen = true;\n      return protocolSlashesInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After protocol, before domain.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterProtocol(code) {\n    // To do: this is different from `markdown-rs`:\n    // https://github.com/wooorm/markdown-rs/blob/b3a921c761309ae00a51fe348d8a43adbc54b518/src/construct/gfm_autolink_literal.rs#L172-L182\n    return code === null || asciiControl(code) || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || unicodePunctuation(code) ? nok(code) : effects.attempt(domain, effects.attempt(path, protocolAfter), nok)(code);\n  }\n\n  /**\n   * After a protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *                              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolAfter(code) {\n    effects.exit('literalAutolinkHttp');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\n/**\n * `www` prefix.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwPrefix(effects, ok, nok) {\n  let size = 0;\n  return wwwPrefixInside;\n\n  /**\n   * In www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *     ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixInside(code) {\n    if ((code === 87 || code === 119) && size < 3) {\n      size++;\n      effects.consume(code);\n      return wwwPrefixInside;\n    }\n    if (code === 46 && size === 3) {\n      effects.consume(code);\n      return wwwPrefixAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixAfter(code) {\n    // If there is *anything*, we can link.\n    return code === null ? nok(code) : ok(code);\n  }\n}\n\n/**\n * Domain.\n *\n * ```markdown\n * > | a https://example.org b\n *               ^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDomain(effects, ok, nok) {\n  /** @type {boolean | undefined} */\n  let underscoreInLastSegment;\n  /** @type {boolean | undefined} */\n  let underscoreInLastLastSegment;\n  /** @type {boolean | undefined} */\n  let seen;\n  return domainInside;\n\n  /**\n   * In domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *             ^^^^^^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainInside(code) {\n    // Check whether this marker, which is a trailing punctuation\n    // marker, optionally followed by more trailing markers, and then\n    // followed by an end.\n    if (code === 46 || code === 95) {\n      return effects.check(trail, domainAfter, domainAtPunctuation)(code);\n    }\n\n    // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can\n    // occur, which sounds like ASCII only, but they also support `www.點看.com`,\n    // so that’s Unicode.\n    // Instead of some new production for Unicode alphanumerics, markdown\n    // already has that for Unicode punctuation and whitespace, so use those.\n    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L12>.\n    if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || code !== 45 && unicodePunctuation(code)) {\n      return domainAfter(code);\n    }\n    seen = true;\n    effects.consume(code);\n    return domainInside;\n  }\n\n  /**\n   * In domain, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainAtPunctuation(code) {\n    // There is an underscore in the last segment of the domain\n    if (code === 95) {\n      underscoreInLastSegment = true;\n    }\n    // Otherwise, it’s a `.`: save the last segment underscore in the\n    // penultimate segment slot.\n    else {\n      underscoreInLastLastSegment = underscoreInLastSegment;\n      underscoreInLastSegment = undefined;\n    }\n    effects.consume(code);\n    return domainInside;\n  }\n\n  /**\n   * After domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^\n   * ```\n   *\n   * @type {State} */\n  function domainAfter(code) {\n    // Note: that’s GH says a dot is needed, but it’s not true:\n    // <https://github.com/github/cmark-gfm/issues/279>\n    if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) {\n      return nok(code);\n    }\n    return ok(code);\n  }\n}\n\n/**\n * Path.\n *\n * ```markdown\n * > | a https://example.org/stuff b\n *                          ^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePath(effects, ok) {\n  let sizeOpen = 0;\n  let sizeClose = 0;\n  return pathInside;\n\n  /**\n   * In path.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathInside(code) {\n    if (code === 40) {\n      sizeOpen++;\n      effects.consume(code);\n      return pathInside;\n    }\n\n    // To do: `markdown-rs` also needs this.\n    // If this is a paren, and there are less closings than openings,\n    // we don’t check for a trail.\n    if (code === 41 && sizeClose < sizeOpen) {\n      return pathAtPunctuation(code);\n    }\n\n    // Check whether this trailing punctuation marker is optionally\n    // followed by more trailing markers, and then followed\n    // by an end.\n    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) {\n      return effects.check(trail, ok, pathAtPunctuation)(code);\n    }\n    if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    effects.consume(code);\n    return pathInside;\n  }\n\n  /**\n   * In path, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com/a\"b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathAtPunctuation(code) {\n    // Count closing parens.\n    if (code === 41) {\n      sizeClose++;\n    }\n    effects.consume(code);\n    return pathInside;\n  }\n}\n\n/**\n * Trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the entire trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | https://example.com\").\n *                        ^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTrail(effects, ok, nok) {\n  return trail;\n\n  /**\n   * In trail of domain or path.\n   *\n   * ```markdown\n   * > | https://example.com\").\n   *                        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trail(code) {\n    // Regular trailing punctuation.\n    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) {\n      effects.consume(code);\n      return trail;\n    }\n\n    // `&` followed by one or more alphabeticals and then a `;`, is\n    // as a whole considered as trailing punctuation.\n    // In all other cases, it is considered as continuation of the URL.\n    if (code === 38) {\n      effects.consume(code);\n      return trailCharacterReferenceStart;\n    }\n\n    // Needed because we allow literals after `[`, as we fix:\n    // <https://github.com/github/cmark-gfm/issues/278>.\n    // Check that it is not followed by `(` or `[`.\n    if (code === 93) {\n      effects.consume(code);\n      return trailBracketAfter;\n    }\n    if (\n    // `<` is an end.\n    code === 60 ||\n    // So is whitespace.\n    code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In trail, after `]`.\n   *\n   * > 👉 **Note**: this deviates from `cmark-gfm` to fix a bug.\n   * > See end of <https://github.com/github/cmark-gfm/issues/278> for more.\n   *\n   * ```markdown\n   * > | https://example.com](\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailBracketAfter(code) {\n    // Whitespace or something that could start a resource or reference is the end.\n    // Switch back to trail otherwise.\n    if (code === null || code === 40 || code === 91 || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    return trail(code);\n  }\n\n  /**\n   * In character-reference like trail, after `&`.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharacterReferenceStart(code) {\n    // When non-alpha, it’s not a trail.\n    return asciiAlpha(code) ? trailCharacterReferenceInside(code) : nok(code);\n  }\n\n  /**\n   * In character-reference like trail.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharacterReferenceInside(code) {\n    // Switch back to trail if this is well-formed.\n    if (code === 59) {\n      effects.consume(code);\n      return trail;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return trailCharacterReferenceInside;\n    }\n\n    // It’s not a trail.\n    return nok(code);\n  }\n}\n\n/**\n * Dot in email domain trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | contact@example.org.\n *                        ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailDomainDotTrail(effects, ok, nok) {\n  return start;\n\n  /**\n   * Dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                    ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Must be dot.\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                     ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Not a trail if alphanumeric.\n    return asciiAlphanumeric(code) ? nok(code) : ok(code);\n  }\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L156>.\n *\n * @type {Previous}\n */\nfunction previousWww(code) {\n  return code === null || code === 40 || code === 42 || code === 95 || code === 91 || code === 93 || code === 126 || markdownLineEndingOrSpace(code);\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L214>.\n *\n * @type {Previous}\n */\nfunction previousProtocol(code) {\n  return !asciiAlpha(code);\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previousEmail(code) {\n  // Do not allow a slash “inside” atext.\n  // The reference code is a bit weird, but that’s what it results in.\n  // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L307>.\n  // Other than slash, every preceding character is allowed.\n  return !(code === 47 || gfmAtext(code));\n}\n\n/**\n * @param {Code} code\n * @returns {boolean}\n */\nfunction gfmAtext(code) {\n  return code === 43 || code === 45 || code === 46 || code === 95 || asciiAlphanumeric(code);\n}\n\n/**\n * @param {Array<Event>} events\n * @returns {boolean}\n */\nfunction previousUnbalanced(events) {\n  let index = events.length;\n  let result = false;\n  while (index--) {\n    const token = events[index][1];\n    if ((token.type === 'labelLink' || token.type === 'labelImage') && !token._balanced) {\n      result = true;\n      break;\n    }\n\n    // If we’ve seen this token, and it was marked as not having any unbalanced\n    // bracket before it, we can exit.\n    if (token._gfmAutolinkLiteralWalkedInto) {\n      result = false;\n      break;\n    }\n  }\n  if (events.length > 0 && !result) {\n    // Mark the last token as “walked into” w/o finding\n    // anything.\n    events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true;\n  }\n  return result;\n}"],"names":["wwwPrefix","tokenizeWwwPrefix","domain","tokenizeDomain","path","tokenizePath","trail","tokenizeTrail","emailDomainDotTrail","tokenizeEmailDomainDotTrail","wwwAutolink","tokenizeWwwAutolink","previousWww","protocolAutolink","tokenizeProtocolAutolink","previousProtocol","emailAutolink","tokenizeEmailAutolink","previousEmail","text","gfmAutolinkLiteral","code","effects","ok","nok","self","dot","data","start","gfmAtext","previousUnbalanced","atext","emailDomain","emailDomainAfter","emailDomainDot","asciiAlphanumeric","asciiAlpha","wwwStart","wwwAfter","buffer","seen","protocolStart","protocolPrefixInside","protocol","protocolSlashesInside","afterProtocol","asciiControl","markdownLineEndingOrSpace","unicodeWhitespace","unicodePunctuation","protocolAfter","size","wwwPrefixInside","wwwPrefixAfter","underscoreInLastSegment","underscoreInLastLastSegment","domainInside","domainAfter","domainAtPunctuation","sizeOpen","sizeClose","pathInside","pathAtPunctuation","trailCharacterReferenceStart","trailBracketAfter","trailCharacterReferenceInside","after","events","index","result","token"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-extension-gfm-footnote/lib/syntax.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.js","sources":["../../../../../../../node_modules/micromark-extension-gfm-footnote/lib/syntax.js"],"sourcesContent":["/**\n * @import {Event, Exiter, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { blankLine } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nconst indent = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n\n// To do: micromark should support a `_hiddenGfmFootnoteSupport`, which only\n// affects label start (image).\n// That will let us drop `tokenizePotentialGfmFootnote*`.\n// It currently has a `_hiddenFootnoteSupport`, which affects that and more.\n// That can be removed when `micromark-extension-footnote` is archived.\n\n/**\n * Create an extension for `micromark` to enable GFM footnote syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to\n *   enable GFM footnote syntax.\n */\nexport function gfmFootnote() {\n  /** @type {Extension} */\n  return {\n    document: {\n      [91]: {\n        name: 'gfmFootnoteDefinition',\n        tokenize: tokenizeDefinitionStart,\n        continuation: {\n          tokenize: tokenizeDefinitionContinuation\n        },\n        exit: gfmFootnoteDefinitionEnd\n      }\n    },\n    text: {\n      [91]: {\n        name: 'gfmFootnoteCall',\n        tokenize: tokenizeGfmFootnoteCall\n      },\n      [93]: {\n        name: 'gfmPotentialFootnoteCall',\n        add: 'after',\n        tokenize: tokenizePotentialGfmFootnoteCall,\n        resolveTo: resolveToPotentialGfmFootnoteCall\n      }\n    }\n  };\n}\n\n// To do: remove after micromark update.\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePotentialGfmFootnoteCall(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  /** @type {Token} */\n  let labelStart;\n\n  // Find an opening.\n  while (index--) {\n    const token = self.events[index][1];\n    if (token.type === \"labelImage\") {\n      labelStart = token;\n      break;\n    }\n\n    // Exit if we’ve walked far enough.\n    if (token.type === 'gfmFootnoteCall' || token.type === \"labelLink\" || token.type === \"label\" || token.type === \"image\" || token.type === \"link\") {\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * @type {State}\n   */\n  function start(code) {\n    if (!labelStart || !labelStart._balanced) {\n      return nok(code);\n    }\n    const id = normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    }));\n    if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) {\n      return nok(code);\n    }\n    effects.enter('gfmFootnoteCallLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallLabelMarker');\n    return ok(code);\n  }\n}\n\n// To do: remove after micromark update.\n/** @type {Resolver} */\nfunction resolveToPotentialGfmFootnoteCall(events, context) {\n  let index = events.length;\n  /** @type {Token | undefined} */\n  let labelStart;\n\n  // Find an opening.\n  while (index--) {\n    if (events[index][1].type === \"labelImage\" && events[index][0] === 'enter') {\n      labelStart = events[index][1];\n      break;\n    }\n  }\n  // Change the `labelImageMarker` to a `data`.\n  events[index + 1][1].type = \"data\";\n  events[index + 3][1].type = 'gfmFootnoteCallLabelMarker';\n\n  // The whole (without `!`):\n  /** @type {Token} */\n  const call = {\n    type: 'gfmFootnoteCall',\n    start: Object.assign({}, events[index + 3][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  };\n  // The `^` marker\n  /** @type {Token} */\n  const marker = {\n    type: 'gfmFootnoteCallMarker',\n    start: Object.assign({}, events[index + 3][1].end),\n    end: Object.assign({}, events[index + 3][1].end)\n  };\n  // Increment the end 1 character.\n  marker.end.column++;\n  marker.end.offset++;\n  marker.end._bufferIndex++;\n  /** @type {Token} */\n  const string = {\n    type: 'gfmFootnoteCallString',\n    start: Object.assign({}, marker.end),\n    end: Object.assign({}, events[events.length - 1][1].start)\n  };\n  /** @type {Token} */\n  const chunk = {\n    type: \"chunkString\",\n    contentType: 'string',\n    start: Object.assign({}, string.start),\n    end: Object.assign({}, string.end)\n  };\n\n  /** @type {Array<Event>} */\n  const replacement = [\n  // Take the `labelImageMarker` (now `data`, the `!`)\n  events[index + 1], events[index + 2], ['enter', call, context],\n  // The `[`\n  events[index + 3], events[index + 4],\n  // The `^`.\n  ['enter', marker, context], ['exit', marker, context],\n  // Everything in between.\n  ['enter', string, context], ['enter', chunk, context], ['exit', chunk, context], ['exit', string, context],\n  // The ending (`]`, properly parsed and labelled).\n  events[events.length - 2], events[events.length - 1], ['exit', call, context]];\n  events.splice(index, events.length - index + 1, ...replacement);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeGfmFootnoteCall(effects, ok, nok) {\n  const self = this;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  let size = 0;\n  /** @type {boolean} */\n  let data;\n\n  // Note: the implementation of `markdown-rs` is different, because it houses\n  // core *and* extensions in one project.\n  // Therefore, it can include footnote logic inside `label-end`.\n  // We can’t do that, but luckily, we can parse footnotes in a simpler way than\n  // needed for labels.\n  return start;\n\n  /**\n   * Start of footnote label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteCall');\n    effects.enter('gfmFootnoteCallLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallLabelMarker');\n    return callStart;\n  }\n\n  /**\n   * After `[`, at `^`.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callStart(code) {\n    if (code !== 94) return nok(code);\n    effects.enter('gfmFootnoteCallMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallMarker');\n    effects.enter('gfmFootnoteCallString');\n    effects.enter('chunkString').contentType = 'string';\n    return callData;\n  }\n\n  /**\n   * In label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callData(code) {\n    if (\n    // Too long.\n    size > 999 ||\n    // Closing brace with nothing.\n    code === 93 && !data ||\n    // Space or tab is not supported by GFM for some reason.\n    // `\\n` and `[` not being supported makes sense.\n    code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit('chunkString');\n      const token = effects.exit('gfmFootnoteCallString');\n      if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) {\n        return nok(code);\n      }\n      effects.enter('gfmFootnoteCallLabelMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteCallLabelMarker');\n      effects.exit('gfmFootnoteCall');\n      return ok;\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true;\n    }\n    size++;\n    effects.consume(code);\n    return code === 92 ? callEscape : callData;\n  }\n\n  /**\n   * On character after escape.\n   *\n   * ```markdown\n   * > | a [^b\\c] d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return callData;\n    }\n    return callData(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionStart(effects, ok, nok) {\n  const self = this;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  /** @type {string} */\n  let identifier;\n  let size = 0;\n  /** @type {boolean | undefined} */\n  let data;\n  return start;\n\n  /**\n   * Start of GFM footnote definition.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteDefinition')._container = true;\n    effects.enter('gfmFootnoteDefinitionLabel');\n    effects.enter('gfmFootnoteDefinitionLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteDefinitionLabelMarker');\n    return labelAtMarker;\n  }\n\n  /**\n   * In label, at caret.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAtMarker(code) {\n    if (code === 94) {\n      effects.enter('gfmFootnoteDefinitionMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteDefinitionMarker');\n      effects.enter('gfmFootnoteDefinitionLabelString');\n      effects.enter('chunkString').contentType = 'string';\n      return labelInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label.\n   *\n   * > 👉 **Note**: `cmark-gfm` prevents whitespace from occurring in footnote\n   * > definition labels.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n    // Too long.\n    size > 999 ||\n    // Closing brace with nothing.\n    code === 93 && !data ||\n    // Space or tab is not supported by GFM for some reason.\n    // `\\n` and `[` not being supported makes sense.\n    code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit('chunkString');\n      const token = effects.exit('gfmFootnoteDefinitionLabelString');\n      identifier = normalizeIdentifier(self.sliceSerialize(token));\n      effects.enter('gfmFootnoteDefinitionLabelMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteDefinitionLabelMarker');\n      effects.exit('gfmFootnoteDefinitionLabel');\n      return labelAfter;\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true;\n    }\n    size++;\n    effects.consume(code);\n    return code === 92 ? labelEscape : labelInside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * > 👉 **Note**: `cmark-gfm` currently does not support escaped brackets:\n   * > <https://github.com/github/cmark-gfm/issues/240>\n   *\n   * ```markdown\n   * > | [^a\\*b]: c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return labelInside;\n    }\n    return labelInside(code);\n  }\n\n  /**\n   * After definition label.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    if (code === 58) {\n      effects.enter('definitionMarker');\n      effects.consume(code);\n      effects.exit('definitionMarker');\n      if (!defined.includes(identifier)) {\n        defined.push(identifier);\n      }\n\n      // Any whitespace after the marker is eaten, forming indented code\n      // is not possible.\n      // No space is also fine, just like a block quote marker.\n      return factorySpace(effects, whitespaceAfter, 'gfmFootnoteDefinitionWhitespace');\n    }\n    return nok(code);\n  }\n\n  /**\n   * After definition prefix.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function whitespaceAfter(code) {\n    // `markdown-rs` has a wrapping token for the prefix that is closed here.\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionContinuation(effects, ok, nok) {\n  /// Start of footnote definition continuation.\n  ///\n  /// ```markdown\n  ///   | [^a]: b\n  /// > |     c\n  ///     ^\n  /// ```\n  //\n  // Either a blank line, which is okay, or an indented thing.\n  return effects.check(blankLine, ok, effects.attempt(indent, ok, nok));\n}\n\n/** @type {Exiter} */\nfunction gfmFootnoteDefinitionEnd(effects) {\n  effects.exit('gfmFootnoteDefinition');\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, 'gfmFootnoteDefinitionIndent', 4 + 1);\n\n  /**\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === 'gfmFootnoteDefinitionIndent' && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok(code) : nok(code);\n  }\n}"],"names":["indent","tokenizeIndent","gfmFootnote","tokenizeDefinitionStart","tokenizeDefinitionContinuation","gfmFootnoteDefinitionEnd","tokenizeGfmFootnoteCall","tokenizePotentialGfmFootnoteCall","resolveToPotentialGfmFootnoteCall","effects","ok","nok","self","index","defined","labelStart","token","start","code","id","normalizeIdentifier","events","context","call","marker","string","chunk","replacement","size","data","callStart","callData","markdownLineEndingOrSpace","callEscape","identifier","labelAtMarker","labelInside","labelAfter","labelEscape","factorySpace","whitespaceAfter","blankLine","afterPrefix","tail"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.js","sources":["../../../../../../../node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js"],"sourcesContent":["/**\n * @import {Options} from 'micromark-extension-gfm-strikethrough'\n * @import {Event, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create an extension for `micromark` to enable GFM strikethrough syntax.\n *\n * @param {Options | null | undefined} [options={}]\n *   Configuration.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions`, to\n *   enable GFM strikethrough syntax.\n */\nexport function gfmStrikethrough(options) {\n  const options_ = options || {};\n  let single = options_.singleTilde;\n  const tokenizer = {\n    name: 'strikethrough',\n    tokenize: tokenizeStrikethrough,\n    resolveAll: resolveAllStrikethrough\n  };\n  if (single === null || single === undefined) {\n    single = true;\n  }\n  return {\n    text: {\n      [126]: tokenizer\n    },\n    insideSpan: {\n      null: [tokenizer]\n    },\n    attentionMarkers: {\n      null: [126]\n    }\n  };\n\n  /**\n   * Take events and resolve strikethrough.\n   *\n   * @type {Resolver}\n   */\n  function resolveAllStrikethrough(events, context) {\n    let index = -1;\n\n    // Walk through all events.\n    while (++index < events.length) {\n      // Find a token that can close.\n      if (events[index][0] === 'enter' && events[index][1].type === 'strikethroughSequenceTemporary' && events[index][1]._close) {\n        let open = index;\n\n        // Now walk back to find an opener.\n        while (open--) {\n          // Find a token that can open the closer.\n          if (events[open][0] === 'exit' && events[open][1].type === 'strikethroughSequenceTemporary' && events[open][1]._open &&\n          // If the sizes are the same:\n          events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {\n            events[index][1].type = 'strikethroughSequence';\n            events[open][1].type = 'strikethroughSequence';\n\n            /** @type {Token} */\n            const strikethrough = {\n              type: 'strikethrough',\n              start: Object.assign({}, events[open][1].start),\n              end: Object.assign({}, events[index][1].end)\n            };\n\n            /** @type {Token} */\n            const text = {\n              type: 'strikethroughText',\n              start: Object.assign({}, events[open][1].end),\n              end: Object.assign({}, events[index][1].start)\n            };\n\n            // Opening.\n            /** @type {Array<Event>} */\n            const nextEvents = [['enter', strikethrough, context], ['enter', events[open][1], context], ['exit', events[open][1], context], ['enter', text, context]];\n            const insideSpan = context.parser.constructs.insideSpan.null;\n            if (insideSpan) {\n              // Between.\n              splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context));\n            }\n\n            // Closing.\n            splice(nextEvents, nextEvents.length, 0, [['exit', text, context], ['enter', events[index][1], context], ['exit', events[index][1], context], ['exit', strikethrough, context]]);\n            splice(events, open - 1, index - open + 3, nextEvents);\n            index = open + nextEvents.length - 2;\n            break;\n          }\n        }\n      }\n    }\n    index = -1;\n    while (++index < events.length) {\n      if (events[index][1].type === 'strikethroughSequenceTemporary') {\n        events[index][1].type = \"data\";\n      }\n    }\n    return events;\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeStrikethrough(effects, ok, nok) {\n    const previous = this.previous;\n    const events = this.events;\n    let size = 0;\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      if (previous === 126 && events[events.length - 1][1].type !== \"characterEscape\") {\n        return nok(code);\n      }\n      effects.enter('strikethroughSequenceTemporary');\n      return more(code);\n    }\n\n    /** @type {State} */\n    function more(code) {\n      const before = classifyCharacter(previous);\n      if (code === 126) {\n        // If this is the third marker, exit.\n        if (size > 1) return nok(code);\n        effects.consume(code);\n        size++;\n        return more;\n      }\n      if (size < 2 && !single) return nok(code);\n      const token = effects.exit('strikethroughSequenceTemporary');\n      const after = classifyCharacter(code);\n      token._open = !after || after === 2 && Boolean(before);\n      token._close = !before || before === 2 && Boolean(after);\n      return ok(code);\n    }\n  }\n}"],"names":["gfmStrikethrough","options","single","tokenizer","tokenizeStrikethrough","resolveAllStrikethrough","events","context","index","open","strikethrough","text","nextEvents","insideSpan","splice","resolveAll","effects","ok","nok","previous","size","start","code","more","before","classifyCharacter","token","after"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.js","sources":["../../../../../../../node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js"],"sourcesContent":["/**\n * @import {Extension, State, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nconst tasklistCheck = {\n  name: 'tasklistCheck',\n  tokenize: tokenizeTasklistCheck\n};\n\n/**\n * Create an HTML extension for `micromark` to support GFM task list items\n * syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `htmlExtensions` to\n *   support GFM task list items when serializing to HTML.\n */\nexport function gfmTaskListItem() {\n  return {\n    text: {\n      [91]: tasklistCheck\n    }\n  };\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTasklistCheck(effects, ok, nok) {\n  const self = this;\n  return open;\n\n  /**\n   * At start of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (\n    // Exit if there’s stuff before.\n    self.previous !== null ||\n    // Exit if not in the first content that is the first child of a list\n    // item.\n    !self._gfmTasklistFirstContentOfListItem) {\n      return nok(code);\n    }\n    effects.enter('taskListCheck');\n    effects.enter('taskListCheckMarker');\n    effects.consume(code);\n    effects.exit('taskListCheckMarker');\n    return inside;\n  }\n\n  /**\n   * In task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // Currently we match how GH works in files.\n    // To match how GH works in comments, use `markdownSpace` (`[\\t ]`) instead\n    // of `markdownLineEndingOrSpace` (`[\\t\\n\\r ]`).\n    if (markdownLineEndingOrSpace(code)) {\n      effects.enter('taskListCheckValueUnchecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueUnchecked');\n      return close;\n    }\n    if (code === 88 || code === 120) {\n      effects.enter('taskListCheckValueChecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueChecked');\n      return close;\n    }\n    return nok(code);\n  }\n\n  /**\n   * At close of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function close(code) {\n    if (code === 93) {\n      effects.enter('taskListCheckMarker');\n      effects.consume(code);\n      effects.exit('taskListCheckMarker');\n      effects.exit('taskListCheck');\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * @type {State}\n   */\n  function after(code) {\n    // EOL in paragraph means there must be something else after it.\n    if (markdownLineEnding(code)) {\n      return ok(code);\n    }\n\n    // Space or tab?\n    // Check what comes after.\n    if (markdownSpace(code)) {\n      return effects.check({\n        tokenize: spaceThenNonSpace\n      }, ok, nok)(code);\n    }\n\n    // EOF, or non-whitespace, both wrong.\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction spaceThenNonSpace(effects, ok, nok) {\n  return factorySpace(effects, after, \"whitespace\");\n\n  /**\n   * After whitespace, after task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // EOF means there was nothing, so bad.\n    // EOL means there’s content after it, so good.\n    // Impossible to have more spaces.\n    // Anything else is good.\n    return code === null ? nok(code) : ok(code);\n  }\n}"],"names":["tasklistCheck","tokenizeTasklistCheck","gfmTaskListItem","effects","ok","nok","self","open","code","inside","markdownLineEndingOrSpace","close","after","markdownLineEnding","markdownSpace","spaceThenNonSpace","factorySpace"],"mappings":";;AAMA,MAAMA,IAAgB;AAAA,EACpB,MAAM;AAAA,EACN,UAAUC;AACZ;AAUO,SAASC,IAAkB;AAChC,SAAO;AAAA,IACL,MAAM;AAAA,MACH,IAAKF;AAAA,IACZ;AAAA,EACA;AACA;AAMA,SAASC,EAAsBE,GAASC,GAAIC,GAAK;AAC/C,QAAMC,IAAO;AACb,SAAOC;AAYP,WAASA,EAAKC,GAAM;AAClB;AAAA;AAAA,MAEAF,EAAK,aAAa;AAAA;AAAA,MAGlB,CAACA,EAAK,qCACGD,EAAIG,CAAI,KAEjBL,EAAQ,MAAM,eAAe,GAC7BA,EAAQ,MAAM,qBAAqB,GACnCA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,qBAAqB,GAC3BM;AAAA;AAAA,EACT;AAYA,WAASA,EAAOD,GAAM;AAIpB,WAAIE,EAA0BF,CAAI,KAChCL,EAAQ,MAAM,6BAA6B,GAC3CA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,6BAA6B,GACnCQ,KAELH,MAAS,MAAMA,MAAS,OAC1BL,EAAQ,MAAM,2BAA2B,GACzCA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,2BAA2B,GACjCQ,KAEFN,EAAIG,CAAI;AAAA,EACjB;AAYA,WAASG,EAAMH,GAAM;AACnB,WAAIA,MAAS,MACXL,EAAQ,MAAM,qBAAqB,GACnCA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,qBAAqB,GAClCA,EAAQ,KAAK,eAAe,GACrBS,KAEFP,EAAIG,CAAI;AAAA,EACjB;AAKA,WAASI,EAAMJ,GAAM;AAEnB,WAAIK,EAAmBL,CAAI,IAClBJ,EAAGI,CAAI,IAKZM,EAAcN,CAAI,IACbL,EAAQ,MAAM;AAAA,MACnB,UAAUY;AAAA,IAClB,GAASX,GAAIC,CAAG,EAAEG,CAAI,IAIXH,EAAIG,CAAI;AAAA,EACjB;AACF;AAMA,SAASO,EAAkBZ,GAASC,GAAIC,GAAK;AAC3C,SAAOW,EAAab,GAASS,GAAO,YAAY;AAYhD,WAASA,EAAMJ,GAAM;AAKnB,WAAOA,MAAS,OAAOH,EAAIG,CAAI,IAAIJ,EAAGI,CAAI;AAAA,EAC5C;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-factory-space/index.js

@@ -1,16 +0,0 @@
-import { markdownSpace as m } from "../micromark-util-character/index.js";
-function p(n, t, i, u) {
-  const o = u ? u - 1 : Number.POSITIVE_INFINITY;
-  let I = 0;
-  return a;
-  function a(r) {
-    return m(r) ? (n.enter(i), e(r)) : t(r);
-  }
-  function e(r) {
-    return m(r) && I++ < o ? (n.consume(r), e) : (n.exit(i), t(r));
-  }
-}
-export {
-  p as factorySpace
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-factory-space/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-factory-space/index.js"],"sourcesContent":["/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { markdownSpace } from 'micromark-util-character';\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return ok(code);\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n    effects.exit(type);\n    return ok(code);\n  }\n}"],"names":["factorySpace","effects","ok","type","max","limit","size","start","code","markdownSpace","prefix"],"mappings":";AAwCO,SAASA,EAAaC,GAASC,GAAIC,GAAMC,GAAK;AACnD,QAAMC,IAAQD,IAAMA,IAAM,IAAI,OAAO;AACrC,MAAIE,IAAO;AACX,SAAOC;AAGP,WAASA,EAAMC,GAAM;AACnB,WAAIC,EAAcD,CAAI,KACpBP,EAAQ,MAAME,CAAI,GACXO,EAAOF,CAAI,KAEbN,EAAGM,CAAI;AAAA,EAChB;AAGA,WAASE,EAAOF,GAAM;AACpB,WAAIC,EAAcD,CAAI,KAAKF,MAASD,KAClCJ,EAAQ,QAAQO,CAAI,GACbE,MAETT,EAAQ,KAAKE,CAAI,GACVD,EAAGM,CAAI;AAAA,EAChB;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-character/index.js

@@ -1,35 +0,0 @@
-const u = t(/[A-Za-z]/), a = t(/[\dA-Za-z]/);
-function c(n) {
-  return (
-    // Special whitespace codes (which have negative values), C0 and Control
-    // character DEL
-    n !== null && (n < 32 || n === 127)
-  );
-}
-function e(n) {
-  return n !== null && n < -2;
-}
-function o(n) {
-  return n !== null && (n < 0 || n === 32);
-}
-function l(n) {
-  return n === -2 || n === -1 || n === 32;
-}
-const s = t(new RegExp("\\p{P}|\\p{S}", "u")), p = t(/\s/);
-function t(n) {
-  return i;
-  function i(r) {
-    return r !== null && r > -1 && n.test(String.fromCharCode(r));
-  }
-}
-export {
-  u as asciiAlpha,
-  a as asciiAlphanumeric,
-  c as asciiControl,
-  e as markdownLineEnding,
-  o as markdownLineEndingOrSpace,
-  l as markdownSpace,
-  s as unicodePunctuation,
-  p as unicodeWhitespace
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-character/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-util-character/index.js"],"sourcesContent":["/**\n * @import {Code} from 'micromark-util-types'\n */\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  );\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n *   Expression.\n * @returns {(code: Code) => boolean}\n *   Check.\n */\nfunction regexCheck(regex) {\n  return check;\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && code > -1 && regex.test(String.fromCharCode(code));\n  }\n}"],"names":["asciiAlpha","regexCheck","asciiAlphanumeric","asciiControl","code","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","check"],"mappings":"AAqBY,MAACA,IAAaC,EAAW,UAAU,GAclCC,IAAoBD,EAAW,YAAY;AAoCjD,SAASE,EAAaC,GAAM;AACjC;AAAA;AAAA;AAAA,IAGEA,MAAS,SAASA,IAAO,MAAMA,MAAS;AAAA;AAE5C;AAiEO,SAASC,EAAmBD,GAAM;AACvC,SAAOA,MAAS,QAAQA,IAAO;AACjC;AAWO,SAASE,EAA0BF,GAAM;AAC9C,SAAOA,MAAS,SAASA,IAAO,KAAKA,MAAS;AAChD;AAiBO,SAASG,EAAcH,GAAM;AAClC,SAAOA,MAAS,MAAMA,MAAS,MAAMA,MAAS;AAChD;AAuBY,MAACI,IAAqBP,EAAW,WAAA,iBAAA,GAAc,IAsB9CQ,IAAoBR,EAAW,IAAI;AAUhD,SAASA,EAAWS,GAAO;AACzB,SAAOC;AAUP,WAASA,EAAMP,GAAM;AACnB,WAAOA,MAAS,QAAQA,IAAO,MAAMM,EAAM,KAAK,OAAO,aAAaN,CAAI,CAAC;AAAA,EAC3E;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-chunked/index.js

@@ -1,13 +0,0 @@
-function p(f, l, n, h) {
-  const e = f.length;
-  let i = 0, c;
-  if (l < 0 ? l = -l > e ? 0 : e + l : l = l > e ? e : l, n = n > 0 ? n : 0, h.length < 1e4)
-    c = Array.from(h), c.unshift(l, n), f.splice(...c);
-  else
-    for (n && f.splice(l, n); i < h.length; )
-      c = h.slice(i, i + 1e4), c.unshift(l, 0), f.splice(...c), i += 1e4, l += 1e4;
-}
-export {
-  p as splice
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-chunked/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-util-chunked/index.js"],"sourcesContent":["/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {undefined}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length;\n  let chunkStart = 0;\n  /** @type {Array<unknown>} */\n  let parameters;\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n  remove = remove > 0 ? remove : 0;\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove);\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items);\n    return list;\n  }\n  return items;\n}"],"names":["splice","list","start","remove","items","end","chunkStart","parameters"],"mappings":"AAsBO,SAASA,EAAOC,GAAMC,GAAOC,GAAQC,GAAO;AACjD,QAAMC,IAAMJ,EAAK;AACjB,MAAIK,IAAa,GAEbC;AAWJ,MARIL,IAAQ,IACVA,IAAQ,CAACA,IAAQG,IAAM,IAAIA,IAAMH,IAEjCA,IAAQA,IAAQG,IAAMA,IAAMH,GAE9BC,IAASA,IAAS,IAAIA,IAAS,GAG3BC,EAAM,SAAS;AACjB,IAAAG,IAAa,MAAM,KAAKH,CAAK,GAC7BG,EAAW,QAAQL,GAAOC,CAAM,GAEhCF,EAAK,OAAO,GAAGM,CAAU;AAAA;AAMzB,SAHIJ,KAAQF,EAAK,OAAOC,GAAOC,CAAM,GAG9BG,IAAaF,EAAM;AACxB,MAAAG,IAAaH,EAAM,MAAME,GAAYA,IAAa,GAAK,GACvDC,EAAW,QAAQL,GAAO,CAAC,GAE3BD,EAAK,OAAO,GAAGM,CAAU,GACzBD,KAAc,KACdJ,KAAS;AAGf;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-classify-character/index.js

@@ -1,11 +0,0 @@
-import { markdownLineEndingOrSpace as i, unicodeWhitespace as r, unicodePunctuation as t } from "../micromark-util-character/index.js";
-function a(n) {
-  if (n === null || i(n) || r(n))
-    return 1;
-  if (t(n))
-    return 2;
-}
-export {
-  a as classifyCharacter
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-classify-character/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-util-classify-character/index.js"],"sourcesContent":["/**\n * @import {Code} from 'micromark-util-types'\n */\n\nimport { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}"],"names":["classifyCharacter","code","markdownLineEndingOrSpace","unicodeWhitespace","unicodePunctuation"],"mappings":";AAmBO,SAASA,EAAkBC,GAAM;AACtC,MAAIA,MAAS,QAAQC,EAA0BD,CAAI,KAAKE,EAAkBF,CAAI;AAC5E,WAAO;AAET,MAAIG,EAAmBH,CAAI;AACzB,WAAO;AAEX;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-combine-extensions/index.js

@@ -1,37 +0,0 @@
-import { splice as a } from "../micromark-util-chunked/index.js";
-const s = {}.hasOwnProperty;
-function d(t) {
-  const e = {};
-  let n = -1;
-  for (; ++n < t.length; )
-    l(e, t[n]);
-  return e;
-}
-function l(t, e) {
-  let n;
-  for (n in e) {
-    const i = (s.call(t, n) ? t[n] : void 0) || (t[n] = {}), f = e[n];
-    let o;
-    if (f)
-      for (o in f) {
-        s.call(i, o) || (i[o] = []);
-        const r = f[o];
-        h(
-          // @ts-expect-error Looks like a list.
-          i[o],
-          Array.isArray(r) ? r : r ? [r] : []
-        );
-      }
-  }
-}
-function h(t, e) {
-  let n = -1;
-  const c = [];
-  for (; ++n < e.length; )
-    (e[n].add === "after" ? t : c).push(e[n]);
-  a(t, 0, 0, c);
-}
-export {
-  d as combineExtensions
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-combine-extensions/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-util-combine-extensions/index.js"],"sourcesContent":["/**\n * @import {\n *   Extension,\n *   Handles,\n *   HtmlExtension,\n *   NormalizedExtension\n * } from 'micromark-util-types'\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {ReadonlyArray<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n *   List of constructs to merge into.\n * @param {Array<unknown>} list\n *   List of constructs to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {ReadonlyArray<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   Single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n"],"names":["hasOwnProperty","combineExtensions","extensions","all","index","syntaxExtension","extension","hook","left","right","code","value","constructs","existing","list","before","splice"],"mappings":";AAWA,MAAMA,IAAiB,CAAA,EAAG;AAUnB,SAASC,EAAkBC,GAAY;AAE5C,QAAMC,IAAM,CAAA;AACZ,MAAIC,IAAQ;AAEZ,SAAO,EAAEA,IAAQF,EAAW;AAC1B,IAAAG,EAAgBF,GAAKD,EAAWE,CAAK,CAAC;AAGxC,SAAOD;AACT;AAYA,SAASE,EAAgBF,GAAKG,GAAW;AAEvC,MAAIC;AAEJ,OAAKA,KAAQD,GAAW;AAGtB,UAAME,KAFQR,EAAe,KAAKG,GAAKI,CAAI,IAAIJ,EAAII,CAAI,IAAI,YAEpCJ,EAAII,CAAI,IAAI,CAAA,IAE7BE,IAAQH,EAAUC,CAAI;AAE5B,QAAIG;AAEJ,QAAID;AACF,WAAKC,KAAQD,GAAO;AAClB,QAAKT,EAAe,KAAKQ,GAAME,CAAI,MAAGF,EAAKE,CAAI,IAAI,CAAA;AACnD,cAAMC,IAAQF,EAAMC,CAAI;AACxB,QAAAE;AAAA;AAAA,UAEEJ,EAAKE,CAAI;AAAA,UACT,MAAM,QAAQC,CAAK,IAAIA,IAAQA,IAAQ,CAACA,CAAK,IAAI,CAAA;AAAA,QAC3D;AAAA,MACM;AAAA,EAEJ;AACF;AAaA,SAASC,EAAWC,GAAUC,GAAM;AAClC,MAAIV,IAAQ;AAEZ,QAAMW,IAAS,CAAA;AAEf,SAAO,EAAEX,IAAQU,EAAK;AAEnB,KAACA,EAAKV,CAAK,EAAE,QAAQ,UAAUS,IAAWE,GAAQ,KAAKD,EAAKV,CAAK,CAAC;AAGrE,EAAAY,EAAOH,GAAU,GAAG,GAAGE,CAAM;AAC/B;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-normalize-identifier/index.js

@@ -1,7 +0,0 @@
-function r(e) {
-  return e.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
-}
-export {
-  r as normalizeIdentifier
-};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-normalize-identifier/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../node_modules/micromark-util-normalize-identifier/index.js"],"sourcesContent":["/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return value\n  // Collapse markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, \" \")\n  // Trim.\n  .replace(/^ | $/g, '')\n  // Some characters are considered “uppercase”, but if their lowercase\n  // counterpart is uppercased will result in a different uppercase\n  // character.\n  // Hence, to get that form, we perform both lower- and uppercase.\n  // Upper case makes sure keys will not interact with default prototypal\n  // methods: no method is uppercase.\n  .toLowerCase().toUpperCase();\n}"],"names":["normalizeIdentifier","value"],"mappings":"AAmBO,SAASA,EAAoBC,GAAO;AACzC,SAAOA,EAEN,QAAQ,eAAe,GAAG,EAE1B,QAAQ,UAAU,EAAE,EAOpB,YAAW,EAAG,YAAW;AAC5B;","x_google_ignoreList":[0]}

package/dist/node_modules/micromark-util-resolve-all/index.js

@@ -1,13 +0,0 @@
-function c(o, e, r) {
-  const i = [];
-  let n = -1;
-  for (; ++n < o.length; ) {
-    const l = o[n].resolveAll;
-    l && !i.includes(l) && (e = l(e, r), i.push(l));
-  }
-  return e;
-}
-export {
-  c as resolveAll
-};
-//# sourceMappingURL=index.js.map