@burdenoff/microfe-store 2026.720.3 → 2026.720.4

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

@@ -0,0 +1,26 @@
+import { markdownLineEnding as e } from "../micromark-util-character/index.js";
+import { factorySpace as t } from "../micromark-factory-space/index.js";
+//#region node_modules/micromark-factory-title/index.js
+function n(n, r, i, a, o, s) {
+	let c;
+	return l;
+	function l(e) {
+		return e === 34 || e === 39 || e === 40 ? (n.enter(a), n.enter(o), n.consume(e), n.exit(o), c = e === 40 ? 41 : e, u) : i(e);
+	}
+	function u(e) {
+		return e === c ? (n.enter(o), n.consume(e), n.exit(o), n.exit(a), r) : (n.enter(s), d(e));
+	}
+	function d(r) {
+		return r === c ? (n.exit(s), u(c)) : r === null ? i(r) : e(r) ? (n.enter("lineEnding"), n.consume(r), n.exit("lineEnding"), t(n, d, "linePrefix")) : (n.enter("chunkString", { contentType: "string" }), f(r));
+	}
+	function f(t) {
+		return t === c || t === null || e(t) ? (n.exit("chunkString"), d(t)) : (n.consume(t), t === 92 ? p : f);
+	}
+	function p(e) {
+		return e === c || e === 92 ? (n.consume(e), f) : f(e);
+	}
+}
+//#endregion
+export { n as factoryTitle };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../node_modules/micromark-factory-title/index.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Effects,\n *   State,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      marker = code === 40 ? 41 : code;\n      return begin;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(code) {\n    if (code === marker) {\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n    effects.enter(stringType);\n    return atBreak(code);\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return begin(marker);\n    }\n    if (code === null) {\n      return nok(code);\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return factorySpace(effects, atBreak, \"linePrefix\");\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return inside(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? escape : inside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return inside;\n    }\n    return inside(code);\n  }\n}"],"x_google_ignoreList":[0],"mappings":";;;AA0CA,SAAgB,EAAa,GAAS,GAAI,GAAK,GAAM,GAAY,GAAY;CAE3E,IAAI;AACJ,QAAO;CAYP,SAAS,EAAM,GAAM;AASnB,SARI,MAAS,MAAM,MAAS,MAAM,MAAS,MACzC,EAAQ,MAAM,EAAK,EACnB,EAAQ,MAAM,EAAW,EACzB,EAAQ,QAAQ,EAAK,EACrB,EAAQ,KAAK,EAAW,EACxB,IAAS,MAAS,KAAK,KAAK,GACrB,KAEF,EAAI,EAAK;;CAelB,SAAS,EAAM,GAAM;AASnB,SARI,MAAS,KACX,EAAQ,MAAM,EAAW,EACzB,EAAQ,QAAQ,EAAK,EACrB,EAAQ,KAAK,EAAW,EACxB,EAAQ,KAAK,EAAK,EACX,MAET,EAAQ,MAAM,EAAW,EAClB,EAAQ,EAAK;;CAatB,SAAS,EAAQ,GAAM;AAoBrB,SAnBI,MAAS,KACX,EAAQ,KAAK,EAAW,EACjB,EAAM,EAAO,IAElB,MAAS,OACJ,EAAI,EAAK,GAId,EAAmB,EAAK,IAE1B,EAAQ,MAAM,aAAa,EAC3B,EAAQ,QAAQ,EAAK,EACrB,EAAQ,KAAK,aAAa,EACnB,EAAa,GAAS,GAAS,aAAa,KAErD,EAAQ,MAAM,eAAe,EAC3B,aAAa,UACd,CAAC,EACK,EAAO,EAAK;;CAQrB,SAAS,EAAO,GAAM;AAMpB,SALI,MAAS,KAAU,MAAS,QAAQ,EAAmB,EAAK,IAC9D,EAAQ,KAAK,cAAc,EACpB,EAAQ,EAAK,KAEtB,EAAQ,QAAQ,EAAK,EACd,MAAS,KAAK,IAAS;;CAahC,SAAS,EAAO,GAAM;AAKpB,SAJI,MAAS,KAAU,MAAS,MAC9B,EAAQ,QAAQ,EAAK,EACd,KAEF,EAAO,EAAK"}

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

@@ -0,0 +1,14 @@
+import { markdownLineEnding as e, markdownSpace as t } from "../micromark-util-character/index.js";
+import { factorySpace as n } from "../micromark-factory-space/index.js";
+//#region node_modules/micromark-factory-whitespace/index.js
+function r(r, i) {
+	let a;
+	return o;
+	function o(s) {
+		return e(s) ? (r.enter("lineEnding"), r.consume(s), r.exit("lineEnding"), a = !0, o) : t(s) ? n(r, o, a ? "linePrefix" : "lineSuffix")(s) : i(s);
+	}
+}
+//#endregion
+export { r as factoryWhitespace };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../node_modules/micromark-factory-whitespace/index.js"],"sourcesContent":["/**\n * @import {Effects, State} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns {State}\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      seen = true;\n      return start;\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? \"linePrefix\" : \"lineSuffix\")(code);\n    }\n    return ok(code);\n  }\n}"],"x_google_ignoreList":[0],"mappings":";;;AAwBA,SAAgB,EAAkB,GAAS,GAAI;CAE7C,IAAI;AACJ,QAAO;CAGP,SAAS,EAAM,GAAM;AAWnB,SAVI,EAAmB,EAAK,IAC1B,EAAQ,MAAM,aAAa,EAC3B,EAAQ,QAAQ,EAAK,EACrB,EAAQ,KAAK,aAAa,EAC1B,IAAO,IACA,KAEL,EAAc,EAAK,GACd,EAAa,GAAS,GAAO,IAAO,eAAe,aAAa,CAAC,EAAK,GAExE,EAAG,EAAK"}

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

@@ -0,0 +1,26 @@
+//#region node_modules/micromark-util-character/index.js
+var e = f(/[A-Za-z]/), t = f(/[\dA-Za-z]/), n = f(/[#-'*+\--9=?A-Z^-~]/);
+function r(e) {
+	return e !== null && (e < 32 || e === 127);
+}
+var i = f(/\d/), a = f(/[\dA-Fa-f]/), o = f(/[!-/:-@[-`{-~]/);
+function s(e) {
+	return e !== null && e < -2;
+}
+function c(e) {
+	return e !== null && (e < 0 || e === 32);
+}
+function l(e) {
+	return e === -2 || e === -1 || e === 32;
+}
+var u = f(/\p{P}|\p{S}/u), d = f(/\s/);
+function f(e) {
+	return t;
+	function t(t) {
+		return t !== null && t > -1 && e.test(String.fromCharCode(t));
+	}
+}
+//#endregion
+export { e as asciiAlpha, t as asciiAlphanumeric, n as asciiAtext, r as asciiControl, i as asciiDigit, a as asciiHexDigit, o as asciiPunctuation, s as markdownLineEnding, c as markdownLineEndingOrSpace, l as markdownSpace, u as unicodePunctuation, d as unicodeWhitespace };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"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}"],"x_google_ignoreList":[0],"mappings":";AAqBA,IAAa,IAAa,EAAW,WAAW,EAcnC,IAAoB,EAAW,aAAa,EAuB5C,IAAa,EAAW,sBAAsB;AAa3D,SAAgB,EAAa,GAAM;AACjC,QAGE,MAAS,SAAS,IAAO,MAAM,MAAS;;AAe5C,IAAa,IAAa,EAAW,KAAK,EAoB7B,IAAgB,EAAW,aAAa,EAexC,IAAmB,EAAW,iBAAiB;AAiB5D,SAAgB,EAAmB,GAAM;AACvC,QAAO,MAAS,QAAQ,IAAO;;AAYjC,SAAgB,EAA0B,GAAM;AAC9C,QAAO,MAAS,SAAS,IAAO,KAAK,MAAS;;AAkBhD,SAAgB,EAAc,GAAM;AAClC,QAAO,MAAS,MAAM,MAAS,MAAM,MAAS;;AAwBhD,IAAa,IAAqB,EAAW,eAAe,EAsB/C,IAAoB,EAAW,KAAK;AAUjD,SAAS,EAAW,GAAO;AACzB,QAAO;CAUP,SAAS,EAAM,GAAM;AACnB,SAAO,MAAS,QAAQ,IAAO,MAAM,EAAM,KAAK,OAAO,aAAa,EAAK,CAAC"}

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

@@ -0,0 +1,13 @@
+//#region node_modules/micromark-util-chunked/index.js
+function e(e, t, n, r) {
+	let i = e.length, a = 0, o;
+	if (t = t < 0 ? -t > i ? 0 : i + t : t > i ? i : t, n = n > 0 ? n : 0, r.length < 1e4) o = Array.from(r), o.unshift(t, n), e.splice(...o);
+	else for (n && e.splice(t, n); a < r.length;) o = r.slice(a, a + 1e4), o.unshift(t, 0), e.splice(...o), a += 1e4, t += 1e4;
+}
+function t(t, n) {
+	return t.length > 0 ? (e(t, t.length, 0, n), t) : n;
+}
+//#endregion
+export { t as push, e as splice };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"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}"],"x_google_ignoreList":[0],"mappings":";AAsBA,SAAgB,EAAO,GAAM,GAAO,GAAQ,GAAO;CACjD,IAAM,IAAM,EAAK,QACb,IAAa,GAEb;AAWJ,KARA,AAGE,IAHE,IAAQ,IACF,CAAC,IAAQ,IAAM,IAAI,IAAM,IAEzB,IAAQ,IAAM,IAAM,GAE9B,IAAS,IAAS,IAAI,IAAS,GAG3B,EAAM,SAAS,IAIjB,CAHA,IAAa,MAAM,KAAK,EAAM,EAC9B,EAAW,QAAQ,GAAO,EAAO,EAEjC,EAAK,OAAO,GAAG,EAAW;KAM1B,MAHI,KAAQ,EAAK,OAAO,GAAO,EAAO,EAG/B,IAAa,EAAM,QAMxB,CALA,IAAa,EAAM,MAAM,GAAY,IAAa,IAAM,EACxD,EAAW,QAAQ,GAAO,EAAE,EAE5B,EAAK,OAAO,GAAG,EAAW,EAC1B,KAAc,KACd,KAAS;;AAqBf,SAAgB,EAAK,GAAM,GAAO;AAKhC,QAJI,EAAK,SAAS,KAChB,EAAO,GAAM,EAAK,QAAQ,GAAG,EAAM,EAC5B,KAEF"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"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}"],"x_google_ignoreList":[0],"mappings":";;AAmBA,SAAgB,EAAkB,GAAM;AACtC,KAAI,MAAS,QAAQ,EAA0B,EAAK,IAAI,EAAkB,EAAK,CAC7E,QAAO;AAET,KAAI,EAAmB,EAAK,CAC1B,QAAO"}

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

@@ -0,0 +1,28 @@
+import { splice as e } from "../micromark-util-chunked/index.js";
+//#region node_modules/micromark-util-combine-extensions/index.js
+var t = {}.hasOwnProperty;
+function n(e) {
+	let t = {}, n = -1;
+	for (; ++n < e.length;) r(t, e[n]);
+	return t;
+}
+function r(e, n) {
+	let r;
+	for (r in n) {
+		let a = (t.call(e, r) ? e[r] : void 0) || (e[r] = {}), o = n[r], s;
+		if (o) for (s in o) {
+			t.call(a, s) || (a[s] = []);
+			let e = o[s];
+			i(a[s], Array.isArray(e) ? e : e ? [e] : []);
+		}
+	}
+}
+function i(t, n) {
+	let r = -1, i = [];
+	for (; ++r < n.length;) (n[r].add === "after" ? t : i).push(n[r]);
+	e(t, 0, 0, i);
+}
+//#endregion
+export { n as combineExtensions };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"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"],"x_google_ignoreList":[0],"mappings":";;AAWA,IAAM,IAAiB,EAAE,CAAC;AAU1B,SAAgB,EAAkB,GAAY;CAE5C,IAAM,IAAM,EAAE,EACV,IAAQ;AAEZ,QAAO,EAAE,IAAQ,EAAW,QAC1B,GAAgB,GAAK,EAAW,GAAO;AAGzC,QAAO;;AAaT,SAAS,EAAgB,GAAK,GAAW;CAEvC,IAAI;AAEJ,MAAK,KAAQ,GAAW;EAGtB,IAAM,KAFQ,EAAe,KAAK,GAAK,EAAK,GAAG,EAAI,KAAQ,KAAA,OAEpC,EAAI,KAAQ,EAAE,GAE/B,IAAQ,EAAU,IAEpB;AAEJ,MAAI,EACF,MAAK,KAAQ,GAAO;AAClB,GAAK,EAAe,KAAK,GAAM,EAAK,KAAE,EAAK,KAAQ,EAAE;GACrD,IAAM,IAAQ,EAAM;AACpB,KAEE,EAAK,IACL,MAAM,QAAQ,EAAM,GAAG,IAAQ,IAAQ,CAAC,EAAM,GAAG,EAAE,CACpD;;;;AAiBT,SAAS,EAAW,GAAU,GAAM;CAClC,IAAI,IAAQ,IAEN,IAAS,EAAE;AAEjB,QAAO,EAAE,IAAQ,EAAK,QAEnB,EAAC,EAAK,GAAO,QAAQ,UAAU,IAAW,GAAQ,KAAK,EAAK,GAAO;AAGtE,GAAO,GAAU,GAAG,GAAG,EAAO"}

package/dist/node_modules/micromark-util-decode-numeric-character-reference/index.js

@@ -0,0 +1,9 @@
+//#region node_modules/micromark-util-decode-numeric-character-reference/index.js
+function e(e, t) {
+	let n = Number.parseInt(e, t);
+	return n < 9 || n === 11 || n > 13 && n < 32 || n > 126 && n < 160 || n > 55295 && n < 57344 || n > 64975 && n < 65008 || (n & 65535) == 65535 || (n & 65535) == 65534 || n > 1114111 ? "�" : String.fromCodePoint(n);
+}
+//#endregion
+export { e as decodeNumericCharacterReference };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../node_modules/micromark-util-decode-numeric-character-reference/index.js"],"sourcesContent":["/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * Sort of like `String.fromCodePoint(Number.parseInt(value, base))`, but makes\n * non-characters and control characters safe.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n *   Character.\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base);\n  if (\n  // C0 except for HT, LF, FF, CR, space.\n  code < 9 || code === 11 || code > 13 && code < 32 ||\n  // Control character (DEL) of C0, and C1 controls.\n  code > 126 && code < 160 ||\n  // Lone high surrogates and low surrogates.\n  code > 55_295 && code < 57_344 ||\n  // Noncharacters.\n  code > 64_975 && code < 65_008 || /* eslint-disable no-bitwise */\n  (code & 65_535) === 65_535 || (code & 65_535) === 65_534 || /* eslint-enable no-bitwise */\n  // Out of range\n  code > 1_114_111) {\n    return \"\\uFFFD\";\n  }\n  return String.fromCodePoint(code);\n}"],"x_google_ignoreList":[0],"mappings":";AAcA,SAAgB,EAAgC,GAAO,GAAM;CAC3D,IAAM,IAAO,OAAO,SAAS,GAAO,EAAK;AAezC,QAZA,IAAO,KAAK,MAAS,MAAM,IAAO,MAAM,IAAO,MAE/C,IAAO,OAAO,IAAO,OAErB,IAAO,SAAU,IAAO,SAExB,IAAO,SAAU,IAAO,UACvB,IAAO,UAAY,UAAW,IAAO,UAAY,SAElD,IAAO,UACE,MAEF,OAAO,cAAc,EAAK"}

package/dist/node_modules/micromark-util-decode-string/index.js

@@ -0,0 +1,19 @@
+import { decodeNamedCharacterReference as e } from "../decode-named-character-reference/index.dom.js";
+import { decodeNumericCharacterReference as t } from "../micromark-util-decode-numeric-character-reference/index.js";
+//#region node_modules/micromark-util-decode-string/index.js
+var n = /\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;
+function r(e) {
+	return e.replace(n, i);
+}
+function i(n, r, i) {
+	if (r) return r;
+	if (i.charCodeAt(0) === 35) {
+		let e = i.charCodeAt(1), n = e === 120 || e === 88;
+		return t(i.slice(n ? 2 : 1), n ? 16 : 10);
+	}
+	return e(i) || n;
+}
+//#endregion
+export { r as decodeString };
+
+//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-decode-string/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../node_modules/micromark-util-decode-string/index.js"],"sourcesContent":["import { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nconst characterEscapeOrReference = /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi;\n\n/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode);\n}\n\n/**\n * @param {string} $0\n *   Match.\n * @param {string} $1\n *   Character escape.\n * @param {string} $2\n *   Character reference.\n * @returns {string}\n *   Decoded value\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1;\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0);\n  if (head === 35) {\n    const head = $2.charCodeAt(1);\n    const hex = head === 120 || head === 88;\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10);\n  }\n  return decodeNamedCharacterReference($2) || $0;\n}"],"x_google_ignoreList":[0],"mappings":";;;AAEA,IAAM,IAA6B;AAcnC,SAAgB,EAAa,GAAO;AAClC,QAAO,EAAM,QAAQ,GAA4B,EAAO;;AAa1D,SAAS,EAAO,GAAI,GAAI,GAAI;AAC1B,KAAI,EAEF,QAAO;AAKT,KADa,EAAG,WAAW,EAAE,KAChB,IAAI;EACf,IAAM,IAAO,EAAG,WAAW,EAAE,EACvB,IAAM,MAAS,OAAO,MAAS;AACrC,SAAO,EAAgC,EAAG,MAAM,IAAM,IAAI,EAAE,EAAE,IAAM,KAAK,GAAG;;AAE9E,QAAO,EAA8B,EAAG,IAAI"}

package/dist/node_modules/micromark-util-html-tag-name/index.js

@@ -0,0 +1,11 @@
+//#region node_modules/micromark-util-html-tag-name/index.js
+var e = /* @__PURE__ */ "address.article.aside.base.basefont.blockquote.body.caption.center.col.colgroup.dd.details.dialog.dir.div.dl.dt.fieldset.figcaption.figure.footer.form.frame.frameset.h1.h2.h3.h4.h5.h6.head.header.hr.html.iframe.legend.li.link.main.menu.menuitem.nav.noframes.ol.optgroup.option.p.param.search.section.summary.table.tbody.td.tfoot.th.thead.title.tr.track.ul".split("."), t = [
+	"pre",
+	"script",
+	"style",
+	"textarea"
+];
+//#endregion
+export { e as htmlBlockNames, t as htmlRawNames };
+
+//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-html-tag-name/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../node_modules/micromark-util-html-tag-name/index.js"],"sourcesContent":["/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n"],"x_google_ignoreList":[0],"mappings":";AAeA,IAAa,IAAiB,gYA+D7B,EAcY,IAAe;CAAC;CAAO;CAAU;CAAS;CAAW"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"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}"],"x_google_ignoreList":[0],"mappings":";AAmBA,SAAgB,EAAoB,GAAO;AACzC,QAAO,EAEN,QAAQ,eAAe,IAAI,CAE3B,QAAQ,UAAU,GAAG,CAOrB,aAAa,CAAC,aAAa"}

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

@@ -0,0 +1,13 @@
+//#region node_modules/micromark-util-resolve-all/index.js
+function e(e, t, n) {
+	let r = [], i = -1;
+	for (; ++i < e.length;) {
+		let a = e[i].resolveAll;
+		a && !r.includes(a) && (t = a(t, n), r.push(a));
+	}
+	return t;
+}
+//#endregion
+export { e as resolveAll };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../node_modules/micromark-util-resolve-all/index.js"],"sourcesContent":["/**\n * @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n"],"x_google_ignoreList":[0],"mappings":";AAgBA,SAAgB,EAAW,GAAY,GAAQ,GAAS;CAEtD,IAAM,IAAS,EAAE,EACb,IAAQ;AAEZ,QAAO,EAAE,IAAQ,EAAW,SAAQ;EAClC,IAAM,IAAU,EAAW,GAAO;AAElC,EAAI,KAAW,CAAC,EAAO,SAAS,EAAQ,KACtC,IAAS,EAAQ,GAAQ,EAAQ,EACjC,EAAO,KAAK,EAAQ;;AAIxB,QAAO"}

package/dist/node_modules/micromark-util-sanitize-uri/index.js

@@ -0,0 +1,20 @@
+import { asciiAlphanumeric as e } from "../micromark-util-character/index.js";
+//#region node_modules/micromark-util-sanitize-uri/index.js
+function t(t) {
+	let n = [], r = -1, i = 0, a = 0;
+	for (; ++r < t.length;) {
+		let o = t.charCodeAt(r), s = "";
+		if (o === 37 && e(t.charCodeAt(r + 1)) && e(t.charCodeAt(r + 2))) a = 2;
+		else if (o < 128) /[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(o)) || (s = String.fromCharCode(o));
+		else if (o > 55295 && o < 57344) {
+			let e = t.charCodeAt(r + 1);
+			o < 56320 && e > 56319 && e < 57344 ? (s = String.fromCharCode(o, e), a = 1) : s = "�";
+		} else s = String.fromCharCode(o);
+		s &&= (n.push(t.slice(i, r), encodeURIComponent(s)), i = r + a + 1, ""), a &&= (r += a, 0);
+	}
+	return n.join("") + t.slice(i);
+}
+//#endregion
+export { t as normalizeUri };
+
+//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-sanitize-uri/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../node_modules/micromark-util-sanitize-uri/index.js"],"sourcesContent":["import { asciiAlphanumeric } from 'micromark-util-character';\nimport { encode } from 'micromark-util-encode';\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri`).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * A regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`, or\n * `/^https?$/i` for `img[src]` (this is what `github.com` allows).\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string | null | undefined} url\n *   URI to sanitize.\n * @param {RegExp | null | undefined} [protocol]\n *   Allowed protocols.\n * @returns {string}\n *   Sanitized URI.\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''));\n  if (!protocol) {\n    return value;\n  }\n  const colon = value.indexOf(':');\n  const questionMark = value.indexOf('?');\n  const numberSign = value.indexOf('#');\n  const slash = value.indexOf('/');\n  if (\n  // If there is no protocol, it’s relative.\n  colon < 0 ||\n  // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n  slash > -1 && colon > slash || questionMark > -1 && colon > questionMark || numberSign > -1 && colon > numberSign ||\n  // It is a protocol, it should be allowed.\n  protocol.test(value.slice(0, colon))) {\n    return value;\n  }\n  return '';\n}\n\n/**\n * Normalize a URL.\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n *   URI to normalize.\n * @returns {string}\n *   Normalized URI.\n */\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = [];\n  let index = -1;\n  let start = 0;\n  let skip = 0;\n  while (++index < value.length) {\n    const code = value.charCodeAt(index);\n    /** @type {string} */\n    let replace = '';\n\n    // A correct percent encoded value.\n    if (code === 37 && asciiAlphanumeric(value.charCodeAt(index + 1)) && asciiAlphanumeric(value.charCodeAt(index + 2))) {\n      skip = 2;\n    }\n    // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code);\n      }\n    }\n    // Astral.\n    else if (code > 55_295 && code < 57_344) {\n      const next = value.charCodeAt(index + 1);\n\n      // A correct surrogate pair.\n      if (code < 56_320 && next > 56_319 && next < 57_344) {\n        replace = String.fromCharCode(code, next);\n        skip = 1;\n      }\n      // Lone surrogate.\n      else {\n        replace = \"\\uFFFD\";\n      }\n    }\n    // Unicode.\n    else {\n      replace = String.fromCharCode(code);\n    }\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace));\n      start = index + skip + 1;\n      replace = '';\n    }\n    if (skip) {\n      index += skip;\n      skip = 0;\n    }\n  }\n  return result.join('') + value.slice(start);\n}"],"x_google_ignoreList":[0],"mappings":";;AAwDA,SAAgB,EAAa,GAAO;CAElC,IAAM,IAAS,EAAE,EACb,IAAQ,IACR,IAAQ,GACR,IAAO;AACX,QAAO,EAAE,IAAQ,EAAM,SAAQ;EAC7B,IAAM,IAAO,EAAM,WAAW,EAAM,EAEhC,IAAU;AAGd,MAAI,MAAS,MAAM,EAAkB,EAAM,WAAW,IAAQ,EAAE,CAAC,IAAI,EAAkB,EAAM,WAAW,IAAQ,EAAE,CAAC,CACjH,KAAO;WAGA,IAAO,KACT,oBAAoB,KAAK,OAAO,aAAa,EAAK,CAAC,KACtD,IAAU,OAAO,aAAa,EAAK;WAI9B,IAAO,SAAU,IAAO,OAAQ;GACvC,IAAM,IAAO,EAAM,WAAW,IAAQ,EAAE;AAGxC,GAAI,IAAO,SAAU,IAAO,SAAU,IAAO,SAC3C,IAAU,OAAO,aAAa,GAAM,EAAK,EACzC,IAAO,KAIP,IAAU;QAKZ,KAAU,OAAO,aAAa,EAAK;AAOrC,EALA,AAGE,OAFA,EAAO,KAAK,EAAM,MAAM,GAAO,EAAM,EAAE,mBAAmB,EAAQ,CAAC,EACnE,IAAQ,IAAQ,IAAO,GACb,KAEZ,AAEE,OADA,KAAS,GACF;;AAGX,QAAO,EAAO,KAAK,GAAG,GAAG,EAAM,MAAM,EAAM"}

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

@@ -0,0 +1,37 @@
+import { splice as e } from "../micromark-util-chunked/index.js";
+import { SpliceBuffer as t } from "./lib/splice-buffer.js";
+//#region node_modules/micromark-util-subtokenize/index.js
+function n(n) {
+	let i = {}, a = -1, o, s, c, l, u, d, f, p = new t(n);
+	for (; ++a < p.length;) {
+		for (; a in i;) a = i[a];
+		if (o = p.get(a), a && o[1].type === "chunkFlow" && p.get(a - 1)[1].type === "listItemPrefix" && (d = o[1]._tokenizer.events, c = 0, c < d.length && d[c][1].type === "lineEndingBlank" && (c += 2), c < d.length && d[c][1].type === "content")) for (; ++c < d.length && d[c][1].type !== "content";) d[c][1].type === "chunkText" && (d[c][1]._isInFirstContentOfListItem = !0, c++);
+		if (o[0] === "enter") o[1].contentType && (Object.assign(i, r(p, a)), a = i[a], f = !0);
+		else if (o[1]._container) {
+			for (c = a, s = void 0; c--;) if (l = p.get(c), l[1].type === "lineEnding" || l[1].type === "lineEndingBlank") l[0] === "enter" && (s && (p.get(s)[1].type = "lineEndingBlank"), l[1].type = "lineEnding", s = c);
+			else if (!(l[1].type === "linePrefix" || l[1].type === "listItemIndent")) break;
+			s && (o[1].end = { ...p.get(s)[1].start }, u = p.slice(s, a), u.unshift(o), p.splice(s, a - s + 1, u));
+		}
+	}
+	return e(n, 0, Infinity, p.slice(0)), !f;
+}
+function r(e, t) {
+	let n = e.get(t)[1], r = e.get(t)[2], i = t - 1, a = [], o = n._tokenizer;
+	o || (o = r.parser[n.contentType](n.start), n._contentTypeTextTrailing && (o._contentTypeTextTrailing = !0));
+	let s = o.events, c = [], l = {}, u, d, f = -1, p = n, m = 0, h = 0, g = [h];
+	for (; p;) {
+		for (; e.get(++i)[1] !== p;);
+		a.push(i), p._tokenizer || (u = r.sliceStream(p), p.next || u.push(null), d && o.defineSkip(p.start), p._isInFirstContentOfListItem && (o._gfmTasklistFirstContentOfListItem = !0), o.write(u), p._isInFirstContentOfListItem && (o._gfmTasklistFirstContentOfListItem = void 0)), d = p, p = p.next;
+	}
+	for (p = n; ++f < s.length;) s[f][0] === "exit" && s[f - 1][0] === "enter" && s[f][1].type === s[f - 1][1].type && s[f][1].start.line !== s[f][1].end.line && (h = f + 1, g.push(h), p._tokenizer = void 0, p.previous = void 0, p = p.next);
+	for (o.events = [], p ? (p._tokenizer = void 0, p.previous = void 0) : g.pop(), f = g.length; f--;) {
+		let t = s.slice(g[f], g[f + 1]), n = a.pop();
+		c.push([n, n + t.length - 1]), e.splice(n, 2, t);
+	}
+	for (c.reverse(), f = -1; ++f < c.length;) l[m + c[f][0]] = m + c[f][1], m += c[f][1] - c[f][0] - 1;
+	return l;
+}
+//#endregion
+export { n as subtokenize };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../node_modules/micromark-util-subtokenize/index.js"],"sourcesContent":["/**\n * @import {Chunk, Event, Token} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { SpliceBuffer } from './lib/splice-buffer.js';\n\n// Hidden API exposed for testing.\nexport { SpliceBuffer } from './lib/splice-buffer.js';\n\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} eventsArray\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\n// eslint-disable-next-line complexity\nexport function subtokenize(eventsArray) {\n  /** @type {Record<string, number>} */\n  const jumps = {};\n  let index = -1;\n  /** @type {Event} */\n  let event;\n  /** @type {number | undefined} */\n  let lineIndex;\n  /** @type {number} */\n  let otherIndex;\n  /** @type {Event} */\n  let otherEvent;\n  /** @type {Array<Event>} */\n  let parameters;\n  /** @type {Array<Event>} */\n  let subevents;\n  /** @type {boolean | undefined} */\n  let more;\n  const events = new SpliceBuffer(eventsArray);\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n    event = events.get(index);\n\n    // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n    if (index && event[1].type === \"chunkFlow\" && events.get(index - 1)[1].type === \"listItemPrefix\") {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"lineEndingBlank\") {\n        otherIndex += 2;\n      }\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"content\") {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === \"content\") {\n            break;\n          }\n          if (subevents[otherIndex][1].type === \"chunkText\") {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    }\n\n    // Enter.\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    }\n    // Exit.\n    else if (event[1]._container) {\n      otherIndex = index;\n      lineIndex = undefined;\n      while (otherIndex--) {\n        otherEvent = events.get(otherIndex);\n        if (otherEvent[1].type === \"lineEnding\" || otherEvent[1].type === \"lineEndingBlank\") {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events.get(lineIndex)[1].type = \"lineEndingBlank\";\n            }\n            otherEvent[1].type = \"lineEnding\";\n            lineIndex = otherIndex;\n          }\n        } else if (otherEvent[1].type === \"linePrefix\" || otherEvent[1].type === \"listItemIndent\") {\n          // Move past.\n        } else {\n          break;\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = {\n          ...events.get(lineIndex)[1].start\n        };\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index);\n        parameters.unshift(event);\n        events.splice(lineIndex, index - lineIndex + 1, parameters);\n      }\n    }\n  }\n\n  // The changes to the `events` buffer must be copied back into the eventsArray\n  splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0));\n  return !more;\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {SpliceBuffer<Event>} events\n *   Events.\n * @param {number} eventIndex\n *   Index.\n * @returns {Record<string, number>}\n *   Gaps.\n */\nfunction subcontent(events, eventIndex) {\n  const token = events.get(eventIndex)[1];\n  const context = events.get(eventIndex)[2];\n  let startPosition = eventIndex - 1;\n  /** @type {Array<number>} */\n  const startPositions = [];\n  let tokenizer = token._tokenizer;\n  if (!tokenizer) {\n    tokenizer = context.parser[token.contentType](token.start);\n    if (token._contentTypeTextTrailing) {\n      tokenizer._contentTypeTextTrailing = true;\n    }\n  }\n  const childEvents = tokenizer.events;\n  /** @type {Array<[number, number]>} */\n  const jumps = [];\n  /** @type {Record<string, number>} */\n  const gaps = {};\n  /** @type {Array<Chunk>} */\n  let stream;\n  /** @type {Token | undefined} */\n  let previous;\n  let index = -1;\n  /** @type {Token | undefined} */\n  let current = token;\n  let adjust = 0;\n  let start = 0;\n  const breaks = [start];\n\n  // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n  while (current) {\n    // Find the position of the event for this token.\n    while (events.get(++startPosition)[1] !== current) {\n      // Empty.\n    }\n    startPositions.push(startPosition);\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current);\n      if (!current.next) {\n        stream.push(null);\n      }\n      if (previous) {\n        tokenizer.defineSkip(current.start);\n      }\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n      tokenizer.write(stream);\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    }\n\n    // Unravel the next token.\n    previous = current;\n    current = current.next;\n  }\n\n  // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n  current = token;\n  while (++index < childEvents.length) {\n    if (\n    // Find a void token that includes a break.\n    childEvents[index][0] === 'exit' && childEvents[index - 1][0] === 'enter' && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      start = index + 1;\n      breaks.push(start);\n      // Help GC.\n      current._tokenizer = undefined;\n      current.previous = undefined;\n      current = current.next;\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = [];\n\n  // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined;\n    current.previous = undefined;\n  } else {\n    breaks.pop();\n  }\n\n  // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n  index = breaks.length;\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1]);\n    const start = startPositions.pop();\n    jumps.push([start, start + slice.length - 1]);\n    events.splice(start, 2, slice);\n  }\n  jumps.reverse();\n  index = -1;\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];\n    adjust += jumps[index][1] - jumps[index][0] - 1;\n  }\n  return gaps;\n}"],"x_google_ignoreList":[0],"mappings":";;;AAmBA,SAAgB,EAAY,GAAa;CAEvC,IAAM,IAAQ,EAAE,EACZ,IAAQ,IAER,GAEA,GAEA,GAEA,GAEA,GAEA,GAEA,GACE,IAAS,IAAI,EAAa,EAAY;AAC5C,QAAO,EAAE,IAAQ,EAAO,SAAQ;AAC9B,SAAO,KAAS,GACd,KAAQ,EAAM;AAMhB,MAJA,IAAQ,EAAO,IAAI,EAAM,EAIrB,KAAS,EAAM,GAAG,SAAS,eAAe,EAAO,IAAI,IAAQ,EAAE,CAAC,GAAG,SAAS,qBAC9E,IAAY,EAAM,GAAG,WAAW,QAChC,IAAa,GACT,IAAa,EAAU,UAAU,EAAU,GAAY,GAAG,SAAS,sBACrE,KAAc,IAEZ,IAAa,EAAU,UAAU,EAAU,GAAY,GAAG,SAAS,WACrE,QAAO,EAAE,IAAa,EAAU,UAC1B,EAAU,GAAY,GAAG,SAAS,WAGtC,CAAI,EAAU,GAAY,GAAG,SAAS,gBACpC,EAAU,GAAY,GAAG,8BAA8B,IACvD;AAOR,MAAI,EAAM,OAAO,SACX,EAAM,GAAG,gBACX,OAAO,OAAO,GAAO,EAAW,GAAQ,EAAM,CAAC,EAC/C,IAAQ,EAAM,IACd,IAAO;WAIF,EAAM,GAAG,YAAY;AAG5B,QAFA,IAAa,GACb,IAAY,KAAA,GACL,KAEL,KADA,IAAa,EAAO,IAAI,EAAW,EAC/B,EAAW,GAAG,SAAS,gBAAgB,EAAW,GAAG,SAAS,mBAC5D,EAAW,OAAO,YAChB,MACF,EAAO,IAAI,EAAU,CAAC,GAAG,OAAO,oBAElC,EAAW,GAAG,OAAO,cACrB,IAAY;YAEL,IAAW,GAAG,SAAS,gBAAgB,EAAW,GAAG,SAAS,kBAGvE;AAGJ,GAAI,MAEF,EAAM,GAAG,MAAM,EACb,GAAG,EAAO,IAAI,EAAU,CAAC,GAAG,OAC7B,EAGD,IAAa,EAAO,MAAM,GAAW,EAAM,EAC3C,EAAW,QAAQ,EAAM,EACzB,EAAO,OAAO,GAAW,IAAQ,IAAY,GAAG,EAAW;;;AAOjE,QADA,EAAO,GAAa,GAAG,UAA0B,EAAO,MAAM,EAAE,CAAC,EAC1D,CAAC;;AAaV,SAAS,EAAW,GAAQ,GAAY;CACtC,IAAM,IAAQ,EAAO,IAAI,EAAW,CAAC,IAC/B,IAAU,EAAO,IAAI,EAAW,CAAC,IACnC,IAAgB,IAAa,GAE3B,IAAiB,EAAE,EACrB,IAAY,EAAM;AACtB,CAAK,MACH,IAAY,EAAQ,OAAO,EAAM,aAAa,EAAM,MAAM,EACtD,EAAM,6BACR,EAAU,2BAA2B;CAGzC,IAAM,IAAc,EAAU,QAExB,IAAQ,EAAE,EAEV,IAAO,EAAE,EAEX,GAEA,GACA,IAAQ,IAER,IAAU,GACV,IAAS,GACT,IAAQ,GACN,IAAS,CAAC,EAAM;AAItB,QAAO,IAAS;AAEd,SAAO,EAAO,IAAI,EAAE,EAAc,CAAC,OAAO;AAuB1C,EApBA,EAAe,KAAK,EAAc,EAC7B,EAAQ,eACX,IAAS,EAAQ,YAAY,EAAQ,EAChC,EAAQ,QACX,EAAO,KAAK,KAAK,EAEf,KACF,EAAU,WAAW,EAAQ,MAAM,EAEjC,EAAQ,gCACV,EAAU,qCAAqC,KAEjD,EAAU,MAAM,EAAO,EACnB,EAAQ,gCACV,EAAU,qCAAqC,KAAA,KAKnD,IAAW,GACX,IAAU,EAAQ;;AAMpB,MADA,IAAU,GACH,EAAE,IAAQ,EAAY,QAC3B,CAEA,EAAY,GAAO,OAAO,UAAU,EAAY,IAAQ,GAAG,OAAO,WAAW,EAAY,GAAO,GAAG,SAAS,EAAY,IAAQ,GAAG,GAAG,QAAQ,EAAY,GAAO,GAAG,MAAM,SAAS,EAAY,GAAO,GAAG,IAAI,SAC3M,IAAQ,IAAQ,GAChB,EAAO,KAAK,EAAM,EAElB,EAAQ,aAAa,KAAA,GACrB,EAAQ,WAAW,KAAA,GACnB,IAAU,EAAQ;AAqBtB,MAhBA,EAAU,SAAS,EAAE,EAKjB,KAEF,EAAQ,aAAa,KAAA,GACrB,EAAQ,WAAW,KAAA,KAEnB,EAAO,KAAK,EAKd,IAAQ,EAAO,QACR,MAAS;EACd,IAAM,IAAQ,EAAY,MAAM,EAAO,IAAQ,EAAO,IAAQ,GAAG,EAC3D,IAAQ,EAAe,KAAK;AAElC,EADA,EAAM,KAAK,CAAC,GAAO,IAAQ,EAAM,SAAS,EAAE,CAAC,EAC7C,EAAO,OAAO,GAAO,GAAG,EAAM;;AAIhC,MAFA,EAAM,SAAS,EACf,IAAQ,IACD,EAAE,IAAQ,EAAM,QAErB,CADA,EAAK,IAAS,EAAM,GAAO,MAAM,IAAS,EAAM,GAAO,IACvD,KAAU,EAAM,GAAO,KAAK,EAAM,GAAO,KAAK;AAEhD,QAAO"}

package/dist/node_modules/micromark-util-subtokenize/lib/splice-buffer.js

@@ -0,0 +1,59 @@
+//#region node_modules/micromark-util-subtokenize/lib/splice-buffer.js
+var e = class {
+	constructor(e) {
+		this.left = e ? [...e] : [], this.right = [];
+	}
+	get(e) {
+		if (e < 0 || e >= this.left.length + this.right.length) throw RangeError("Cannot access index `" + e + "` in a splice buffer of size `" + (this.left.length + this.right.length) + "`");
+		return e < this.left.length ? this.left[e] : this.right[this.right.length - e + this.left.length - 1];
+	}
+	get length() {
+		return this.left.length + this.right.length;
+	}
+	shift() {
+		return this.setCursor(0), this.right.pop();
+	}
+	slice(e, t) {
+		let n = t ?? Infinity;
+		return n < this.left.length ? this.left.slice(e, n) : e > this.left.length ? this.right.slice(this.right.length - n + this.left.length, this.right.length - e + this.left.length).reverse() : this.left.slice(e).concat(this.right.slice(this.right.length - n + this.left.length).reverse());
+	}
+	splice(e, n, r) {
+		let i = n || 0;
+		this.setCursor(Math.trunc(e));
+		let a = this.right.splice(this.right.length - i, Infinity);
+		return r && t(this.left, r), a.reverse();
+	}
+	pop() {
+		return this.setCursor(Infinity), this.left.pop();
+	}
+	push(e) {
+		this.setCursor(Infinity), this.left.push(e);
+	}
+	pushMany(e) {
+		this.setCursor(Infinity), t(this.left, e);
+	}
+	unshift(e) {
+		this.setCursor(0), this.right.push(e);
+	}
+	unshiftMany(e) {
+		this.setCursor(0), t(this.right, e.reverse());
+	}
+	setCursor(e) {
+		if (!(e === this.left.length || e > this.left.length && this.right.length === 0 || e < 0 && this.left.length === 0)) if (e < this.left.length) {
+			let n = this.left.splice(e, Infinity);
+			t(this.right, n.reverse());
+		} else {
+			let n = this.right.splice(this.left.length + this.right.length - e, Infinity);
+			t(this.left, n.reverse());
+		}
+	}
+};
+function t(e, t) {
+	let n = 0;
+	if (t.length < 1e4) e.push(...t);
+	else for (; n < t.length;) e.push(...t.slice(n, n + 1e4)), n += 1e4;
+}
+//#endregion
+export { e as SpliceBuffer };
+
+//# sourceMappingURL=splice-buffer.js.map

package/dist/node_modules/micromark-util-subtokenize/lib/splice-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splice-buffer.js","names":[],"sources":["../../../../node_modules/micromark-util-subtokenize/lib/splice-buffer.js"],"sourcesContent":["/**\n * Some of the internal operations of micromark do lots of editing\n * operations on very large arrays. This runs into problems with two\n * properties of most circa-2020 JavaScript interpreters:\n *\n *  - Array-length modifications at the high end of an array (push/pop) are\n *    expected to be common and are implemented in (amortized) time\n *    proportional to the number of elements added or removed, whereas\n *    other operations (shift/unshift and splice) are much less efficient.\n *  - Function arguments are passed on the stack, so adding tens of thousands\n *    of elements to an array with `arr.push(...newElements)` will frequently\n *    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)\n *\n * SpliceBuffers are an implementation of gap buffers, which are a\n * generalization of the \"queue made of two stacks\" idea. The splice buffer\n * maintains a cursor, and moving the cursor has cost proportional to the\n * distance the cursor moves, but inserting, deleting, or splicing in\n * new information at the cursor is as efficient as the push/pop operation.\n * This allows for an efficient sequence of splices (or pushes, pops, shifts,\n * or unshifts) as long such edits happen at the same part of the array or\n * generally sweep through the array from the beginning to the end.\n *\n * The interface for splice buffers also supports large numbers of inputs by\n * passing a single array argument rather passing multiple arguments on the\n * function call stack.\n *\n * @template T\n *   Item type.\n */\nexport class SpliceBuffer {\n  /**\n   * @param {ReadonlyArray<T> | null | undefined} [initial]\n   *   Initial items (optional).\n   * @returns\n   *   Splice buffer.\n   */\n  constructor(initial) {\n    /** @type {Array<T>} */\n    this.left = initial ? [...initial] : [];\n    /** @type {Array<T>} */\n    this.right = [];\n  }\n\n  /**\n   * Array access;\n   * does not move the cursor.\n   *\n   * @param {number} index\n   *   Index.\n   * @return {T}\n   *   Item.\n   */\n  get(index) {\n    if (index < 0 || index >= this.left.length + this.right.length) {\n      throw new RangeError('Cannot access index `' + index + '` in a splice buffer of size `' + (this.left.length + this.right.length) + '`');\n    }\n    if (index < this.left.length) return this.left[index];\n    return this.right[this.right.length - index + this.left.length - 1];\n  }\n\n  /**\n   * The length of the splice buffer, one greater than the largest index in the\n   * array.\n   */\n  get length() {\n    return this.left.length + this.right.length;\n  }\n\n  /**\n   * Remove and return `list[0]`;\n   * moves the cursor to `0`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  shift() {\n    this.setCursor(0);\n    return this.right.pop();\n  }\n\n  /**\n   * Slice the buffer to get an array;\n   * does not move the cursor.\n   *\n   * @param {number} start\n   *   Start.\n   * @param {number | null | undefined} [end]\n   *   End (optional).\n   * @returns {Array<T>}\n   *   Array of items.\n   */\n  slice(start, end) {\n    /** @type {number} */\n    const stop = end === null || end === undefined ? Number.POSITIVE_INFINITY : end;\n    if (stop < this.left.length) {\n      return this.left.slice(start, stop);\n    }\n    if (start > this.left.length) {\n      return this.right.slice(this.right.length - stop + this.left.length, this.right.length - start + this.left.length).reverse();\n    }\n    return this.left.slice(start).concat(this.right.slice(this.right.length - stop + this.left.length).reverse());\n  }\n\n  /**\n   * Mimics the behavior of Array.prototype.splice() except for the change of\n   * interface necessary to avoid segfaults when patching in very large arrays.\n   *\n   * This operation moves cursor is moved to `start` and results in the cursor\n   * placed after any inserted items.\n   *\n   * @param {number} start\n   *   Start;\n   *   zero-based index at which to start changing the array;\n   *   negative numbers count backwards from the end of the array and values\n   *   that are out-of bounds are clamped to the appropriate end of the array.\n   * @param {number | null | undefined} [deleteCount=0]\n   *   Delete count (default: `0`);\n   *   maximum number of elements to delete, starting from start.\n   * @param {Array<T> | null | undefined} [items=[]]\n   *   Items to include in place of the deleted items (default: `[]`).\n   * @return {Array<T>}\n   *   Any removed items.\n   */\n  splice(start, deleteCount, items) {\n    /** @type {number} */\n    const count = deleteCount || 0;\n    this.setCursor(Math.trunc(start));\n    const removed = this.right.splice(this.right.length - count, Number.POSITIVE_INFINITY);\n    if (items) chunkedPush(this.left, items);\n    return removed.reverse();\n  }\n\n  /**\n   * Remove and return the highest-numbered item in the array, so\n   * `list[list.length - 1]`;\n   * Moves the cursor to `length`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  pop() {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    return this.left.pop();\n  }\n\n  /**\n   * Inserts a single item to the high-numbered side of the array;\n   * moves the cursor to `length`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  push(item) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    this.left.push(item);\n  }\n\n  /**\n   * Inserts many items to the high-numbered side of the array.\n   * Moves the cursor to `length`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  pushMany(items) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    chunkedPush(this.left, items);\n  }\n\n  /**\n   * Inserts a single item to the low-numbered side of the array;\n   * Moves the cursor to `0`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshift(item) {\n    this.setCursor(0);\n    this.right.push(item);\n  }\n\n  /**\n   * Inserts many items to the low-numbered side of the array;\n   * moves the cursor to `0`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshiftMany(items) {\n    this.setCursor(0);\n    chunkedPush(this.right, items.reverse());\n  }\n\n  /**\n   * Move the cursor to a specific position in the array. Requires\n   * time proportional to the distance moved.\n   *\n   * If `n < 0`, the cursor will end up at the beginning.\n   * If `n > length`, the cursor will end up at the end.\n   *\n   * @param {number} n\n   *   Position.\n   * @return {undefined}\n   *   Nothing.\n   */\n  setCursor(n) {\n    if (n === this.left.length || n > this.left.length && this.right.length === 0 || n < 0 && this.left.length === 0) return;\n    if (n < this.left.length) {\n      // Move cursor to the this.left\n      const removed = this.left.splice(n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.right, removed.reverse());\n    } else {\n      // Move cursor to the this.right\n      const removed = this.right.splice(this.left.length + this.right.length - n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.left, removed.reverse());\n    }\n  }\n}\n\n/**\n * Avoid stack overflow by pushing items onto the stack in segments\n *\n * @template T\n *   Item type.\n * @param {Array<T>} list\n *   List to inject into.\n * @param {ReadonlyArray<T>} right\n *   Items to inject.\n * @return {undefined}\n *   Nothing.\n */\nfunction chunkedPush(list, right) {\n  /** @type {number} */\n  let chunkStart = 0;\n  if (right.length < 10000) {\n    list.push(...right);\n  } else {\n    while (chunkStart < right.length) {\n      list.push(...right.slice(chunkStart, chunkStart + 10000));\n      chunkStart += 10000;\n    }\n  }\n}"],"x_google_ignoreList":[0],"mappings":";AA6BA,IAAa,IAAb,MAA0B;CAOxB,YAAY,GAAS;AAInB,EAFA,KAAK,OAAO,IAAU,CAAC,GAAG,EAAQ,GAAG,EAAE,EAEvC,KAAK,QAAQ,EAAE;;CAYjB,IAAI,GAAO;AACT,MAAI,IAAQ,KAAK,KAAS,KAAK,KAAK,SAAS,KAAK,MAAM,OACtD,OAAU,WAAW,0BAA0B,IAAQ,oCAAoC,KAAK,KAAK,SAAS,KAAK,MAAM,UAAU,IAAI;AAGzI,SADI,IAAQ,KAAK,KAAK,SAAe,KAAK,KAAK,KACxC,KAAK,MAAM,KAAK,MAAM,SAAS,IAAQ,KAAK,KAAK,SAAS;;CAOnE,IAAI,SAAS;AACX,SAAO,KAAK,KAAK,SAAS,KAAK,MAAM;;CAUvC,QAAQ;AAEN,SADA,KAAK,UAAU,EAAE,EACV,KAAK,MAAM,KAAK;;CAczB,MAAM,GAAO,GAAK;EAEhB,IAAM,IAAO,KAAoC;AAOjD,SANI,IAAO,KAAK,KAAK,SACZ,KAAK,KAAK,MAAM,GAAO,EAAK,GAEjC,IAAQ,KAAK,KAAK,SACb,KAAK,MAAM,MAAM,KAAK,MAAM,SAAS,IAAO,KAAK,KAAK,QAAQ,KAAK,MAAM,SAAS,IAAQ,KAAK,KAAK,OAAO,CAAC,SAAS,GAEvH,KAAK,KAAK,MAAM,EAAM,CAAC,OAAO,KAAK,MAAM,MAAM,KAAK,MAAM,SAAS,IAAO,KAAK,KAAK,OAAO,CAAC,SAAS,CAAC;;CAuB/G,OAAO,GAAO,GAAa,GAAO;EAEhC,IAAM,IAAQ,KAAe;AAC7B,OAAK,UAAU,KAAK,MAAM,EAAM,CAAC;EACjC,IAAM,IAAU,KAAK,MAAM,OAAO,KAAK,MAAM,SAAS,GAAO,SAAyB;AAEtF,SADI,KAAO,EAAY,KAAK,MAAM,EAAM,EACjC,EAAQ,SAAS;;CAW1B,MAAM;AAEJ,SADA,KAAK,UAAU,SAAyB,EACjC,KAAK,KAAK,KAAK;;CAYxB,KAAK,GAAM;AAET,EADA,KAAK,UAAU,SAAyB,EACxC,KAAK,KAAK,KAAK,EAAK;;CAYtB,SAAS,GAAO;AAEd,EADA,KAAK,UAAU,SAAyB,EACxC,EAAY,KAAK,MAAM,EAAM;;CAY/B,QAAQ,GAAM;AAEZ,EADA,KAAK,UAAU,EAAE,EACjB,KAAK,MAAM,KAAK,EAAK;;CAYvB,YAAY,GAAO;AAEjB,EADA,KAAK,UAAU,EAAE,EACjB,EAAY,KAAK,OAAO,EAAM,SAAS,CAAC;;CAe1C,UAAU,GAAG;AACP,cAAM,KAAK,KAAK,UAAU,IAAI,KAAK,KAAK,UAAU,KAAK,MAAM,WAAW,KAAK,IAAI,KAAK,KAAK,KAAK,WAAW,GAC/G,KAAI,IAAI,KAAK,KAAK,QAAQ;GAExB,IAAM,IAAU,KAAK,KAAK,OAAO,GAAG,SAAyB;AAC7D,KAAY,KAAK,OAAO,EAAQ,SAAS,CAAC;SACrC;GAEL,IAAM,IAAU,KAAK,MAAM,OAAO,KAAK,KAAK,SAAS,KAAK,MAAM,SAAS,GAAG,SAAyB;AACrG,KAAY,KAAK,MAAM,EAAQ,SAAS,CAAC;;;;AAiB/C,SAAS,EAAY,GAAM,GAAO;CAEhC,IAAI,IAAa;AACjB,KAAI,EAAM,SAAS,IACjB,GAAK,KAAK,GAAG,EAAM;KAEnB,QAAO,IAAa,EAAM,QAExB,CADA,EAAK,KAAK,GAAG,EAAM,MAAM,GAAY,IAAa,IAAM,CAAC,EACzD,KAAc"}

package/dist/node_modules/property-information/index.js

@@ -0,0 +1,28 @@
+import { merge as e } from "./lib/util/merge.js";
+import "./lib/normalize.js";
+import { aria as t } from "./lib/aria.js";
+import { html as n } from "./lib/html.js";
+import { svg as r } from "./lib/svg.js";
+import { xlink as i } from "./lib/xlink.js";
+import { xmlns as a } from "./lib/xmlns.js";
+import { xml as o } from "./lib/xml.js";
+import "./lib/hast-to-react.js";
+import "./lib/find.js";
+//#region node_modules/property-information/index.js
+var s = e([
+	t,
+	n,
+	i,
+	a,
+	o
+], "html"), c = e([
+	t,
+	r,
+	i,
+	a,
+	o
+], "svg");
+//#endregion
+export { s as html, c as svg };
+
+//# sourceMappingURL=index.js.map

package/dist/node_modules/property-information/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["htmlBase","svgBase"],"sources":["../../../node_modules/property-information/index.js"],"sourcesContent":["// Note: types exposed from `index.d.ts`.\nimport {merge} from './lib/util/merge.js'\nimport {aria} from './lib/aria.js'\nimport {html as htmlBase} from './lib/html.js'\nimport {svg as svgBase} from './lib/svg.js'\nimport {xlink} from './lib/xlink.js'\nimport {xmlns} from './lib/xmlns.js'\nimport {xml} from './lib/xml.js'\n\nexport {hastToReact} from './lib/hast-to-react.js'\n\nexport const html = merge([aria, htmlBase, xlink, xmlns, xml], 'html')\n\nexport {find} from './lib/find.js'\nexport {normalize} from './lib/normalize.js'\n\nexport const svg = merge([aria, svgBase, xlink, xmlns, xml], 'svg')\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;AAWA,IAAa,IAAO,EAAM;CAAC;CAAMA;CAAU;CAAO;CAAO;CAAI,EAAE,OAAO,EAKzD,IAAM,EAAM;CAAC;CAAMC;CAAS;CAAO;CAAO;CAAI,EAAE,MAAM"}

package/dist/node_modules/property-information/lib/aria.js

@@ -0,0 +1,63 @@
+import { booleanish as e, number as t, spaceSeparated as n } from "./util/types.js";
+import { create as r } from "./util/create.js";
+//#region node_modules/property-information/lib/aria.js
+var i = r({
+	properties: {
+		ariaActiveDescendant: null,
+		ariaAtomic: e,
+		ariaAutoComplete: null,
+		ariaBusy: e,
+		ariaChecked: e,
+		ariaColCount: t,
+		ariaColIndex: t,
+		ariaColSpan: t,
+		ariaControls: n,
+		ariaCurrent: null,
+		ariaDescribedBy: n,
+		ariaDetails: null,
+		ariaDisabled: e,
+		ariaDropEffect: n,
+		ariaErrorMessage: null,
+		ariaExpanded: e,
+		ariaFlowTo: n,
+		ariaGrabbed: e,
+		ariaHasPopup: null,
+		ariaHidden: e,
+		ariaInvalid: null,
+		ariaKeyShortcuts: null,
+		ariaLabel: null,
+		ariaLabelledBy: n,
+		ariaLevel: t,
+		ariaLive: null,
+		ariaModal: e,
+		ariaMultiLine: e,
+		ariaMultiSelectable: e,
+		ariaOrientation: null,
+		ariaOwns: n,
+		ariaPlaceholder: null,
+		ariaPosInSet: t,
+		ariaPressed: e,
+		ariaReadOnly: e,
+		ariaRelevant: null,
+		ariaRequired: e,
+		ariaRoleDescription: n,
+		ariaRowCount: t,
+		ariaRowIndex: t,
+		ariaRowSpan: t,
+		ariaSelected: e,
+		ariaSetSize: t,
+		ariaSort: null,
+		ariaValueMax: t,
+		ariaValueMin: t,
+		ariaValueNow: t,
+		ariaValueText: null,
+		role: null
+	},
+	transform(e, t) {
+		return t === "role" ? t : "aria-" + t.slice(4).toLowerCase();
+	}
+});
+//#endregion
+export { i as aria };
+
+//# sourceMappingURL=aria.js.map

package/dist/node_modules/property-information/lib/aria.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aria.js","names":[],"sources":["../../../../node_modules/property-information/lib/aria.js"],"sourcesContent":["import {create} from './util/create.js'\nimport {booleanish, number, spaceSeparated} from './util/types.js'\n\nexport const aria = create({\n  properties: {\n    ariaActiveDescendant: null,\n    ariaAtomic: booleanish,\n    ariaAutoComplete: null,\n    ariaBusy: booleanish,\n    ariaChecked: booleanish,\n    ariaColCount: number,\n    ariaColIndex: number,\n    ariaColSpan: number,\n    ariaControls: spaceSeparated,\n    ariaCurrent: null,\n    ariaDescribedBy: spaceSeparated,\n    ariaDetails: null,\n    ariaDisabled: booleanish,\n    ariaDropEffect: spaceSeparated,\n    ariaErrorMessage: null,\n    ariaExpanded: booleanish,\n    ariaFlowTo: spaceSeparated,\n    ariaGrabbed: booleanish,\n    ariaHasPopup: null,\n    ariaHidden: booleanish,\n    ariaInvalid: null,\n    ariaKeyShortcuts: null,\n    ariaLabel: null,\n    ariaLabelledBy: spaceSeparated,\n    ariaLevel: number,\n    ariaLive: null,\n    ariaModal: booleanish,\n    ariaMultiLine: booleanish,\n    ariaMultiSelectable: booleanish,\n    ariaOrientation: null,\n    ariaOwns: spaceSeparated,\n    ariaPlaceholder: null,\n    ariaPosInSet: number,\n    ariaPressed: booleanish,\n    ariaReadOnly: booleanish,\n    ariaRelevant: null,\n    ariaRequired: booleanish,\n    ariaRoleDescription: spaceSeparated,\n    ariaRowCount: number,\n    ariaRowIndex: number,\n    ariaRowSpan: number,\n    ariaSelected: booleanish,\n    ariaSetSize: number,\n    ariaSort: null,\n    ariaValueMax: number,\n    ariaValueMin: number,\n    ariaValueNow: number,\n    ariaValueText: null,\n    role: null\n  },\n  transform(_, property) {\n    return property === 'role'\n      ? property\n      : 'aria-' + property.slice(4).toLowerCase()\n  }\n})\n"],"x_google_ignoreList":[0],"mappings":";;;AAGA,IAAa,IAAO,EAAO;CACzB,YAAY;EACV,sBAAsB;EACtB,YAAY;EACZ,kBAAkB;EAClB,UAAU;EACV,aAAa;EACb,cAAc;EACd,cAAc;EACd,aAAa;EACb,cAAc;EACd,aAAa;EACb,iBAAiB;EACjB,aAAa;EACb,cAAc;EACd,gBAAgB;EAChB,kBAAkB;EAClB,cAAc;EACd,YAAY;EACZ,aAAa;EACb,cAAc;EACd,YAAY;EACZ,aAAa;EACb,kBAAkB;EAClB,WAAW;EACX,gBAAgB;EAChB,WAAW;EACX,UAAU;EACV,WAAW;EACX,eAAe;EACf,qBAAqB;EACrB,iBAAiB;EACjB,UAAU;EACV,iBAAiB;EACjB,cAAc;EACd,aAAa;EACb,cAAc;EACd,cAAc;EACd,cAAc;EACd,qBAAqB;EACrB,cAAc;EACd,cAAc;EACd,aAAa;EACb,cAAc;EACd,aAAa;EACb,UAAU;EACV,cAAc;EACd,cAAc;EACd,cAAc;EACd,eAAe;EACf,MAAM;EACP;CACD,UAAU,GAAG,GAAU;AACrB,SAAO,MAAa,SAChB,IACA,UAAU,EAAS,MAAM,EAAE,CAAC,aAAa;;CAEhD,CAAC"}

package/dist/node_modules/property-information/lib/find.js

@@ -0,0 +1,33 @@
+import { normalize as e } from "./normalize.js";
+import { Info as t } from "./util/info.js";
+import { DefinedInfo as n } from "./util/defined-info.js";
+//#region node_modules/property-information/lib/find.js
+var r = /[A-Z]/g, i = /-[a-z]/g, a = /^data[-\w.:]+$/i;
+function o(o, l) {
+	let u = e(l), d = l, f = t;
+	if (u in o.normal) return o.property[o.normal[u]];
+	if (u.length > 4 && u.slice(0, 4) === "data" && a.test(l)) {
+		if (l.charAt(4) === "-") {
+			let e = l.slice(5).replace(i, c);
+			d = "data" + e.charAt(0).toUpperCase() + e.slice(1);
+		} else {
+			let e = l.slice(4);
+			if (!i.test(e)) {
+				let t = e.replace(r, s);
+				t.charAt(0) !== "-" && (t = "-" + t), l = "data" + t;
+			}
+		}
+		f = n;
+	}
+	return new f(d, l);
+}
+function s(e) {
+	return "-" + e.toLowerCase();
+}
+function c(e) {
+	return e.charAt(1).toUpperCase();
+}
+//#endregion
+export { o as find };
+
+//# sourceMappingURL=find.js.map