@e-llm-studio/citation 0.0.140-beta.6 → 0.0.141

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","test","value","type","EXIT","Boolean","depth","toString","options","setext"],"mappings":"qNAaO,SAASA,EAAsBC,EAAMC,GAC1C,IAAIC,GAAmB,EAcvB,OAVAC,EAAMH,EAAM,SAAUA,GACpB,GACG,UAAWA,GAAQ,WAAWI,KAAKJ,EAAKK,QAC3B,UAAdL,EAAKM,KAGL,OADAJ,GAAmB,EACZK,CAEb,GAESC,UACHR,EAAKS,OAAST,EAAKS,MAAQ,IAC3BC,EAASV,KACRC,EAAMU,QAAQC,QAAUV,GAE/B"}

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

@@ -1,2 +0,0 @@
-import{toString as t}from"../../../mdast-util-to-string/lib/index.js";function r(r,e){const i=t(r);return Boolean(!e.options.resourceLink&&r.url&&!r.title&&r.children&&1===r.children.length&&"text"===r.children[0].type&&(i===r.url||"mailto:"+i===r.url)&&/^[a-z][a-z+.-]+:/i.test(r.url)&&!/[\0- <>\u007F]/.test(r.url))}export{r as formatLinkAsAutolink};
-//# sourceMappingURL=format-link-as-autolink.js.map

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","Boolean","options","resourceLink","url","title","children","length","type","test"],"mappings":"sEAYO,SAASA,EAAqBC,EAAMC,GACzC,MAAMC,EAAMC,EAASH,GAErB,OAAOI,SACJH,EAAMI,QAAQC,cAEbN,EAAKO,MAEJP,EAAKQ,OAENR,EAAKS,UACoB,IAAzBT,EAAKS,SAASC,QACY,SAA1BV,EAAKS,SAAS,GAAGE,OAEhBT,IAAQF,EAAKO,KAAO,UAAYL,IAAQF,EAAKO,MAE9C,oBAAoBK,KAAKZ,EAAKO,OAG7B,iBAAiBK,KAAKZ,EAAKO,KAElC"}

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

@@ -1,2 +0,0 @@
-function n(n,r){return t(n,r.inConstruct,!0)&&!t(n,r.notInConstruct,!1)}function t(n,t,r){if("string"==typeof t&&(t=[t]),!t||0===t.length)return r;let e=-1;for(;++e<t.length;)if(n.includes(t[e]))return!0;return!1}export{n as patternInScope};
-//# sourceMappingURL=pattern-in-scope.js.map

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","inConstruct","notInConstruct","list","none","length","index","includes"],"mappings":"AASO,SAASA,EAAeC,EAAOC,GACpC,OACEC,EAAYF,EAAOC,EAAQE,aAAa,KACvCD,EAAYF,EAAOC,EAAQG,gBAAgB,EAEhD,CAQA,SAASF,EAAYF,EAAOK,EAAMC,GAKhC,GAJoB,iBAATD,IACTA,EAAO,CAACA,KAGLA,GAAwB,IAAhBA,EAAKE,OAChB,OAAOD,EAGT,IAAIE,GAAS,EAEb,OAASA,EAAQH,EAAKE,QACpB,GAAIP,EAAMS,SAASJ,EAAKG,IACtB,OAAO,EAIX,OAAO,CACT"}

package/dist/node_modules/mdast-util-to-markdown/node_modules/unist-util-visit/lib/index.js

@@ -1,2 +0,0 @@
-import{visitParents as i}from"../../../../unist-util-visit-parents/lib/index.js";export{CONTINUE,EXIT,SKIP}from"../../../../unist-util-visit-parents/lib/index.js";function t(t,n,o,e){let r,f,s;"function"==typeof n&&"function"!=typeof o?(f=void 0,s=n,r=o):(f=n,s=o,r=e),i(t,f,function(i,t){const n=t[t.length-1],o=n?n.children.indexOf(i):void 0;return s(i,o,n)},r)}export{t as visit};
-//# sourceMappingURL=index.js.map

package/dist/node_modules/mdast-util-to-markdown/node_modules/unist-util-visit/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../node_modules/mdast-util-to-markdown/node_modules/unist-util-visit/lib/index.js"],"sourcesContent":["/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\n * @import {VisitorResult} from 'unist-util-visit-parents'\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends ReadonlyArray<any>\n *   ? MatchesOne<Value, Check[number]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse\n  /** @type {Test} */\n  let test\n  /** @type {Visitor} */\n  let visitor\n\n  if (\n    typeof testOrVisitor === 'function' &&\n    typeof visitorOrReverse !== 'function'\n  ) {\n    test = undefined\n    visitor = testOrVisitor\n    reverse = visitorOrReverse\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse\n    reverse = maybeReverse\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1]\n    const index = parent ? parent.children.indexOf(node) : undefined\n    return visitor(node, index, parent)\n  }\n}\n"],"names":["visit","tree","testOrVisitor","visitorOrReverse","maybeReverse","reverse","test","visitor","undefined","visitParents","node","parents","parent","length","index","children","indexOf"],"mappings":"mKAqRO,SAASA,EAAMC,EAAMC,EAAeC,EAAkBC,GAE3D,IAAIC,EAEAC,EAEAC,EAGuB,mBAAlBL,GACqB,mBAArBC,GAEPG,OAAOE,EACPD,EAAUL,EACVG,EAAUF,IAGVG,EAAOJ,EAEPK,EAAUJ,EACVE,EAAUD,GAGZK,EAAaR,EAAMK,EAMnB,SAAkBI,EAAMC,GACtB,MAAMC,EAASD,EAAQA,EAAQE,OAAS,GAClCC,EAAQF,EAASA,EAAOG,SAASC,QAAQN,QAAQF,EACvD,OAAOD,EAAQG,EAAMI,EAAOF,EAC7B,EAVkCP,EAWrC"}

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

@@ -1,2 +0,0 @@
-const n={};function t(t,r){const l=r||n;return e(t,"boolean"!=typeof l.includeImageAlt||l.includeImageAlt,"boolean"!=typeof l.includeHtml||l.includeHtml)}function e(n,t,e){if(function(n){return Boolean(n&&"object"==typeof n)}(n)){if("value"in n)return"html"!==n.type||e?n.value:"";if(t&&"alt"in n&&n.alt)return n.alt;if("children"in n)return r(n.children,t,e)}return Array.isArray(n)?r(n,t,e):""}function r(n,t,r){const l=[];let o=-1;for(;++o<n.length;)l[o]=e(n[o],t,r);return l.join("")}export{t 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","one","includeImageAlt","includeHtml","Boolean","node","type","alt","all","children","Array","isArray","values","result","index","length","join"],"mappings":"AAYA,MAAMA,EAAe,CAAE,EAehB,SAASC,EAASC,EAAOC,GAC9B,MAAMC,EAAWD,GAAWH,EAQ5B,OAAOK,EAAIH,EAN2B,kBAA7BE,EAASE,iBACZF,EAASE,gBAGmB,kBAAzBF,EAASG,aAA4BH,EAASG,YAGzD,CAcA,SAASF,EAAIH,EAAOI,EAAiBC,GACnC,GAqDF,SAAcL,GACZ,OAAOM,QAAQN,GAA0B,iBAAVA,EACjC,CAvDMO,CAAKP,GAAQ,CACf,GAAI,UAAWA,EACb,MAAsB,SAAfA,EAAMQ,MAAoBH,EAAmBL,EAAMA,MAAX,GAGjD,GAAII,GAAmB,QAASJ,GAASA,EAAMS,IAC7C,OAAOT,EAAMS,IAGf,GAAI,aAAcT,EAChB,OAAOU,EAAIV,EAAMW,SAAUP,EAAiBC,EAE/C,CAED,OAAIO,MAAMC,QAAQb,GACTU,EAAIV,EAAOI,EAAiBC,GAG9B,EACT,CAcA,SAASK,EAAII,EAAQV,EAAiBC,GAEpC,MAAMU,EAAS,GACf,IAAIC,GAAS,EAEb,OAASA,EAAQF,EAAOG,QACtBF,EAAOC,GAASb,EAAIW,EAAOE,GAAQZ,EAAiBC,GAGtD,OAAOU,EAAOG,KAAK,GACrB"}

package/dist/node_modules/memoize-one/dist/memoize-one.esm.js

@@ -1,2 +0,0 @@
-var r=Number.isNaN||function(r){return"number"==typeof r&&r!=r};function n(n,t){return n===t||!(!r(n)||!r(t))}function t(r,t){if(r.length!==t.length)return!1;for(var e=0;e<r.length;e++)if(!n(r[e],t[e]))return!1;return!0}function e(r,n){var e;void 0===n&&(n=t);var u,i=[],f=!1;return function(){for(var t=[],o=0;o<arguments.length;o++)t[o]=arguments[o];return f&&e===this&&n(t,i)||(u=r.apply(this,t),f=!0,e=this,i=t),u}}export{e as default};
-//# sourceMappingURL=memoize-one.esm.js.map

package/dist/node_modules/memoize-one/dist/memoize-one.esm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoize-one.esm.js","sources":["../../../../node_modules/memoize-one/dist/memoize-one.esm.js"],"sourcesContent":["var safeIsNaN = Number.isNaN ||\n    function ponyfill(value) {\n        return typeof value === 'number' && value !== value;\n    };\nfunction isEqual(first, second) {\n    if (first === second) {\n        return true;\n    }\n    if (safeIsNaN(first) && safeIsNaN(second)) {\n        return true;\n    }\n    return false;\n}\nfunction areInputsEqual(newInputs, lastInputs) {\n    if (newInputs.length !== lastInputs.length) {\n        return false;\n    }\n    for (var i = 0; i < newInputs.length; i++) {\n        if (!isEqual(newInputs[i], lastInputs[i])) {\n            return false;\n        }\n    }\n    return true;\n}\n\nfunction memoizeOne(resultFn, isEqual) {\n    if (isEqual === void 0) { isEqual = areInputsEqual; }\n    var lastThis;\n    var lastArgs = [];\n    var lastResult;\n    var calledOnce = false;\n    function memoized() {\n        var newArgs = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            newArgs[_i] = arguments[_i];\n        }\n        if (calledOnce && lastThis === this && isEqual(newArgs, lastArgs)) {\n            return lastResult;\n        }\n        lastResult = resultFn.apply(this, newArgs);\n        calledOnce = true;\n        lastThis = this;\n        lastArgs = newArgs;\n        return lastResult;\n    }\n    return memoized;\n}\n\nexport default memoizeOne;\n"],"names":["safeIsNaN","Number","isNaN","value","isEqual","first","second","areInputsEqual","newInputs","lastInputs","length","i","memoizeOne","resultFn","lastThis","lastResult","lastArgs","calledOnce","newArgs","_i","arguments","this","apply"],"mappings":"AAAA,IAAIA,EAAYC,OAAOC,OACnB,SAAkBC,GACd,MAAwB,iBAAVA,GAAsBA,GAAUA,CACtD,EACA,SAASC,EAAQC,EAAOC,GACpB,OAAID,IAAUC,MAGVN,EAAUK,KAAUL,EAAUM,GAItC,CACA,SAASC,EAAeC,EAAWC,GAC/B,GAAID,EAAUE,SAAWD,EAAWC,OAChC,OAAO,EAEX,IAAK,IAAIC,EAAI,EAAGA,EAAIH,EAAUE,OAAQC,IAClC,IAAKP,EAAQI,EAAUG,GAAIF,EAAWE,IAClC,OAAO,EAGf,OAAO,CACX,CAEA,SAASC,EAAWC,EAAUT,GAE1B,IAAIU,OADiB,IAAjBV,IAAsBA,EAAUG,GAEpC,IACIQ,EADAC,EAAW,GAEXC,GAAa,EAejB,OAdA,WAEI,IADA,IAAIC,EAAU,GACLC,EAAK,EAAGA,EAAKC,UAAUV,OAAQS,IACpCD,EAAQC,GAAMC,UAAUD,GAE5B,OAAIF,GAAcH,IAAaO,MAAQjB,EAAQc,EAASF,KAGxDD,EAAaF,EAASS,MAAMD,KAAMH,GAClCD,GAAa,EACbH,EAAWO,KACXL,EAAWE,GALAH,CAOd,CAEL"}

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

