@axdspub/axiom-ui-forms 0.2.8 → 0.2.9

package/library/esm/node_modules/mdast-util-to-hast/lib/state.js

@@ -0,0 +1,322 @@
+import structuredClone from '../../@ungap/structured-clone/esm/index.js';
+import { handlers } from './handlers/index.js';
+import { visit } from '../../unist-util-visit/lib/index.js';
+import { position } from '../../unist-util-position/lib/index.js';
+
+/**
+ * @typedef {import('hast').Element} HastElement
+ * @typedef {import('hast').ElementContent} HastElementContent
+ * @typedef {import('hast').Nodes} HastNodes
+ * @typedef {import('hast').Properties} HastProperties
+ * @typedef {import('hast').RootContent} HastRootContent
+ * @typedef {import('hast').Text} HastText
+ *
+ * @typedef {import('mdast').Definition} MdastDefinition
+ * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition
+ * @typedef {import('mdast').Nodes} MdastNodes
+ * @typedef {import('mdast').Parents} MdastParents
+ *
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate
+ * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate
+ */
+
+
+const own = {}.hasOwnProperty;
+
+/** @type {Options} */
+const emptyOptions = {};
+
+/**
+ * Create `state` from an mdast tree.
+ *
+ * @param {MdastNodes} tree
+ *   mdast node to transform.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {State}
+ *   `state` function.
+ */
+function createState(tree, options) {
+  const settings = options || emptyOptions;
+  /** @type {Map<string, MdastDefinition>} */
+  const definitionById = new Map();
+  /** @type {Map<string, MdastFootnoteDefinition>} */
+  const footnoteById = new Map();
+  /** @type {Map<string, number>} */
+  const footnoteCounts = new Map();
+  /** @type {Handlers} */
+  // @ts-expect-error: the root handler returns a root.
+  // Hard to type.
+  const handlers$1 = {...handlers, ...settings.handlers};
+
+  /** @type {State} */
+  const state = {
+    all,
+    applyData,
+    definitionById,
+    footnoteById,
+    footnoteCounts,
+    footnoteOrder: [],
+    handlers: handlers$1,
+    one,
+    options: settings,
+    patch,
+    wrap
+  };
+
+  visit(tree, function (node) {
+    if (node.type === 'definition' || node.type === 'footnoteDefinition') {
+      const map = node.type === 'definition' ? definitionById : footnoteById;
+      const id = String(node.identifier).toUpperCase();
+
+      // Mimick CM behavior of link definitions.
+      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.
+      if (!map.has(id)) {
+        // @ts-expect-error: node type matches map.
+        map.set(id, node);
+      }
+    }
+  });
+
+  return state
+
+  /**
+   * Transform an mdast node into a hast node.
+   *
+   * @param {MdastNodes} node
+   *   mdast node.
+   * @param {MdastParents | undefined} [parent]
+   *   Parent of `node`.
+   * @returns {Array<HastElementContent> | HastElementContent | undefined}
+   *   Resulting hast node.
+   */
+  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)
+    }
+
+    if (state.options.passThrough && state.options.passThrough.includes(type)) {
+      if ('children' in node) {
+        const {children, ...shallow} = node;
+        const result = structuredClone(shallow);
+        // @ts-expect-error: TS doesn’t understand…
+        result.children = state.all(node);
+        // @ts-expect-error: TS doesn’t understand…
+        return result
+      }
+
+      // @ts-expect-error: it’s custom.
+      return structuredClone(node)
+    }
+
+    const unknown = state.options.unknownHandler || defaultUnknownHandler;
+
+    return unknown(state, node, parent)
+  }
+
+  /**
+   * Transform the children of an mdast node into hast nodes.
+   *
+   * @param {MdastNodes} parent
+   *   mdast node to compile
+   * @returns {Array<HastElementContent>}
+   *   Resulting hast nodes.
+   */
+  function all(parent) {
+    /** @type {Array<HastElementContent>} */
+    const values = [];
+
+    if ('children' in parent) {
+      const nodes = parent.children;
+      let index = -1;
+      while (++index < nodes.length) {
+        const result = state.one(nodes[index], parent);
+
+        // To do: see if we van clean this? Can we merge texts?
+        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);
+          }
+        }
+      }
+    }
+
+    return values
+  }
+}
+
+/**
+ * Copy a node’s positional info.
+ *
+ * @param {MdastNodes} from
+ *   mdast node to copy from.
+ * @param {HastNodes} to
+ *   hast node to copy into.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function patch(from, to) {
+  if (from.position) to.position = position(from);
+}
+
+/**
+ * Honor the `data` of `from` and maybe generate an element instead of `to`.
+ *
+ * @template {HastNodes} Type
+ *   Node type.
+ * @param {MdastNodes} from
+ *   mdast node to use data from.
+ * @param {Type} to
+ *   hast node to change.
+ * @returns {HastElement | Type}
+ *   Nothing.
+ */
+function applyData(from, to) {
+  /** @type {HastElement | Type} */
+  let result = to;
+
+  // Handle `data.hName`, `data.hProperties, `data.hChildren`.
+  if (from && from.data) {
+    const hName = from.data.hName;
+    const hChildren = from.data.hChildren;
+    const hProperties = from.data.hProperties;
+
+    if (typeof hName === 'string') {
+      // Transforming the node resulted in an element with a different name
+      // than wanted:
+      if (result.type === 'element') {
+        result.tagName = hName;
+      }
+      // Transforming the node resulted in a non-element, which happens for
+      // raw, text, and root nodes (unless custom handlers are passed).
+      // The intent of `hName` is to create an element, but likely also to keep
+      // the content around (otherwise: pass `hChildren`).
+      else {
+        /** @type {Array<HastElementContent>} */
+        // @ts-expect-error: assume no doctypes in `root`.
+        const children = 'children' in result ? result.children : [result];
+        result = {type: 'element', tagName: hName, properties: {}, children};
+      }
+    }
+
+    if (result.type === 'element' && hProperties) {
+      Object.assign(result.properties, structuredClone(hProperties));
+    }
+
+    if (
+      'children' in result &&
+      result.children &&
+      hChildren !== null &&
+      hChildren !== undefined
+    ) {
+      result.children = hChildren;
+    }
+  }
+
+  return result
+}
+
+/**
+ * Transform an unknown node.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdastNodes} node
+ *   Unknown mdast node.
+ * @returns {HastElement | HastText}
+ *   Resulting hast node.
+ */
+function defaultUnknownHandler(state, node) {
+  const data = node.data || {};
+  /** @type {HastElement | HastText} */
+  const result =
+    'value' in node &&
+    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))
+      ? {type: 'text', value: node.value}
+      : {
+          type: 'element',
+          tagName: 'div',
+          properties: {},
+          children: state.all(node)
+        };
+
+  state.patch(node, result);
+  return state.applyData(node, result)
+}
+
+/**
+ * Wrap `nodes` with line endings between each node.
+ *
+ * @template {HastRootContent} Type
+ *   Node type.
+ * @param {Array<Type>} nodes
+ *   List of nodes to wrap.
+ * @param {boolean | undefined} [loose=false]
+ *   Whether to add line endings at start and end (default: `false`).
+ * @returns {Array<HastText | Type>}
+ *   Wrapped nodes.
+ */
+function wrap(nodes, loose) {
+  /** @type {Array<HastText | Type>} */
+  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
+}
+
+/**
+ * Trim spaces and tabs at the start of `value`.
+ *
+ * @param {string} value
+ *   Value to trim.
+ * @returns {string}
+ *   Result.
+ */
+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 { createState, wrap };
+//# sourceMappingURL=state.js.map

