@easyv/biz-components 1.0.29 → 2.1.0

package/dist/lib/node_modules/.pnpm/micromark-factory-title@2.0.1/node_modules/micromark-factory-title/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-factory-title@2.0.1/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}"],"names":[],"mappings":";;AA0CO,SAAS,aAAa,SAAS,IAAI,KAAK,MAAM,YAAY,YAAY;AAE3E,MAAI;AACJ,SAAO;AAYP,WAAS,MAAM,MAAM;AACnB,QAAI,SAAS,MAAM,SAAS,MAAM,SAAS,IAAI;AAC7C,cAAQ,MAAM,IAAI;AAClB,cAAQ,MAAM,UAAU;AACxB,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,UAAU;AACvB,eAAS,SAAS,KAAK,KAAK;AAC5B,aAAO;AAAA,IACb;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AAcE,WAAS,MAAM,MAAM;AACnB,QAAI,SAAS,QAAQ;AACnB,cAAQ,MAAM,UAAU;AACxB,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,UAAU;AACvB,cAAQ,KAAK,IAAI;AACjB,aAAO;AAAA,IACb;AACI,YAAQ,MAAM,UAAU;AACxB,WAAO,QAAQ,IAAI;AAAA,EACvB;AAYE,WAAS,QAAQ,MAAM;AACrB,QAAI,SAAS,QAAQ;AACnB,cAAQ,KAAK,UAAU;AACvB,aAAO,MAAM,MAAM;AAAA,IACzB;AACI,QAAI,SAAS,MAAM;AACjB,aAAO,IAAI,IAAI;AAAA,IACrB;AAGI,QAAI,mBAAmB,IAAI,GAAG;AAE5B,cAAQ,MAAM,YAAY;AAC1B,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,YAAY;AACzB,aAAO,aAAa,SAAS,SAAS,YAAY;AAAA,IACxD;AACI,YAAQ,MAAM,eAAe;AAAA,MAC3B,aAAa;AAAA,IACnB,CAAK;AACD,WAAO,OAAO,IAAI;AAAA,EACtB;AAOE,WAAS,OAAO,MAAM;AACpB,QAAI,SAAS,UAAU,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAChE,cAAQ,KAAK,aAAa;AAC1B,aAAO,QAAQ,IAAI;AAAA,IACzB;AACI,YAAQ,QAAQ,IAAI;AACpB,WAAO,SAAS,KAAK,SAAS;AAAA,EAClC;AAYE,WAAS,OAAO,MAAM;AACpB,QAAI,SAAS,UAAU,SAAS,IAAI;AAClC,cAAQ,QAAQ,IAAI;AACpB,aAAO;AAAA,IACb;AACI,WAAO,OAAO,IAAI;AAAA,EACtB;AACA;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-factory-whitespace@2.0.1/node_modules/micromark-factory-whitespace/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-factory-whitespace@2.0.1/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}"],"names":[],"mappings":";;AAwBO,SAAS,kBAAkB,SAAS,IAAI;AAE7C,MAAI;AACJ,SAAO;AAGP,WAAS,MAAM,MAAM;AACnB,QAAI,mBAAmB,IAAI,GAAG;AAC5B,cAAQ,MAAM,YAAY;AAC1B,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,YAAY;AACzB,aAAO;AACP,aAAO;AAAA,IACb;AACI,QAAI,cAAc,IAAI,GAAG;AACvB,aAAO,aAAa,SAAS,OAAO,OAAO,eAAe,YAAY,EAAE,IAAI;AAAA,IAClF;AACI,WAAO,GAAG,IAAI;AAAA,EAClB;AACA;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-character@2.1.1/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":[],"mappings":"AAqBY,MAAC,aAAa,WAAW,UAAU;AAcnC,MAAC,oBAAoB,WAAW,YAAY;AAuB5C,MAAC,aAAa,WAAW,qBAAqB;AAanD,SAAS,aAAa,MAAM;AACjC;AAAA;AAAA;AAAA,IAGE,SAAS,SAAS,OAAO,MAAM,SAAS;AAAA;AAE5C;AAaY,MAAC,aAAa,WAAW,IAAI;AAoB7B,MAAC,gBAAgB,WAAW,YAAY;AAexC,MAAC,mBAAmB,WAAW,gBAAgB;AAiBpD,SAAS,mBAAmB,MAAM;AACvC,SAAO,SAAS,QAAQ,OAAO;AACjC;AAWO,SAAS,0BAA0B,MAAM;AAC9C,SAAO,SAAS,SAAS,OAAO,KAAK,SAAS;AAChD;AAiBO,SAAS,cAAc,MAAM;AAClC,SAAO,SAAS,MAAM,SAAS,MAAM,SAAS;AAChD;AAuBY,MAAC,qBAAqB,WAAW,WAAc,iBAAA,GAAA;AAsB/C,MAAC,oBAAoB,WAAW,IAAI;AAUhD,SAAS,WAAW,OAAO;AACzB,SAAO;AAUP,WAAS,MAAM,MAAM;AACnB,WAAO,SAAS,QAAQ,OAAO,MAAM,MAAM,KAAK,OAAO,aAAa,IAAI,CAAC;AAAA,EAC7E;AACA;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-chunked@2.0.1/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":[],"mappings":"AAsBO,SAAS,OAAO,MAAM,OAAO,QAAQ,OAAO;AACjD,QAAM,MAAM,KAAK;AACjB,MAAI,aAAa;AAEjB,MAAI;AAGJ,MAAI,QAAQ,GAAG;AACb,YAAQ,CAAC,QAAQ,MAAM,IAAI,MAAM;AAAA,EACrC,OAAS;AACL,YAAQ,QAAQ,MAAM,MAAM;AAAA,EAChC;AACE,WAAS,SAAS,IAAI,SAAS;AAG/B,MAAI,MAAM,SAAS,KAAO;AACxB,iBAAa,MAAM,KAAK,KAAK;AAC7B,eAAW,QAAQ,OAAO,MAAM;AAEhC,SAAK,OAAO,GAAG,UAAU;AAAA,EAC7B,OAAS;AAEL,QAAI,OAAQ,MAAK,OAAO,OAAO,MAAM;AAGrC,WAAO,aAAa,MAAM,QAAQ;AAChC,mBAAa,MAAM,MAAM,YAAY,aAAa,GAAK;AACvD,iBAAW,QAAQ,OAAO,CAAC;AAE3B,WAAK,OAAO,GAAG,UAAU;AACzB,oBAAc;AACd,eAAS;AAAA,IACf;AAAA,EACA;AACA;AAkBO,SAAS,KAAK,MAAM,OAAO;AAChC,MAAI,KAAK,SAAS,GAAG;AACnB,WAAO,MAAM,KAAK,QAAQ,GAAG,KAAK;AAClC,WAAO;AAAA,EACX;AACE,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-classify-character@2.0.1/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":[],"mappings":";AAmBO,SAAS,kBAAkB,MAAM;AACtC,MAAI,SAAS,QAAQ,0BAA0B,IAAI,KAAK,kBAAkB,IAAI,GAAG;AAC/E,WAAO;AAAA,EACX;AACE,MAAI,mBAAmB,IAAI,GAAG;AAC5B,WAAO;AAAA,EACX;AACA;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-combine-extensions@2.0.1/node_modules/micromark-util-combine-extensions/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-combine-extensions@2.0.1/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":[],"mappings":";AAWA,MAAM,iBAAiB,CAAA,EAAG;AAUnB,SAAS,kBAAkB,YAAY;AAE5C,QAAM,MAAM,CAAA;AACZ,MAAI,QAAQ;AAEZ,SAAO,EAAE,QAAQ,WAAW,QAAQ;AAClC,oBAAgB,KAAK,WAAW,KAAK,CAAC;AAAA,EAC1C;AAEE,SAAO;AACT;AAYA,SAAS,gBAAgB,KAAK,WAAW;AAEvC,MAAI;AAEJ,OAAK,QAAQ,WAAW;AACtB,UAAM,QAAQ,eAAe,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI;AAE3D,UAAM,OAAO,UAAU,IAAI,IAAI,IAAI,CAAE;AAErC,UAAM,QAAQ,UAAU,IAAI;AAE5B,QAAI;AAEJ,QAAI,OAAO;AACT,WAAK,QAAQ,OAAO;AAClB,YAAI,CAAC,eAAe,KAAK,MAAM,IAAI,EAAG,MAAK,IAAI,IAAI,CAAA;AACnD,cAAM,QAAQ,MAAM,IAAI;AACxB;AAAA;AAAA,UAEE,KAAK,IAAI;AAAA,UACT,MAAM,QAAQ,KAAK,IAAI,QAAQ,QAAQ,CAAC,KAAK,IAAI,CAAA;AAAA,QAC3D;AAAA,MACA;AAAA,IACA;AAAA,EACA;AACA;AAaA,SAAS,WAAW,UAAU,MAAM;AAClC,MAAI,QAAQ;AAEZ,QAAM,SAAS,CAAA;AAEf,SAAO,EAAE,QAAQ,KAAK,QAAQ;AAE3B,KAAC,KAAK,KAAK,EAAE,QAAQ,UAAU,WAAW,QAAQ,KAAK,KAAK,KAAK,CAAC;AAAA,EACvE;AAEE,SAAO,UAAU,GAAG,GAAG,MAAM;AAC/B;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-decode-numeric-character-reference@2.0.2/node_modules/micromark-util-decode-numeric-character-reference/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-decode-numeric-character-reference@2.0.2/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}"],"names":[],"mappings":"AAcO,SAAS,gCAAgC,OAAO,MAAM;AAC3D,QAAM,OAAO,OAAO,SAAS,OAAO,IAAI;AACxC;AAAA;AAAA,IAEA,OAAO,KAAK,SAAS,MAAM,OAAO,MAAM,OAAO;AAAA,IAE/C,OAAO,OAAO,OAAO;AAAA,IAErB,OAAO,SAAU,OAAO;AAAA,IAExB,OAAO,SAAU,OAAO;AAAA,KACvB,OAAO,WAAY,UAAW,OAAO,WAAY;AAAA;AAAA,IAElD,OAAO;AAAA,IAAW;AAChB,WAAO;AAAA,EACX;AACE,SAAO,OAAO,cAAc,IAAI;AAClC;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-decode-string@2.0.1/node_modules/micromark-util-decode-string/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-decode-string@2.0.1/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}"],"names":["head"],"mappings":";;AAEA,MAAM,6BAA6B;AAc5B,SAAS,aAAa,OAAO;AAClC,SAAO,MAAM,QAAQ,4BAA4B,MAAM;AACzD;AAYA,SAAS,OAAO,IAAI,IAAI,IAAI;AAC1B,MAAI,IAAI;AAEN,WAAO;AAAA,EACX;AAGE,QAAM,OAAO,GAAG,WAAW,CAAC;AAC5B,MAAI,SAAS,IAAI;AACf,UAAMA,QAAO,GAAG,WAAW,CAAC;AAC5B,UAAM,MAAMA,UAAS,OAAOA,UAAS;AACrC,WAAO,gCAAgC,GAAG,MAAM,MAAM,IAAI,CAAC,GAAG,MAAM,KAAK,EAAE;AAAA,EAC/E;AACE,SAAO,8BAA8B,EAAE,KAAK;AAC9C;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-html-tag-name@2.0.1/node_modules/micromark-util-html-tag-name/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-html-tag-name@2.0.1/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"],"names":[],"mappings":"AAeY,MAAC,iBAAiB;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAcY,MAAC,eAAe,CAAC,OAAO,UAAU,SAAS,UAAU;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-normalize-identifier@2.0.1/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":[],"mappings":"AAmBO,SAAS,oBAAoB,OAAO;AACzC,SAAO,MAEN,QAAQ,eAAe,GAAG,EAE1B,QAAQ,UAAU,EAAE,EAOpB,YAAW,EAAG,YAAa;AAC9B;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-resolve-all@2.0.1/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"],"names":[],"mappings":"AAgBO,SAAS,WAAW,YAAY,QAAQ,SAAS;AAEtD,QAAM,SAAS,CAAA;AACf,MAAI,QAAQ;AAEZ,SAAO,EAAE,QAAQ,WAAW,QAAQ;AAClC,UAAM,UAAU,WAAW,KAAK,EAAE;AAElC,QAAI,WAAW,CAAC,OAAO,SAAS,OAAO,GAAG;AACxC,eAAS,QAAQ,QAAQ,OAAO;AAChC,aAAO,KAAK,OAAO;AAAA,IACzB;AAAA,EACA;AAEE,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-sanitize-uri@2.0.1/node_modules/micromark-util-sanitize-uri/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-sanitize-uri@2.0.1/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}"],"names":[],"mappings":";AAwDO,SAAS,aAAa,OAAO;AAElC,QAAM,SAAS,CAAE;AACjB,MAAI,QAAQ;AACZ,MAAI,QAAQ;AACZ,MAAI,OAAO;AACX,SAAO,EAAE,QAAQ,MAAM,QAAQ;AAC7B,UAAM,OAAO,MAAM,WAAW,KAAK;AAEnC,QAAI,UAAU;AAGd,QAAI,SAAS,MAAM,kBAAkB,MAAM,WAAW,QAAQ,CAAC,CAAC,KAAK,kBAAkB,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG;AACnH,aAAO;AAAA,IACb,WAEa,OAAO,KAAK;AACnB,UAAI,CAAC,oBAAoB,KAAK,OAAO,aAAa,IAAI,CAAC,GAAG;AACxD,kBAAU,OAAO,aAAa,IAAI;AAAA,MAC1C;AAAA,IACA,WAEa,OAAO,SAAU,OAAO,OAAQ;AACvC,YAAM,OAAO,MAAM,WAAW,QAAQ,CAAC;AAGvC,UAAI,OAAO,SAAU,OAAO,SAAU,OAAO,OAAQ;AACnD,kBAAU,OAAO,aAAa,MAAM,IAAI;AACxC,eAAO;AAAA,MACf,OAEW;AACH,kBAAU;AAAA,MAClB;AAAA,IACA,OAES;AACH,gBAAU,OAAO,aAAa,IAAI;AAAA,IACxC;AACI,QAAI,SAAS;AACX,aAAO,KAAK,MAAM,MAAM,OAAO,KAAK,GAAG,mBAAmB,OAAO,CAAC;AAClE,cAAQ,QAAQ,OAAO;AACvB,gBAAU;AAAA,IAChB;AACI,QAAI,MAAM;AACR,eAAS;AACT,aAAO;AAAA,IACb;AAAA,EACA;AACE,SAAO,OAAO,KAAK,EAAE,IAAI,MAAM,MAAM,KAAK;AAC5C;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-subtokenize@2.1.0/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}"],"names":["start"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/lib/splice-buffer.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splice-buffer.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark-util-subtokenize@2.1.0/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}"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/constructs.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructs.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/constructs.js"],"sourcesContent":["/**\n * @import {Extension} from 'micromark-util-types'\n */\n\nimport { attention, autolink, blockQuote, characterEscape, characterReference, codeFenced, codeIndented, codeText, definition, hardBreakEscape, headingAtx, htmlFlow, htmlText, labelEnd, labelStartImage, labelStartLink, lineEnding, list, setextUnderline, thematicBreak } from 'micromark-core-commonmark';\nimport { resolver as resolveText } from './initialize/text.js';\n\n/** @satisfies {Extension['document']} */\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n};\n\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n  [91]: definition\n};\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n};\n\n/** @satisfies {Extension['flow']} */\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n};\n\n/** @satisfies {Extension['string']} */\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n};\n\n/** @satisfies {Extension['text']} */\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n};\n\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n  null: [attention, resolveText]\n};\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n  null: [42, 95]\n};\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n  null: []\n};"],"names":["resolveText"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAQY,MAAC,WAAW;AAAA,EACtB,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AACR;AAGY,MAAC,iBAAiB;AAAA,EAC5B,CAAC,EAAE,GAAG;AACR;AAGY,MAAC,cAAc;AAAA,EACzB,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AACR;AAGY,MAAC,OAAO;AAAA,EAClB,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG,CAAC,iBAAiB,aAAa;AAAA,EACrC,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,GAAG,GAAG;AACT;AAGY,MAAC,SAAS;AAAA,EACpB,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AACR;AAGY,MAAC,OAAO;AAAA,EAClB,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG,CAAC,UAAU,QAAQ;AAAA,EACzB,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG,CAAC,iBAAiB,eAAe;AAAA,EACvC,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AAAA,EACN,CAAC,EAAE,GAAG;AACR;AAGY,MAAC,aAAa;AAAA,EACxB,MAAM,CAAC,WAAWA,QAAW;AAC/B;AAGY,MAAC,mBAAmB;AAAA,EAC9B,MAAM,CAAC,IAAI,EAAE;AACf;AAGY,MAAC,UAAU;AAAA,EACrB,MAAM,CAAA;AACR;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/create-tokenizer.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-tokenizer.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/create-tokenizer.js"],"sourcesContent":["/**\n * @import {\n *   Chunk,\n *   Code,\n *   ConstructRecord,\n *   Construct,\n *   Effects,\n *   InitialConstruct,\n *   ParseContext,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @callback Restore\n *   Restore the state.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef Info\n *   Info.\n * @property {Restore} restore\n *   Restore.\n * @property {number} from\n *   From.\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n *   Construct.\n * @param {Info} info\n *   Info.\n * @returns {undefined}\n *   Nothing.\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n *   Parser.\n * @param {InitialConstruct} initialize\n *   Construct.\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n *   Point (optional).\n * @returns {TokenizeContext}\n *   Context.\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = {\n    _bufferIndex: -1,\n    _index: 0,\n    line: from && from.line || 1,\n    column: from && from.column || 1,\n    offset: from && from.offset || 0\n  };\n  /** @type {Record<string, number>} */\n  const columnStart = {};\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = [];\n  /** @type {Array<Chunk>} */\n  let chunks = [];\n  /** @type {Array<Token>} */\n  let stack = [];\n  /** @type {boolean | undefined} */\n  let consumed = true;\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    consume,\n    enter,\n    exit,\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  };\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    code: null,\n    containerState: {},\n    defineSkip,\n    events: [],\n    now,\n    parser,\n    previous: null,\n    sliceSerialize,\n    sliceStream,\n    write\n  };\n\n  /**\n   * The state function.\n   *\n   * @type {State | undefined}\n   */\n  let state = initialize.tokenize.call(context, effects);\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode;\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  }\n  return context;\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice);\n    main();\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n    addResult(initialize, 0);\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs);\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    } = point;\n    return {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    };\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  }\n\n  //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex;\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index];\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   *   Code.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function go(code) {\n    consumed = undefined;\n    expectedCode = code;\n    state = state(code);\n  }\n\n  /** @type {Effects['consume']} */\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++;\n\n      // At end of string chunk.\n      if (point._bufferIndex ===\n      // Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      /** @type {string} */\n      chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code;\n\n    // Mark as consumed.\n    consumed = true;\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore();\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   *   Callback.\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   *   Fields.\n   */\n  function constructFactory(onreturn, fields) {\n    return hook;\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | ConstructRecord | Construct} constructs\n     *   Constructs.\n     * @param {State} returnState\n     *   State.\n     * @param {State | undefined} [bogusState]\n     *   State.\n     * @returns {State}\n     *   State.\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {ReadonlyArray<Construct>} */\n      let listOfConstructs;\n      /** @type {number} */\n      let constructIndex;\n      /** @type {Construct} */\n      let currentConstruct;\n      /** @type {Info} */\n      let info;\n      return Array.isArray(constructs) ? /* c8 ignore next 1 */\n      handleListOfConstructs(constructs) : 'tokenize' in constructs ?\n      // Looks like a construct.\n      handleListOfConstructs([(/** @type {Construct} */constructs)]) : handleMapOfConstructs(constructs);\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleMapOfConstructs(map) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          const left = code !== null && map[code];\n          const all = code !== null && map.null;\n          const list = [\n          // To do: add more extension tests.\n          /* c8 ignore next 2 */\n          ...(Array.isArray(left) ? left : left ? [left] : []), ...(Array.isArray(all) ? all : all ? [all] : [])];\n          return handleListOfConstructs(list)(code);\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ReadonlyArray<Construct>} list\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        if (list.length === 0) {\n          return bogusState;\n        }\n        return handleConstruct(list[constructIndex]);\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       *   Construct.\n       * @returns {State}\n       *   State.\n       */\n      function handleConstruct(construct) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          // Always populated by defaults.\n\n          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {\n            return nok(code);\n          }\n          return construct.tokenize.call(\n          // If we do have fields, create an object w/ `context` as its\n          // prototype.\n          // This allows a “live binding”, which is needed for `interrupt`.\n          fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true;\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true;\n        info.restore();\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n        return bogusState;\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   *   Construct.\n   * @param {number} from\n   *   From.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   *   Info.\n   */\n  function store() {\n    const startPoint = now();\n    const startPrevious = context.previous;\n    const startCurrentConstruct = context.currentConstruct;\n    const startEventsIndex = context.events.length;\n    const startStack = Array.from(stack);\n    return {\n      from: startEventsIndex,\n      restore\n    };\n\n    /**\n     * Restore state.\n     *\n     * @returns {undefined}\n     *   Nothing.\n     */\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {Pick<Token, 'end' | 'start'>} token\n *   Token.\n * @returns {Array<Chunk>}\n *   Chunks.\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index;\n  const startBufferIndex = token.start._bufferIndex;\n  const endIndex = token.end._index;\n  const endBufferIndex = token.end._bufferIndex;\n  /** @type {Array<Chunk>} */\n  let view;\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n    if (startBufferIndex > -1) {\n      const head = view[0];\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex);\n        /* c8 ignore next 4 -- used to be used, no longer */\n      } else {\n        view.shift();\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n  return view;\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {boolean | undefined} [expandTabs=false]\n *   Whether to expand tabs (default: `false`).\n * @returns {string}\n *   Result.\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1;\n  /** @type {Array<string>} */\n  const result = [];\n  /** @type {boolean | undefined} */\n  let atTab;\n  while (++index < chunks.length) {\n    const chunk = chunks[index];\n    /** @type {string} */\n    let value;\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else switch (chunk) {\n      case -5:\n        {\n          value = \"\\r\";\n          break;\n        }\n      case -4:\n        {\n          value = \"\\n\";\n          break;\n        }\n      case -3:\n        {\n          value = \"\\r\" + \"\\n\";\n          break;\n        }\n      case -2:\n        {\n          value = expandTabs ? \" \" : \"\\t\";\n          break;\n        }\n      case -1:\n        {\n          if (!expandTabs && atTab) continue;\n          value = \" \";\n          break;\n        }\n      default:\n        {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk);\n        }\n    }\n    atTab = chunk === -2;\n    result.push(value);\n  }\n  return result.join('');\n}"],"names":["from"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/content.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.es.js","sources":["../../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/content.js"],"sourcesContent":["/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Initializer}\n *   Content.\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  /** @type {Token} */\n  let previous;\n  return contentStart;\n\n  /** @type {State} */\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, contentStart, \"linePrefix\");\n  }\n\n  /** @type {State} */\n  function paragraphInitial(code) {\n    effects.enter(\"paragraph\");\n    return lineStart(code);\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    const token = effects.enter(\"chunkText\", {\n      contentType: \"text\",\n      previous\n    });\n    if (previous) {\n      previous.next = token;\n    }\n    previous = token;\n    return data(code);\n  }\n\n  /** @type {State} */\n  function data(code) {\n    if (code === null) {\n      effects.exit(\"chunkText\");\n      effects.exit(\"paragraph\");\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit(\"chunkText\");\n      return lineStart;\n    }\n\n    // Data.\n    effects.consume(code);\n    return data;\n  }\n}"],"names":[],"mappings":";;AAaY,MAAC,UAAU;AAAA,EACrB,UAAU;AACZ;AAQA,SAAS,kBAAkB,SAAS;AAClC,QAAM,eAAe,QAAQ,QAAQ,KAAK,OAAO,WAAW,gBAAgB,4BAA4B,gBAAgB;AAExH,MAAI;AACJ,SAAO;AAGP,WAAS,2BAA2B,MAAM;AACxC,QAAI,SAAS,MAAM;AACjB,cAAQ,QAAQ,IAAI;AACpB;AAAA,IACN;AACI,YAAQ,MAAM,YAAY;AAC1B,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,YAAY;AACzB,WAAO,aAAa,SAAS,cAAc,YAAY;AAAA,EAC3D;AAGE,WAAS,iBAAiB,MAAM;AAC9B,YAAQ,MAAM,WAAW;AACzB,WAAO,UAAU,IAAI;AAAA,EACzB;AAGE,WAAS,UAAU,MAAM;AACvB,UAAM,QAAQ,QAAQ,MAAM,aAAa;AAAA,MACvC,aAAa;AAAA,MACb;AAAA,IACN,CAAK;AACD,QAAI,UAAU;AACZ,eAAS,OAAO;AAAA,IACtB;AACI,eAAW;AACX,WAAO,KAAK,IAAI;AAAA,EACpB;AAGE,WAAS,KAAK,MAAM;AAClB,QAAI,SAAS,MAAM;AACjB,cAAQ,KAAK,WAAW;AACxB,cAAQ,KAAK,WAAW;AACxB,cAAQ,QAAQ,IAAI;AACpB;AAAA,IACN;AACI,QAAI,mBAAmB,IAAI,GAAG;AAC5B,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,WAAW;AACxB,aAAO;AAAA,IACb;AAGI,YAAQ,QAAQ,IAAI;AACpB,WAAO;AAAA,EACX;AACA;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/document.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.es.js","sources":["../../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/document.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   ContainerState,\n *   InitialConstruct,\n *   Initializer,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n *   Construct and its state.\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {InitialConstruct} */\nexport const document = {\n  tokenize: initializeDocument\n};\n\n/** @type {Construct} */\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeDocument(effects) {\n  const self = this;\n  /** @type {Array<StackItem>} */\n  const stack = [];\n  let continued = 0;\n  /** @type {TokenizeContext | undefined} */\n  let childFlow;\n  /** @type {Token | undefined} */\n  let childToken;\n  /** @type {number} */\n  let lineStartOffset;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued];\n      self.containerState = item[1];\n      return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code);\n    }\n\n    // Done.\n    return checkNewContainers(code);\n  }\n\n  /** @type {State} */\n  function documentContinue(code) {\n    continued++;\n\n    // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined;\n      if (childFlow) {\n        closeFlow();\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the flow chunk.\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          point = self.events[indexBeforeFlow][1].end;\n          break;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      let index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n      return checkNewContainers(code);\n    }\n    return start(code);\n  }\n\n  /** @type {State} */\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code);\n      }\n\n      // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code);\n      }\n\n      // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n      // needed in micromark-extension-gfm-table@1.0.6).\n      self.interrupt = Boolean(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack);\n    }\n\n    // Check if there is a new container.\n    self.containerState = {};\n    return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code);\n  }\n\n  /** @type {State} */\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow();\n    exitContainers(continued);\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length;\n    lineStartOffset = self.now().offset;\n    return flowStart(code);\n  }\n\n  /** @type {State} */\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n\n  /** @type {State} */\n  function containerContinue(code) {\n    continued++;\n    stack.push([self.currentConstruct, self.containerState]);\n    // Try another.\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow();\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter(\"chunkFlow\", {\n      _tokenizer: childFlow,\n      contentType: \"flow\",\n      previous: childToken\n    });\n    return flowContinue(code);\n  }\n\n  /** @type {State} */\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit(\"chunkFlow\"), true);\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      writeToChild(effects.exit(\"chunkFlow\"));\n      // Get ready for the next line.\n      continued = 0;\n      self.interrupt = undefined;\n      return start;\n    }\n    effects.consume(code);\n    return flowContinue;\n  }\n\n  /**\n   * @param {Token} token\n   *   Token.\n   * @param {boolean | undefined} [endOfFile]\n   *   Whether the token is at the end of the file (default: `false`).\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function writeToChild(token, endOfFile) {\n    const stream = self.sliceStream(token);\n    if (endOfFile) stream.push(null);\n    token.previous = childToken;\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.defineSkip(token.start);\n    childFlow.write(stream);\n\n    // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length;\n      while (index--) {\n        if (\n        // The token starts before the line ending…\n        childFlow.events[index][1].start.offset < lineStartOffset && (\n        // …and either is not ended yet…\n        !childFlow.events[index][1].end ||\n        // …or ends after it.\n        childFlow.events[index][1].end.offset > lineStartOffset)) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return;\n        }\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {boolean | undefined} */\n      let seen;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the previous chunk (the one before the lazy line).\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end;\n            break;\n          }\n          seen = true;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n    }\n  }\n\n  /**\n   * @param {number} size\n   *   Size.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function exitContainers(size) {\n    let index = stack.length;\n\n    // Exit open containers.\n    while (index-- > size) {\n      const entry = stack[index];\n      self.containerState = entry[1];\n      entry[0].exit.call(self, effects);\n    }\n    stack.length = size;\n  }\n  function closeFlow() {\n    childFlow.write([null]);\n    childToken = undefined;\n    childFlow = undefined;\n    self.containerState._closeFlow = undefined;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n *   Tokenizer.\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), \"linePrefix\", this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n}"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/flow.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.es.js","sources":["../../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/flow.js"],"sourcesContent":["/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nimport { blankLine, content } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeFlow(effects) {\n  const self = this;\n  const initial = effects.attempt(\n  // Try to parse a blank line.\n  blankLine, atBlankEnding,\n  // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), \"linePrefix\")));\n  return initial;\n\n  /** @type {State} */\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEndingBlank\");\n    effects.consume(code);\n    effects.exit(\"lineEndingBlank\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n\n  /** @type {State} */\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}"],"names":[],"mappings":";;;AAaY,MAAC,OAAO;AAAA,EAClB,UAAU;AACZ;AAQA,SAAS,eAAe,SAAS;AAC/B,QAAM,OAAO;AACb,QAAM,UAAU,QAAQ;AAAA;AAAA,IAExB;AAAA,IAAW;AAAA;AAAA,IAEX,QAAQ,QAAQ,KAAK,OAAO,WAAW,aAAa,gBAAgB,aAAa,SAAS,QAAQ,QAAQ,KAAK,OAAO,WAAW,MAAM,gBAAgB,QAAQ,QAAQ,SAAS,cAAc,CAAC,GAAG,YAAY,CAAC;AAAA,EAAC;AAChN,SAAO;AAGP,WAAS,cAAc,MAAM;AAC3B,QAAI,SAAS,MAAM;AACjB,cAAQ,QAAQ,IAAI;AACpB;AAAA,IACN;AACI,YAAQ,MAAM,iBAAiB;AAC/B,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,iBAAiB;AAC9B,SAAK,mBAAmB;AACxB,WAAO;AAAA,EACX;AAGE,WAAS,eAAe,MAAM;AAC5B,QAAI,SAAS,MAAM;AACjB,cAAQ,QAAQ,IAAI;AACpB;AAAA,IACN;AACI,YAAQ,MAAM,YAAY;AAC1B,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,YAAY;AACzB,SAAK,mBAAmB;AACxB,WAAO;AAAA,EACX;AACA;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/text.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.es.js","sources":["../../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/text.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   InitialConstruct,\n *   Initializer,\n *   Resolver,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n};\nexport const string = initializeFactory('string');\nexport const text = initializeFactory('text');\n\n/**\n * @param {'string' | 'text'} field\n *   Field.\n * @returns {InitialConstruct}\n *   Construct.\n */\nfunction initializeFactory(field) {\n  return {\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),\n    tokenize: initializeText\n  };\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Initializer}\n   */\n  function initializeText(effects) {\n    const self = this;\n    const constructs = this.parser.constructs[field];\n    const text = effects.attempt(constructs, start, notText);\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n      effects.enter(\"data\");\n      effects.consume(code);\n      return data;\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit(\"data\");\n        return text(code);\n      }\n\n      // Data.\n      effects.consume(code);\n      return data;\n    }\n\n    /**\n     * @param {Code} code\n     *   Code.\n     * @returns {boolean}\n     *   Whether the code is a break.\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true;\n      }\n      const list = constructs[code];\n      let index = -1;\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index];\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n *   Resolver.\n * @returns {Resolver}\n *   Resolver.\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1;\n    /** @type {number | undefined} */\n    let enter;\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === \"data\") {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== \"data\") {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n        enter = undefined;\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n}\n\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0; // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === \"lineEnding\") && events[eventIndex - 1][1].type === \"data\") {\n      const data = events[eventIndex - 1][1];\n      const chunks = context.sliceStream(data);\n      let index = chunks.length;\n      let bufferIndex = -1;\n      let size = 0;\n      /** @type {boolean | undefined} */\n      let tabs;\n      while (index--) {\n        const chunk = chunks[index];\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        }\n        // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n\n      // Allow final trailing whitespace.\n      if (context._contentTypeTextTrailing && eventIndex === events.length) {\n        size = 0;\n      }\n      if (size) {\n        const token = {\n          type: eventIndex === events.length || tabs || size < 2 ? \"lineSuffix\" : \"hardBreakTrailing\",\n          start: {\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,\n            _index: data.start._index + index,\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size\n          },\n          end: {\n            ...data.end\n          }\n        };\n        data.end = {\n          ...token.start\n        };\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n      eventIndex++;\n    }\n  }\n  return events;\n}"],"names":["text"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/parse.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/parse.js"],"sourcesContent":["/**\n * @import {\n *   Create,\n *   FullNormalizedExtension,\n *   InitialConstruct,\n *   ParseContext,\n *   ParseOptions\n * } from 'micromark-util-types'\n */\n\nimport { combineExtensions } from 'micromark-util-combine-extensions';\nimport { content } from './initialize/content.js';\nimport { document } from './initialize/document.js';\nimport { flow } from './initialize/flow.js';\nimport { string, text } from './initialize/text.js';\nimport * as defaultConstructs from './constructs.js';\nimport { createTokenizer } from './create-tokenizer.js';\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ParseContext}\n *   Parser.\n */\nexport function parse(options) {\n  const settings = options || {};\n  const constructs = /** @type {FullNormalizedExtension} */\n  combineExtensions([defaultConstructs, ...(settings.extensions || [])]);\n\n  /** @type {ParseContext} */\n  const parser = {\n    constructs,\n    content: create(content),\n    defined: [],\n    document: create(document),\n    flow: create(flow),\n    lazy: {},\n    string: create(string),\n    text: create(text)\n  };\n  return parser;\n\n  /**\n   * @param {InitialConstruct} initial\n   *   Construct to start with.\n   * @returns {Create}\n   *   Create a tokenizer.\n   */\n  function create(initial) {\n    return creator;\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from);\n    }\n  }\n}"],"names":["constructs","defaultConstructs"],"mappings":";;;;;;;AAwBO,SAAS,MAAM,SAAS;AAC7B,QAAM,WAAW,WAAW,CAAE;AAC9B,QAAMA;AAAAA;AAAAA,IACN,kBAAkB,CAACC,YAAmB,GAAI,SAAS,cAAc,CAAE,CAAC,CAAC;AAAA;AAGrE,QAAM,SAAS;AAAA,IACjB,YAAID;AAAAA,IACA,SAAS,OAAO,OAAO;AAAA,IACvB,SAAS,CAAE;AAAA,IACX,UAAU,OAAO,QAAQ;AAAA,IACzB,MAAM,OAAO,IAAI;AAAA,IACjB,MAAM,CAAE;AAAA,IACR,QAAQ,OAAO,MAAM;AAAA,IACrB,MAAM,OAAO,IAAI;AAAA,EAClB;AACD,SAAO;AAQP,WAAS,OAAO,SAAS;AACvB,WAAO;AAEP,aAAS,QAAQ,MAAM;AACrB,aAAO,gBAAgB,QAAQ,SAAS,IAAI;AAAA,IAClD;AAAA,EACA;AACA;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/postprocess.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postprocess.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/postprocess.js"],"sourcesContent":["/**\n * @import {Event} from 'micromark-util-types'\n */\n\nimport { subtokenize } from 'micromark-util-subtokenize';\n\n/**\n * @param {Array<Event>} events\n *   Events.\n * @returns {Array<Event>}\n *   Events.\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events;\n}"],"names":[],"mappings":";AAYO,SAAS,YAAY,QAAQ;AAClC,SAAO,CAAC,YAAY,MAAM,GAAG;AAAA,EAE/B;AACE,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/preprocess.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preprocess.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/preprocess.js"],"sourcesContent":["/**\n * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'\n */\n\n/**\n * @callback Preprocessor\n *   Preprocess a value.\n * @param {Value} value\n *   Value.\n * @param {Encoding | null | undefined} [encoding]\n *   Encoding when `value` is a typed array (optional).\n * @param {boolean | null | undefined} [end=false]\n *   Whether this is the last chunk (default: `false`).\n * @returns {Array<Chunk>}\n *   Chunks.\n */\n\nconst search = /[\\0\\t\\n\\r]/g;\n\n/**\n * @returns {Preprocessor}\n *   Preprocess a value.\n */\nexport function preprocess() {\n  let column = 1;\n  let buffer = '';\n  /** @type {boolean | undefined} */\n  let start = true;\n  /** @type {boolean | undefined} */\n  let atCarriageReturn;\n  return preprocessor;\n\n  /** @type {Preprocessor} */\n  // eslint-disable-next-line complexity\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = [];\n    /** @type {RegExpMatchArray | null} */\n    let match;\n    /** @type {number} */\n    let next;\n    /** @type {number} */\n    let startPosition;\n    /** @type {number} */\n    let endPosition;\n    /** @type {Code} */\n    let code;\n    value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value));\n    startPosition = 0;\n    buffer = '';\n    if (start) {\n      // To do: `markdown-rs` actually parses BOMs (byte order mark).\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n      start = undefined;\n    }\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match && match.index !== undefined ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n        switch (code) {\n          case 0:\n            {\n              chunks.push(65533);\n              column++;\n              break;\n            }\n          case 9:\n            {\n              next = Math.ceil(column / 4) * 4;\n              chunks.push(-2);\n              while (column++ < next) chunks.push(-1);\n              break;\n            }\n          case 10:\n            {\n              chunks.push(-4);\n              column = 1;\n              break;\n            }\n          default:\n            {\n              atCarriageReturn = true;\n              column = 1;\n            }\n        }\n      }\n      startPosition = endPosition + 1;\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n    return chunks;\n  }\n}"],"names":[],"mappings":"AAiBA,MAAM,SAAS;AAMR,SAAS,aAAa;AAC3B,MAAI,SAAS;AACb,MAAI,SAAS;AAEb,MAAI,QAAQ;AAEZ,MAAI;AACJ,SAAO;AAIP,WAAS,aAAa,OAAO,UAAU,KAAK;AAE1C,UAAM,SAAS,CAAE;AAEjB,QAAI;AAEJ,QAAI;AAEJ,QAAI;AAEJ,QAAI;AAEJ,QAAI;AACJ,YAAQ,UAAU,OAAO,UAAU,WAAW,MAAM,SAAQ,IAAK,IAAI,YAAY,YAAY,MAAS,EAAE,OAAO,KAAK;AACpH,oBAAgB;AAChB,aAAS;AACT,QAAI,OAAO;AAET,UAAI,MAAM,WAAW,CAAC,MAAM,OAAO;AACjC;AAAA,MACR;AACM,cAAQ;AAAA,IACd;AACI,WAAO,gBAAgB,MAAM,QAAQ;AACnC,aAAO,YAAY;AACnB,cAAQ,OAAO,KAAK,KAAK;AACzB,oBAAc,SAAS,MAAM,UAAU,SAAY,MAAM,QAAQ,MAAM;AACvE,aAAO,MAAM,WAAW,WAAW;AACnC,UAAI,CAAC,OAAO;AACV,iBAAS,MAAM,MAAM,aAAa;AAClC;AAAA,MACR;AACM,UAAI,SAAS,MAAM,kBAAkB,eAAe,kBAAkB;AACpE,eAAO,KAAK,EAAE;AACd,2BAAmB;AAAA,MAC3B,OAAa;AACL,YAAI,kBAAkB;AACpB,iBAAO,KAAK,EAAE;AACd,6BAAmB;AAAA,QAC7B;AACQ,YAAI,gBAAgB,aAAa;AAC/B,iBAAO,KAAK,MAAM,MAAM,eAAe,WAAW,CAAC;AACnD,oBAAU,cAAc;AAAA,QAClC;AACQ,gBAAQ,MAAI;AAAA,UACV,KAAK,GACH;AACE,mBAAO,KAAK,KAAK;AACjB;AACA;AAAA,UACd;AAAA,UACU,KAAK,GACH;AACE,mBAAO,KAAK,KAAK,SAAS,CAAC,IAAI;AAC/B,mBAAO,KAAK,EAAE;AACd,mBAAO,WAAW,KAAM,QAAO,KAAK,EAAE;AACtC;AAAA,UACd;AAAA,UACU,KAAK,IACH;AACE,mBAAO,KAAK,EAAE;AACd,qBAAS;AACT;AAAA,UACd;AAAA,UACU,SACE;AACE,+BAAmB;AACnB,qBAAS;AAAA,UACvB;AAAA,QACA;AAAA,MACA;AACM,sBAAgB,cAAc;AAAA,IACpC;AACI,QAAI,KAAK;AACP,UAAI,iBAAkB,QAAO,KAAK,EAAE;AACpC,UAAI,OAAQ,QAAO,KAAK,MAAM;AAC9B,aAAO,KAAK,IAAI;AAAA,IACtB;AACI,WAAO;AAAA,EACX;AACA;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/nanoid@3.3.11/node_modules/nanoid/index.browser.es.js

@@ -0,0 +1,23 @@
+let random = (bytes) => crypto.getRandomValues(new Uint8Array(bytes));
+let customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << Math.log(alphabet.length - 1) / Math.LN2) - 1;
+  let step = -~(1.6 * mask * defaultSize / alphabet.length);
+  return (size = defaultSize) => {
+    let id = "";
+    while (true) {
+      let bytes = getRandom(step);
+      let j = step | 0;
+      while (j--) {
+        id += alphabet[bytes[j] & mask] || "";
+        if (id.length === size) return id;
+      }
+    }
+  };
+};
+let customAlphabet = (alphabet, size = 21) => customRandom(alphabet, size, random);
+export {
+  customAlphabet,
+  customRandom,
+  random
+};
+//# sourceMappingURL=index.browser.es.js.map

package/dist/lib/node_modules/.pnpm/nanoid@3.3.11/node_modules/nanoid/index.browser.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.browser.es.js","sources":["../../../../../../../../../node_modules/.pnpm/nanoid@3.3.11/node_modules/nanoid/index.browser.js"],"sourcesContent":["import { urlAlphabet } from './url-alphabet/index.js'\nlet random = bytes => crypto.getRandomValues(new Uint8Array(bytes))\nlet customRandom = (alphabet, defaultSize, getRandom) => {\n  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1\n  let step = -~((1.6 * mask * defaultSize) / alphabet.length)\n  return (size = defaultSize) => {\n    let id = ''\n    while (true) {\n      let bytes = getRandom(step)\n      let j = step | 0\n      while (j--) {\n        id += alphabet[bytes[j] & mask] || ''\n        if (id.length === size) return id\n      }\n    }\n  }\n}\nlet customAlphabet = (alphabet, size = 21) =>\n  customRandom(alphabet, size, random)\nlet nanoid = (size = 21) =>\n  crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {\n    byte &= 63\n    if (byte < 36) {\n      id += byte.toString(36)\n    } else if (byte < 62) {\n      id += (byte - 26).toString(36).toUpperCase()\n    } else if (byte > 62) {\n      id += '-'\n    } else {\n      id += '_'\n    }\n    return id\n  }, '')\nexport { nanoid, customAlphabet, customRandom, urlAlphabet, random }\n"],"names":[],"mappings":"AACG,IAAC,SAAS,WAAS,OAAO,gBAAgB,IAAI,WAAW,KAAK,CAAC;AAC/D,IAAC,eAAe,CAAC,UAAU,aAAa,cAAc;AACvD,MAAI,QAAQ,KAAM,KAAK,IAAI,SAAS,SAAS,CAAC,IAAI,KAAK,OAAQ;AAC/D,MAAI,OAAO,CAAC,EAAG,MAAM,OAAO,cAAe,SAAS;AACpD,SAAO,CAAC,OAAO,gBAAgB;AAC7B,QAAI,KAAK;AACT,WAAO,MAAM;AACX,UAAI,QAAQ,UAAU,IAAI;AAC1B,UAAI,IAAI,OAAO;AACf,aAAO,KAAK;AACV,cAAM,SAAS,MAAM,CAAC,IAAI,IAAI,KAAK;AACnC,YAAI,GAAG,WAAW,KAAM,QAAO;AAAA,MACvC;AAAA,IACA;AAAA,EACA;AACA;AACG,IAAC,iBAAiB,CAAC,UAAU,OAAO,OACrC,aAAa,UAAU,MAAM,MAAM;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js"],"sourcesContent":["/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n"],"names":[],"mappings":";;;;;;;;;;AAQA,MAAI,wBAAwB,OAAO;AACnC,MAAI,iBAAiB,OAAO,UAAU;AACtC,MAAI,mBAAmB,OAAO,UAAU;AAExC,WAAS,SAAS,KAAK;AACtB,QAAI,QAAQ,QAAQ,QAAQ,QAAW;AACtC,YAAM,IAAI,UAAU,uDAAuD;AAAA;AAG5E,WAAO,OAAO,GAAG;AAAA;AAGlB,WAAS,kBAAkB;AAC1B,QAAI;AACH,UAAI,CAAC,OAAO,QAAQ;AACnB,eAAO;AAAA;AAMR,UAAI,QAAQ,IAAI,OAAO,KAAK;AAC5B,YAAM,CAAC,IAAI;AACX,UAAI,OAAO,oBAAoB,KAAK,EAAE,CAAC,MAAM,KAAK;AACjD,eAAO;AAAA;AAIR,UAAI,QAAQ,CAAE;AACd,eAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AAC5B,cAAM,MAAM,OAAO,aAAa,CAAC,CAAC,IAAI;AAAA;AAEvC,UAAI,SAAS,OAAO,oBAAoB,KAAK,EAAE,IAAI,SAAU,GAAG;AAC/D,eAAO,MAAM,CAAC;AAAA,MACjB,CAAG;AACD,UAAI,OAAO,KAAK,EAAE,MAAM,cAAc;AACrC,eAAO;AAAA;AAIR,UAAI,QAAQ,CAAE;AACd,6BAAuB,MAAM,EAAE,EAAE,QAAQ,SAAU,QAAQ;AAC1D,cAAM,MAAM,IAAI;AAAA,MACnB,CAAG;AACD,UAAI,OAAO,KAAK,OAAO,OAAO,CAAE,GAAE,KAAK,CAAC,EAAE,KAAK,EAAE,MAC/C,wBAAwB;AACzB,eAAO;AAAA;AAGR,aAAO;AAAA,IACP,SAAQ,KAAK;AAEb,aAAO;AAAA;;AAIT,iBAAiB,gBAAe,IAAK,OAAO,SAAS,SAAU,QAAQ,QAAQ;AAC9E,QAAI;AACJ,QAAI,KAAK,SAAS,MAAM;AACxB,QAAI;AAEJ,aAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AAC1C,aAAO,OAAO,UAAU,CAAC,CAAC;AAE1B,eAAS,OAAO,MAAM;AACrB,YAAI,eAAe,KAAK,MAAM,GAAG,GAAG;AACnC,aAAG,GAAG,IAAI,KAAK,GAAG;AAAA;;AAIpB,UAAI,uBAAuB;AAC1B,kBAAU,sBAAsB,IAAI;AACpC,iBAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACxC,cAAI,iBAAiB,KAAK,MAAM,QAAQ,CAAC,CAAC,GAAG;AAC5C,eAAG,QAAQ,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;AAAA;;;;AAMpC,WAAO;AAAA,EACP;;;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/checkPropTypes.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkPropTypes.es.js","sources":["../../../../../../../../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/checkPropTypes.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar printWarning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n  var loggedTypeFailures = {};\n  var has = require('./lib/has');\n\n  printWarning = function(text) {\n    var message = 'Warning: ' + text;\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) { /**/ }\n  };\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n  if (process.env.NODE_ENV !== 'production') {\n    for (var typeSpecName in typeSpecs) {\n      if (has(typeSpecs, typeSpecName)) {\n        var error;\n        // Prop type validation may throw. In case they do, we don't want to\n        // fail the render phase where it didn't fail before. So we log it.\n        // After these have been cleaned up, we'll let them throw.\n        try {\n          // This is intentionally an invariant that gets caught. It's the same\n          // behavior as without this statement except with a better message.\n          if (typeof typeSpecs[typeSpecName] !== 'function') {\n            var err = Error(\n              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +\n              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +\n              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'\n            );\n            err.name = 'Invariant Violation';\n            throw err;\n          }\n          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n        } catch (ex) {\n          error = ex;\n        }\n        if (error && !(error instanceof Error)) {\n          printWarning(\n            (componentName || 'React class') + ': type specification of ' +\n            location + ' `' + typeSpecName + '` is invalid; the type checker ' +\n            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +\n            'You may have forgotten to pass an argument to the type checker ' +\n            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +\n            'shape all require an argument).'\n          );\n        }\n        if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n          // Only monitor this failure once because there tends to be a lot of the\n          // same error.\n          loggedTypeFailures[error.message] = true;\n\n          var stack = getStack ? getStack() : '';\n\n          printWarning(\n            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')\n          );\n        }\n      }\n    }\n  }\n}\n\n/**\n * Resets warning cache when testing.\n *\n * @private\n */\ncheckPropTypes.resetWarningCache = function() {\n  if (process.env.NODE_ENV !== 'production') {\n    loggedTypeFailures = {};\n  }\n}\n\nmodule.exports = checkPropTypes;\n"],"names":["require$$0","require$$1"],"mappings":";;;;;;;AASA,MAAI,eAAe,WAAW;AAAA,EAAE;AAEhC,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAI,uBAAuBA,4BAAqC;AAChE,QAAI,qBAAqB,CAAE;AAC3B,QAAI,MAAMC,WAAoB;AAE9B,mBAAe,SAAS,MAAM;AAC5B,UAAI,UAAU,cAAc;AAC5B,UAAI,OAAO,YAAY,aAAa;AAClC,gBAAQ,MAAM,OAAO;AAAA;AAEvB,UAAI;AAIF,cAAM,IAAI,MAAM,OAAO;AAAA,MACxB,SAAQ,GAAG;AAAA,MAAA;AAAA,IACb;AAAA;AAcH,WAAS,eAAe,WAAW,QAAQ,UAAU,eAAe,UAAU;AAC5E,QAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,eAAS,gBAAgB,WAAW;AAClC,YAAI,IAAI,WAAW,YAAY,GAAG;AAChC,cAAI;AAIJ,cAAI;AAGF,gBAAI,OAAO,UAAU,YAAY,MAAM,YAAY;AACjD,kBAAI,MAAM;AAAA,iBACP,iBAAiB,iBAAiB,OAAO,WAAW,YAAY,eAAe,+FACC,OAAO,UAAU,YAAY,IAAI;AAAA,cAEnH;AACD,kBAAI,OAAO;AACX,oBAAM;AAAA;AAER,oBAAQ,UAAU,YAAY,EAAE,QAAQ,cAAc,eAAe,UAAU,MAAM,oBAAoB;AAAA,UAC1G,SAAQ,IAAI;AACX,oBAAQ;AAAA;AAEV,cAAI,SAAS,EAAE,iBAAiB,QAAQ;AACtC;AAAA,eACG,iBAAiB,iBAAiB,6BACnC,WAAW,OAAO,eAAe,6FAC6B,OAAO,QAAQ;AAAA,YAI9E;AAAA;AAEH,cAAI,iBAAiB,SAAS,EAAE,MAAM,WAAW,qBAAqB;AAGpE,+BAAmB,MAAM,OAAO,IAAI;AAEpC,gBAAI,QAAQ,WAAW,SAAQ,IAAK;AAEpC;AAAA,cACE,YAAY,WAAW,YAAY,MAAM,WAAW,SAAS,OAAO,QAAQ;AAAA,YAC7E;AAAA;;;;;AAYX,iBAAe,oBAAoB,WAAW;AAC5C,QAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,2BAAqB,CAAE;AAAA;;AAI3B,qBAAiB;;;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/factoryWithThrowingShims.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factoryWithThrowingShims.es.js","sources":["../../../../../../../../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/factoryWithThrowingShims.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bigint: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n"],"names":["require$$0"],"mappings":";;;;;;AASA,MAAI,uBAAuBA,4BAAqC;AAEhE,WAAS,gBAAgB;AAAA,EAAA;AACzB,WAAS,yBAAyB;AAAA,EAAA;AAClC,yBAAuB,oBAAoB;AAE3C,6BAAiB,WAAW;AAC1B,aAAS,KAAK,OAAO,UAAU,eAAe,UAAU,cAAc,QAAQ;AAC5E,UAAI,WAAW,sBAAsB;AAEnC;AAAA;AAEF,UAAI,MAAM,IAAI;AAAA,QACZ;AAAA,MAGD;AACD,UAAI,OAAO;AACX,YAAM;AAAA,IACV;AACE,SAAK,aAAa;AAClB,aAAS,UAAU;AACjB,aAAO;AAAA,IAEX;AAEE,QAAI,iBAAiB;AAAA,MACnB,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,MAAM;AAAA,MACN,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,QAAQ;AAAA,MAER,KAAK;AAAA,MACL,SAAS;AAAA,MACT,SAAS;AAAA,MACT,aAAa;AAAA,MACb,YAAY;AAAA,MACZ,MAAM;AAAA,MACN,UAAU;AAAA,MACV,OAAO;AAAA,MACP,WAAW;AAAA,MACX,OAAO;AAAA,MACP,OAAO;AAAA,MAEP,gBAAgB;AAAA,MAChB,mBAAmB;AAAA,IACpB;AAED,mBAAe,YAAY;AAE3B,WAAO;AAAA,EACR;;;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/factoryWithTypeCheckers.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factoryWithTypeCheckers.es.js","sources":["../../../../../../../../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/factoryWithTypeCheckers.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactIs = require('react-is');\nvar assign = require('object-assign');\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\nvar has = require('./lib/has');\nvar checkPropTypes = require('./checkPropTypes');\n\nvar printWarning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  printWarning = function(text) {\n    var message = 'Warning: ' + text;\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) {}\n  };\n}\n\nfunction emptyFunctionThatReturnsNull() {\n  return null;\n}\n\nmodule.exports = function(isValidElement, throwOnDirectAccess) {\n  /* global Symbol */\n  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n  /**\n   * Returns the iterator method function contained on the iterable object.\n   *\n   * Be sure to invoke the function with the iterable as context:\n   *\n   *     var iteratorFn = getIteratorFn(myIterable);\n   *     if (iteratorFn) {\n   *       var iterator = iteratorFn.call(myIterable);\n   *       ...\n   *     }\n   *\n   * @param {?object} maybeIterable\n   * @return {?function}\n   */\n  function getIteratorFn(maybeIterable) {\n    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  /**\n   * Collection of methods that allow declaration and validation of props that are\n   * supplied to React components. Example usage:\n   *\n   *   var Props = require('ReactPropTypes');\n   *   var MyArticle = React.createClass({\n   *     propTypes: {\n   *       // An optional string prop named \"description\".\n   *       description: Props.string,\n   *\n   *       // A required enum prop named \"category\".\n   *       category: Props.oneOf(['News','Photos']).isRequired,\n   *\n   *       // A prop named \"dialog\" that requires an instance of Dialog.\n   *       dialog: Props.instanceOf(Dialog).isRequired\n   *     },\n   *     render: function() { ... }\n   *   });\n   *\n   * A more formal specification of how these methods are used:\n   *\n   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\n   *   decl := ReactPropTypes.{type}(.isRequired)?\n   *\n   * Each and every declaration produces a function with the same signature. This\n   * allows the creation of custom validation functions. For example:\n   *\n   *  var MyLink = React.createClass({\n   *    propTypes: {\n   *      // An optional string or URI prop named \"href\".\n   *      href: function(props, propName, componentName) {\n   *        var propValue = props[propName];\n   *        if (propValue != null && typeof propValue !== 'string' &&\n   *            !(propValue instanceof URI)) {\n   *          return new Error(\n   *            'Expected a string or an URI for ' + propName + ' in ' +\n   *            componentName\n   *          );\n   *        }\n   *      }\n   *    },\n   *    render: function() {...}\n   *  });\n   *\n   * @internal\n   */\n\n  var ANONYMOUS = '<<anonymous>>';\n\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.\n  var ReactPropTypes = {\n    array: createPrimitiveTypeChecker('array'),\n    bigint: createPrimitiveTypeChecker('bigint'),\n    bool: createPrimitiveTypeChecker('boolean'),\n    func: createPrimitiveTypeChecker('function'),\n    number: createPrimitiveTypeChecker('number'),\n    object: createPrimitiveTypeChecker('object'),\n    string: createPrimitiveTypeChecker('string'),\n    symbol: createPrimitiveTypeChecker('symbol'),\n\n    any: createAnyTypeChecker(),\n    arrayOf: createArrayOfTypeChecker,\n    element: createElementTypeChecker(),\n    elementType: createElementTypeTypeChecker(),\n    instanceOf: createInstanceTypeChecker,\n    node: createNodeChecker(),\n    objectOf: createObjectOfTypeChecker,\n    oneOf: createEnumTypeChecker,\n    oneOfType: createUnionTypeChecker,\n    shape: createShapeTypeChecker,\n    exact: createStrictShapeTypeChecker,\n  };\n\n  /**\n   * inlined Object.is polyfill to avoid requiring consumers ship their own\n   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n   */\n  /*eslint-disable no-self-compare*/\n  function is(x, y) {\n    // SameValue algorithm\n    if (x === y) {\n      // Steps 1-5, 7-10\n      // Steps 6.b-6.e: +0 != -0\n      return x !== 0 || 1 / x === 1 / y;\n    } else {\n      // Step 6.a: NaN == NaN\n      return x !== x && y !== y;\n    }\n  }\n  /*eslint-enable no-self-compare*/\n\n  /**\n   * We use an Error-like object for backward compatibility as people may call\n   * PropTypes directly and inspect their output. However, we don't use real\n   * Errors anymore. We don't inspect their stack anyway, and creating them\n   * is prohibitively expensive if they are created too often, such as what\n   * happens in oneOfType() for any type before the one that matched.\n   */\n  function PropTypeError(message, data) {\n    this.message = message;\n    this.data = data && typeof data === 'object' ? data: {};\n    this.stack = '';\n  }\n  // Make `instanceof Error` still work for returned errors.\n  PropTypeError.prototype = Error.prototype;\n\n  function createChainableTypeChecker(validate) {\n    if (process.env.NODE_ENV !== 'production') {\n      var manualPropTypeCallCache = {};\n      var manualPropTypeWarningCount = 0;\n    }\n    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {\n      componentName = componentName || ANONYMOUS;\n      propFullName = propFullName || propName;\n\n      if (secret !== ReactPropTypesSecret) {\n        if (throwOnDirectAccess) {\n          // New behavior only for users of `prop-types` package\n          var err = new Error(\n            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n            'Use `PropTypes.checkPropTypes()` to call them. ' +\n            'Read more at http://fb.me/use-check-prop-types'\n          );\n          err.name = 'Invariant Violation';\n          throw err;\n        } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {\n          // Old behavior for people using React.PropTypes\n          var cacheKey = componentName + ':' + propName;\n          if (\n            !manualPropTypeCallCache[cacheKey] &&\n            // Avoid spamming the console because they are often not actionable except for lib authors\n            manualPropTypeWarningCount < 3\n          ) {\n            printWarning(\n              'You are manually calling a React.PropTypes validation ' +\n              'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +\n              'and will throw in the standalone `prop-types` package. ' +\n              'You may be seeing this warning due to a third-party PropTypes ' +\n              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'\n            );\n            manualPropTypeCallCache[cacheKey] = true;\n            manualPropTypeWarningCount++;\n          }\n        }\n      }\n      if (props[propName] == null) {\n        if (isRequired) {\n          if (props[propName] === null) {\n            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));\n          }\n          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));\n        }\n        return null;\n      } else {\n        return validate(props, propName, componentName, location, propFullName);\n      }\n    }\n\n    var chainedCheckType = checkType.bind(null, false);\n    chainedCheckType.isRequired = checkType.bind(null, true);\n\n    return chainedCheckType;\n  }\n\n  function createPrimitiveTypeChecker(expectedType) {\n    function validate(props, propName, componentName, location, propFullName, secret) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== expectedType) {\n        // `propValue` being instance of, say, date/regexp, pass the 'object'\n        // check, but we can offer a more precise error message here rather than\n        // 'of type `object`'.\n        var preciseType = getPreciseType(propValue);\n\n        return new PropTypeError(\n          'Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'),\n          {expectedType: expectedType}\n        );\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createAnyTypeChecker() {\n    return createChainableTypeChecker(emptyFunctionThatReturnsNull);\n  }\n\n  function createArrayOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');\n      }\n      var propValue = props[propName];\n      if (!Array.isArray(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));\n      }\n      for (var i = 0; i < propValue.length; i++) {\n        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);\n        if (error instanceof Error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createElementTypeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      if (!isValidElement(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createElementTypeTypeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      if (!ReactIs.isValidElementType(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createInstanceTypeChecker(expectedClass) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!(props[propName] instanceof expectedClass)) {\n        var expectedClassName = expectedClass.name || ANONYMOUS;\n        var actualClassName = getClassName(props[propName]);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createEnumTypeChecker(expectedValues) {\n    if (!Array.isArray(expectedValues)) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (arguments.length > 1) {\n          printWarning(\n            'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +\n            'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'\n          );\n        } else {\n          printWarning('Invalid argument supplied to oneOf, expected an array.');\n        }\n      }\n      return emptyFunctionThatReturnsNull;\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      for (var i = 0; i < expectedValues.length; i++) {\n        if (is(propValue, expectedValues[i])) {\n          return null;\n        }\n      }\n\n      var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {\n        var type = getPreciseType(value);\n        if (type === 'symbol') {\n          return String(value);\n        }\n        return value;\n      });\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createObjectOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');\n      }\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));\n      }\n      for (var key in propValue) {\n        if (has(propValue, key)) {\n          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n          if (error instanceof Error) {\n            return error;\n          }\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createUnionTypeChecker(arrayOfTypeCheckers) {\n    if (!Array.isArray(arrayOfTypeCheckers)) {\n      process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;\n      return emptyFunctionThatReturnsNull;\n    }\n\n    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n      var checker = arrayOfTypeCheckers[i];\n      if (typeof checker !== 'function') {\n        printWarning(\n          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +\n          'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'\n        );\n        return emptyFunctionThatReturnsNull;\n      }\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      var expectedTypes = [];\n      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n        var checker = arrayOfTypeCheckers[i];\n        var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);\n        if (checkerResult == null) {\n          return null;\n        }\n        if (checkerResult.data && has(checkerResult.data, 'expectedType')) {\n          expectedTypes.push(checkerResult.data.expectedType);\n        }\n      }\n      var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': '';\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createNodeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!isNode(props[propName])) {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function invalidValidatorError(componentName, location, propFullName, key, type) {\n    return new PropTypeError(\n      (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' +\n      'it must be a function, usually from the `prop-types` package, but received `' + type + '`.'\n    );\n  }\n\n  function createShapeTypeChecker(shapeTypes) {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n      }\n      for (var key in shapeTypes) {\n        var checker = shapeTypes[key];\n        if (typeof checker !== 'function') {\n          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));\n        }\n        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n        if (error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createStrictShapeTypeChecker(shapeTypes) {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n      }\n      // We need to check all keys in case some are required but missing from props.\n      var allKeys = assign({}, props[propName], shapeTypes);\n      for (var key in allKeys) {\n        var checker = shapeTypes[key];\n        if (has(shapeTypes, key) && typeof checker !== 'function') {\n          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));\n        }\n        if (!checker) {\n          return new PropTypeError(\n            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +\n            '\\nBad object: ' + JSON.stringify(props[propName], null, '  ') +\n            '\\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  ')\n          );\n        }\n        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n        if (error) {\n          return error;\n        }\n      }\n      return null;\n    }\n\n    return createChainableTypeChecker(validate);\n  }\n\n  function isNode(propValue) {\n    switch (typeof propValue) {\n      case 'number':\n      case 'string':\n      case 'undefined':\n        return true;\n      case 'boolean':\n        return !propValue;\n      case 'object':\n        if (Array.isArray(propValue)) {\n          return propValue.every(isNode);\n        }\n        if (propValue === null || isValidElement(propValue)) {\n          return true;\n        }\n\n        var iteratorFn = getIteratorFn(propValue);\n        if (iteratorFn) {\n          var iterator = iteratorFn.call(propValue);\n          var step;\n          if (iteratorFn !== propValue.entries) {\n            while (!(step = iterator.next()).done) {\n              if (!isNode(step.value)) {\n                return false;\n              }\n            }\n          } else {\n            // Iterator will provide entry [k,v] tuples rather than values.\n            while (!(step = iterator.next()).done) {\n              var entry = step.value;\n              if (entry) {\n                if (!isNode(entry[1])) {\n                  return false;\n                }\n              }\n            }\n          }\n        } else {\n          return false;\n        }\n\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  function isSymbol(propType, propValue) {\n    // Native Symbol.\n    if (propType === 'symbol') {\n      return true;\n    }\n\n    // falsy value can't be a Symbol\n    if (!propValue) {\n      return false;\n    }\n\n    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\n    if (propValue['@@toStringTag'] === 'Symbol') {\n      return true;\n    }\n\n    // Fallback for non-spec compliant Symbols which are polyfilled.\n    if (typeof Symbol === 'function' && propValue instanceof Symbol) {\n      return true;\n    }\n\n    return false;\n  }\n\n  // Equivalent of `typeof` but with special handling for array and regexp.\n  function getPropType(propValue) {\n    var propType = typeof propValue;\n    if (Array.isArray(propValue)) {\n      return 'array';\n    }\n    if (propValue instanceof RegExp) {\n      // Old webkits (at least until Android 4.0) return 'function' rather than\n      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\n      // passes PropTypes.object.\n      return 'object';\n    }\n    if (isSymbol(propType, propValue)) {\n      return 'symbol';\n    }\n    return propType;\n  }\n\n  // This handles more types than `getPropType`. Only used for error messages.\n  // See `createPrimitiveTypeChecker`.\n  function getPreciseType(propValue) {\n    if (typeof propValue === 'undefined' || propValue === null) {\n      return '' + propValue;\n    }\n    var propType = getPropType(propValue);\n    if (propType === 'object') {\n      if (propValue instanceof Date) {\n        return 'date';\n      } else if (propValue instanceof RegExp) {\n        return 'regexp';\n      }\n    }\n    return propType;\n  }\n\n  // Returns a string that is postfixed to a warning about an invalid type.\n  // For example, \"undefined\" or \"of type array\"\n  function getPostfixForTypeWarning(value) {\n    var type = getPreciseType(value);\n    switch (type) {\n      case 'array':\n      case 'object':\n        return 'an ' + type;\n      case 'boolean':\n      case 'date':\n      case 'regexp':\n        return 'a ' + type;\n      default:\n        return type;\n    }\n  }\n\n  // Returns class name of the object, if any.\n  function getClassName(propValue) {\n    if (!propValue.constructor || !propValue.constructor.name) {\n      return ANONYMOUS;\n    }\n    return propValue.constructor.name;\n  }\n\n  ReactPropTypes.checkPropTypes = checkPropTypes;\n  ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n"],"names":["require$$0","require$$1","require$$2","require$$3","require$$4","i","checker"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/index.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n"],"names":["require$$0","propTypesModule","require$$1","require$$2"],"mappings":";;;;;AAOA,IAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,MAAI,UAAUA,eAAmB;AAIjC,MAAI,sBAAsB;AAC1BC,YAAA,UAAiBC,+BAAA,EAAqC,QAAQ,WAAW,mBAAmB;AAC9F,OAAO;AAGLD,YAAc,UAAGE,kCAAuC;AAC1D;;;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/lib/ReactPropTypesSecret.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactPropTypesSecret.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/lib/ReactPropTypesSecret.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n"],"names":[],"mappings":";;;;;AASA,MAAI,uBAAuB;AAE3B,2BAAiB;;;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/lib/has.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/lib/has.js"],"sourcesContent":["module.exports = Function.call.bind(Object.prototype.hasOwnProperty);\n"],"names":[],"mappings":";;;;;AAAA,QAAiB,SAAS,KAAK,KAAK,OAAO,UAAU,cAAc;;;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/property-information@7.0.0/node_modules/property-information/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/property-information@7.0.0/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"],"names":["htmlBase","svgBase"],"mappings":";;;;;;;AAWY,MAAC,OAAO,MAAM,CAAC,MAAMA,QAAU,OAAO,OAAO,GAAG,GAAG,MAAM;AAKzD,MAAC,MAAM,MAAM,CAAC,MAAMC,OAAS,OAAO,OAAO,GAAG,GAAG,KAAK;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/property-information@7.0.0/node_modules/property-information/lib/aria.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aria.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/property-information@7.0.0/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"],"names":[],"mappings":";;AAGY,MAAC,OAAO,OAAO;AAAA,EACzB,YAAY;AAAA,IACV,sBAAsB;AAAA,IACtB,YAAY;AAAA,IACZ,kBAAkB;AAAA,IAClB,UAAU;AAAA,IACV,aAAa;AAAA,IACb,cAAc;AAAA,IACd,cAAc;AAAA,IACd,aAAa;AAAA,IACb,cAAc;AAAA,IACd,aAAa;AAAA,IACb,iBAAiB;AAAA,IACjB,aAAa;AAAA,IACb,cAAc;AAAA,IACd,gBAAgB;AAAA,IAChB,kBAAkB;AAAA,IAClB,cAAc;AAAA,IACd,YAAY;AAAA,IACZ,aAAa;AAAA,IACb,cAAc;AAAA,IACd,YAAY;AAAA,IACZ,aAAa;AAAA,IACb,kBAAkB;AAAA,IAClB,WAAW;AAAA,IACX,gBAAgB;AAAA,IAChB,WAAW;AAAA,IACX,UAAU;AAAA,IACV,WAAW;AAAA,IACX,eAAe;AAAA,IACf,qBAAqB;AAAA,IACrB,iBAAiB;AAAA,IACjB,UAAU;AAAA,IACV,iBAAiB;AAAA,IACjB,cAAc;AAAA,IACd,aAAa;AAAA,IACb,cAAc;AAAA,IACd,cAAc;AAAA,IACd,cAAc;AAAA,IACd,qBAAqB;AAAA,IACrB,cAAc;AAAA,IACd,cAAc;AAAA,IACd,aAAa;AAAA,IACb,cAAc;AAAA,IACd,aAAa;AAAA,IACb,UAAU;AAAA,IACV,cAAc;AAAA,IACd,cAAc;AAAA,IACd,cAAc;AAAA,IACd,eAAe;AAAA,IACf,MAAM;AAAA,EACP;AAAA,EACD,UAAU,GAAG,UAAU;AACrB,WAAO,aAAa,SAChB,WACA,UAAU,SAAS,MAAM,CAAC,EAAE,YAAW;AAAA,EAC/C;AACA,CAAC;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/property-information@7.0.0/node_modules/property-information/lib/find.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/property-information@7.0.0/node_modules/property-information/lib/find.js"],"sourcesContent":["/**\n * @import {Schema} from 'property-information'\n */\n\nimport {DefinedInfo} from './util/defined-info.js'\nimport {Info} from './util/info.js'\nimport {normalize} from './normalize.js'\n\nconst cap = /[A-Z]/g\nconst dash = /-[a-z]/g\nconst valid = /^data[-\\w.:]+$/i\n\n/**\n * Look up info on a property.\n *\n * In most cases the given `schema` contains info on the property.\n * All standard,\n * most legacy,\n * and some non-standard properties are supported.\n * For these cases,\n * the returned `Info` has hints about the value of the property.\n *\n * `name` can also be a valid data attribute or property,\n * in which case an `Info` object with the correctly cased `attribute` and\n * `property` is returned.\n *\n * `name` can be an unknown attribute,\n * in which case an `Info` object with `attribute` and `property` set to the\n * given name is returned.\n * It is not recommended to provide unsupported legacy or recently specced\n * properties.\n *\n *\n * @param {Schema} schema\n *   Schema;\n *   either the `html` or `svg` export.\n * @param {string} value\n *   An attribute-like or property-like name;\n *   it will be passed through `normalize` to hopefully find the correct info.\n * @returns {Info}\n *   Info.\n */\nexport function find(schema, value) {\n  const normal = normalize(value)\n  let property = value\n  let Type = Info\n\n  if (normal in schema.normal) {\n    return schema.property[schema.normal[normal]]\n  }\n\n  if (normal.length > 4 && normal.slice(0, 4) === 'data' && valid.test(value)) {\n    // Attribute or property.\n    if (value.charAt(4) === '-') {\n      // Turn it into a property.\n      const rest = value.slice(5).replace(dash, camelcase)\n      property = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1)\n    } else {\n      // Turn it into an attribute.\n      const rest = value.slice(4)\n\n      if (!dash.test(rest)) {\n        let dashes = rest.replace(cap, kebab)\n\n        if (dashes.charAt(0) !== '-') {\n          dashes = '-' + dashes\n        }\n\n        value = 'data' + dashes\n      }\n    }\n\n    Type = DefinedInfo\n  }\n\n  return new Type(property, value)\n}\n\n/**\n * @param {string} $0\n *   Value.\n * @returns {string}\n *   Kebab.\n */\nfunction kebab($0) {\n  return '-' + $0.toLowerCase()\n}\n\n/**\n * @param {string} $0\n *   Value.\n * @returns {string}\n *   Camel.\n */\nfunction camelcase($0) {\n  return $0.charAt(1).toUpperCase()\n}\n"],"names":[],"mappings":";;;AAQA,MAAM,MAAM;AACZ,MAAM,OAAO;AACb,MAAM,QAAQ;AAgCP,SAAS,KAAK,QAAQ,OAAO;AAClC,QAAM,SAAS,UAAU,KAAK;AAC9B,MAAI,WAAW;AACf,MAAI,OAAO;AAEX,MAAI,UAAU,OAAO,QAAQ;AAC3B,WAAO,OAAO,SAAS,OAAO,OAAO,MAAM,CAAC;AAAA,EAChD;AAEE,MAAI,OAAO,SAAS,KAAK,OAAO,MAAM,GAAG,CAAC,MAAM,UAAU,MAAM,KAAK,KAAK,GAAG;AAE3E,QAAI,MAAM,OAAO,CAAC,MAAM,KAAK;AAE3B,YAAM,OAAO,MAAM,MAAM,CAAC,EAAE,QAAQ,MAAM,SAAS;AACnD,iBAAW,SAAS,KAAK,OAAO,CAAC,EAAE,YAAa,IAAG,KAAK,MAAM,CAAC;AAAA,IACrE,OAAW;AAEL,YAAM,OAAO,MAAM,MAAM,CAAC;AAE1B,UAAI,CAAC,KAAK,KAAK,IAAI,GAAG;AACpB,YAAI,SAAS,KAAK,QAAQ,KAAK,KAAK;AAEpC,YAAI,OAAO,OAAO,CAAC,MAAM,KAAK;AAC5B,mBAAS,MAAM;AAAA,QACzB;AAEQ,gBAAQ,SAAS;AAAA,MACzB;AAAA,IACA;AAEI,WAAO;AAAA,EACX;AAEE,SAAO,IAAI,KAAK,UAAU,KAAK;AACjC;AAQA,SAAS,MAAM,IAAI;AACjB,SAAO,MAAM,GAAG,YAAW;AAC7B;AAQA,SAAS,UAAU,IAAI;AACrB,SAAO,GAAG,OAAO,CAAC,EAAE,YAAW;AACjC;","x_google_ignoreList":[0]}