@@ -1,2 +0,0 @@
-import{factorySpace as r}from"../../micromark-factory-space/index.js";import{markdownSpace as n,markdownLineEnding as t}from"../../micromark-util-character/index.js";const i={partial:!0,tokenize:function(i,o,e){return function(t){return n(t)?r(i,c,"linePrefix")(t):c(t)};function c(r){return null===r||t(r)?o(r):e(r)}}};export{i 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","partial","tokenize","effects","ok","nok","code","markdownSpace","factorySpace","after","markdownLineEnding"],"mappings":"sKAYY,MAACA,EAAY,CACvBC,SAAS,EACTC,SAQF,SAA2BC,EAASC,EAAIC,GACtC,OAgBA,SAAeC,GACb,OAAOC,EAAcD,GAAQE,EAAaL,EAASM,EAAO,aAA7BD,CAA2CF,GAAQG,EAAMH,EACvF,EAgBD,SAASG,EAAMH,GACb,OAAgB,OAATA,GAAiBI,EAAmBJ,GAAQF,EAAGE,GAAQD,EAAIC,EACnE,CACH"}

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

@@ -1,2 +0,0 @@
-import{combineExtensions as i}from"../micromark-util-combine-extensions/index.js";import{gfmAutolinkLiteral as o}from"../micromark-extension-gfm-autolink-literal/lib/syntax.js";import{gfmFootnote as m}from"../micromark-extension-gfm-footnote/lib/syntax.js";import{gfmStrikethrough as t}from"../micromark-extension-gfm-strikethrough/lib/syntax.js";import{gfmTable as r}from"../micromark-extension-gfm-table/lib/syntax.js";import{gfmTaskListItem as n}from"../micromark-extension-gfm-task-list-item/lib/syntax.js";function e(e){return i([o(),m(),t(e),r(),n()])}export{e 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":"+fAsCO,SAASA,EAAIC,GAClB,OAAOC,EAAkB,CACvBC,IACAC,IACAC,EAAiBJ,GACjBK,IACAC,KAEJ"}

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

@@ -1,2 +0,0 @@
-import{asciiAlphanumeric as n,asciiAlpha as t,markdownLineEndingOrSpace as e,asciiControl as r,unicodeWhitespace as u,unicodePunctuation as i}from"../../micromark-util-character/index.js";const o={tokenize:function(n,t,e){let r=0;return function t(i){if((87===i||119===i)&&r<3)return r++,n.consume(i),t;if(46===i&&3===r)return n.consume(i),u;return e(i)};function u(n){return null===n?e(n):t(n)}},partial:!0},l={tokenize:function(n,t,r){let o,l,c;return a;function a(t){return 46===t||95===t?n.check(f,m,s)(t):null===t||e(t)||u(t)||45!==t&&i(t)?m(t):(c=!0,n.consume(t),a)}function s(t){return 95===t?o=!0:(l=o,o=void 0),n.consume(t),a}function m(n){return l||o||!c?r(n):t(n)}},partial:!0},c={tokenize:function(n,t){let r=0,i=0;return o;function o(c){return 40===c?(r++,n.consume(c),o):41===c&&i<r?l(c):33===c||34===c||38===c||39===c||41===c||42===c||44===c||46===c||58===c||59===c||60===c||63===c||93===c||95===c||126===c?n.check(f,t,l)(c):null===c||e(c)||u(c)?t(c):(n.consume(c),o)}function l(t){return 41===t&&i++,n.consume(t),o}},partial:!0},f={tokenize:function(n,r,i){return o;function o(t){return 33===t||34===t||39===t||41===t||42===t||44===t||46===t||58===t||59===t||63===t||95===t||126===t?(n.consume(t),o):38===t?(n.consume(t),c):93===t?(n.consume(t),l):60===t||null===t||e(t)||u(t)?r(t):i(t)}function l(n){return null===n||40===n||91===n||e(n)||u(n)?r(n):o(n)}function c(n){return t(n)?f(n):i(n)}function f(e){return 59===e?(n.consume(e),o):t(e)?(n.consume(e),f):i(e)}},partial:!0},a={tokenize:function(t,e,r){return function(n){return t.consume(n),u};function u(t){return n(t)?r(t):e(t)}},partial:!0},s={name:"wwwAutolink",tokenize:function(n,t,e){const r=this;return function(t){if(87!==t&&119!==t||!v.call(r,r.previous)||z(r.events))return e(t);return n.enter("literalAutolink"),n.enter("literalAutolinkWww"),n.check(o,n.attempt(l,n.attempt(c,u),e),e)(t)};function u(e){return n.exit("literalAutolinkWww"),n.exit("literalAutolink"),t(e)}},previous:v},m={name:"protocolAutolink",tokenize:function(n,o,f){const a=this;let s="",m=!1;return function(t){if((72===t||104===t)&&g.call(a,a.previous)&&!z(a.events))return n.enter("literalAutolink"),n.enter("literalAutolinkHttp"),s+=String.fromCodePoint(t),n.consume(t),k;return f(t)};function k(e){if(t(e)&&s.length<5)return s+=String.fromCodePoint(e),n.consume(e),k;if(58===e){const t=s.toLowerCase();if("http"===t||"https"===t)return n.consume(e),p}return f(e)}function p(t){return 47===t?(n.consume(t),m?A:(m=!0,p)):f(t)}function A(t){return null===t||r(t)||e(t)||u(t)||i(t)?f(t):n.attempt(l,n.attempt(c,h),f)(t)}function h(t){return n.exit("literalAutolinkHttp"),n.exit("literalAutolink"),o(t)}},previous:g},k={name:"emailAutolink",tokenize:function(e,r,u){const i=this;let o,l;return function(n){if(!w(n)||!x.call(i,i.previous)||z(i.events))return u(n);return e.enter("literalAutolink"),e.enter("literalAutolinkEmail"),c(n)};function c(n){return w(n)?(e.consume(n),c):64===n?(e.consume(n),f):u(n)}function f(t){return 46===t?e.check(a,m,s)(t):45===t||95===t||n(t)?(l=!0,e.consume(t),f):m(t)}function s(n){return e.consume(n),o=!0,f}function m(n){return l&&o&&t(i.previous)?(e.exit("literalAutolinkEmail"),e.exit("literalAutolink"),r(n)):u(n)}},previous:x},p={};function A(){return{text:p}}let h=48;for(;h<123;)p[h]=k,h++,58===h?h=65:91===h&&(h=97);function v(n){return null===n||40===n||42===n||95===n||91===n||93===n||126===n||e(n)}function g(n){return!t(n)}function x(n){return!(47===n||w(n))}function w(t){return 43===t||45===t||46===t||95===t||n(t)}function z(n){let t=n.length,e=!1;for(;t--;){const r=n[t][1];if(("labelLink"===r.type||"labelImage"===r.type)&&!r._balanced){e=!0;break}if(r._gfmAutolinkLiteralWalkedInto){e=!1;break}}return n.length>0&&!e&&(n[n.length-1][1]._gfmAutolinkLiteralWalkedInto=!0),e}p[43]=k,p[45]=k,p[46]=k,p[95]=k,p[72]=[k,m],p[104]=[k,m],p[87]=[k,s],p[119]=[k,s];export{A as gfmAutolinkLiteral};
-//# sourceMappingURL=syntax.js.map

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","tokenize","effects","ok","nok","size","wwwPrefixInside","code","consume","wwwPrefixAfter","partial","domain","underscoreInLastSegment","underscoreInLastLastSegment","seen","domainInside","check","trail","domainAfter","domainAtPunctuation","markdownLineEndingOrSpace","unicodeWhitespace","unicodePunctuation","undefined","path","sizeOpen","sizeClose","pathInside","pathAtPunctuation","trailCharacterReferenceStart","trailBracketAfter","asciiAlpha","trailCharacterReferenceInside","emailDomainDotTrail","after","asciiAlphanumeric","wwwAutolink","name","self","this","previousWww","call","previous","previousUnbalanced","events","enter","attempt","wwwAfter","exit","protocolAutolink","buffer","previousProtocol","String","fromCodePoint","protocolPrefixInside","length","protocol","toLowerCase","protocolSlashesInside","afterProtocol","asciiControl","protocolAfter","emailAutolink","dot","data","gfmAtext","previousEmail","atext","emailDomain","emailDomainAfter","emailDomainDot","text","gfmAutolinkLiteral","index","result","token","type","_balanced","_gfmAutolinkLiteralWalkedInto"],"mappings":"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"}

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

@@ -1,2 +0,0 @@
-import{markdownLineEndingOrSpace as e}from"../../micromark-util-character/index.js";import{blankLine as t}from"../../micromark-core-commonmark/lib/blank-line.js";import{factorySpace as n}from"../../micromark-factory-space/index.js";import"../../decode-named-character-reference/index.dom.js";import{normalizeIdentifier as o}from"../../micromark-util-normalize-identifier/index.js";const r={tokenize:function(e,t,o){const r=this;return n(e,function(e){const n=r.events[r.events.length-1];return n&&"gfmFootnoteDefinitionIndent"===n[1].type&&4===n[2].sliceSerialize(n[1],!0).length?t(e):o(e)},"gfmFootnoteDefinitionIndent",5)},partial:!0};function i(){return{document:{91:{name:"gfmFootnoteDefinition",tokenize:c,continuation:{tokenize:s},exit:m}},text:{91:{name:"gfmFootnoteCall",tokenize:f},93:{name:"gfmPotentialFootnoteCall",add:"after",tokenize:a,resolveTo:l}}}}function a(e,t,n){const r=this;let i=r.events.length;const a=r.parser.gfmFootnotes||(r.parser.gfmFootnotes=[]);let l;for(;i--;){const e=r.events[i][1];if("labelImage"===e.type){l=e;break}if("gfmFootnoteCall"===e.type||"labelLink"===e.type||"label"===e.type||"image"===e.type||"link"===e.type)break}return function(i){if(!l||!l._balanced)return n(i);const f=o(r.sliceSerialize({start:l.end,end:r.now()}));if(94!==f.codePointAt(0)||!a.includes(f.slice(1)))return n(i);return e.enter("gfmFootnoteCallLabelMarker"),e.consume(i),e.exit("gfmFootnoteCallLabelMarker"),t(i)}}function l(e,t){let n=e.length;for(;n--;)if("labelImage"===e[n][1].type&&"enter"===e[n][0]){e[n][1];break}e[n+1][1].type="data",e[n+3][1].type="gfmFootnoteCallLabelMarker";const o={type:"gfmFootnoteCall",start:Object.assign({},e[n+3][1].start),end:Object.assign({},e[e.length-1][1].end)},r={type:"gfmFootnoteCallMarker",start:Object.assign({},e[n+3][1].end),end:Object.assign({},e[n+3][1].end)};r.end.column++,r.end.offset++,r.end._bufferIndex++;const i={type:"gfmFootnoteCallString",start:Object.assign({},r.end),end:Object.assign({},e[e.length-1][1].start)},a={type:"chunkString",contentType:"string",start:Object.assign({},i.start),end:Object.assign({},i.end)},l=[e[n+1],e[n+2],["enter",o,t],e[n+3],e[n+4],["enter",r,t],["exit",r,t],["enter",i,t],["enter",a,t],["exit",a,t],["exit",i,t],e[e.length-2],e[e.length-1],["exit",o,t]];return e.splice(n,e.length-n+1,...l),e}function f(t,n,r){const i=this,a=i.parser.gfmFootnotes||(i.parser.gfmFootnotes=[]);let l,f=0;return function(e){return t.enter("gfmFootnoteCall"),t.enter("gfmFootnoteCallLabelMarker"),t.consume(e),t.exit("gfmFootnoteCallLabelMarker"),c};function c(e){return 94!==e?r(e):(t.enter("gfmFootnoteCallMarker"),t.consume(e),t.exit("gfmFootnoteCallMarker"),t.enter("gfmFootnoteCallString"),t.enter("chunkString").contentType="string",s)}function s(c){if(f>999||93===c&&!l||null===c||91===c||e(c))return r(c);if(93===c){t.exit("chunkString");const e=t.exit("gfmFootnoteCallString");return a.includes(o(i.sliceSerialize(e)))?(t.enter("gfmFootnoteCallLabelMarker"),t.consume(c),t.exit("gfmFootnoteCallLabelMarker"),t.exit("gfmFootnoteCall"),n):r(c)}return e(c)||(l=!0),f++,t.consume(c),92===c?m:s}function m(e){return 91===e||92===e||93===e?(t.consume(e),f++,s):s(e)}}function c(t,r,i){const a=this,l=a.parser.gfmFootnotes||(a.parser.gfmFootnotes=[]);let f,c,s=0;return function(e){return t.enter("gfmFootnoteDefinition")._container=!0,t.enter("gfmFootnoteDefinitionLabel"),t.enter("gfmFootnoteDefinitionLabelMarker"),t.consume(e),t.exit("gfmFootnoteDefinitionLabelMarker"),m};function m(e){return 94===e?(t.enter("gfmFootnoteDefinitionMarker"),t.consume(e),t.exit("gfmFootnoteDefinitionMarker"),t.enter("gfmFootnoteDefinitionLabelString"),t.enter("chunkString").contentType="string",g):i(e)}function g(n){if(s>999||93===n&&!c||null===n||91===n||e(n))return i(n);if(93===n){t.exit("chunkString");const e=t.exit("gfmFootnoteDefinitionLabelString");return f=o(a.sliceSerialize(e)),t.enter("gfmFootnoteDefinitionLabelMarker"),t.consume(n),t.exit("gfmFootnoteDefinitionLabelMarker"),t.exit("gfmFootnoteDefinitionLabel"),F}return e(n)||(c=!0),s++,t.consume(n),92===n?u:g}function u(e){return 91===e||92===e||93===e?(t.consume(e),s++,g):g(e)}function F(e){return 58===e?(t.enter("definitionMarker"),t.consume(e),t.exit("definitionMarker"),l.includes(f)||l.push(f),n(t,k,"gfmFootnoteDefinitionWhitespace")):i(e)}function k(e){return r(e)}}function s(e,n,o){return e.check(t,n,e.attempt(r,n,o))}function m(e){e.exit("gfmFootnoteDefinition")}export{i as gfmFootnote};
-//# sourceMappingURL=syntax.js.map

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","tokenize","effects","ok","nok","self","this","factorySpace","code","tail","events","length","type","sliceSerialize","partial","gfmFootnote","document","name","tokenizeDefinitionStart","continuation","tokenizeDefinitionContinuation","exit","gfmFootnoteDefinitionEnd","text","tokenizeGfmFootnoteCall","add","tokenizePotentialGfmFootnoteCall","resolveTo","resolveToPotentialGfmFootnoteCall","index","defined","parser","gfmFootnotes","labelStart","token","_balanced","id","normalizeIdentifier","start","end","now","codePointAt","includes","slice","enter","consume","context","call","Object","assign","marker","column","offset","_bufferIndex","string","chunk","contentType","replacement","splice","data","size","callStart","callData","markdownLineEndingOrSpace","callEscape","identifier","_container","labelAtMarker","labelInside","labelAfter","labelEscape","push","whitespaceAfter","check","blankLine","attempt"],"mappings":"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"}

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

@@ -1,2 +0,0 @@
-import{splice as e}from"../../micromark-util-chunked/index.js";import{classifyCharacter as t}from"../../micromark-util-classify-character/index.js";import{resolveAll as r}from"../../micromark-util-resolve-all/index.js";function n(n){let o=(n||{}).singleTilde;const s={name:"strikethrough",tokenize:function(e,r,n){const s=this.previous,i=this.events;let u=0;return function(t){if(126===s&&"characterEscape"!==i[i.length-1][1].type)return n(t);return e.enter("strikethroughSequenceTemporary"),c(t)};function c(i){const a=t(s);if(126===i)return u>1?n(i):(e.consume(i),u++,c);if(u<2&&!o)return n(i);const l=e.exit("strikethroughSequenceTemporary"),h=t(i);return l._open=!h||2===h&&Boolean(a),l._close=!a||2===a&&Boolean(h),r(i)}},resolveAll:function(t,n){let o=-1;for(;++o<t.length;)if("enter"===t[o][0]&&"strikethroughSequenceTemporary"===t[o][1].type&&t[o][1]._close){let s=o;for(;s--;)if("exit"===t[s][0]&&"strikethroughSequenceTemporary"===t[s][1].type&&t[s][1]._open&&t[o][1].end.offset-t[o][1].start.offset===t[s][1].end.offset-t[s][1].start.offset){t[o][1].type="strikethroughSequence",t[s][1].type="strikethroughSequence";const i={type:"strikethrough",start:Object.assign({},t[s][1].start),end:Object.assign({},t[o][1].end)},u={type:"strikethroughText",start:Object.assign({},t[s][1].end),end:Object.assign({},t[o][1].start)},c=[["enter",i,n],["enter",t[s][1],n],["exit",t[s][1],n],["enter",u,n]],a=n.parser.constructs.insideSpan.null;a&&e(c,c.length,0,r(a,t.slice(s+1,o),n)),e(c,c.length,0,[["exit",u,n],["enter",t[o][1],n],["exit",t[o][1],n],["exit",i,n]]),e(t,s-1,o-s+3,c),o=s+c.length-2;break}}o=-1;for(;++o<t.length;)"strikethroughSequenceTemporary"===t[o][1].type&&(t[o][1].type="data");return t}};return null==o&&(o=!0),{text:{126:s},insideSpan:{null:[s]},attentionMarkers:{null:[126]}}}export{n as gfmStrikethrough};
-//# sourceMappingURL=syntax.js.map

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","singleTilde","tokenizer","name","tokenize","effects","ok","nok","previous","this","events","size","code","length","type","enter","more","before","classifyCharacter","consume","token","exit","after","_open","Boolean","_close","resolveAll","context","index","open","end","offset","start","strikethrough","Object","assign","text","nextEvents","insideSpan","parser","constructs","null","splice","slice","attentionMarkers"],"mappings":"2NAiBO,SAASA,EAAiBC,GAE/B,IAAIC,GADaD,GAAW,IACNE,YACtB,MAAMC,EAAY,CAChBC,KAAM,gBACNC,SAsFF,SAA+BC,EAASC,EAAIC,GAC1C,MAAMC,EAAWC,KAAKD,SAChBE,EAASD,KAAKC,OACpB,IAAIC,EAAO,EACX,OAGA,SAAeC,GACb,GAAiB,MAAbJ,GAA0D,oBAAtCE,EAAOA,EAAOG,OAAS,GAAG,GAAGC,KACnD,OAAOP,EAAIK,GAGb,OADAP,EAAQU,MAAM,kCACPC,EAAKJ,EACb,EAGD,SAASI,EAAKJ,GACZ,MAAMK,EAASC,EAAkBV,GACjC,GAAa,MAATI,EAEF,OAAID,EAAO,EAAUJ,EAAIK,IACzBP,EAAQc,QAAQP,GAChBD,IACOK,GAET,GAAIL,EAAO,IAAMX,EAAQ,OAAOO,EAAIK,GACpC,MAAMQ,EAAQf,EAAQgB,KAAK,kCACrBC,EAAQJ,EAAkBN,GAGhC,OAFAQ,EAAMG,OAASD,GAAmB,IAAVA,GAAeE,QAAQP,GAC/CG,EAAMK,QAAUR,GAAqB,IAAXA,GAAgBO,QAAQF,GAC3ChB,EAAGM,EACX,CACF,EArHCc,WAsBF,SAAiChB,EAAQiB,GACvC,IAAIC,GAAS,EAGb,OAASA,EAAQlB,EAAOG,QAEtB,GAAyB,UAArBH,EAAOkB,GAAO,IAA4C,mCAA1BlB,EAAOkB,GAAO,GAAGd,MAA6CJ,EAAOkB,GAAO,GAAGH,OAAQ,CACzH,IAAII,EAAOD,EAGX,KAAOC,KAEL,GAAwB,SAApBnB,EAAOmB,GAAM,IAA0C,mCAAzBnB,EAAOmB,GAAM,GAAGf,MAA6CJ,EAAOmB,GAAM,GAAGN,OAE/Gb,EAAOkB,GAAO,GAAGE,IAAIC,OAASrB,EAAOkB,GAAO,GAAGI,MAAMD,SAAWrB,EAAOmB,GAAM,GAAGC,IAAIC,OAASrB,EAAOmB,GAAM,GAAGG,MAAMD,OAAQ,CACzHrB,EAAOkB,GAAO,GAAGd,KAAO,wBACxBJ,EAAOmB,GAAM,GAAGf,KAAO,wBAGvB,MAAMmB,EAAgB,CACpBnB,KAAM,gBACNkB,MAAOE,OAAOC,OAAO,CAAE,EAAEzB,EAAOmB,GAAM,GAAGG,OACzCF,IAAKI,OAAOC,OAAO,CAAE,EAAEzB,EAAOkB,GAAO,GAAGE,MAIpCM,EAAO,CACXtB,KAAM,oBACNkB,MAAOE,OAAOC,OAAO,CAAE,EAAEzB,EAAOmB,GAAM,GAAGC,KACzCA,IAAKI,OAAOC,OAAO,CAAE,EAAEzB,EAAOkB,GAAO,GAAGI,QAKpCK,EAAa,CAAC,CAAC,QAASJ,EAAeN,GAAU,CAAC,QAASjB,EAAOmB,GAAM,GAAIF,GAAU,CAAC,OAAQjB,EAAOmB,GAAM,GAAIF,GAAU,CAAC,QAASS,EAAMT,IAC1IW,EAAaX,EAAQY,OAAOC,WAAWF,WAAWG,KACpDH,GAEFI,EAAOL,EAAYA,EAAWxB,OAAQ,EAAGa,EAAWY,EAAY5B,EAAOiC,MAAMd,EAAO,EAAGD,GAAQD,IAIjGe,EAAOL,EAAYA,EAAWxB,OAAQ,EAAG,CAAC,CAAC,OAAQuB,EAAMT,GAAU,CAAC,QAASjB,EAAOkB,GAAO,GAAID,GAAU,CAAC,OAAQjB,EAAOkB,GAAO,GAAID,GAAU,CAAC,OAAQM,EAAeN,KACtKe,EAAOhC,EAAQmB,EAAO,EAAGD,EAAQC,EAAO,EAAGQ,GAC3CT,EAAQC,EAAOQ,EAAWxB,OAAS,EACnC,KACD,CAEJ,CAEHe,GAAS,EACT,OAASA,EAAQlB,EAAOG,QACQ,mCAA1BH,EAAOkB,GAAO,GAAGd,OACnBJ,EAAOkB,GAAO,GAAGd,KAAO,QAG5B,OAAOJ,CACR,GA1ED,OAHIV,UACFA,GAAS,GAEJ,CACLoC,KAAM,CACJ,IAAOlC,GAEToC,WAAY,CACVG,KAAM,CAACvC,IAET0C,iBAAkB,CAChBH,KAAM,CAAC,MAyGb"}

package/dist/node_modules/micromark-extension-gfm-table/lib/edit-map.js

@@ -1,2 +0,0 @@
-class t{constructor(){this.map=[]}add(t,p,s){!function(t,p,s,h){let n=0;if(0===s&&0===h.length)return;for(;n<t.map.length;){if(t.map[n][0]===p)return t.map[n][1]+=s,void t.map[n][2].push(...h);n+=1}t.map.push([p,s,h])}(this,t,p,s)}consume(t){if(this.map.sort(function(t,p){return t[0]-p[0]}),0===this.map.length)return;let p=this.map.length;const s=[];for(;p>0;)p-=1,s.push(t.slice(this.map[p][0]+this.map[p][1]),this.map[p][2]),t.length=this.map[p][0];s.push(t.slice()),t.length=0;let h=s.pop();for(;h;){for(const p of h)t.push(p);h=s.pop()}this.map.length=0}}export{t as EditMap};
-//# sourceMappingURL=edit-map.js.map

package/dist/node_modules/micromark-extension-gfm-table/lib/edit-map.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"edit-map.js","sources":["../../../../node_modules/micromark-extension-gfm-table/lib/edit-map.js"],"sourcesContent":["/**\n * @import {Event} from 'micromark-util-types'\n */\n\n// Port of `edit_map.rs` from `markdown-rs`.\n// This should move to `markdown-js` later.\n\n// Deal with several changes in events, batching them together.\n//\n// Preferably, changes should be kept to a minimum.\n// Sometimes, it’s needed to change the list of events, because parsing can be\n// messy, and it helps to expose a cleaner interface of events to the compiler\n// and other users.\n// It can also help to merge many adjacent similar events.\n// And, in other cases, it’s needed to parse subcontent: pass some events\n// through another tokenizer and inject the result.\n\n/**\n * @typedef {[number, number, Array<Event>]} Change\n * @typedef {[number, number, number]} Jump\n */\n\n/**\n * Tracks a bunch of edits.\n */\nexport class EditMap {\n  /**\n   * Create a new edit map.\n   */\n  constructor() {\n    /**\n     * Record of changes.\n     *\n     * @type {Array<Change>}\n     */\n    this.map = [];\n  }\n\n  /**\n   * Create an edit: a remove and/or add at a certain place.\n   *\n   * @param {number} index\n   * @param {number} remove\n   * @param {Array<Event>} add\n   * @returns {undefined}\n   */\n  add(index, remove, add) {\n    addImplementation(this, index, remove, add);\n  }\n\n  // To do: add this when moving to `micromark`.\n  // /**\n  //  * Create an edit: but insert `add` before existing additions.\n  //  *\n  //  * @param {number} index\n  //  * @param {number} remove\n  //  * @param {Array<Event>} add\n  //  * @returns {undefined}\n  //  */\n  // addBefore(index, remove, add) {\n  //   addImplementation(this, index, remove, add, true)\n  // }\n\n  /**\n   * Done, change the events.\n   *\n   * @param {Array<Event>} events\n   * @returns {undefined}\n   */\n  consume(events) {\n    this.map.sort(function (a, b) {\n      return a[0] - b[0];\n    });\n\n    /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n    if (this.map.length === 0) {\n      return;\n    }\n\n    // To do: if links are added in events, like they are in `markdown-rs`,\n    // this is needed.\n    // // Calculate jumps: where items in the current list move to.\n    // /** @type {Array<Jump>} */\n    // const jumps = []\n    // let index = 0\n    // let addAcc = 0\n    // let removeAcc = 0\n    // while (index < this.map.length) {\n    //   const [at, remove, add] = this.map[index]\n    //   removeAcc += remove\n    //   addAcc += add.length\n    //   jumps.push([at, removeAcc, addAcc])\n    //   index += 1\n    // }\n    //\n    // . shiftLinks(events, jumps)\n\n    let index = this.map.length;\n    /** @type {Array<Array<Event>>} */\n    const vecs = [];\n    while (index > 0) {\n      index -= 1;\n      vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);\n\n      // Truncate rest.\n      events.length = this.map[index][0];\n    }\n    vecs.push(events.slice());\n    events.length = 0;\n    let slice = vecs.pop();\n    while (slice) {\n      for (const element of slice) {\n        events.push(element);\n      }\n      slice = vecs.pop();\n    }\n\n    // Truncate everything.\n    this.map.length = 0;\n  }\n}\n\n/**\n * Create an edit.\n *\n * @param {EditMap} editMap\n * @param {number} at\n * @param {number} remove\n * @param {Array<Event>} add\n * @returns {undefined}\n */\nfunction addImplementation(editMap, at, remove, add) {\n  let index = 0;\n\n  /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n  if (remove === 0 && add.length === 0) {\n    return;\n  }\n  while (index < editMap.map.length) {\n    if (editMap.map[index][0] === at) {\n      editMap.map[index][1] += remove;\n\n      // To do: before not used by tables, use when moving to micromark.\n      // if (before) {\n      //   add.push(...editMap.map[index][2])\n      //   editMap.map[index][2] = add\n      // } else {\n      editMap.map[index][2].push(...add);\n      // }\n\n      return;\n    }\n    index += 1;\n  }\n  editMap.map.push([at, remove, add]);\n}\n\n// /**\n//  * Shift `previous` and `next` links according to `jumps`.\n//  *\n//  * This fixes links in case there are events removed or added between them.\n//  *\n//  * @param {Array<Event>} events\n//  * @param {Array<Jump>} jumps\n//  */\n// function shiftLinks(events, jumps) {\n//   let jumpIndex = 0\n//   let index = 0\n//   let add = 0\n//   let rm = 0\n\n//   while (index < events.length) {\n//     const rmCurr = rm\n\n//     while (jumpIndex < jumps.length && jumps[jumpIndex][0] <= index) {\n//       add = jumps[jumpIndex][2]\n//       rm = jumps[jumpIndex][1]\n//       jumpIndex += 1\n//     }\n\n//     // Ignore items that will be removed.\n//     if (rm > rmCurr) {\n//       index += rm - rmCurr\n//     } else {\n//       // ?\n//       // if let Some(link) = &events[index].link {\n//       //     if let Some(next) = link.next {\n//       //         events[next].link.as_mut().unwrap().previous = Some(index + add - rm);\n//       //         while jumpIndex < jumps.len() && jumps[jumpIndex].0 <= next {\n//       //             add = jumps[jumpIndex].2;\n//       //             rm = jumps[jumpIndex].1;\n//       //             jumpIndex += 1;\n//       //         }\n//       //         events[index].link.as_mut().unwrap().next = Some(next + add - rm);\n//       //         index = next;\n//       //         continue;\n//       //     }\n//       // }\n//       index += 1\n//     }\n//   }\n// }"],"names":["EditMap","constructor","this","map","add","index","remove","editMap","at","length","push","addImplementation","consume","events","sort","a","b","vecs","slice","pop","element"],"mappings":"AAyBO,MAAMA,EAIX,WAAAC,GAMEC,KAAKC,IAAM,EACZ,CAUD,GAAAC,CAAIC,EAAOC,EAAQF,IAqFrB,SAA2BG,EAASC,EAAIF,EAAQF,GAC9C,IAAIC,EAAQ,EAGZ,GAAe,IAAXC,GAA+B,IAAfF,EAAIK,OACtB,OAEF,KAAOJ,EAAQE,EAAQJ,IAAIM,QAAQ,CACjC,GAAIF,EAAQJ,IAAIE,GAAO,KAAOG,EAW5B,OAVAD,EAAQJ,IAAIE,GAAO,IAAMC,OAOzBC,EAAQJ,IAAIE,GAAO,GAAGK,QAAQN,GAKhCC,GAAS,CACV,CACDE,EAAQJ,IAAIO,KAAK,CAACF,EAAIF,EAAQF,GAChC,CA5GIO,CAAkBT,KAAMG,EAAOC,EAAQF,EACxC,CAqBD,OAAAQ,CAAQC,GAMN,GALAX,KAAKC,IAAIW,KAAK,SAAUC,EAAGC,GACzB,OAAOD,EAAE,GAAKC,EAAE,EACtB,GAG4B,IAApBd,KAAKC,IAAIM,OACX,OAqBF,IAAIJ,EAAQH,KAAKC,IAAIM,OAErB,MAAMQ,EAAO,GACb,KAAOZ,EAAQ,GACbA,GAAS,EACTY,EAAKP,KAAKG,EAAOK,MAAMhB,KAAKC,IAAIE,GAAO,GAAKH,KAAKC,IAAIE,GAAO,IAAKH,KAAKC,IAAIE,GAAO,IAGjFQ,EAAOJ,OAASP,KAAKC,IAAIE,GAAO,GAElCY,EAAKP,KAAKG,EAAOK,SACjBL,EAAOJ,OAAS,EAChB,IAAIS,EAAQD,EAAKE,MACjB,KAAOD,GAAO,CACZ,IAAK,MAAME,KAAWF,EACpBL,EAAOH,KAAKU,GAEdF,EAAQD,EAAKE,KACd,CAGDjB,KAAKC,IAAIM,OAAS,CACnB"}

package/dist/node_modules/micromark-extension-gfm-table/lib/infer.js

@@ -1,2 +0,0 @@
-function e(e,t){let l=!1;const n=[];for(;t<e.length;){const r=e[t];if(l){if("enter"===r[0])"tableContent"===r[1].type&&n.push("tableDelimiterMarker"===e[t+1][1].type?"left":"none");else if("tableContent"===r[1].type){if("tableDelimiterMarker"===e[t-1][1].type){const e=n.length-1;n[e]="left"===n[e]?"center":"right"}}else if("tableDelimiterRow"===r[1].type)break}else"enter"===r[0]&&"tableDelimiterRow"===r[1].type&&(l=!0);t+=1}return n}export{e as gfmTableAlign};
-//# sourceMappingURL=infer.js.map

package/dist/node_modules/micromark-extension-gfm-table/lib/infer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"infer.js","sources":["../../../../node_modules/micromark-extension-gfm-table/lib/infer.js"],"sourcesContent":["/**\n * @import {Event} from 'micromark-util-types'\n */\n\n/**\n * @typedef {'center' | 'left' | 'none' | 'right'} Align\n */\n\n/**\n * Figure out the alignment of a GFM table.\n *\n * @param {Readonly<Array<Event>>} events\n *   List of events.\n * @param {number} index\n *   Table enter event.\n * @returns {Array<Align>}\n *   List of aligns.\n */\nexport function gfmTableAlign(events, index) {\n  let inDelimiterRow = false;\n  /** @type {Array<Align>} */\n  const align = [];\n  while (index < events.length) {\n    const event = events[index];\n    if (inDelimiterRow) {\n      if (event[0] === 'enter') {\n        // Start of alignment value: set a new column.\n        // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n        if (event[1].type === 'tableContent') {\n          align.push(events[index + 1][1].type === 'tableDelimiterMarker' ? 'left' : 'none');\n        }\n      }\n      // Exits:\n      // End of alignment value: change the column.\n      // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n      else if (event[1].type === 'tableContent') {\n        if (events[index - 1][1].type === 'tableDelimiterMarker') {\n          const alignIndex = align.length - 1;\n          align[alignIndex] = align[alignIndex] === 'left' ? 'center' : 'right';\n        }\n      }\n      // Done!\n      else if (event[1].type === 'tableDelimiterRow') {\n        break;\n      }\n    } else if (event[0] === 'enter' && event[1].type === 'tableDelimiterRow') {\n      inDelimiterRow = true;\n    }\n    index += 1;\n  }\n  return align;\n}"],"names":["gfmTableAlign","events","index","inDelimiterRow","align","length","event","type","push","alignIndex"],"mappings":"AAkBO,SAASA,EAAcC,EAAQC,GACpC,IAAIC,GAAiB,EAErB,MAAMC,EAAQ,GACd,KAAOF,EAAQD,EAAOI,QAAQ,CAC5B,MAAMC,EAAQL,EAAOC,GACrB,GAAIC,GACF,GAAiB,UAAbG,EAAM,GAGc,iBAAlBA,EAAM,GAAGC,MACXH,EAAMI,KAAmC,yBAA9BP,EAAOC,EAAQ,GAAG,GAAGK,KAAkC,OAAS,aAM1E,GAAsB,iBAAlBD,EAAM,GAAGC,MAChB,GAAkC,yBAA9BN,EAAOC,EAAQ,GAAG,GAAGK,KAAiC,CACxD,MAAME,EAAaL,EAAMC,OAAS,EAClCD,EAAMK,GAAoC,SAAtBL,EAAMK,GAAyB,SAAW,OAC/D,OAGE,GAAsB,sBAAlBH,EAAM,GAAGC,KAChB,UAEoB,UAAbD,EAAM,IAAoC,sBAAlBA,EAAM,GAAGC,OAC1CJ,GAAiB,GAEnBD,GAAS,CACV,CACD,OAAOE,CACT"}

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