package/library/esm/node_modules/mdast-util-to-hast/lib/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sources":["../../../../../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":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAkKA,MAAM,GAAG,GAAG,EAAE,CAAC;;AAEf;AACA,MAAM,YAAY,GAAG;;AAErB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE;AAC3C,EAAE,MAAM,QAAQ,GAAG,OAAO,IAAI;AAC9B;AACA,EAAE,MAAM,cAAc,GAAG,IAAI,GAAG;AAChC;AACA,EAAE,MAAM,YAAY,GAAG,IAAI,GAAG;AAC9B;AACA,EAAE,MAAM,cAAc,GAAG,IAAI,GAAG;AAChC;AACA;AACA;AACA,EAAE,MAAMA,UAAQ,GAAG,CAAC,GAAGC,QAAe,EAAE,GAAG,QAAQ,CAAC,QAAQ;;AAE5D;AACA,EAAE,MAAM,KAAK,GAAG;AAChB,IAAI,GAAG;AACP,IAAI,SAAS;AACb,IAAI,cAAc;AAClB,IAAI,YAAY;AAChB,IAAI,cAAc;AAClB,IAAI,aAAa,EAAE,EAAE;AACrB,cAAID,UAAQ;AACZ,IAAI,GAAG;AACP,IAAI,OAAO,EAAE,QAAQ;AACrB,IAAI,KAAK;AACT,IAAI;AACJ;;AAEA,EAAE,KAAK,CAAC,IAAI,EAAE,UAAU,IAAI,EAAE;AAC9B,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,YAAY,IAAI,IAAI,CAAC,IAAI,KAAK,oBAAoB,EAAE;AAC1E,MAAM,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,KAAK,YAAY,GAAG,cAAc,GAAG;AAChE,MAAM,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,WAAW;;AAEpD;AACA;AACA,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;AACxB;AACA,QAAQ,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI;AACxB;AACA;AACA,GAAG;;AAEH,EAAE,OAAO;;AAET;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE;AAC7B,IAAI,MAAM,IAAI,GAAG,IAAI,CAAC;AACtB,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI;;AAEtC,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,MAAM,EAAE;AAClD,MAAM,OAAO,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM;AACvC;;AAEA,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AAC/E,MAAM,IAAI,UAAU,IAAI,IAAI,EAAE;AAC9B,QAAQ,MAAM,CAAC,QAAQ,EAAE,GAAG,OAAO,CAAC,GAAG;AACvC,QAAQ,MAAM,MAAM,GAAG,eAAe,CAAC,OAAO;AAC9C;AACA,QAAQ,MAAM,CAAC,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI;AACxC;AACA,QAAQ,OAAO;AACf;;AAEA;AACA,MAAM,OAAO,eAAe,CAAC,IAAI;AACjC;;AAEA,IAAI,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,cAAc,IAAI;;AAEpD,IAAI,OAAO,OAAO,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM;AACtC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,SAAS,GAAG,CAAC,MAAM,EAAE;AACvB;AACA,IAAI,MAAM,MAAM,GAAG;;AAEnB,IAAI,IAAI,UAAU,IAAI,MAAM,EAAE;AAC9B,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC;AAC3B,MAAM,IAAI,KAAK,GAAG;AAClB,MAAM,OAAO,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE;AACrC,QAAQ,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM;;AAErD;AACA,QAAQ,IAAI,MAAM,EAAE;AACpB,UAAU,IAAI,KAAK,IAAI,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,EAAE;AAC1D,YAAY,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,KAAK,MAAM,EAAE;AAClE,cAAc,MAAM,CAAC,KAAK,GAAG,sBAAsB,CAAC,MAAM,CAAC,KAAK;AAChE;;AAEA,YAAY,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE;AACrE,cAAc,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;;AAE5C,cAAc,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE;AAChD,gBAAgB,IAAI,CAAC,KAAK,GAAG,sBAAsB,CAAC,IAAI,CAAC,KAAK;AAC9D;AACA;AACA;;AAEA,UAAU,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;AACrC,YAAY,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM;AACjC,WAAW,MAAM;AACjB,YAAY,MAAM,CAAC,IAAI,CAAC,MAAM;AAC9B;AACA;AACA;AACA;;AAEA,IAAI,OAAO;AACX;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE;AACzB,EAAE,IAAI,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,GAAG,QAAQ,CAAC,IAAI;AAChD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,SAAS,CAAC,IAAI,EAAE,EAAE,EAAE;AAC7B;AACA,EAAE,IAAI,MAAM,GAAG;;AAEf;AACA,EAAE,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE;AACzB,IAAI,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC;AAC5B,IAAI,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC;AAChC,IAAI,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC;;AAElC,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;AACnC;AACA;AACA,MAAM,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE;AACrC,QAAQ,MAAM,CAAC,OAAO,GAAG;AACzB;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA,QAAQ,MAAM,QAAQ,GAAG,UAAU,IAAI,MAAM,GAAG,MAAM,CAAC,QAAQ,GAAG,CAAC,MAAM;AACzE,QAAQ,MAAM,GAAG,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ;AAC3E;AACA;;AAEA,IAAI,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,WAAW,EAAE;AAClD,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,eAAe,CAAC,WAAW,CAAC;AACnE;;AAEA,IAAI;AACJ,MAAM,UAAU,IAAI,MAAM;AAC1B,MAAM,MAAM,CAAC,QAAQ;AACrB,MAAM,SAAS,KAAK,IAAI;AACxB,MAAM,SAAS,KAAK;AACpB,MAAM;AACN,MAAM,MAAM,CAAC,QAAQ,GAAG;AACxB;AACA;;AAEA,EAAE,OAAO;AACT;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,qBAAqB,CAAC,KAAK,EAAE,IAAI,EAAE;AAC5C,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI;AAC5B;AACA,EAAE,MAAM,MAAM;AACd,IAAI,OAAO,IAAI,IAAI;AACnB,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC;AAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK;AACxC,QAAQ;AACR,UAAU,IAAI,EAAE,SAAS;AACzB,UAAU,OAAO,EAAE,KAAK;AACxB,UAAU,UAAU,EAAE,EAAE;AACxB,UAAU,QAAQ,EAAE,KAAK,CAAC,GAAG,CAAC,IAAI;AAClC;;AAEA,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM;AAC1B,EAAE,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM;AACrC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE;AACnC;AACA,EAAE,MAAM,MAAM,GAAG;AACjB,EAAE,IAAI,KAAK,GAAG;;AAEd,EAAE,IAAI,KAAK,EAAE;AACb,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC;AAC3C;;AAEA,EAAE,OAAO,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE;AACjC,IAAI,IAAI,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC;AACtD,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;AAC5B;;AAEA,EAAE,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;AACjC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC;AAC3C;;AAEA,EAAE,OAAO;AACT;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,sBAAsB,CAAC,KAAK,EAAE;AACvC,EAAE,IAAI,KAAK,GAAG;AACd,EAAE,IAAI,IAAI,GAAG,KAAK,CAAC,UAAU,CAAC,KAAK;;AAEnC,EAAE,OAAO,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,EAAE,EAAE;AACpC,IAAI,KAAK;AACT,IAAI,IAAI,GAAG,KAAK,CAAC,UAAU,CAAC,KAAK;AACjC;;AAEA,EAAE,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK;AAC1B;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,111 @@
+/**
+ * @typedef {import('mdast').Nodes} Nodes
+ *
+ * @typedef Options
+ *   Configuration (optional).
+ * @property {boolean | null | undefined} [includeImageAlt=true]
+ *   Whether to use `alt` for `image`s (default: `true`).
+ * @property {boolean | null | undefined} [includeHtml=true]
+ *   Whether to use `value` of HTML (default: `true`).
+ */
+
+/** @type {Options} */
+const emptyOptions = {};
+
+/**
+ * Get the text content of a node or list of nodes.
+ *
+ * Prefers the node’s plain-text fields, otherwise serializes its children,
+ * and if the given value is an array, serialize the nodes in it.
+ *
+ * @param {unknown} [value]
+ *   Thing to serialize, typically `Node`.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {string}
+ *   Serialized `value`.
+ */
+function toString(value, options) {
+  const settings = emptyOptions;
+  const includeImageAlt =
+    typeof settings.includeImageAlt === 'boolean'
+      ? settings.includeImageAlt
+      : true;
+  const includeHtml =
+    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true;
+
+  return one(value, includeImageAlt, includeHtml)
+}
+
+/**
+ * One node or several nodes.
+ *
+ * @param {unknown} value
+ *   Thing to serialize.
+ * @param {boolean} includeImageAlt
+ *   Include image `alt`s.
+ * @param {boolean} includeHtml
+ *   Include HTML.
+ * @returns {string}
+ *   Serialized node.
+ */
+function one(value, includeImageAlt, includeHtml) {
+  if (node(value)) {
+    if ('value' in value) {
+      return value.type === 'html' && !includeHtml ? '' : value.value
+    }
+
+    if (includeImageAlt && 'alt' in value && value.alt) {
+      return value.alt
+    }
+
+    if ('children' in value) {
+      return all(value.children, includeImageAlt, includeHtml)
+    }
+  }
+
+  if (Array.isArray(value)) {
+    return all(value, includeImageAlt, includeHtml)
+  }
+
+  return ''
+}
+
+/**
+ * Serialize a list of nodes.
+ *
+ * @param {Array<unknown>} values
+ *   Thing to serialize.
+ * @param {boolean} includeImageAlt
+ *   Include image `alt`s.
+ * @param {boolean} includeHtml
+ *   Include HTML.
+ * @returns {string}
+ *   Serialized nodes.
+ */
+function all(values, includeImageAlt, includeHtml) {
+  /** @type {Array<string>} */
+  const result = [];
+  let index = -1;
+
+  while (++index < values.length) {
+    result[index] = one(values[index], includeImageAlt, includeHtml);
+  }
+
+  return result.join('')
+}
+
+/**
+ * Check if `value` looks like a node.
+ *
+ * @param {unknown} value
+ *   Thing.
+ * @returns {value is Nodes}
+ *   Whether `value` is a node.
+ */
+function node(value) {
+  return Boolean(value && typeof value === 'object')
+}
+
+export { toString };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../node_modules/mdast-util-to-string/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('mdast').Nodes} Nodes\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s (default: `true`).\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML (default: `true`).\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} [value]\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Nodes}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,MAAM,YAAY,GAAG;;AAErB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE;AACzC,EAAE,MAAM,QAAQ,GAAc;AAC9B,EAAE,MAAM,eAAe;AACvB,IAAI,OAAO,QAAQ,CAAC,eAAe,KAAK;AACxC,QAAQ,QAAQ,CAAC;AACjB,QAAQ;AACR,EAAE,MAAM,WAAW;AACnB,IAAI,OAAO,QAAQ,CAAC,WAAW,KAAK,SAAS,GAAG,QAAQ,CAAC,WAAW,GAAG;;AAEvE,EAAE,OAAO,GAAG,CAAC,KAAK,EAAE,eAAe,EAAE,WAAW;AAChD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,GAAG,CAAC,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE;AAClD,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE;AACnB,IAAI,IAAI,OAAO,IAAI,KAAK,EAAE;AAC1B,MAAM,OAAO,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,CAAC,WAAW,GAAG,EAAE,GAAG,KAAK,CAAC;AAChE;;AAEA,IAAI,IAAI,eAAe,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,CAAC,GAAG,EAAE;AACxD,MAAM,OAAO,KAAK,CAAC;AACnB;;AAEA,IAAI,IAAI,UAAU,IAAI,KAAK,EAAE;AAC7B,MAAM,OAAO,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,eAAe,EAAE,WAAW;AAC7D;AACA;;AAEA,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AAC5B,IAAI,OAAO,GAAG,CAAC,KAAK,EAAE,eAAe,EAAE,WAAW;AAClD;;AAEA,EAAE,OAAO;AACT;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,WAAW,EAAE;AACnD;AACA,EAAE,MAAM,MAAM,GAAG;AACjB,EAAE,IAAI,KAAK,GAAG;;AAEd,EAAE,OAAO,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE;AAClC,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,eAAe,EAAE,WAAW;AACnE;;AAEA,EAAE,OAAO,MAAM,CAAC,IAAI,CAAC,EAAE;AACvB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,CAAC,KAAK,EAAE;AACrB,EAAE,OAAO,OAAO,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;AACnD;;;;","x_google_ignoreList":[0]}

