@easyv/biz-components 0.0.19 → 0.0.21

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/index.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('./state.js').Options} Options\n */\n\nimport {ok as assert} from 'devlop'\nimport {footer} from './footer.js'\nimport {createState} from './state.js'\n\n/**\n * Transform mdast to hast.\n *\n * ##### Notes\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most utilities ignore `raw` nodes but two notable ones don’t:\n *\n * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful\n *     if you completely trust authors\n * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only\n *     way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `mdast-util-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * Example: headings (DOM clobbering) in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @param {MdastNodes} tree\n *   mdast tree.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {HastNodes}\n *   hast tree.\n */\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, undefined)\n  const foot = footer(state)\n  /** @type {HastNodes} */\n  const result = Array.isArray(node)\n    ? {type: 'root', children: node}\n    : node || {type: 'root', children: []}\n\n  if (foot) {\n    // If there’s a footer, there were definitions, meaning block\n    // content.\n    // So `result` is a parent node.\n    assert('children' in result)\n    result.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  return result\n}\n"],"names":["toHast","tree","options","state","createState","node","foot","footer","result"],"mappings":";;AAuFO,SAASA,EAAOC,GAAMC,GAAS;AACpC,QAAMC,IAAQC,EAAYH,GAAMC,CAAO,GACjCG,IAAOF,EAAM,IAAIF,GAAM,MAAS,GAChCK,IAAOC,EAAOJ,CAAK,GAEnBK,IAAS,MAAM,QAAQH,CAAI,IAC7B,EAAC,MAAM,QAAQ,UAAUA,EAAI,IAC7BA,KAAQ,EAAC,MAAM,QAAQ,UAAU,CAAE,EAAA;AAEvC,SAAIC,KAKFE,EAAO,SAAS,KAAK,EAAC,MAAM,QAAQ,OAAO;AAAA,EAAI,GAAGF,CAAI,GAGjDE;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('./state.js').Options} Options\n */\n\nimport {ok as assert} from 'devlop'\nimport {footer} from './footer.js'\nimport {createState} from './state.js'\n\n/**\n * Transform mdast to hast.\n *\n * ##### Notes\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most utilities ignore `raw` nodes but two notable ones don’t:\n *\n * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful\n *     if you completely trust authors\n * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only\n *     way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `mdast-util-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * Example: headings (DOM clobbering) in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @param {MdastNodes} tree\n *   mdast tree.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {HastNodes}\n *   hast tree.\n */\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, undefined)\n  const foot = footer(state)\n  /** @type {HastNodes} */\n  const result = Array.isArray(node)\n    ? {type: 'root', children: node}\n    : node || {type: 'root', children: []}\n\n  if (foot) {\n    // If there’s a footer, there were definitions, meaning block\n    // content.\n    // So `result` is a parent node.\n    assert('children' in result)\n    result.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  return result\n}\n"],"names":[],"mappings":";;AAuFO,SAAS,OAAO,MAAM,SAAS;AACpC,QAAM,QAAQ,YAAY,MAAM,OAAO;AACvC,QAAM,OAAO,MAAM,IAAI,MAAM,MAAS;AACtC,QAAM,OAAO,OAAO,KAAK;AAEzB,QAAM,SAAS,MAAM,QAAQ,IAAI,IAC7B,EAAC,MAAM,QAAQ,UAAU,KAAI,IAC7B,QAAQ,EAAC,MAAM,QAAQ,UAAU,CAAE,EAAA;AAEvC,MAAI,MAAM;AAKR,WAAO,SAAS,KAAK,EAAC,MAAM,QAAQ,OAAO,KAAI,GAAG,IAAI;AAAA,EAC1D;AAEE,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/revert.es.js

@@ -1,14 +1,30 @@
-function s(i, e) {
-  const f = e.referenceType;
-  let l = "]";
-  if (f === "collapsed" ? l += "[]" : f === "full" && (l += "[" + (e.label || e.identifier) + "]"), e.type === "imageReference")
-    return [{ type: "text", value: "![" + e.alt + l }];
-  const t = i.all(e), u = t[0];
-  u && u.type === "text" ? u.value = "[" + u.value : t.unshift({ type: "text", value: "[" });
-  const a = t[t.length - 1];
-  return a && a.type === "text" ? a.value += l : t.push({ type: "text", value: l }), t;
+function revert(state, node) {
+  const subtype = node.referenceType;
+  let suffix = "]";
+  if (subtype === "collapsed") {
+    suffix += "[]";
+  } else if (subtype === "full") {
+    suffix += "[" + (node.label || node.identifier) + "]";
+  }
+  if (node.type === "imageReference") {
+    return [{ type: "text", value: "![" + node.alt + suffix }];
+  }
+  const contents = state.all(node);
+  const head = contents[0];
+  if (head && head.type === "text") {
+    head.value = "[" + head.value;
+  } else {
+    contents.unshift({ type: "text", value: "[" });
+  }
+  const tail = contents[contents.length - 1];
+  if (tail && tail.type === "text") {
+    tail.value += suffix;
+  } else {
+    contents.push({ type: "text", value: suffix });
+  }
+  return contents;
 }
 export {
-  s as revert
+  revert
 };
 //# sourceMappingURL=revert.es.js.map

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/revert.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"revert.es.js","sources":["../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/revert.js"],"sourcesContent":["/**\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Reference} Reference\n *\n * @typedef {import('./state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Extract<Nodes, Reference>} node\n *   Reference node (image, link).\n * @returns {Array<ElementContent>}\n *   hast content.\n */\nexport function revert(state, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return [{type: 'text', value: '![' + node.alt + suffix}]\n  }\n\n  const contents = state.all(node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift({type: 'text', value: '['})\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push({type: 'text', value: suffix})\n  }\n\n  return contents\n}\n"],"names":["revert","state","node","subtype","suffix","contents","head","tail"],"mappings":"AAsBO,SAASA,EAAOC,GAAOC,GAAM;AAClC,QAAMC,IAAUD,EAAK;AACrB,MAAIE,IAAS;AAQb,MANID,MAAY,cACdC,KAAU,OACDD,MAAY,WACrBC,KAAU,OAAOF,EAAK,SAASA,EAAK,cAAc,MAGhDA,EAAK,SAAS;AAChB,WAAO,CAAC,EAAC,MAAM,QAAQ,OAAO,OAAOA,EAAK,MAAME,EAAM,CAAC;AAGzD,QAAMC,IAAWJ,EAAM,IAAIC,CAAI,GACzBI,IAAOD,EAAS,CAAC;AAEvB,EAAIC,KAAQA,EAAK,SAAS,SACxBA,EAAK,QAAQ,MAAMA,EAAK,QAExBD,EAAS,QAAQ,EAAC,MAAM,QAAQ,OAAO,IAAG,CAAC;AAG7C,QAAME,IAAOF,EAASA,EAAS,SAAS,CAAC;AAEzC,SAAIE,KAAQA,EAAK,SAAS,SACxBA,EAAK,SAASH,IAEdC,EAAS,KAAK,EAAC,MAAM,QAAQ,OAAOD,EAAM,CAAC,GAGtCC;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"revert.es.js","sources":["../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/revert.js"],"sourcesContent":["/**\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Reference} Reference\n *\n * @typedef {import('./state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Extract<Nodes, Reference>} node\n *   Reference node (image, link).\n * @returns {Array<ElementContent>}\n *   hast content.\n */\nexport function revert(state, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return [{type: 'text', value: '![' + node.alt + suffix}]\n  }\n\n  const contents = state.all(node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift({type: 'text', value: '['})\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push({type: 'text', value: suffix})\n  }\n\n  return contents\n}\n"],"names":[],"mappings":"AAsBO,SAAS,OAAO,OAAO,MAAM;AAClC,QAAM,UAAU,KAAK;AACrB,MAAI,SAAS;AAEb,MAAI,YAAY,aAAa;AAC3B,cAAU;AAAA,EACd,WAAa,YAAY,QAAQ;AAC7B,cAAU,OAAO,KAAK,SAAS,KAAK,cAAc;AAAA,EACtD;AAEE,MAAI,KAAK,SAAS,kBAAkB;AAClC,WAAO,CAAC,EAAC,MAAM,QAAQ,OAAO,OAAO,KAAK,MAAM,OAAM,CAAC;AAAA,EAC3D;AAEE,QAAM,WAAW,MAAM,IAAI,IAAI;AAC/B,QAAM,OAAO,SAAS,CAAC;AAEvB,MAAI,QAAQ,KAAK,SAAS,QAAQ;AAChC,SAAK,QAAQ,MAAM,KAAK;AAAA,EAC5B,OAAS;AACL,aAAS,QAAQ,EAAC,MAAM,QAAQ,OAAO,IAAG,CAAC;AAAA,EAC/C;AAEE,QAAM,OAAO,SAAS,SAAS,SAAS,CAAC;AAEzC,MAAI,QAAQ,KAAK,SAAS,QAAQ;AAChC,SAAK,SAAS;AAAA,EAClB,OAAS;AACL,aAAS,KAAK,EAAC,MAAM,QAAQ,OAAO,OAAM,CAAC;AAAA,EAC/C;AAEE,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/state.es.js

@@ -1,105 +1,149 @@
-import d from "../../../../@ungap_structured-clone@1.3.0/node_modules/@ungap/structured-clone/esm/index.es.js";
-import { handlers as A } from "./handlers/index.es.js";
-import { visit as C } from "../../../../unist-util-visit@5.0.0/node_modules/unist-util-visit/lib/index.es.js";
-import { position as k } from "../../../../unist-util-position@5.0.0/node_modules/unist-util-position/lib/index.es.js";
-const y = {}.hasOwnProperty, N = {};
-function I(e, n) {
-  const t = n || N, r = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), f = { ...A, ...t.handlers }, l = {
-    all: v,
-    applyData: O,
-    definitionById: r,
-    footnoteById: p,
-    footnoteCounts: u,
+import structuredClone from "../../../../@ungap_structured-clone@1.3.0/node_modules/@ungap/structured-clone/esm/index.es.js";
+import { handlers } from "./handlers/index.es.js";
+import { visit } from "../../../../unist-util-visit@5.0.0/node_modules/unist-util-visit/lib/index.es.js";
+import { position } from "../../../../unist-util-position@5.0.0/node_modules/unist-util-position/lib/index.es.js";
+const own = {}.hasOwnProperty;
+const emptyOptions = {};
+function createState(tree, options) {
+  const settings = options || emptyOptions;
+  const definitionById = /* @__PURE__ */ new Map();
+  const footnoteById = /* @__PURE__ */ new Map();
+  const footnoteCounts = /* @__PURE__ */ new Map();
+  const handlers$1 = { ...handlers, ...settings.handlers };
+  const state = {
+    all,
+    applyData,
+    definitionById,
+    footnoteById,
+    footnoteCounts,
     footnoteOrder: [],
-    handlers: f,
-    one: g,
-    options: t,
-    patch: M,
-    wrap: S
+    handlers: handlers$1,
+    one,
+    options: settings,
+    patch,
+    wrap
   };
-  return C(e, function(i) {
-    if (i.type === "definition" || i.type === "footnoteDefinition") {
-      const a = i.type === "definition" ? r : p, o = String(i.identifier).toUpperCase();
-      a.has(o) || a.set(o, i);
+  visit(tree, function(node) {
+    if (node.type === "definition" || node.type === "footnoteDefinition") {
+      const map = node.type === "definition" ? definitionById : footnoteById;
+      const id = String(node.identifier).toUpperCase();
+      if (!map.has(id)) {
+        map.set(id, node);
+      }
+    }
+  });
+  return state;
+  function one(node, parent) {
+    const type = node.type;
+    const handle = state.handlers[type];
+    if (own.call(state.handlers, type) && handle) {
+      return handle(state, node, parent);
     }
-  }), l;
-  function g(i, a) {
-    const o = i.type, c = l.handlers[o];
-    if (y.call(l.handlers, o) && c)
-      return c(l, i, a);
-    if (l.options.passThrough && l.options.passThrough.includes(o)) {
-      if ("children" in i) {
-        const { children: h, ...x } = i, m = d(x);
-        return m.children = l.all(i), m;
+    if (state.options.passThrough && state.options.passThrough.includes(type)) {
+      if ("children" in node) {
+        const { children, ...shallow } = node;
+        const result = structuredClone(shallow);
+        result.children = state.all(node);
+        return result;
       }
-      return d(i);
+      return structuredClone(node);
     }
-    return (l.options.unknownHandler || P)(l, i, a);
+    const unknown = state.options.unknownHandler || defaultUnknownHandler;
+    return unknown(state, node, parent);
   }
-  function v(i) {
-    const a = [];
-    if ("children" in i) {
-      const o = i.children;
-      let c = -1;
-      for (; ++c < o.length; ) {
-        const s = l.one(o[c], i);
-        if (s) {
-          if (c && o[c - 1].type === "break" && (!Array.isArray(s) && s.type === "text" && (s.value = w(s.value)), !Array.isArray(s) && s.type === "element")) {
-            const h = s.children[0];
-            h && h.type === "text" && (h.value = w(h.value));
+  function all(parent) {
+    const values = [];
+    if ("children" in parent) {
+      const nodes = parent.children;
+      let index = -1;
+      while (++index < nodes.length) {
+        const result = state.one(nodes[index], parent);
+        if (result) {
+          if (index && nodes[index - 1].type === "break") {
+            if (!Array.isArray(result) && result.type === "text") {
+              result.value = trimMarkdownSpaceStart(result.value);
+            }
+            if (!Array.isArray(result) && result.type === "element") {
+              const head = result.children[0];
+              if (head && head.type === "text") {
+                head.value = trimMarkdownSpaceStart(head.value);
+              }
+            }
+          }
+          if (Array.isArray(result)) {
+            values.push(...result);
+          } else {
+            values.push(result);
           }
-          Array.isArray(s) ? a.push(...s) : a.push(s);
         }
       }
     }
-    return a;
+    return values;
   }
 }
-function M(e, n) {
-  e.position && (n.position = k(e));
+function patch(from, to) {
+  if (from.position) to.position = position(from);
 }
-function O(e, n) {
-  let t = n;
-  if (e && e.data) {
-    const r = e.data.hName, p = e.data.hChildren, u = e.data.hProperties;
-    if (typeof r == "string")
-      if (t.type === "element")
-        t.tagName = r;
-      else {
-        const f = "children" in t ? t.children : [t];
-        t = { type: "element", tagName: r, properties: {}, children: f };
+function applyData(from, to) {
+  let result = to;
+  if (from && from.data) {
+    const hName = from.data.hName;
+    const hChildren = from.data.hChildren;
+    const hProperties = from.data.hProperties;
+    if (typeof hName === "string") {
+      if (result.type === "element") {
+        result.tagName = hName;
+      } else {
+        const children = "children" in result ? result.children : [result];
+        result = { type: "element", tagName: hName, properties: {}, children };
       }
-    t.type === "element" && u && Object.assign(t.properties, d(u)), "children" in t && t.children && p !== null && p !== void 0 && (t.children = p);
+    }
+    if (result.type === "element" && hProperties) {
+      Object.assign(result.properties, structuredClone(hProperties));
+    }
+    if ("children" in result && result.children && hChildren !== null && hChildren !== void 0) {
+      result.children = hChildren;
+    }
   }
-  return t;
+  return result;
 }
-function P(e, n) {
-  const t = n.data || {}, r = "value" in n && !(y.call(t, "hProperties") || y.call(t, "hChildren")) ? { type: "text", value: n.value } : {
+function defaultUnknownHandler(state, node) {
+  const data = node.data || {};
+  const result = "value" in node && !(own.call(data, "hProperties") || own.call(data, "hChildren")) ? { type: "text", value: node.value } : {
     type: "element",
     tagName: "div",
     properties: {},
-    children: e.all(n)
+    children: state.all(node)
   };
-  return e.patch(n, r), e.applyData(n, r);
+  state.patch(node, result);
+  return state.applyData(node, result);
 }
-function S(e, n) {
-  const t = [];
-  let r = -1;
-  for (n && t.push({ type: "text", value: `
-` }); ++r < e.length; )
-    r && t.push({ type: "text", value: `
-` }), t.push(e[r]);
-  return n && e.length > 0 && t.push({ type: "text", value: `
-` }), t;
+function wrap(nodes, loose) {
+  const result = [];
+  let index = -1;
+  if (loose) {
+    result.push({ type: "text", value: "\n" });
+  }
+  while (++index < nodes.length) {
+    if (index) result.push({ type: "text", value: "\n" });
+    result.push(nodes[index]);
+  }
+  if (loose && nodes.length > 0) {
+    result.push({ type: "text", value: "\n" });
+  }
+  return result;
 }
-function w(e) {
-  let n = 0, t = e.charCodeAt(n);
-  for (; t === 9 || t === 32; )
-    n++, t = e.charCodeAt(n);
-  return e.slice(n);
+function trimMarkdownSpaceStart(value) {
+  let index = 0;
+  let code = value.charCodeAt(index);
+  while (code === 9 || code === 32) {
+    index++;
+    code = value.charCodeAt(index);
+  }
+  return value.slice(index);
 }
 export {
-  I as createState,
-  S as wrap
+  createState,
+  wrap
 };
 //# sourceMappingURL=state.es.js.map

package/dist/node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/state.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"state.es.js","sources":["../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/state.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('hast').Properties} HastProperties\n * @typedef {import('hast').RootContent} HastRootContent\n * @typedef {import('hast').Text} HastText\n *\n * @typedef {import('mdast').Definition} MdastDefinition\n * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('mdast').Parents} MdastParents\n *\n * @typedef {import('vfile').VFile} VFile\n *\n * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate\n * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate\n */\n\n/**\n * @callback Handler\n *   Handle a node.\n * @param {State} state\n *   Info passed around.\n * @param {any} node\n *   mdast node to handle.\n * @param {MdastParents | undefined} parent\n *   Parent of `node`.\n * @returns {Array<HastElementContent> | HastElementContent | undefined}\n *   hast node.\n *\n * @typedef {Partial<Record<MdastNodes['type'], Handler>>} Handlers\n *   Handle nodes.\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [allowDangerousHtml=false]\n *   Whether to persist raw HTML in markdown in the hast tree (default:\n *   `false`).\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` property on footnotes to prevent them from\n *   *clobbering* (default: `'user-content-'`).\n *\n *   Pass `''` for trusted markdown and when you are careful with\n *   polyfilling.\n *   You could pass a different prefix.\n *\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=\"x\"></p>\n *   <script>alert(x) // `x` now refers to the `p#x` DOM element</script>\n *   ```\n *\n *   The above example shows that elements are made available by browsers, by\n *   their ID, on the `window` object.\n *   This is a security risk because you might be expecting some other variable\n *   at that place.\n *   It can also break polyfills.\n *   Using a prefix solves these problems.\n * @property {VFile | null | undefined} [file]\n *   Corresponding virtual file representing the input document (optional).\n * @property {FootnoteBackContentTemplate | string | null | undefined} [footnoteBackContent]\n *   Content of the backreference back to references (default: `defaultFootnoteBackContent`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackContent(_, rereferenceIndex) {\n *     const result = [{type: 'text', value: '↩'}]\n *\n *     if (rereferenceIndex > 1) {\n *       result.push({\n *         type: 'element',\n *         tagName: 'sup',\n *         properties: {},\n *         children: [{type: 'text', value: String(rereferenceIndex)}]\n *       })\n *     }\n *\n *     return result\n *   }\n *   ```\n *\n *   This content is used in the `a` element of each backreference (the `↩`\n *   links).\n * @property {FootnoteBackLabelTemplate | string | null | undefined} [footnoteBackLabel]\n *   Label to describe the backreference back to references (default:\n *   `defaultFootnoteBackLabel`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n *    return (\n *      'Back to reference ' +\n *      (referenceIndex + 1) +\n *      (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n *    )\n *   }\n *   ```\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is used in the `ariaLabel` property on each backreference\n *   (the `↩` links).\n *   It affects users of assistive technology.\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Textual label to use for the footnotes section (default: `'Footnotes'`).\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (default: `{className:\n *   ['sr-only']}`).\n *\n *   Change it to show the label and add other properties.\n *\n *   This label is typically hidden visually (assuming an `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass an empty string.\n *   You can also add different properties.\n *\n *   > **Note**: `id: 'footnote-label'` is always added, because footnote\n *   > calls use it with `aria-describedby` to provide an accessible label.\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   HTML tag name to use for the footnote label element (default: `'h2'`).\n *\n *   Change it to match your document structure.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes (optional).\n * @property {Array<MdastNodes['type']> | null | undefined} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast (note that\n *   the node itself is passed, but eventual children are transformed)\n *   (optional).\n * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes (optional).\n *\n * @typedef State\n *   Info passed around.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {Map<string, MdastDefinition>} definitionById\n *   Definitions by their identifier.\n * @property {Map<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Map<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {(node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined} one\n *   Transform an mdast node to hast.\n * @property {Options} options\n *   Configuration.\n * @property {(from: MdastNodes, node: HastNodes) => undefined} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {visit} from 'unist-util-visit'\nimport {position} from 'unist-util-position'\nimport {handlers as defaultHandlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Create `state` from an mdast tree.\n *\n * @param {MdastNodes} tree\n *   mdast node to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || emptyOptions\n  /** @type {Map<string, MdastDefinition>} */\n  const definitionById = new Map()\n  /** @type {Map<string, MdastFootnoteDefinition>} */\n  const footnoteById = new Map()\n  /** @type {Map<string, number>} */\n  const footnoteCounts = new Map()\n  /** @type {Handlers} */\n  // @ts-expect-error: the root handler returns a root.\n  // Hard to type.\n  const handlers = {...defaultHandlers, ...settings.handlers}\n\n  /** @type {State} */\n  const state = {\n    all,\n    applyData,\n    definitionById,\n    footnoteById,\n    footnoteCounts,\n    footnoteOrder: [],\n    handlers,\n    one,\n    options: settings,\n    patch,\n    wrap\n  }\n\n  visit(tree, function (node) {\n    if (node.type === 'definition' || node.type === 'footnoteDefinition') {\n      const map = node.type === 'definition' ? definitionById : footnoteById\n      const id = String(node.identifier).toUpperCase()\n\n      // Mimick CM behavior of link definitions.\n      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.\n      if (!map.has(id)) {\n        // @ts-expect-error: node type matches map.\n        map.set(id, node)\n      }\n    }\n  })\n\n  return state\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {Array<HastElementContent> | HastElementContent | undefined}\n   *   Resulting hast node.\n   */\n  function one(node, parent) {\n    const type = node.type\n    const handle = state.handlers[type]\n\n    if (own.call(state.handlers, type) && handle) {\n      return handle(state, node, parent)\n    }\n\n    if (state.options.passThrough && state.options.passThrough.includes(type)) {\n      if ('children' in node) {\n        const {children, ...shallow} = node\n        const result = structuredClone(shallow)\n        // @ts-expect-error: TS doesn’t understand…\n        result.children = state.all(node)\n        // @ts-expect-error: TS doesn’t understand…\n        return result\n      }\n\n      // @ts-expect-error: it’s custom.\n      return structuredClone(node)\n    }\n\n    const unknown = state.options.unknownHandler || defaultUnknownHandler\n\n    return unknown(state, node, parent)\n  }\n\n  /**\n   * Transform the children of an mdast node into hast nodes.\n   *\n   * @param {MdastNodes} parent\n   *   mdast node to compile\n   * @returns {Array<HastElementContent>}\n   *   Resulting hast nodes.\n   */\n  function all(parent) {\n    /** @type {Array<HastElementContent>} */\n    const values = []\n\n    if ('children' in parent) {\n      const nodes = parent.children\n      let index = -1\n      while (++index < nodes.length) {\n        const result = state.one(nodes[index], parent)\n\n        // To do: see if we van clean this? Can we merge texts?\n        if (result) {\n          if (index && nodes[index - 1].type === 'break') {\n            if (!Array.isArray(result) && result.type === 'text') {\n              result.value = trimMarkdownSpaceStart(result.value)\n            }\n\n            if (!Array.isArray(result) && result.type === 'element') {\n              const head = result.children[0]\n\n              if (head && head.type === 'text') {\n                head.value = trimMarkdownSpaceStart(head.value)\n              }\n            }\n          }\n\n          if (Array.isArray(result)) {\n            values.push(...result)\n          } else {\n            values.push(result)\n          }\n        }\n      }\n    }\n\n    return values\n  }\n}\n\n/**\n * Copy a node’s positional info.\n *\n * @param {MdastNodes} from\n *   mdast node to copy from.\n * @param {HastNodes} to\n *   hast node to copy into.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(from, to) {\n  if (from.position) to.position = position(from)\n}\n\n/**\n * Honor the `data` of `from` and maybe generate an element instead of `to`.\n *\n * @template {HastNodes} Type\n *   Node type.\n * @param {MdastNodes} from\n *   mdast node to use data from.\n * @param {Type} to\n *   hast node to change.\n * @returns {HastElement | Type}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {HastElement | Type} */\n  let result = to\n\n  // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n  if (from && from.data) {\n    const hName = from.data.hName\n    const hChildren = from.data.hChildren\n    const hProperties = from.data.hProperties\n\n    if (typeof hName === 'string') {\n      // Transforming the node resulted in an element with a different name\n      // than wanted:\n      if (result.type === 'element') {\n        result.tagName = hName\n      }\n      // Transforming the node resulted in a non-element, which happens for\n      // raw, text, and root nodes (unless custom handlers are passed).\n      // The intent of `hName` is to create an element, but likely also to keep\n      // the content around (otherwise: pass `hChildren`).\n      else {\n        /** @type {Array<HastElementContent>} */\n        // @ts-expect-error: assume no doctypes in `root`.\n        const children = 'children' in result ? result.children : [result]\n        result = {type: 'element', tagName: hName, properties: {}, children}\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      Object.assign(result.properties, structuredClone(hProperties))\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      result.children = hChildren\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform an unknown node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   Unknown mdast node.\n * @returns {HastElement | HastText}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastElement | HastText} */\n  const result =\n    'value' in node &&\n    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))\n      ? {type: 'text', value: node.value}\n      : {\n          type: 'element',\n          tagName: 'div',\n          properties: {},\n          children: state.all(node)\n        }\n\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * Wrap `nodes` with line endings between each node.\n *\n * @template {HastRootContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | undefined} [loose=false]\n *   Whether to add line endings at start and end (default: `false`).\n * @returns {Array<HastText | Type>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<HastText | Type>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push({type: 'text', value: '\\n'})\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  return result\n}\n\n/**\n * Trim spaces and tabs at the start of `value`.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Result.\n */\nfunction trimMarkdownSpaceStart(value) {\n  let index = 0\n  let code = value.charCodeAt(index)\n\n  while (code === 9 || code === 32) {\n    index++\n    code = value.charCodeAt(index)\n  }\n\n  return value.slice(index)\n}\n"],"names":["own","emptyOptions","createState","tree","options","settings","definitionById","footnoteById","footnoteCounts","handlers","defaultHandlers","state","all","applyData","one","patch","wrap","visit","node","map","id","parent","type","handle","children","shallow","result","structuredClone","defaultUnknownHandler","values","nodes","index","trimMarkdownSpaceStart","head","from","to","position","hName","hChildren","hProperties","data","loose","value","code"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"state.es.js","sources":["../../../../../../../../../node_modules/.pnpm/mdast-util-to-hast@13.2.0/node_modules/mdast-util-to-hast/lib/state.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('hast').Properties} HastProperties\n * @typedef {import('hast').RootContent} HastRootContent\n * @typedef {import('hast').Text} HastText\n *\n * @typedef {import('mdast').Definition} MdastDefinition\n * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('mdast').Parents} MdastParents\n *\n * @typedef {import('vfile').VFile} VFile\n *\n * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate\n * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate\n */\n\n/**\n * @callback Handler\n *   Handle a node.\n * @param {State} state\n *   Info passed around.\n * @param {any} node\n *   mdast node to handle.\n * @param {MdastParents | undefined} parent\n *   Parent of `node`.\n * @returns {Array<HastElementContent> | HastElementContent | undefined}\n *   hast node.\n *\n * @typedef {Partial<Record<MdastNodes['type'], Handler>>} Handlers\n *   Handle nodes.\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [allowDangerousHtml=false]\n *   Whether to persist raw HTML in markdown in the hast tree (default:\n *   `false`).\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` property on footnotes to prevent them from\n *   *clobbering* (default: `'user-content-'`).\n *\n *   Pass `''` for trusted markdown and when you are careful with\n *   polyfilling.\n *   You could pass a different prefix.\n *\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=\"x\"></p>\n *   <script>alert(x) // `x` now refers to the `p#x` DOM element</script>\n *   ```\n *\n *   The above example shows that elements are made available by browsers, by\n *   their ID, on the `window` object.\n *   This is a security risk because you might be expecting some other variable\n *   at that place.\n *   It can also break polyfills.\n *   Using a prefix solves these problems.\n * @property {VFile | null | undefined} [file]\n *   Corresponding virtual file representing the input document (optional).\n * @property {FootnoteBackContentTemplate | string | null | undefined} [footnoteBackContent]\n *   Content of the backreference back to references (default: `defaultFootnoteBackContent`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackContent(_, rereferenceIndex) {\n *     const result = [{type: 'text', value: '↩'}]\n *\n *     if (rereferenceIndex > 1) {\n *       result.push({\n *         type: 'element',\n *         tagName: 'sup',\n *         properties: {},\n *         children: [{type: 'text', value: String(rereferenceIndex)}]\n *       })\n *     }\n *\n *     return result\n *   }\n *   ```\n *\n *   This content is used in the `a` element of each backreference (the `↩`\n *   links).\n * @property {FootnoteBackLabelTemplate | string | null | undefined} [footnoteBackLabel]\n *   Label to describe the backreference back to references (default:\n *   `defaultFootnoteBackLabel`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n *    return (\n *      'Back to reference ' +\n *      (referenceIndex + 1) +\n *      (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n *    )\n *   }\n *   ```\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is used in the `ariaLabel` property on each backreference\n *   (the `↩` links).\n *   It affects users of assistive technology.\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Textual label to use for the footnotes section (default: `'Footnotes'`).\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (default: `{className:\n *   ['sr-only']}`).\n *\n *   Change it to show the label and add other properties.\n *\n *   This label is typically hidden visually (assuming an `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass an empty string.\n *   You can also add different properties.\n *\n *   > **Note**: `id: 'footnote-label'` is always added, because footnote\n *   > calls use it with `aria-describedby` to provide an accessible label.\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   HTML tag name to use for the footnote label element (default: `'h2'`).\n *\n *   Change it to match your document structure.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes (optional).\n * @property {Array<MdastNodes['type']> | null | undefined} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast (note that\n *   the node itself is passed, but eventual children are transformed)\n *   (optional).\n * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes (optional).\n *\n * @typedef State\n *   Info passed around.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {Map<string, MdastDefinition>} definitionById\n *   Definitions by their identifier.\n * @property {Map<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Map<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {(node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined} one\n *   Transform an mdast node to hast.\n * @property {Options} options\n *   Configuration.\n * @property {(from: MdastNodes, node: HastNodes) => undefined} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {visit} from 'unist-util-visit'\nimport {position} from 'unist-util-position'\nimport {handlers as defaultHandlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Create `state` from an mdast tree.\n *\n * @param {MdastNodes} tree\n *   mdast node to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || emptyOptions\n  /** @type {Map<string, MdastDefinition>} */\n  const definitionById = new Map()\n  /** @type {Map<string, MdastFootnoteDefinition>} */\n  const footnoteById = new Map()\n  /** @type {Map<string, number>} */\n  const footnoteCounts = new Map()\n  /** @type {Handlers} */\n  // @ts-expect-error: the root handler returns a root.\n  // Hard to type.\n  const handlers = {...defaultHandlers, ...settings.handlers}\n\n  /** @type {State} */\n  const state = {\n    all,\n    applyData,\n    definitionById,\n    footnoteById,\n    footnoteCounts,\n    footnoteOrder: [],\n    handlers,\n    one,\n    options: settings,\n    patch,\n    wrap\n  }\n\n  visit(tree, function (node) {\n    if (node.type === 'definition' || node.type === 'footnoteDefinition') {\n      const map = node.type === 'definition' ? definitionById : footnoteById\n      const id = String(node.identifier).toUpperCase()\n\n      // Mimick CM behavior of link definitions.\n      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.\n      if (!map.has(id)) {\n        // @ts-expect-error: node type matches map.\n        map.set(id, node)\n      }\n    }\n  })\n\n  return state\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {Array<HastElementContent> | HastElementContent | undefined}\n   *   Resulting hast node.\n   */\n  function one(node, parent) {\n    const type = node.type\n    const handle = state.handlers[type]\n\n    if (own.call(state.handlers, type) && handle) {\n      return handle(state, node, parent)\n    }\n\n    if (state.options.passThrough && state.options.passThrough.includes(type)) {\n      if ('children' in node) {\n        const {children, ...shallow} = node\n        const result = structuredClone(shallow)\n        // @ts-expect-error: TS doesn’t understand…\n        result.children = state.all(node)\n        // @ts-expect-error: TS doesn’t understand…\n        return result\n      }\n\n      // @ts-expect-error: it’s custom.\n      return structuredClone(node)\n    }\n\n    const unknown = state.options.unknownHandler || defaultUnknownHandler\n\n    return unknown(state, node, parent)\n  }\n\n  /**\n   * Transform the children of an mdast node into hast nodes.\n   *\n   * @param {MdastNodes} parent\n   *   mdast node to compile\n   * @returns {Array<HastElementContent>}\n   *   Resulting hast nodes.\n   */\n  function all(parent) {\n    /** @type {Array<HastElementContent>} */\n    const values = []\n\n    if ('children' in parent) {\n      const nodes = parent.children\n      let index = -1\n      while (++index < nodes.length) {\n        const result = state.one(nodes[index], parent)\n\n        // To do: see if we van clean this? Can we merge texts?\n        if (result) {\n          if (index && nodes[index - 1].type === 'break') {\n            if (!Array.isArray(result) && result.type === 'text') {\n              result.value = trimMarkdownSpaceStart(result.value)\n            }\n\n            if (!Array.isArray(result) && result.type === 'element') {\n              const head = result.children[0]\n\n              if (head && head.type === 'text') {\n                head.value = trimMarkdownSpaceStart(head.value)\n              }\n            }\n          }\n\n          if (Array.isArray(result)) {\n            values.push(...result)\n          } else {\n            values.push(result)\n          }\n        }\n      }\n    }\n\n    return values\n  }\n}\n\n/**\n * Copy a node’s positional info.\n *\n * @param {MdastNodes} from\n *   mdast node to copy from.\n * @param {HastNodes} to\n *   hast node to copy into.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(from, to) {\n  if (from.position) to.position = position(from)\n}\n\n/**\n * Honor the `data` of `from` and maybe generate an element instead of `to`.\n *\n * @template {HastNodes} Type\n *   Node type.\n * @param {MdastNodes} from\n *   mdast node to use data from.\n * @param {Type} to\n *   hast node to change.\n * @returns {HastElement | Type}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {HastElement | Type} */\n  let result = to\n\n  // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n  if (from && from.data) {\n    const hName = from.data.hName\n    const hChildren = from.data.hChildren\n    const hProperties = from.data.hProperties\n\n    if (typeof hName === 'string') {\n      // Transforming the node resulted in an element with a different name\n      // than wanted:\n      if (result.type === 'element') {\n        result.tagName = hName\n      }\n      // Transforming the node resulted in a non-element, which happens for\n      // raw, text, and root nodes (unless custom handlers are passed).\n      // The intent of `hName` is to create an element, but likely also to keep\n      // the content around (otherwise: pass `hChildren`).\n      else {\n        /** @type {Array<HastElementContent>} */\n        // @ts-expect-error: assume no doctypes in `root`.\n        const children = 'children' in result ? result.children : [result]\n        result = {type: 'element', tagName: hName, properties: {}, children}\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      Object.assign(result.properties, structuredClone(hProperties))\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      result.children = hChildren\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform an unknown node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   Unknown mdast node.\n * @returns {HastElement | HastText}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastElement | HastText} */\n  const result =\n    'value' in node &&\n    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))\n      ? {type: 'text', value: node.value}\n      : {\n          type: 'element',\n          tagName: 'div',\n          properties: {},\n          children: state.all(node)\n        }\n\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * Wrap `nodes` with line endings between each node.\n *\n * @template {HastRootContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | undefined} [loose=false]\n *   Whether to add line endings at start and end (default: `false`).\n * @returns {Array<HastText | Type>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<HastText | Type>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push({type: 'text', value: '\\n'})\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  return result\n}\n\n/**\n * Trim spaces and tabs at the start of `value`.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Result.\n */\nfunction trimMarkdownSpaceStart(value) {\n  let index = 0\n  let code = value.charCodeAt(index)\n\n  while (code === 9 || code === 32) {\n    index++\n    code = value.charCodeAt(index)\n  }\n\n  return value.slice(index)\n}\n"],"names":["handlers","defaultHandlers"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/blockquote.es.js

@@ -1,16 +1,19 @@
-function k(e, o, n, c) {
-  const t = n.enter("blockquote"), r = n.createTracker(c);
-  r.move("> "), r.shift(2);
-  const u = n.indentLines(
-    n.containerFlow(e, r.current()),
-    i
+function blockquote(node, _, state, info) {
+  const exit = state.enter("blockquote");
+  const tracker = state.createTracker(info);
+  tracker.move("> ");
+  tracker.shift(2);
+  const value = state.indentLines(
+    state.containerFlow(node, tracker.current()),
+    map
   );
-  return t(), u;
+  exit();
+  return value;
 }
-function i(e, o, n) {
-  return ">" + (n ? "" : " ") + e;
+function map(line, _, blank) {
+  return ">" + (blank ? "" : " ") + line;
 }
 export {
-  k as blockquote
+  blockquote
 };
 //# sourceMappingURL=blockquote.es.js.map

package/dist/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/blockquote.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"blockquote.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/blockquote.js"],"sourcesContent":["/**\n * @import {Blockquote, Parents} from 'mdast'\n * @import {Info, Map, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {Blockquote} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function blockquote(node, _, state, info) {\n  const exit = state.enter('blockquote')\n  const tracker = state.createTracker(info)\n  tracker.move('> ')\n  tracker.shift(2)\n  const value = state.indentLines(\n    state.containerFlow(node, tracker.current()),\n    map\n  )\n  exit()\n  return value\n}\n\n/** @type {Map} */\nfunction map(line, _, blank) {\n  return '>' + (blank ? '' : ' ') + line\n}\n"],"names":["blockquote","node","_","state","info","exit","tracker","value","map","line","blank"],"mappings":"AAYO,SAASA,EAAWC,GAAMC,GAAGC,GAAOC,GAAM;AAC/C,QAAMC,IAAOF,EAAM,MAAM,YAAY,GAC/BG,IAAUH,EAAM,cAAcC,CAAI;AACxC,EAAAE,EAAQ,KAAK,IAAI,GACjBA,EAAQ,MAAM,CAAC;AACf,QAAMC,IAAQJ,EAAM;AAAA,IAClBA,EAAM,cAAcF,GAAMK,EAAQ,QAAO,CAAE;AAAA,IAC3CE;AAAA,EACJ;AACE,SAAAH,EAAI,GACGE;AACT;AAGA,SAASC,EAAIC,GAAMP,GAAGQ,GAAO;AAC3B,SAAO,OAAOA,IAAQ,KAAK,OAAOD;AACpC;","x_google_ignoreList":[0]}
+{"version":3,"file":"blockquote.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/blockquote.js"],"sourcesContent":["/**\n * @import {Blockquote, Parents} from 'mdast'\n * @import {Info, Map, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {Blockquote} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function blockquote(node, _, state, info) {\n  const exit = state.enter('blockquote')\n  const tracker = state.createTracker(info)\n  tracker.move('> ')\n  tracker.shift(2)\n  const value = state.indentLines(\n    state.containerFlow(node, tracker.current()),\n    map\n  )\n  exit()\n  return value\n}\n\n/** @type {Map} */\nfunction map(line, _, blank) {\n  return '>' + (blank ? '' : ' ') + line\n}\n"],"names":[],"mappings":"AAYO,SAAS,WAAW,MAAM,GAAG,OAAO,MAAM;AAC/C,QAAM,OAAO,MAAM,MAAM,YAAY;AACrC,QAAM,UAAU,MAAM,cAAc,IAAI;AACxC,UAAQ,KAAK,IAAI;AACjB,UAAQ,MAAM,CAAC;AACf,QAAM,QAAQ,MAAM;AAAA,IAClB,MAAM,cAAc,MAAM,QAAQ,QAAO,CAAE;AAAA,IAC3C;AAAA,EACJ;AACE,OAAI;AACJ,SAAO;AACT;AAGA,SAAS,IAAI,MAAM,GAAG,OAAO;AAC3B,SAAO,OAAO,QAAQ,KAAK,OAAO;AACpC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/break.es.js

@@ -1,14 +1,14 @@
-import { patternInScope as t } from "../util/pattern-in-scope.es.js";
-function u(f, a, e, r) {
-  let n = -1;
-  for (; ++n < e.unsafe.length; )
-    if (e.unsafe[n].character === `
-` && t(e.stack, e.unsafe[n]))
-      return /[ \t]/.test(r.before) ? "" : " ";
-  return `\\
-`;
+import { patternInScope } from "../util/pattern-in-scope.es.js";
+function hardBreak(_, _1, state, info) {
+  let index = -1;
+  while (++index < state.unsafe.length) {
+    if (state.unsafe[index].character === "\n" && patternInScope(state.stack, state.unsafe[index])) {
+      return /[ \t]/.test(info.before) ? "" : " ";
+    }
+  }
+  return "\\\n";
 }
 export {
-  u as hardBreak
+  hardBreak
 };
 //# sourceMappingURL=break.es.js.map

package/dist/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/break.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"break.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/break.js"],"sourcesContent":["/**\n * @import {Break, Parents} from 'mdast'\n * @import {Info, State} from 'mdast-util-to-markdown'\n */\n\nimport {patternInScope} from '../util/pattern-in-scope.js'\n\n/**\n * @param {Break} _\n * @param {Parents | undefined} _1\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function hardBreak(_, _1, state, info) {\n  let index = -1\n\n  while (++index < state.unsafe.length) {\n    // If we can’t put eols in this construct (setext headings, tables), use a\n    // space instead.\n    if (\n      state.unsafe[index].character === '\\n' &&\n      patternInScope(state.stack, state.unsafe[index])\n    ) {\n      return /[ \\t]/.test(info.before) ? '' : ' '\n    }\n  }\n\n  return '\\\\\\n'\n}\n"],"names":["hardBreak","_","_1","state","info","index","patternInScope"],"mappings":";AAcO,SAASA,EAAUC,GAAGC,GAAIC,GAAOC,GAAM;AAC5C,MAAIC,IAAQ;AAEZ,SAAO,EAAEA,IAAQF,EAAM,OAAO;AAG5B,QACEA,EAAM,OAAOE,CAAK,EAAE,cAAc;AAAA,KAClCC,EAAeH,EAAM,OAAOA,EAAM,OAAOE,CAAK,CAAC;AAE/C,aAAO,QAAQ,KAAKD,EAAK,MAAM,IAAI,KAAK;AAI5C,SAAO;AAAA;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"break.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/break.js"],"sourcesContent":["/**\n * @import {Break, Parents} from 'mdast'\n * @import {Info, State} from 'mdast-util-to-markdown'\n */\n\nimport {patternInScope} from '../util/pattern-in-scope.js'\n\n/**\n * @param {Break} _\n * @param {Parents | undefined} _1\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function hardBreak(_, _1, state, info) {\n  let index = -1\n\n  while (++index < state.unsafe.length) {\n    // If we can’t put eols in this construct (setext headings, tables), use a\n    // space instead.\n    if (\n      state.unsafe[index].character === '\\n' &&\n      patternInScope(state.stack, state.unsafe[index])\n    ) {\n      return /[ \\t]/.test(info.before) ? '' : ' '\n    }\n  }\n\n  return '\\\\\\n'\n}\n"],"names":[],"mappings":";AAcO,SAAS,UAAU,GAAG,IAAI,OAAO,MAAM;AAC5C,MAAI,QAAQ;AAEZ,SAAO,EAAE,QAAQ,MAAM,OAAO,QAAQ;AAGpC,QACE,MAAM,OAAO,KAAK,EAAE,cAAc,QAClC,eAAe,MAAM,OAAO,MAAM,OAAO,KAAK,CAAC,GAC/C;AACA,aAAO,QAAQ,KAAK,KAAK,MAAM,IAAI,KAAK;AAAA,IAC9C;AAAA,EACA;AAEE,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/code.es.js

@@ -1,45 +1,57 @@
-import { longestStreak as s } from "../../../../../longest-streak@3.1.0/node_modules/longest-streak/index.es.js";
-import { formatCodeAsIndented as l } from "../util/format-code-as-indented.es.js";
-import { checkFence as x } from "../util/check-fence.es.js";
-function F(n, i, e, u) {
-  const m = x(e), t = n.value || "", f = m === "`" ? "GraveAccent" : "Tilde";
-  if (l(n, e)) {
-    const o = e.enter("codeIndented"), v = e.indentLines(t, p);
-    return o(), v;
+import { longestStreak } from "../../../../../longest-streak@3.1.0/node_modules/longest-streak/index.es.js";
+import { formatCodeAsIndented } from "../util/format-code-as-indented.es.js";
+import { checkFence } from "../util/check-fence.es.js";
+function code(node, _, state, info) {
+  const marker = checkFence(state);
+  const raw = node.value || "";
+  const suffix = marker === "`" ? "GraveAccent" : "Tilde";
+  if (formatCodeAsIndented(node, state)) {
+    const exit2 = state.enter("codeIndented");
+    const value2 = state.indentLines(raw, map);
+    exit2();
+    return value2;
   }
-  const r = e.createTracker(u), a = m.repeat(Math.max(s(t, m) + 1, 3)), d = e.enter("codeFenced");
-  let c = r.move(a);
-  if (n.lang) {
-    const o = e.enter(`codeFencedLang${f}`);
-    c += r.move(
-      e.safe(n.lang, {
-        before: c,
+  const tracker = state.createTracker(info);
+  const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3));
+  const exit = state.enter("codeFenced");
+  let value = tracker.move(sequence);
+  if (node.lang) {
+    const subexit = state.enter(`codeFencedLang${suffix}`);
+    value += tracker.move(
+      state.safe(node.lang, {
+        before: value,
         after: " ",
         encode: ["`"],
-        ...r.current()
+        ...tracker.current()
       })
-    ), o();
+    );
+    subexit();
   }
-  if (n.lang && n.meta) {
-    const o = e.enter(`codeFencedMeta${f}`);
-    c += r.move(" "), c += r.move(
-      e.safe(n.meta, {
-        before: c,
-        after: `
-`,
+  if (node.lang && node.meta) {
+    const subexit = state.enter(`codeFencedMeta${suffix}`);
+    value += tracker.move(" ");
+    value += tracker.move(
+      state.safe(node.meta, {
+        before: value,
+        after: "\n",
         encode: ["`"],
-        ...r.current()
+        ...tracker.current()
       })
-    ), o();
+    );
+    subexit();
   }
-  return c += r.move(`
-`), t && (c += r.move(t + `
-`)), c += r.move(a), d(), c;
+  value += tracker.move("\n");
+  if (raw) {
+    value += tracker.move(raw + "\n");
+  }
+  value += tracker.move(sequence);
+  exit();
+  return value;
 }
-function p(n, i, e) {
-  return (e ? "" : "    ") + n;
+function map(line, _, blank) {
+  return (blank ? "" : "    ") + line;
 }
 export {
-  F as code
+  code
 };
 //# sourceMappingURL=code.es.js.map

package/dist/node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/code.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"code.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/code.js"],"sourcesContent":["/**\n * @import {Info, Map, State} from 'mdast-util-to-markdown'\n * @import {Code, Parents} from 'mdast'\n */\n\nimport {longestStreak} from 'longest-streak'\nimport {formatCodeAsIndented} from '../util/format-code-as-indented.js'\nimport {checkFence} from '../util/check-fence.js'\n\n/**\n * @param {Code} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function code(node, _, state, info) {\n  const marker = checkFence(state)\n  const raw = node.value || ''\n  const suffix = marker === '`' ? 'GraveAccent' : 'Tilde'\n\n  if (formatCodeAsIndented(node, state)) {\n    const exit = state.enter('codeIndented')\n    const value = state.indentLines(raw, map)\n    exit()\n    return value\n  }\n\n  const tracker = state.createTracker(info)\n  const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3))\n  const exit = state.enter('codeFenced')\n  let value = tracker.move(sequence)\n\n  if (node.lang) {\n    const subexit = state.enter(`codeFencedLang${suffix}`)\n    value += tracker.move(\n      state.safe(node.lang, {\n        before: value,\n        after: ' ',\n        encode: ['`'],\n        ...tracker.current()\n      })\n    )\n    subexit()\n  }\n\n  if (node.lang && node.meta) {\n    const subexit = state.enter(`codeFencedMeta${suffix}`)\n    value += tracker.move(' ')\n    value += tracker.move(\n      state.safe(node.meta, {\n        before: value,\n        after: '\\n',\n        encode: ['`'],\n        ...tracker.current()\n      })\n    )\n    subexit()\n  }\n\n  value += tracker.move('\\n')\n\n  if (raw) {\n    value += tracker.move(raw + '\\n')\n  }\n\n  value += tracker.move(sequence)\n  exit()\n  return value\n}\n\n/** @type {Map} */\nfunction map(line, _, blank) {\n  return (blank ? '' : '    ') + line\n}\n"],"names":["code","node","_","state","info","marker","checkFence","raw","suffix","formatCodeAsIndented","exit","value","map","tracker","sequence","longestStreak","subexit","line","blank"],"mappings":";;;AAgBO,SAASA,EAAKC,GAAMC,GAAGC,GAAOC,GAAM;AACzC,QAAMC,IAASC,EAAWH,CAAK,GACzBI,IAAMN,EAAK,SAAS,IACpBO,IAASH,MAAW,MAAM,gBAAgB;AAEhD,MAAII,EAAqBR,GAAME,CAAK,GAAG;AACrC,UAAMO,IAAOP,EAAM,MAAM,cAAc,GACjCQ,IAAQR,EAAM,YAAYI,GAAKK,CAAG;AACxC,WAAAF,EAAI,GACGC;AAAA,EACX;AAEE,QAAME,IAAUV,EAAM,cAAcC,CAAI,GAClCU,IAAWT,EAAO,OAAO,KAAK,IAAIU,EAAcR,GAAKF,CAAM,IAAI,GAAG,CAAC,CAAC,GACpEK,IAAOP,EAAM,MAAM,YAAY;AACrC,MAAIQ,IAAQE,EAAQ,KAAKC,CAAQ;AAEjC,MAAIb,EAAK,MAAM;AACb,UAAMe,IAAUb,EAAM,MAAM,iBAAiBK,CAAM,EAAE;AACrD,IAAAG,KAASE,EAAQ;AAAA,MACfV,EAAM,KAAKF,EAAK,MAAM;AAAA,QACpB,QAAQU;AAAA,QACR,OAAO;AAAA,QACP,QAAQ,CAAC,GAAG;AAAA,QACZ,GAAGE,EAAQ,QAAO;AAAA,MACnB,CAAA;AAAA,IACP,GACIG,EAAO;AAAA,EACX;AAEE,MAAIf,EAAK,QAAQA,EAAK,MAAM;AAC1B,UAAMe,IAAUb,EAAM,MAAM,iBAAiBK,CAAM,EAAE;AACrD,IAAAG,KAASE,EAAQ,KAAK,GAAG,GACzBF,KAASE,EAAQ;AAAA,MACfV,EAAM,KAAKF,EAAK,MAAM;AAAA,QACpB,QAAQU;AAAA,QACR,OAAO;AAAA;AAAA,QACP,QAAQ,CAAC,GAAG;AAAA,QACZ,GAAGE,EAAQ,QAAO;AAAA,MACnB,CAAA;AAAA,IACP,GACIG,EAAO;AAAA,EACX;AAEE,SAAAL,KAASE,EAAQ,KAAK;AAAA,CAAI,GAEtBN,MACFI,KAASE,EAAQ,KAAKN,IAAM;AAAA,CAAI,IAGlCI,KAASE,EAAQ,KAAKC,CAAQ,GAC9BJ,EAAI,GACGC;AACT;AAGA,SAASC,EAAIK,GAAMf,GAAGgB,GAAO;AAC3B,UAAQA,IAAQ,KAAK,UAAUD;AACjC;","x_google_ignoreList":[0]}
+{"version":3,"file":"code.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/mdast-util-to-markdown@2.1.2/node_modules/mdast-util-to-markdown/lib/handle/code.js"],"sourcesContent":["/**\n * @import {Info, Map, State} from 'mdast-util-to-markdown'\n * @import {Code, Parents} from 'mdast'\n */\n\nimport {longestStreak} from 'longest-streak'\nimport {formatCodeAsIndented} from '../util/format-code-as-indented.js'\nimport {checkFence} from '../util/check-fence.js'\n\n/**\n * @param {Code} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function code(node, _, state, info) {\n  const marker = checkFence(state)\n  const raw = node.value || ''\n  const suffix = marker === '`' ? 'GraveAccent' : 'Tilde'\n\n  if (formatCodeAsIndented(node, state)) {\n    const exit = state.enter('codeIndented')\n    const value = state.indentLines(raw, map)\n    exit()\n    return value\n  }\n\n  const tracker = state.createTracker(info)\n  const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3))\n  const exit = state.enter('codeFenced')\n  let value = tracker.move(sequence)\n\n  if (node.lang) {\n    const subexit = state.enter(`codeFencedLang${suffix}`)\n    value += tracker.move(\n      state.safe(node.lang, {\n        before: value,\n        after: ' ',\n        encode: ['`'],\n        ...tracker.current()\n      })\n    )\n    subexit()\n  }\n\n  if (node.lang && node.meta) {\n    const subexit = state.enter(`codeFencedMeta${suffix}`)\n    value += tracker.move(' ')\n    value += tracker.move(\n      state.safe(node.meta, {\n        before: value,\n        after: '\\n',\n        encode: ['`'],\n        ...tracker.current()\n      })\n    )\n    subexit()\n  }\n\n  value += tracker.move('\\n')\n\n  if (raw) {\n    value += tracker.move(raw + '\\n')\n  }\n\n  value += tracker.move(sequence)\n  exit()\n  return value\n}\n\n/** @type {Map} */\nfunction map(line, _, blank) {\n  return (blank ? '' : '    ') + line\n}\n"],"names":["exit","value"],"mappings":";;;AAgBO,SAAS,KAAK,MAAM,GAAG,OAAO,MAAM;AACzC,QAAM,SAAS,WAAW,KAAK;AAC/B,QAAM,MAAM,KAAK,SAAS;AAC1B,QAAM,SAAS,WAAW,MAAM,gBAAgB;AAEhD,MAAI,qBAAqB,MAAM,KAAK,GAAG;AACrC,UAAMA,QAAO,MAAM,MAAM,cAAc;AACvC,UAAMC,SAAQ,MAAM,YAAY,KAAK,GAAG;AACxC,IAAAD,MAAI;AACJ,WAAOC;AAAA,EACX;AAEE,QAAM,UAAU,MAAM,cAAc,IAAI;AACxC,QAAM,WAAW,OAAO,OAAO,KAAK,IAAI,cAAc,KAAK,MAAM,IAAI,GAAG,CAAC,CAAC;AAC1E,QAAM,OAAO,MAAM,MAAM,YAAY;AACrC,MAAI,QAAQ,QAAQ,KAAK,QAAQ;AAEjC,MAAI,KAAK,MAAM;AACb,UAAM,UAAU,MAAM,MAAM,iBAAiB,MAAM,EAAE;AACrD,aAAS,QAAQ;AAAA,MACf,MAAM,KAAK,KAAK,MAAM;AAAA,QACpB,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,QAAQ,CAAC,GAAG;AAAA,QACZ,GAAG,QAAQ,QAAO;AAAA,MACnB,CAAA;AAAA,IACP;AACI,YAAO;AAAA,EACX;AAEE,MAAI,KAAK,QAAQ,KAAK,MAAM;AAC1B,UAAM,UAAU,MAAM,MAAM,iBAAiB,MAAM,EAAE;AACrD,aAAS,QAAQ,KAAK,GAAG;AACzB,aAAS,QAAQ;AAAA,MACf,MAAM,KAAK,KAAK,MAAM;AAAA,QACpB,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,QAAQ,CAAC,GAAG;AAAA,QACZ,GAAG,QAAQ,QAAO;AAAA,MACnB,CAAA;AAAA,IACP;AACI,YAAO;AAAA,EACX;AAEE,WAAS,QAAQ,KAAK,IAAI;AAE1B,MAAI,KAAK;AACP,aAAS,QAAQ,KAAK,MAAM,IAAI;AAAA,EACpC;AAEE,WAAS,QAAQ,KAAK,QAAQ;AAC9B,OAAI;AACJ,SAAO;AACT;AAGA,SAAS,IAAI,MAAM,GAAG,OAAO;AAC3B,UAAQ,QAAQ,KAAK,UAAU;AACjC;","x_google_ignoreList":[0]}