@@ -1,2 +0,0 @@
-import{factorySpace as e}from"../../micromark-factory-space/index.js";import{markdownLineEnding as t,markdownSpace as n,markdownLineEndingOrSpace as i}from"../../micromark-util-character/index.js";import{EditMap as r}from"./edit-map.js";import{gfmTableAlign as l}from"./infer.js";function a(){return{flow:{null:{name:"table",tokenize:o,resolveAll:s}}}}function o(r,l,a){const o=this;let s,u=0,c=0;return function(e){let t=o.events.length-1;for(;t>-1;){const e=o.events[t][1].type;if("lineEnding"!==e&&"linePrefix"!==e)break;t--}const n=t>-1?o.events[t][1].type:null,i="tableHead"===n||"tableRow"===n?h:d;if(i===h&&o.parser.lazy[o.now().line])return a(e);return i(e)};function d(e){return r.enter("tableHead"),r.enter("tableRow"),function(e){if(124===e)return b(e);return s=!0,c+=1,b(e)}(e)}function b(i){return null===i?a(i):t(i)?c>1?(c=0,o.interrupt=!0,r.exit("tableRow"),r.enter("lineEnding"),r.consume(i),r.exit("lineEnding"),p):a(i):n(i)?e(r,b,"whitespace")(i):(c+=1,s&&(s=!1,u+=1),124===i?(r.enter("tableCellDivider"),r.consume(i),r.exit("tableCellDivider"),s=!0,b):(r.enter("data"),f(i)))}function f(e){return null===e||124===e||i(e)?(r.exit("data"),b(e)):(r.consume(e),92===e?m:f)}function m(e){return 92===e||124===e?(r.consume(e),f):f(e)}function p(t){return o.interrupt=!1,o.parser.lazy[o.now().line]?a(t):(r.enter("tableDelimiterRow"),s=!1,n(t)?e(r,v,"linePrefix",o.parser.constructs.disable.null.includes("codeIndented")?void 0:4)(t):v(t))}function v(e){return 45===e||58===e?x(e):124===e?(s=!0,r.enter("tableCellDivider"),r.consume(e),r.exit("tableCellDivider"),y):O(e)}function y(t){return n(t)?e(r,x,"whitespace")(t):x(t)}function x(e){return 58===e?(c+=1,s=!0,r.enter("tableDelimiterMarker"),r.consume(e),r.exit("tableDelimiterMarker"),D):45===e?(c+=1,D(e)):null===e||t(e)?j(e):O(e)}function D(e){return 45===e?(r.enter("tableDelimiterFiller"),g(e)):O(e)}function g(e){return 45===e?(r.consume(e),g):58===e?(s=!0,r.exit("tableDelimiterFiller"),r.enter("tableDelimiterMarker"),r.consume(e),r.exit("tableDelimiterMarker"),w):(r.exit("tableDelimiterFiller"),w(e))}function w(t){return n(t)?e(r,j,"whitespace")(t):j(t)}function j(e){return 124===e?v(e):(null===e||t(e))&&s&&u===c?(r.exit("tableDelimiterRow"),r.exit("tableHead"),l(e)):O(e)}function O(e){return a(e)}function h(e){return r.enter("tableRow"),R(e)}function R(i){return 124===i?(r.enter("tableCellDivider"),r.consume(i),r.exit("tableCellDivider"),R):null===i||t(i)?(r.exit("tableRow"),l(i)):n(i)?e(r,R,"whitespace")(i):(r.enter("data"),k(i))}function k(e){return null===e||124===e||i(e)?(r.exit("data"),R(e)):(r.consume(e),92===e?C:k)}function C(e){return 92===e||124===e?(r.consume(e),k):k(e)}}function s(e,t){let n,i,a,o=-1,s=!0,d=0,b=[0,0,0,0],f=[0,0,0,0],m=!1,p=0;const v=new r;for(;++o<e.length;){const r=e[o],l=r[1];"enter"===r[0]?"tableHead"===l.type?(m=!1,0!==p&&(c(v,t,p,n,i),i=void 0,p=0),n={type:"table",start:Object.assign({},l.start),end:Object.assign({},l.end)},v.add(o,0,[["enter",n,t]])):"tableRow"===l.type||"tableDelimiterRow"===l.type?(s=!0,a=void 0,b=[0,0,0,0],f=[0,o+1,0,0],m&&(m=!1,i={type:"tableBody",start:Object.assign({},l.start),end:Object.assign({},l.end)},v.add(o,0,[["enter",i,t]])),d="tableDelimiterRow"===l.type?2:i?3:1):!d||"data"!==l.type&&"tableDelimiterMarker"!==l.type&&"tableDelimiterFiller"!==l.type?"tableCellDivider"===l.type&&(s?s=!1:(0!==b[1]&&(f[0]=f[1],a=u(v,t,b,d,void 0,a)),b=f,f=[b[1],o,0,0])):(s=!1,0===f[2]&&(0!==b[1]&&(f[0]=f[1],a=u(v,t,b,d,void 0,a),b=[0,0,0,0]),f[2]=o)):"tableHead"===l.type?(m=!0,p=o):"tableRow"===l.type||"tableDelimiterRow"===l.type?(p=o,0!==b[1]?(f[0]=f[1],a=u(v,t,b,d,o,a)):0!==f[1]&&(a=u(v,t,f,d,o,a)),d=0):!d||"data"!==l.type&&"tableDelimiterMarker"!==l.type&&"tableDelimiterFiller"!==l.type||(f[3]=o)}for(0!==p&&c(v,t,p,n,i),v.consume(t.events),o=-1;++o<t.events.length;){const e=t.events[o];"enter"===e[0]&&"table"===e[1].type&&(e[1]._align=l(t.events,o))}return e}function u(e,t,n,i,r,l){const a=1===i?"tableHeader":2===i?"tableDelimiter":"tableData";0!==n[0]&&(l.end=Object.assign({},d(t.events,n[0])),e.add(n[0],0,[["exit",l,t]]));const o=d(t.events,n[1]);if(l={type:a,start:Object.assign({},o),end:Object.assign({},o)},e.add(n[1],0,[["enter",l,t]]),0!==n[2]){const r=d(t.events,n[2]),l=d(t.events,n[3]),a={type:"tableContent",start:Object.assign({},r),end:Object.assign({},l)};if(e.add(n[2],0,[["enter",a,t]]),2!==i){const i=t.events[n[2]],r=t.events[n[3]];if(i[1].end=Object.assign({},r[1].end),i[1].type="chunkText",i[1].contentType="text",n[3]>n[2]+1){const t=n[2]+1,i=n[3]-n[2]-1;e.add(t,i,[])}}e.add(n[3]+1,0,[["exit",a,t]])}return void 0!==r&&(l.end=Object.assign({},d(t.events,r)),e.add(r,0,[["exit",l,t]]),l=void 0),l}function c(e,t,n,i,r){const l=[],a=d(t.events,n);r&&(r.end=Object.assign({},a),l.push(["exit",r,t])),i.end=Object.assign({},a),l.push(["exit",i,t]),e.add(n+1,0,l)}function d(e,t){const n=e[t],i="enter"===n[0]?"start":"end";return n[1][i]}export{a as gfmTable};
-//# sourceMappingURL=syntax.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.js","sources":["../../../../node_modules/micromark-extension-gfm-table/lib/syntax.js"],"sourcesContent":["/**\n * @import {Event, Extension, Point, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\n/**\n * @typedef {[number, number, number, number]} Range\n *   Cell info.\n *\n * @typedef {0 | 1 | 2 | 3} RowKind\n *   Where we are: `1` for head row, `2` for delimiter row, `3` for body row.\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { EditMap } from './edit-map.js';\nimport { gfmTableAlign } from './infer.js';\n\n/**\n * Create an HTML extension for `micromark` to support GitHub tables syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   table syntax.\n */\nexport function gfmTable() {\n  return {\n    flow: {\n      null: {\n        name: 'table',\n        tokenize: tokenizeTable,\n        resolveAll: resolveTable\n      }\n    }\n  };\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTable(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  let sizeB = 0;\n  /** @type {boolean | undefined} */\n  let seen;\n  return start;\n\n  /**\n   * Start of a GFM table.\n   *\n   * If there is a valid table row or table head before, then we try to parse\n   * another row.\n   * Otherwise, we try to parse a head.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length - 1;\n    while (index > -1) {\n      const type = self.events[index][1].type;\n      if (type === \"lineEnding\" ||\n      // Note: markdown-rs uses `whitespace` instead of `linePrefix`\n      type === \"linePrefix\") index--;else break;\n    }\n    const tail = index > -1 ? self.events[index][1].type : null;\n    const next = tail === 'tableHead' || tail === 'tableRow' ? bodyRowStart : headRowBefore;\n\n    // Don’t allow lazy body rows.\n    if (next === bodyRowStart && self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    return next(code);\n  }\n\n  /**\n   * Before table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBefore(code) {\n    effects.enter('tableHead');\n    effects.enter('tableRow');\n    return headRowStart(code);\n  }\n\n  /**\n   * Before table head row, after whitespace.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowStart(code) {\n    if (code === 124) {\n      return headRowBreak(code);\n    }\n\n    // To do: micromark-js should let us parse our own whitespace in extensions,\n    // like `markdown-rs`:\n    //\n    // ```js\n    // // 4+ spaces.\n    // if (markdownSpace(code)) {\n    //   return nok(code)\n    // }\n    // ```\n\n    seen = true;\n    // Count the first character, that isn’t a pipe, double.\n    sizeB += 1;\n    return headRowBreak(code);\n  }\n\n  /**\n   * At break in table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *       ^\n   *         ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBreak(code) {\n    if (code === null) {\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      // If anything other than one pipe (ignoring whitespace) was used, it’s fine.\n      if (sizeB > 1) {\n        sizeB = 0;\n        // To do: check if this works.\n        // Feel free to interrupt:\n        self.interrupt = true;\n        effects.exit('tableRow');\n        effects.enter(\"lineEnding\");\n        effects.consume(code);\n        effects.exit(\"lineEnding\");\n        return headDelimiterStart;\n      }\n\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code);\n    }\n    if (markdownSpace(code)) {\n      // To do: check if this is fine.\n      // effects.attempt(State::Next(StateName::GfmTableHeadRowBreak), State::Nok)\n      // State::Retry(space_or_tab(tokenizer))\n      return factorySpace(effects, headRowBreak, \"whitespace\")(code);\n    }\n    sizeB += 1;\n    if (seen) {\n      seen = false;\n      // Header cell count.\n      size += 1;\n    }\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      // Whether a delimiter was seen.\n      seen = true;\n      return headRowBreak;\n    }\n\n    // Anything else is cell data.\n    effects.enter(\"data\");\n    return headRowData(code);\n  }\n\n  /**\n   * In table head row data.\n   *\n   * ```markdown\n   * > | | a |\n   *       ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"data\");\n      return headRowBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? headRowEscape : headRowData;\n  }\n\n  /**\n   * In table head row escape.\n   *\n   * ```markdown\n   * > | | a\\-b |\n   *         ^\n   *   | | ---- |\n   *   | | c    |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return headRowData;\n    }\n    return headRowData(code);\n  }\n\n  /**\n   * Before delimiter row.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterStart(code) {\n    // Reset `interrupt`.\n    self.interrupt = false;\n\n    // Note: in `markdown-rs`, we need to handle piercing here too.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    effects.enter('tableDelimiterRow');\n    // Track if we’ve seen a `:` or `|`.\n    seen = false;\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return headDelimiterBefore(code);\n  }\n\n  /**\n   * Before delimiter row, after optional whitespace.\n   *\n   * Reused when a `|` is found later, to parse another cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterBefore(code) {\n    if (code === 45 || code === 58) {\n      return headDelimiterValueBefore(code);\n    }\n    if (code === 124) {\n      seen = true;\n      // If we start with a pipe, we open a cell marker.\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return headDelimiterCellBefore;\n    }\n\n    // More whitespace / empty row not allowed at start.\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * After `|`, before delimiter cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellBefore(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterValueBefore, \"whitespace\")(code);\n    }\n    return headDelimiterValueBefore(code);\n  }\n\n  /**\n   * Before delimiter cell value.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterValueBefore(code) {\n    // Align: left.\n    if (code === 58) {\n      sizeB += 1;\n      seen = true;\n      effects.enter('tableDelimiterMarker');\n      effects.consume(code);\n      effects.exit('tableDelimiterMarker');\n      return headDelimiterLeftAlignmentAfter;\n    }\n\n    // Align: none.\n    if (code === 45) {\n      sizeB += 1;\n      // To do: seems weird that this *isn’t* left aligned, but that state is used?\n      return headDelimiterLeftAlignmentAfter(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return headDelimiterCellAfter(code);\n    }\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * After delimiter cell left alignment marker.\n   *\n   * ```markdown\n   *   | | a  |\n   * > | | :- |\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterLeftAlignmentAfter(code) {\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller');\n      return headDelimiterFiller(code);\n    }\n\n    // Anything else is not ok after the left-align colon.\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * In delimiter cell filler.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterFiller(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return headDelimiterFiller;\n    }\n\n    // Align is `center` if it was `left`, `right` otherwise.\n    if (code === 58) {\n      seen = true;\n      effects.exit('tableDelimiterFiller');\n      effects.enter('tableDelimiterMarker');\n      effects.consume(code);\n      effects.exit('tableDelimiterMarker');\n      return headDelimiterRightAlignmentAfter;\n    }\n    effects.exit('tableDelimiterFiller');\n    return headDelimiterRightAlignmentAfter(code);\n  }\n\n  /**\n   * After delimiter cell right alignment marker.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterRightAlignmentAfter(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterCellAfter, \"whitespace\")(code);\n    }\n    return headDelimiterCellAfter(code);\n  }\n\n  /**\n   * After delimiter cell.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellAfter(code) {\n    if (code === 124) {\n      return headDelimiterBefore(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      // Exit when:\n      // * there was no `:` or `|` at all (it’s a thematic break or setext\n      //   underline instead)\n      // * the header cell count is not the delimiter cell count\n      if (!seen || size !== sizeB) {\n        return headDelimiterNok(code);\n      }\n\n      // Note: in markdown-rs`, a reset is needed here.\n      effects.exit('tableDelimiterRow');\n      effects.exit('tableHead');\n      // To do: in `markdown-rs`, resolvers need to be registered manually.\n      // effects.register_resolver(ResolveName::GfmTable)\n      return ok(code);\n    }\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * In delimiter row, at a disallowed byte.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | x |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterNok(code) {\n    // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n    return nok(code);\n  }\n\n  /**\n   * Before table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowStart(code) {\n    // Note: in `markdown-rs` we need to manually take care of a prefix,\n    // but in `micromark-js` that is done for us, so if we’re here, we’re\n    // never at whitespace.\n    effects.enter('tableRow');\n    return bodyRowBreak(code);\n  }\n\n  /**\n   * At break in table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   *       ^\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowBreak(code) {\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return bodyRowBreak;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('tableRow');\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, bodyRowBreak, \"whitespace\")(code);\n    }\n\n    // Anything else is cell content.\n    effects.enter(\"data\");\n    return bodyRowData(code);\n  }\n\n  /**\n   * In table body row data.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"data\");\n      return bodyRowBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? bodyRowEscape : bodyRowData;\n  }\n\n  /**\n   * In table body row escape.\n   *\n   * ```markdown\n   *   | | a    |\n   *   | | ---- |\n   * > | | b\\-c |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return bodyRowData;\n    }\n    return bodyRowData(code);\n  }\n}\n\n/** @type {Resolver} */\n\nfunction resolveTable(events, context) {\n  let index = -1;\n  let inFirstCellAwaitingPipe = true;\n  /** @type {RowKind} */\n  let rowKind = 0;\n  /** @type {Range} */\n  let lastCell = [0, 0, 0, 0];\n  /** @type {Range} */\n  let cell = [0, 0, 0, 0];\n  let afterHeadAwaitingFirstBodyRow = false;\n  let lastTableEnd = 0;\n  /** @type {Token | undefined} */\n  let currentTable;\n  /** @type {Token | undefined} */\n  let currentBody;\n  /** @type {Token | undefined} */\n  let currentCell;\n  const map = new EditMap();\n  while (++index < events.length) {\n    const event = events[index];\n    const token = event[1];\n    if (event[0] === 'enter') {\n      // Start of head.\n      if (token.type === 'tableHead') {\n        afterHeadAwaitingFirstBodyRow = false;\n\n        // Inject previous (body end and) table end.\n        if (lastTableEnd !== 0) {\n          flushTableEnd(map, context, lastTableEnd, currentTable, currentBody);\n          currentBody = undefined;\n          lastTableEnd = 0;\n        }\n\n        // Inject table start.\n        currentTable = {\n          type: 'table',\n          start: Object.assign({}, token.start),\n          // Note: correct end is set later.\n          end: Object.assign({}, token.end)\n        };\n        map.add(index, 0, [['enter', currentTable, context]]);\n      } else if (token.type === 'tableRow' || token.type === 'tableDelimiterRow') {\n        inFirstCellAwaitingPipe = true;\n        currentCell = undefined;\n        lastCell = [0, 0, 0, 0];\n        cell = [0, index + 1, 0, 0];\n\n        // Inject table body start.\n        if (afterHeadAwaitingFirstBodyRow) {\n          afterHeadAwaitingFirstBodyRow = false;\n          currentBody = {\n            type: 'tableBody',\n            start: Object.assign({}, token.start),\n            // Note: correct end is set later.\n            end: Object.assign({}, token.end)\n          };\n          map.add(index, 0, [['enter', currentBody, context]]);\n        }\n        rowKind = token.type === 'tableDelimiterRow' ? 2 : currentBody ? 3 : 1;\n      }\n      // Cell data.\n      else if (rowKind && (token.type === \"data\" || token.type === 'tableDelimiterMarker' || token.type === 'tableDelimiterFiller')) {\n        inFirstCellAwaitingPipe = false;\n\n        // First value in cell.\n        if (cell[2] === 0) {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1];\n            currentCell = flushCell(map, context, lastCell, rowKind, undefined, currentCell);\n            lastCell = [0, 0, 0, 0];\n          }\n          cell[2] = index;\n        }\n      } else if (token.type === 'tableCellDivider') {\n        if (inFirstCellAwaitingPipe) {\n          inFirstCellAwaitingPipe = false;\n        } else {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1];\n            currentCell = flushCell(map, context, lastCell, rowKind, undefined, currentCell);\n          }\n          lastCell = cell;\n          cell = [lastCell[1], index, 0, 0];\n        }\n      }\n    }\n    // Exit events.\n    else if (token.type === 'tableHead') {\n      afterHeadAwaitingFirstBodyRow = true;\n      lastTableEnd = index;\n    } else if (token.type === 'tableRow' || token.type === 'tableDelimiterRow') {\n      lastTableEnd = index;\n      if (lastCell[1] !== 0) {\n        cell[0] = cell[1];\n        currentCell = flushCell(map, context, lastCell, rowKind, index, currentCell);\n      } else if (cell[1] !== 0) {\n        currentCell = flushCell(map, context, cell, rowKind, index, currentCell);\n      }\n      rowKind = 0;\n    } else if (rowKind && (token.type === \"data\" || token.type === 'tableDelimiterMarker' || token.type === 'tableDelimiterFiller')) {\n      cell[3] = index;\n    }\n  }\n  if (lastTableEnd !== 0) {\n    flushTableEnd(map, context, lastTableEnd, currentTable, currentBody);\n  }\n  map.consume(context.events);\n\n  // To do: move this into `html`, when events are exposed there.\n  // That’s what `markdown-rs` does.\n  // That needs updates to `mdast-util-gfm-table`.\n  index = -1;\n  while (++index < context.events.length) {\n    const event = context.events[index];\n    if (event[0] === 'enter' && event[1].type === 'table') {\n      event[1]._align = gfmTableAlign(context.events, index);\n    }\n  }\n  return events;\n}\n\n/**\n * Generate a cell.\n *\n * @param {EditMap} map\n * @param {Readonly<TokenizeContext>} context\n * @param {Readonly<Range>} range\n * @param {RowKind} rowKind\n * @param {number | undefined} rowEnd\n * @param {Token | undefined} previousCell\n * @returns {Token | undefined}\n */\n// eslint-disable-next-line max-params\nfunction flushCell(map, context, range, rowKind, rowEnd, previousCell) {\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCell' : 'tableCell'\n  const groupName = rowKind === 1 ? 'tableHeader' : rowKind === 2 ? 'tableDelimiter' : 'tableData';\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCellValue' : 'tableCellText'\n  const valueName = 'tableContent';\n\n  // Insert an exit for the previous cell, if there is one.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //          ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[0] !== 0) {\n    previousCell.end = Object.assign({}, getPoint(context.events, range[0]));\n    map.add(range[0], 0, [['exit', previousCell, context]]);\n  }\n\n  // Insert enter of this cell.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //           ^-- enter\n  //           ^^^^-- this cell\n  // ```\n  const now = getPoint(context.events, range[1]);\n  previousCell = {\n    type: groupName,\n    start: Object.assign({}, now),\n    // Note: correct end is set later.\n    end: Object.assign({}, now)\n  };\n  map.add(range[1], 0, [['enter', previousCell, context]]);\n\n  // Insert text start at first data start and end at last data end, and\n  // remove events between.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //            ^-- enter\n  //             ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[2] !== 0) {\n    const relatedStart = getPoint(context.events, range[2]);\n    const relatedEnd = getPoint(context.events, range[3]);\n    /** @type {Token} */\n    const valueToken = {\n      type: valueName,\n      start: Object.assign({}, relatedStart),\n      end: Object.assign({}, relatedEnd)\n    };\n    map.add(range[2], 0, [['enter', valueToken, context]]);\n    if (rowKind !== 2) {\n      // Fix positional info on remaining events\n      const start = context.events[range[2]];\n      const end = context.events[range[3]];\n      start[1].end = Object.assign({}, end[1].end);\n      start[1].type = \"chunkText\";\n      start[1].contentType = \"text\";\n\n      // Remove if needed.\n      if (range[3] > range[2] + 1) {\n        const a = range[2] + 1;\n        const b = range[3] - range[2] - 1;\n        map.add(a, b, []);\n      }\n    }\n    map.add(range[3] + 1, 0, [['exit', valueToken, context]]);\n  }\n\n  // Insert an exit for the last cell, if at the row end.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //                    ^-- exit\n  //               ^^^^^^-- this cell (the last one contains two “between” parts)\n  // ```\n  if (rowEnd !== undefined) {\n    previousCell.end = Object.assign({}, getPoint(context.events, rowEnd));\n    map.add(rowEnd, 0, [['exit', previousCell, context]]);\n    previousCell = undefined;\n  }\n  return previousCell;\n}\n\n/**\n * Generate table end (and table body end).\n *\n * @param {Readonly<EditMap>} map\n * @param {Readonly<TokenizeContext>} context\n * @param {number} index\n * @param {Token} table\n * @param {Token | undefined} tableBody\n */\n// eslint-disable-next-line max-params\nfunction flushTableEnd(map, context, index, table, tableBody) {\n  /** @type {Array<Event>} */\n  const exits = [];\n  const related = getPoint(context.events, index);\n  if (tableBody) {\n    tableBody.end = Object.assign({}, related);\n    exits.push(['exit', tableBody, context]);\n  }\n  table.end = Object.assign({}, related);\n  exits.push(['exit', table, context]);\n  map.add(index + 1, 0, exits);\n}\n\n/**\n * @param {Readonly<Array<Event>>} events\n * @param {number} index\n * @returns {Readonly<Point>}\n */\nfunction getPoint(events, index) {\n  const event = events[index];\n  const side = event[0] === 'enter' ? 'start' : 'end';\n  return event[1][side];\n}"],"names":["gfmTable","flow","null","name","tokenize","tokenizeTable","resolveAll","resolveTable","effects","ok","nok","self","this","seen","size","sizeB","code","index","events","length","type","tail","next","bodyRowStart","headRowBefore","parser","lazy","now","line","enter","headRowBreak","headRowStart","markdownLineEnding","interrupt","exit","consume","headDelimiterStart","markdownSpace","factorySpace","headRowData","markdownLineEndingOrSpace","headRowEscape","headDelimiterBefore","constructs","disable","includes","undefined","headDelimiterValueBefore","headDelimiterCellBefore","headDelimiterNok","headDelimiterLeftAlignmentAfter","headDelimiterCellAfter","headDelimiterFiller","headDelimiterRightAlignmentAfter","bodyRowBreak","bodyRowData","bodyRowEscape","context","currentTable","currentBody","currentCell","inFirstCellAwaitingPipe","rowKind","lastCell","cell","afterHeadAwaitingFirstBodyRow","lastTableEnd","map","EditMap","event","token","flushTableEnd","start","Object","assign","end","add","flushCell","_align","gfmTableAlign","range","rowEnd","previousCell","groupName","getPoint","relatedStart","relatedEnd","valueToken","contentType","a","b","table","tableBody","exits","related","push","side"],"mappings":"wRAwBO,SAASA,IACd,MAAO,CACLC,KAAM,CACJC,KAAM,CACJC,KAAM,QACNC,SAAUC,EACVC,WAAYC,IAIpB,CAMA,SAASF,EAAcG,EAASC,EAAIC,GAClC,MAAMC,EAAOC,KACb,IAGIC,EAHAC,EAAO,EACPC,EAAQ,EAGZ,OAkBA,SAAeC,GACb,IAAIC,EAAQN,EAAKO,OAAOC,OAAS,EACjC,KAAOF,GAAS,GAAG,CACjB,MAAMG,EAAOT,EAAKO,OAAOD,GAAO,GAAGG,KACnC,GAAa,eAATA,GAEK,eAATA,EAAoC,MAAbH,GACxB,CACD,MAAMI,EAAOJ,GAAS,EAAIN,EAAKO,OAAOD,GAAO,GAAGG,KAAO,KACjDE,EAAgB,cAATD,GAAiC,aAATA,EAAsBE,EAAeC,EAG1E,GAAIF,IAASC,GAAgBZ,EAAKc,OAAOC,KAAKf,EAAKgB,MAAMC,MACvD,OAAOlB,EAAIM,GAEb,OAAOM,EAAKN,EACb,EAcD,SAASQ,EAAcR,GAGrB,OAFAR,EAAQqB,MAAM,aACdrB,EAAQqB,MAAM,YAgBhB,SAAsBb,GACpB,GAAa,MAATA,EACF,OAAOc,EAAad,GAgBtB,OAHAH,GAAO,EAEPE,GAAS,EACFe,EAAad,EACrB,CAlCQe,CAAaf,EACrB,CAiDD,SAASc,EAAad,GACpB,OAAa,OAATA,EAEKN,EAAIM,GAETgB,EAAmBhB,GAEjBD,EAAQ,GACVA,EAAQ,EAGRJ,EAAKsB,WAAY,EACjBzB,EAAQ0B,KAAK,YACb1B,EAAQqB,MAAM,cACdrB,EAAQ2B,QAAQnB,GAChBR,EAAQ0B,KAAK,cACNE,GAIF1B,EAAIM,GAETqB,EAAcrB,GAITsB,EAAa9B,EAASsB,EAAc,aAApCQ,CAAkDtB,IAE3DD,GAAS,EACLF,IACFA,GAAO,EAEPC,GAAQ,GAEG,MAATE,GACFR,EAAQqB,MAAM,oBACdrB,EAAQ2B,QAAQnB,GAChBR,EAAQ0B,KAAK,oBAEbrB,GAAO,EACAiB,IAITtB,EAAQqB,MAAM,QACPU,EAAYvB,IACpB,CAcD,SAASuB,EAAYvB,GACnB,OAAa,OAATA,GAA0B,MAATA,GAAgBwB,EAA0BxB,IAC7DR,EAAQ0B,KAAK,QACNJ,EAAad,KAEtBR,EAAQ2B,QAAQnB,GACA,KAATA,EAAcyB,EAAgBF,EACtC,CAcD,SAASE,EAAczB,GACrB,OAAa,KAATA,GAAwB,MAATA,GACjBR,EAAQ2B,QAAQnB,GACTuB,GAEFA,EAAYvB,EACpB,CAcD,SAASoB,EAAmBpB,GAK1B,OAHAL,EAAKsB,WAAY,EAGbtB,EAAKc,OAAOC,KAAKf,EAAKgB,MAAMC,MACvBlB,EAAIM,IAEbR,EAAQqB,MAAM,qBAEdhB,GAAO,EACHwB,EAAcrB,GACTsB,EAAa9B,EAASkC,EAAqB,aAAc/B,EAAKc,OAAOkB,WAAWC,QAAQ1C,KAAK2C,SAAS,qBAAkBC,EAAY,EAApIR,CAAuItB,GAEzI0B,EAAoB1B,GAC5B,CAgBD,SAAS0B,EAAoB1B,GAC3B,OAAa,KAATA,GAAwB,KAATA,EACV+B,EAAyB/B,GAErB,MAATA,GACFH,GAAO,EAEPL,EAAQqB,MAAM,oBACdrB,EAAQ2B,QAAQnB,GAChBR,EAAQ0B,KAAK,oBACNc,GAIFC,EAAiBjC,EACzB,CAaD,SAASgC,EAAwBhC,GAC/B,OAAIqB,EAAcrB,GACTsB,EAAa9B,EAASuC,EAA0B,aAAhDT,CAA8DtB,GAEhE+B,EAAyB/B,EACjC,CAaD,SAAS+B,EAAyB/B,GAEhC,OAAa,KAATA,GACFD,GAAS,EACTF,GAAO,EACPL,EAAQqB,MAAM,wBACdrB,EAAQ2B,QAAQnB,GAChBR,EAAQ0B,KAAK,wBACNgB,GAII,KAATlC,GACFD,GAAS,EAEFmC,EAAgClC,IAE5B,OAATA,GAAiBgB,EAAmBhB,GAC/BmC,EAAuBnC,GAEzBiC,EAAiBjC,EACzB,CAaD,SAASkC,EAAgClC,GACvC,OAAa,KAATA,GACFR,EAAQqB,MAAM,wBACPuB,EAAoBpC,IAItBiC,EAAiBjC,EACzB,CAaD,SAASoC,EAAoBpC,GAC3B,OAAa,KAATA,GACFR,EAAQ2B,QAAQnB,GACToC,GAII,KAATpC,GACFH,GAAO,EACPL,EAAQ0B,KAAK,wBACb1B,EAAQqB,MAAM,wBACdrB,EAAQ2B,QAAQnB,GAChBR,EAAQ0B,KAAK,wBACNmB,IAET7C,EAAQ0B,KAAK,wBACNmB,EAAiCrC,GACzC,CAaD,SAASqC,EAAiCrC,GACxC,OAAIqB,EAAcrB,GACTsB,EAAa9B,EAAS2C,EAAwB,aAA9Cb,CAA4DtB,GAE9DmC,EAAuBnC,EAC/B,CAaD,SAASmC,EAAuBnC,GAC9B,OAAa,MAATA,EACK0B,EAAoB1B,IAEhB,OAATA,GAAiBgB,EAAmBhB,KAKjCH,GAAQC,IAASC,GAKtBP,EAAQ0B,KAAK,qBACb1B,EAAQ0B,KAAK,aAGNzB,EAAGO,IAELiC,EAAiBjC,EACzB,CAaD,SAASiC,EAAiBjC,GAExB,OAAON,EAAIM,EACZ,CAcD,SAASO,EAAaP,GAKpB,OADAR,EAAQqB,MAAM,YACPyB,EAAatC,EACrB,CAgBD,SAASsC,EAAatC,GACpB,OAAa,MAATA,GACFR,EAAQqB,MAAM,oBACdrB,EAAQ2B,QAAQnB,GAChBR,EAAQ0B,KAAK,oBACNoB,GAEI,OAATtC,GAAiBgB,EAAmBhB,IACtCR,EAAQ0B,KAAK,YACNzB,EAAGO,IAERqB,EAAcrB,GACTsB,EAAa9B,EAAS8C,EAAc,aAApChB,CAAkDtB,IAI3DR,EAAQqB,MAAM,QACP0B,EAAYvC,GACpB,CAcD,SAASuC,EAAYvC,GACnB,OAAa,OAATA,GAA0B,MAATA,GAAgBwB,EAA0BxB,IAC7DR,EAAQ0B,KAAK,QACNoB,EAAatC,KAEtBR,EAAQ2B,QAAQnB,GACA,KAATA,EAAcwC,EAAgBD,EACtC,CAcD,SAASC,EAAcxC,GACrB,OAAa,KAATA,GAAwB,MAATA,GACjBR,EAAQ2B,QAAQnB,GACTuC,GAEFA,EAAYvC,EACpB,CACH,CAIA,SAAST,EAAaW,EAAQuC,GAC5B,IAWIC,EAEAC,EAEAC,EAfA3C,GAAS,EACT4C,GAA0B,EAE1BC,EAAU,EAEVC,EAAW,CAAC,EAAG,EAAG,EAAG,GAErBC,EAAO,CAAC,EAAG,EAAG,EAAG,GACjBC,GAAgC,EAChCC,EAAe,EAOnB,MAAMC,EAAM,IAAIC,EAChB,OAASnD,EAAQC,EAAOC,QAAQ,CAC9B,MAAMkD,EAAQnD,EAAOD,GACfqD,EAAQD,EAAM,GACH,UAAbA,EAAM,GAEW,cAAfC,EAAMlD,MACR6C,GAAgC,EAGX,IAAjBC,IACFK,EAAcJ,EAAKV,EAASS,EAAcR,EAAcC,GACxDA,OAAcb,EACdoB,EAAe,GAIjBR,EAAe,CACbtC,KAAM,QACNoD,MAAOC,OAAOC,OAAO,CAAA,EAAIJ,EAAME,OAE/BG,IAAKF,OAAOC,OAAO,CAAA,EAAIJ,EAAMK,MAE/BR,EAAIS,IAAI3D,EAAO,EAAG,CAAC,CAAC,QAASyC,EAAcD,MACnB,aAAfa,EAAMlD,MAAsC,sBAAfkD,EAAMlD,MAC5CyC,GAA0B,EAC1BD,OAAcd,EACdiB,EAAW,CAAC,EAAG,EAAG,EAAG,GACrBC,EAAO,CAAC,EAAG/C,EAAQ,EAAG,EAAG,GAGrBgD,IACFA,GAAgC,EAChCN,EAAc,CACZvC,KAAM,YACNoD,MAAOC,OAAOC,OAAO,CAAA,EAAIJ,EAAME,OAE/BG,IAAKF,OAAOC,OAAO,CAAA,EAAIJ,EAAMK,MAE/BR,EAAIS,IAAI3D,EAAO,EAAG,CAAC,CAAC,QAAS0C,EAAaF,MAE5CK,EAAyB,sBAAfQ,EAAMlD,KAA+B,EAAIuC,EAAc,EAAI,IAG9DG,GAA2B,SAAfQ,EAAMlD,MAAkC,yBAAfkD,EAAMlD,MAAkD,yBAAfkD,EAAMlD,KAYnE,qBAAfkD,EAAMlD,OACXyC,EACFA,GAA0B,GAEN,IAAhBE,EAAS,KACXC,EAAK,GAAKA,EAAK,GACfJ,EAAciB,EAAUV,EAAKV,EAASM,EAAUD,OAAShB,EAAWc,IAEtEG,EAAWC,EACXA,EAAO,CAACD,EAAS,GAAI9C,EAAO,EAAG,MApBjC4C,GAA0B,EAGV,IAAZG,EAAK,KACa,IAAhBD,EAAS,KACXC,EAAK,GAAKA,EAAK,GACfJ,EAAciB,EAAUV,EAAKV,EAASM,EAAUD,OAAShB,EAAWc,GACpEG,EAAW,CAAC,EAAG,EAAG,EAAG,IAEvBC,EAAK,GAAK/C,IAgBQ,cAAfqD,EAAMlD,MACb6C,GAAgC,EAChCC,EAAejD,GACS,aAAfqD,EAAMlD,MAAsC,sBAAfkD,EAAMlD,MAC5C8C,EAAejD,EACK,IAAhB8C,EAAS,IACXC,EAAK,GAAKA,EAAK,GACfJ,EAAciB,EAAUV,EAAKV,EAASM,EAAUD,EAAS7C,EAAO2C,IAC3C,IAAZI,EAAK,KACdJ,EAAciB,EAAUV,EAAKV,EAASO,EAAMF,EAAS7C,EAAO2C,IAE9DE,EAAU,IACDA,GAA2B,SAAfQ,EAAMlD,MAAkC,yBAAfkD,EAAMlD,MAAkD,yBAAfkD,EAAMlD,OAC7F4C,EAAK,GAAK/C,EAEb,CAUD,IATqB,IAAjBiD,GACFK,EAAcJ,EAAKV,EAASS,EAAcR,EAAcC,GAE1DQ,EAAIhC,QAAQsB,EAAQvC,QAKpBD,GAAS,IACAA,EAAQwC,EAAQvC,OAAOC,QAAQ,CACtC,MAAMkD,EAAQZ,EAAQvC,OAAOD,GACZ,UAAboD,EAAM,IAAoC,UAAlBA,EAAM,GAAGjD,OACnCiD,EAAM,GAAGS,OAASC,EAActB,EAAQvC,OAAQD,GAEnD,CACD,OAAOC,CACT,CAcA,SAAS2D,EAAUV,EAAKV,EAASuB,EAAOlB,EAASmB,EAAQC,GAGvD,MAAMC,EAAwB,IAAZrB,EAAgB,cAA4B,IAAZA,EAAgB,iBAAmB,YAYpE,IAAbkB,EAAM,KACRE,EAAaP,IAAMF,OAAOC,OAAO,CAAA,EAAIU,EAAS3B,EAAQvC,OAAQ8D,EAAM,KACpEb,EAAIS,IAAII,EAAM,GAAI,EAAG,CAAC,CAAC,OAAQE,EAAczB,MAU/C,MAAM9B,EAAMyD,EAAS3B,EAAQvC,OAAQ8D,EAAM,IAkB3C,GAjBAE,EAAe,CACb9D,KAAM+D,EACNX,MAAOC,OAAOC,OAAO,CAAA,EAAI/C,GAEzBgD,IAAKF,OAAOC,OAAO,CAAA,EAAI/C,IAEzBwC,EAAIS,IAAII,EAAM,GAAI,EAAG,CAAC,CAAC,QAASE,EAAczB,KAW7B,IAAbuB,EAAM,GAAU,CAClB,MAAMK,EAAeD,EAAS3B,EAAQvC,OAAQ8D,EAAM,IAC9CM,EAAaF,EAAS3B,EAAQvC,OAAQ8D,EAAM,IAE5CO,EAAa,CACjBnE,KA5Cc,eA6CdoD,MAAOC,OAAOC,OAAO,CAAA,EAAIW,GACzBV,IAAKF,OAAOC,OAAO,CAAA,EAAIY,IAGzB,GADAnB,EAAIS,IAAII,EAAM,GAAI,EAAG,CAAC,CAAC,QAASO,EAAY9B,KAC5B,IAAZK,EAAe,CAEjB,MAAMU,EAAQf,EAAQvC,OAAO8D,EAAM,IAC7BL,EAAMlB,EAAQvC,OAAO8D,EAAM,IAMjC,GALAR,EAAM,GAAGG,IAAMF,OAAOC,OAAO,CAAE,EAAEC,EAAI,GAAGA,KACxCH,EAAM,GAAGpD,KAAO,YAChBoD,EAAM,GAAGgB,YAAc,OAGnBR,EAAM,GAAKA,EAAM,GAAK,EAAG,CAC3B,MAAMS,EAAIT,EAAM,GAAK,EACfU,EAAIV,EAAM,GAAKA,EAAM,GAAK,EAChCb,EAAIS,IAAIa,EAAGC,EAAG,GACf,CACF,CACDvB,EAAIS,IAAII,EAAM,GAAK,EAAG,EAAG,CAAC,CAAC,OAAQO,EAAY9B,IAChD,CAcD,YALeX,IAAXmC,IACFC,EAAaP,IAAMF,OAAOC,OAAO,CAAA,EAAIU,EAAS3B,EAAQvC,OAAQ+D,IAC9Dd,EAAIS,IAAIK,EAAQ,EAAG,CAAC,CAAC,OAAQC,EAAczB,KAC3CyB,OAAepC,GAEVoC,CACT,CAYA,SAASX,EAAcJ,EAAKV,EAASxC,EAAO0E,EAAOC,GAEjD,MAAMC,EAAQ,GACRC,EAAUV,EAAS3B,EAAQvC,OAAQD,GACrC2E,IACFA,EAAUjB,IAAMF,OAAOC,OAAO,CAAE,EAAEoB,GAClCD,EAAME,KAAK,CAAC,OAAQH,EAAWnC,KAEjCkC,EAAMhB,IAAMF,OAAOC,OAAO,CAAE,EAAEoB,GAC9BD,EAAME,KAAK,CAAC,OAAQJ,EAAOlC,IAC3BU,EAAIS,IAAI3D,EAAQ,EAAG,EAAG4E,EACxB,CAOA,SAAST,EAASlE,EAAQD,GACxB,MAAMoD,EAAQnD,EAAOD,GACf+E,EAAoB,UAAb3B,EAAM,GAAiB,QAAU,MAC9C,OAAOA,EAAM,GAAG2B,EAClB"}

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