package/library/esm/node_modules/micromark/lib/constructs.js

@@ -0,0 +1,108 @@
+import { resolver } from './initialize/text.js';
+import { blockQuote } from '../../micromark-core-commonmark/lib/block-quote.js';
+import { list } from '../../micromark-core-commonmark/lib/list.js';
+import { definition } from '../../micromark-core-commonmark/lib/definition.js';
+import { codeIndented } from '../../micromark-core-commonmark/lib/code-indented.js';
+import { codeFenced } from '../../micromark-core-commonmark/lib/code-fenced.js';
+import { thematicBreak } from '../../micromark-core-commonmark/lib/thematic-break.js';
+import { setextUnderline } from '../../micromark-core-commonmark/lib/setext-underline.js';
+import { htmlFlow } from '../../micromark-core-commonmark/lib/html-flow.js';
+import { headingAtx } from '../../micromark-core-commonmark/lib/heading-atx.js';
+import { characterEscape } from '../../micromark-core-commonmark/lib/character-escape.js';
+import { characterReference } from '../../micromark-core-commonmark/lib/character-reference.js';
+import { codeText } from '../../micromark-core-commonmark/lib/code-text.js';
+import { attention } from '../../micromark-core-commonmark/lib/attention.js';
+import { labelEnd } from '../../micromark-core-commonmark/lib/label-end.js';
+import { hardBreakEscape } from '../../micromark-core-commonmark/lib/hard-break-escape.js';
+import { labelStartLink } from '../../micromark-core-commonmark/lib/label-start-link.js';
+import { autolink } from '../../micromark-core-commonmark/lib/autolink.js';
+import { htmlText } from '../../micromark-core-commonmark/lib/html-text.js';
+import { labelStartImage } from '../../micromark-core-commonmark/lib/label-start-image.js';
+import { lineEnding } from '../../micromark-core-commonmark/lib/line-ending.js';
+
+/**
+ * @import {Extension} from 'micromark-util-types'
+ */
+
+
+/** @satisfies {Extension['document']} */
+const document = {
+  [42]: list,
+  [43]: list,
+  [45]: list,
+  [48]: list,
+  [49]: list,
+  [50]: list,
+  [51]: list,
+  [52]: list,
+  [53]: list,
+  [54]: list,
+  [55]: list,
+  [56]: list,
+  [57]: list,
+  [62]: blockQuote
+};
+
+/** @satisfies {Extension['contentInitial']} */
+const contentInitial = {
+  [91]: definition
+};
+
+/** @satisfies {Extension['flowInitial']} */
+const flowInitial = {
+  [-2]: codeIndented,
+  [-1]: codeIndented,
+  [32]: codeIndented
+};
+
+/** @satisfies {Extension['flow']} */
+const flow = {
+  [35]: headingAtx,
+  [42]: thematicBreak,
+  [45]: [setextUnderline, thematicBreak],
+  [60]: htmlFlow,
+  [61]: setextUnderline,
+  [95]: thematicBreak,
+  [96]: codeFenced,
+  [126]: codeFenced
+};
+
+/** @satisfies {Extension['string']} */
+const string = {
+  [38]: characterReference,
+  [92]: characterEscape
+};
+
+/** @satisfies {Extension['text']} */
+const text = {
+  [-5]: lineEnding,
+  [-4]: lineEnding,
+  [-3]: lineEnding,
+  [33]: labelStartImage,
+  [38]: characterReference,
+  [42]: attention,
+  [60]: [autolink, htmlText],
+  [91]: labelStartLink,
+  [92]: [hardBreakEscape, characterEscape],
+  [93]: labelEnd,
+  [95]: attention,
+  [96]: codeText
+};
+
+/** @satisfies {Extension['insideSpan']} */
+const insideSpan = {
+  null: [attention, resolver]
+};
+
+/** @satisfies {Extension['attentionMarkers']} */
+const attentionMarkers = {
+  null: [42, 95]
+};
+
+/** @satisfies {Extension['disable']} */
+const disable = {
+  null: []
+};
+
+export { attentionMarkers, contentInitial, disable, document, flow, flowInitial, insideSpan, string, text };
+//# sourceMappingURL=constructs.js.map

package/library/esm/node_modules/micromark/lib/constructs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructs.js","sources":["../../../../../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":";;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AACA;;;AAKA;AACY,MAAC,QAAQ,GAAG;AACxB,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG,IAAI;AACZ,EAAE,CAAC,EAAE,GAAG;AACR;;AAEA;AACY,MAAC,cAAc,GAAG;AAC9B,EAAE,CAAC,EAAE,GAAG;AACR;;AAEA;AACY,MAAC,WAAW,GAAG;AAC3B,EAAE,CAAC,EAAE,GAAG,YAAY;AACpB,EAAE,CAAC,EAAE,GAAG,YAAY;AACpB,EAAE,CAAC,EAAE,GAAG;AACR;;AAEA;AACY,MAAC,IAAI,GAAG;AACpB,EAAE,CAAC,EAAE,GAAG,UAAU;AAClB,EAAE,CAAC,EAAE,GAAG,aAAa;AACrB,EAAE,CAAC,EAAE,GAAG,CAAC,eAAe,EAAE,aAAa,CAAC;AACxC,EAAE,CAAC,EAAE,GAAG,QAAQ;AAChB,EAAE,CAAC,EAAE,GAAG,eAAe;AACvB,EAAE,CAAC,EAAE,GAAG,aAAa;AACrB,EAAE,CAAC,EAAE,GAAG,UAAU;AAClB,EAAE,CAAC,GAAG,GAAG;AACT;;AAEA;AACY,MAAC,MAAM,GAAG;AACtB,EAAE,CAAC,EAAE,GAAG,kBAAkB;AAC1B,EAAE,CAAC,EAAE,GAAG;AACR;;AAEA;AACY,MAAC,IAAI,GAAG;AACpB,EAAE,CAAC,EAAE,GAAG,UAAU;AAClB,EAAE,CAAC,EAAE,GAAG,UAAU;AAClB,EAAE,CAAC,EAAE,GAAG,UAAU;AAClB,EAAE,CAAC,EAAE,GAAG,eAAe;AACvB,EAAE,CAAC,EAAE,GAAG,kBAAkB;AAC1B,EAAE,CAAC,EAAE,GAAG,SAAS;AACjB,EAAE,CAAC,EAAE,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC;AAC5B,EAAE,CAAC,EAAE,GAAG,cAAc;AACtB,EAAE,CAAC,EAAE,GAAG,CAAC,eAAe,EAAE,eAAe,CAAC;AAC1C,EAAE,CAAC,EAAE,GAAG,QAAQ;AAChB,EAAE,CAAC,EAAE,GAAG,SAAS;AACjB,EAAE,CAAC,EAAE,GAAG;AACR;;AAEA;AACY,MAAC,UAAU,GAAG;AAC1B,EAAE,IAAI,EAAE,CAAC,SAAS,EAAEA,QAAW;AAC/B;;AAEA;AACY,MAAC,gBAAgB,GAAG;AAChC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE;AACf;;AAEA;AACY,MAAC,OAAO,GAAG;AACvB,EAAE,IAAI,EAAE;AACR;;;;","x_google_ignoreList":[0]}