@@ -1,2 +0,0 @@
-import{factorySpace as e}from"../../micromark-factory-space/index.js";import{markdownLineEndingOrSpace as t,markdownLineEnding as n,markdownSpace as r}from"../../micromark-util-character/index.js";const c={name:"tasklistCheck",tokenize:function(e,c,i){const k=this;return function(t){if(null!==k.previous||!k._gfmTasklistFirstContentOfListItem)return i(t);return e.enter("taskListCheck"),e.enter("taskListCheckMarker"),e.consume(t),e.exit("taskListCheckMarker"),u};function u(n){return t(n)?(e.enter("taskListCheckValueUnchecked"),e.consume(n),e.exit("taskListCheckValueUnchecked"),a):88===n||120===n?(e.enter("taskListCheckValueChecked"),e.consume(n),e.exit("taskListCheckValueChecked"),a):i(n)}function a(t){return 93===t?(e.enter("taskListCheckMarker"),e.consume(t),e.exit("taskListCheckMarker"),e.exit("taskListCheck"),o):i(t)}function o(t){return n(t)?c(t):r(t)?e.check({tokenize:s},c,i)(t):i(t)}}};function i(){return{text:{91:c}}}function s(t,n,r){return e(t,function(e){return null===e?r(e):n(e)},"whitespace")}export{i as gfmTaskListItem};
-//# sourceMappingURL=syntax.js.map

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","name","tokenize","effects","ok","nok","self","this","code","previous","_gfmTasklistFirstContentOfListItem","enter","consume","exit","inside","markdownLineEndingOrSpace","close","after","markdownLineEnding","markdownSpace","check","spaceThenNonSpace","gfmTaskListItem","text","factorySpace"],"mappings":"qMAMA,MAAMA,EAAgB,CACpBC,KAAM,gBACNC,SAuBF,SAA+BC,EAASC,EAAIC,GAC1C,MAAMC,EAAOC,KACb,OAYA,SAAcC,GACZ,GAEkB,OAAlBF,EAAKG,WAGJH,EAAKI,mCACJ,OAAOL,EAAIG,GAMb,OAJAL,EAAQQ,MAAM,iBACdR,EAAQQ,MAAM,uBACdR,EAAQS,QAAQJ,GAChBL,EAAQU,KAAK,uBACNC,CACR,EAYD,SAASA,EAAON,GAId,OAAIO,EAA0BP,IAC5BL,EAAQQ,MAAM,+BACdR,EAAQS,QAAQJ,GAChBL,EAAQU,KAAK,+BACNG,GAEI,KAATR,GAAwB,MAATA,GACjBL,EAAQQ,MAAM,6BACdR,EAAQS,QAAQJ,GAChBL,EAAQU,KAAK,6BACNG,GAEFX,EAAIG,EACZ,CAYD,SAASQ,EAAMR,GACb,OAAa,KAATA,GACFL,EAAQQ,MAAM,uBACdR,EAAQS,QAAQJ,GAChBL,EAAQU,KAAK,uBACbV,EAAQU,KAAK,iBACNI,GAEFZ,EAAIG,EACZ,CAKD,SAASS,EAAMT,GAEb,OAAIU,EAAmBV,GACdJ,EAAGI,GAKRW,EAAcX,GACTL,EAAQiB,MAAM,CACnBlB,SAAUmB,GACTjB,EAAIC,EAFAF,CAEKK,GAIPH,EAAIG,EACZ,CACH,GAhHO,SAASc,IACd,MAAO,CACLC,KAAM,CACJ,GAAMvB,GAGZ,CAgHA,SAASqB,EAAkBlB,EAASC,EAAIC,GACtC,OAAOmB,EAAarB,EAYpB,SAAeK,GAKb,OAAgB,OAATA,EAAgBH,EAAIG,GAAQJ,EAAGI,EACvC,EAlBmC,aAmBtC"}

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

@@ -1,2 +0,0 @@
-import{markdownSpace as r}from"../micromark-util-character/index.js";function t(t,n,e,u){const i=u?u-1:Number.POSITIVE_INFINITY;let o=0;return function(u){if(r(u))return t.enter(e),c(u);return n(u)};function c(u){return r(u)&&o++<i?(t.consume(u),c):(t.exit(e),n(u))}}export{t 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","Number","POSITIVE_INFINITY","size","code","markdownSpace","enter","prefix","consume","exit"],"mappings":"qEAwCO,SAASA,EAAaC,EAASC,EAAIC,EAAMC,GAC9C,MAAMC,EAAQD,EAAMA,EAAM,EAAIE,OAAOC,kBACrC,IAAIC,EAAO,EACX,OAGA,SAAeC,GACb,GAAIC,EAAcD,GAEhB,OADAR,EAAQU,MAAMR,GACPS,EAAOH,GAEhB,OAAOP,EAAGO,EACX,EAGD,SAASG,EAAOH,GACd,OAAIC,EAAcD,IAASD,IAASH,GAClCJ,EAAQY,QAAQJ,GACTG,IAETX,EAAQa,KAAKX,GACND,EAAGO,GACX,CACH"}

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

@@ -1,2 +0,0 @@
-const n=f(/[A-Za-z]/),t=f(/[\dA-Za-z]/);function u(n){return null!==n&&(n<32||127===n)}function r(n){return null!==n&&n<-2}function o(n){return null!==n&&(n<0||32===n)}function e(n){return-2===n||-1===n||32===n}const c=f(/\p{P}|\p{S}/u),l=f(/\s/);function f(n){return function(t){return null!==t&&t>-1&&n.test(String.fromCharCode(t))}}export{n as asciiAlpha,t as asciiAlphanumeric,u as asciiControl,r as markdownLineEnding,o as markdownLineEndingOrSpace,e as markdownSpace,c as unicodePunctuation,l 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","test","String","fromCharCode"],"mappings":"AAqBY,MAACA,EAAaC,EAAW,YAcxBC,EAAoBD,EAAW,cAoCrC,SAASE,EAAaC,GAC3B,OAGW,OAATA,IAAkBA,EAAO,IAAe,MAATA,EAEnC,CAiEO,SAASC,EAAmBD,GACjC,OAAgB,OAATA,GAAiBA,GAAQ,CAClC,CAWO,SAASE,EAA0BF,GACxC,OAAgB,OAATA,IAAkBA,EAAO,GAAc,KAATA,EACvC,CAiBO,SAASG,EAAcH,GAC5B,OAAiB,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,CACvC,CAuBY,MAACI,EAAqBP,EAAW,gBAsBhCQ,EAAoBR,EAAW,MAU5C,SAASA,EAAWS,GAClB,OAUA,SAAeN,GACb,OAAgB,OAATA,GAAiBA,GAAQ,GAAKM,EAAMC,KAAKC,OAAOC,aAAaT,GACrE,CACH"}

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

@@ -1,2 +0,0 @@
-function e(e,l,t,i){const n=e.length;let s,c=0;if(l=l<0?-l>n?0:n+l:l>n?n:l,t=t>0?t:0,i.length<1e4)s=Array.from(i),s.unshift(l,t),e.splice(...s);else for(t&&e.splice(l,t);c<i.length;)s=i.slice(c,c+1e4),s.unshift(l,0),e.splice(...s),c+=1e4,l+=1e4}export{e 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","length","parameters","chunkStart","Array","from","unshift","slice"],"mappings":"AAsBO,SAASA,EAAOC,EAAMC,EAAOC,EAAQC,GAC1C,MAAMC,EAAMJ,EAAKK,OACjB,IAEIC,EAFAC,EAAa,EAajB,GAPEN,EADEA,EAAQ,GACDA,EAAQG,EAAM,EAAIA,EAAMH,EAEzBA,EAAQG,EAAMA,EAAMH,EAE9BC,EAASA,EAAS,EAAIA,EAAS,EAG3BC,EAAME,OAAS,IACjBC,EAAaE,MAAMC,KAAKN,GACxBG,EAAWI,QAAQT,EAAOC,GAE1BF,EAAKD,UAAUO,QAMf,IAHIJ,GAAQF,EAAKD,OAAOE,EAAOC,GAGxBK,EAAaJ,EAAME,QACxBC,EAAaH,EAAMQ,MAAMJ,EAAYA,EAAa,KAClDD,EAAWI,QAAQT,EAAO,GAE1BD,EAAKD,UAAUO,GACfC,GAAc,IACdN,GAAS,GAGf"}

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

@@ -1,2 +0,0 @@
-import{markdownLineEndingOrSpace as r,unicodeWhitespace as i,unicodePunctuation as o}from"../micromark-util-character/index.js";function t(t){return null===t||r(t)||i(t)?1:o(t)?2:void 0}export{t 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":"gIAmBO,SAASA,EAAkBC,GAChC,OAAa,OAATA,GAAiBC,EAA0BD,IAASE,EAAkBF,GACjE,EAELG,EAAmBH,GACd,OADT,CAGF"}

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

@@ -1,2 +0,0 @@
-import{splice as t}from"../micromark-util-chunked/index.js";const n={}.hasOwnProperty;function o(t){const n={};let o=-1;for(;++o<t.length;)r(n,t[o]);return n}function r(t,o){let r;for(r in o){const e=(n.call(t,r)?t[r]:void 0)||(t[r]={}),i=o[r];let l;if(i)for(l in i){n.call(e,l)||(e[l]=[]);const t=i[l];c(e[l],Array.isArray(t)?t:t?[t]:[])}}}function c(n,o){let r=-1;const c=[];for(;++r<o.length;)("after"===o[r].add?n:c).push(o[r]);t(n,0,0,c)}export{o 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","length","syntaxExtension","extension","hook","left","call","undefined","right","code","value","constructs","Array","isArray","existing","list","before","add","push","splice"],"mappings":"4DAWA,MAAMA,EAAiB,CAAE,EAACA,eAUnB,SAASC,EAAkBC,GAEhC,MAAMC,EAAM,CAAE,EACd,IAAIC,GAAS,EAEb,OAASA,EAAQF,EAAWG,QAC1BC,EAAgBH,EAAKD,EAAWE,IAGlC,OAAOD,CACT,CAYA,SAASG,EAAgBH,EAAKI,GAE5B,IAAIC,EAEJ,IAAKA,KAAQD,EAAW,CACtB,MAEME,GAFQT,EAAeU,KAAKP,EAAKK,GAAQL,EAAIK,QAAQG,KAEpCR,EAAIK,GAAQ,CAAA,GAE7BI,EAAQL,EAAUC,GAExB,IAAIK,EAEJ,GAAID,EACF,IAAKC,KAAQD,EAAO,CACbZ,EAAeU,KAAKD,EAAMI,KAAOJ,EAAKI,GAAQ,IACnD,MAAMC,EAAQF,EAAMC,GACpBE,EAEEN,EAAKI,GACLG,MAAMC,QAAQH,GAASA,EAAQA,EAAQ,CAACA,GAAS,GAEpD,CAEJ,CACH,CAaA,SAASC,EAAWG,EAAUC,GAC5B,IAAIf,GAAS,EAEb,MAAMgB,EAAS,GAEf,OAAShB,EAAQe,EAAKd,SAEE,UAApBc,EAAKf,GAAOiB,IAAkBH,EAAWE,GAAQE,KAAKH,EAAKf,IAG/DmB,EAAOL,EAAU,EAAG,EAAGE,EACzB"}

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

@@ -1,2 +0,0 @@
-function e(e){return e.replace(/[\t\n\r ]+/g," ").replace(/^ | $/g,"").toLowerCase().toUpperCase()}export{e 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","replace","toLowerCase","toUpperCase"],"mappings":"AAmBO,SAASA,EAAoBC,GAClC,OAAOA,EAENC,QAAQ,cAAe,KAEvBA,QAAQ,SAAU,IAOlBC,cAAcC,aACjB"}

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

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