@axdspub/axiom-ui-forms 0.2.8 → 0.2.9

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

@@ -0,0 +1,27 @@
+/**
+ * @typedef {import('hast').Parents} HastParents
+ * @typedef {import('hast').Root} HastRoot
+ * @typedef {import('mdast').Root} MdastRoot
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `root` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdastRoot} node
+ *   mdast node.
+ * @returns {HastParents}
+ *   hast node.
+ */
+function root(state, node) {
+  /** @type {HastRoot} */
+  const result = {type: 'root', children: state.wrap(state.all(node))};
+  state.patch(node, result);
+  return state.applyData(node, result)
+}
+
+export { root };
+//# sourceMappingURL=root.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"root.js","sources":["../../../../../../node_modules/mdast-util-to-hast/lib/handlers/root.js"],"sourcesContent":["/**\n * @typedef {import('hast').Parents} HastParents\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `root` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastRoot} node\n *   mdast node.\n * @returns {HastParents}\n *   hast node.\n */\nexport function root(state, node) {\n  /** @type {HastRoot} */\n  const result = {type: 'root', children: state.wrap(state.all(node))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE;AAClC;AACA,EAAE,MAAM,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACrE,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM;AAC1B,EAAE,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM;AACrC;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,31 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Strong} Strong
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `strong` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Strong} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function strong(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'strong',
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result)
+}
+
+export { strong };
+//# sourceMappingURL=strong.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strong.js","sources":["../../../../../../node_modules/mdast-util-to-hast/lib/handlers/strong.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `strong` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Strong} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strong(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'strong',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE;AACpC;AACA,EAAE,MAAM,MAAM,GAAG;AACjB,IAAI,IAAI,EAAE,SAAS;AACnB,IAAI,OAAO,EAAE,QAAQ;AACrB,IAAI,UAAU,EAAE,EAAE;AAClB,IAAI,QAAQ,EAAE,KAAK,CAAC,GAAG,CAAC,IAAI;AAC5B;AACA,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM;AAC1B,EAAE,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM;AACrC;;;;","x_google_ignoreList":[0]}

package/library/esm/node_modules/mdast-util-to-hast/lib/handlers/table-cell.js

@@ -0,0 +1,33 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').TableCell} TableCell
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `tableCell` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {TableCell} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function tableCell(state, node) {
+  // Note: this function is normally not called: see `table-row` for how rows
+  // and their cells are compiled.
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'td', // Assume body cell.
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result)
+}
+
+export { tableCell };
+//# sourceMappingURL=table-cell.js.map

package/library/esm/node_modules/mdast-util-to-hast/lib/handlers/table-cell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-cell.js","sources":["../../../../../../node_modules/mdast-util-to-hast/lib/handlers/table-cell.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableCell` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableCell} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function tableCell(state, node) {\n  // Note: this function is normally not called: see `table-row` for how rows\n  // and their cells are compiled.\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'td', // Assume body cell.\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE;AACvC;AACA;AACA;AACA,EAAE,MAAM,MAAM,GAAG;AACjB,IAAI,IAAI,EAAE,SAAS;AACnB,IAAI,OAAO,EAAE,IAAI;AACjB,IAAI,UAAU,EAAE,EAAE;AAClB,IAAI,QAAQ,EAAE,KAAK,CAAC,GAAG,CAAC,IAAI;AAC5B;AACA,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM;AAC1B,EAAE,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM;AACrC;;;;","x_google_ignoreList":[0]}

package/library/esm/node_modules/mdast-util-to-hast/lib/handlers/table-row.js

@@ -0,0 +1,70 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Parents} Parents
+ * @typedef {import('mdast').TableRow} TableRow
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `tableRow` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {TableRow} node
+ *   mdast node.
+ * @param {Parents | undefined} parent
+ *   Parent of `node`.
+ * @returns {Element}
+ *   hast node.
+ */
+function tableRow(state, node, parent) {
+  const siblings = parent ? parent.children : undefined;
+  // Generate a body row when without parent.
+  const rowIndex = siblings ? siblings.indexOf(node) : 1;
+  const tagName = rowIndex === 0 ? 'th' : 'td';
+  // To do: option to use `style`?
+  const align = parent && parent.type === 'table' ? parent.align : undefined;
+  const length = align ? align.length : node.children.length;
+  let cellIndex = -1;
+  /** @type {Array<ElementContent>} */
+  const cells = [];
+
+  while (++cellIndex < length) {
+    // Note: can also be undefined.
+    const cell = node.children[cellIndex];
+    /** @type {Properties} */
+    const properties = {};
+    const alignValue = align ? align[cellIndex] : undefined;
+
+    if (alignValue) {
+      properties.align = alignValue;
+    }
+
+    /** @type {Element} */
+    let result = {type: 'element', tagName, properties, children: []};
+
+    if (cell) {
+      result.children = state.all(cell);
+      state.patch(cell, result);
+      result = state.applyData(cell, result);
+    }
+
+    cells.push(result);
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'tr',
+    properties: {},
+    children: state.wrap(cells, true)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result)
+}
+
+export { tableRow };
+//# sourceMappingURL=table-row.js.map

package/library/esm/node_modules/mdast-util-to-hast/lib/handlers/table-row.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-row.js","sources":["../../../../../../node_modules/mdast-util-to-hast/lib/handlers/table-row.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableRow` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableRow} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function tableRow(state, node, parent) {\n  const siblings = parent ? parent.children : undefined\n  // Generate a body row when without parent.\n  const rowIndex = siblings ? siblings.indexOf(node) : 1\n  const tagName = rowIndex === 0 ? 'th' : 'td'\n  // To do: option to use `style`?\n  const align = parent && parent.type === 'table' ? parent.align : undefined\n  const length = align ? align.length : node.children.length\n  let cellIndex = -1\n  /** @type {Array<ElementContent>} */\n  const cells = []\n\n  while (++cellIndex < length) {\n    // Note: can also be undefined.\n    const cell = node.children[cellIndex]\n    /** @type {Properties} */\n    const properties = {}\n    const alignValue = align ? align[cellIndex] : undefined\n\n    if (alignValue) {\n      properties.align = alignValue\n    }\n\n    /** @type {Element} */\n    let result = {type: 'element', tagName, properties, children: []}\n\n    if (cell) {\n      result.children = state.all(cell)\n      state.patch(cell, result)\n      result = state.applyData(cell, result)\n    }\n\n    cells.push(result)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'tr',\n    properties: {},\n    children: state.wrap(cells, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE;AAC9C,EAAE,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC,QAAQ,GAAG;AAC9C;AACA,EAAE,MAAM,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG;AACvD,EAAE,MAAM,OAAO,GAAG,QAAQ,KAAK,CAAC,GAAG,IAAI,GAAG;AAC1C;AACA,EAAE,MAAM,KAAK,GAAG,MAAM,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,GAAG,MAAM,CAAC,KAAK,GAAG;AACnE,EAAE,MAAM,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC;AACtD,EAAE,IAAI,SAAS,GAAG;AAClB;AACA,EAAE,MAAM,KAAK,GAAG;;AAEhB,EAAE,OAAO,EAAE,SAAS,GAAG,MAAM,EAAE;AAC/B;AACA,IAAI,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS;AACxC;AACA,IAAI,MAAM,UAAU,GAAG;AACvB,IAAI,MAAM,UAAU,GAAG,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,GAAG;;AAElD,IAAI,IAAI,UAAU,EAAE;AACpB,MAAM,UAAU,CAAC,KAAK,GAAG;AACzB;;AAEA;AACA,IAAI,IAAI,MAAM,GAAG,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE;;AAEpE,IAAI,IAAI,IAAI,EAAE;AACd,MAAM,MAAM,CAAC,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI;AACtC,MAAM,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM;AAC9B,MAAM,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM;AAC3C;;AAEA,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM;AACrB;;AAEA;AACA,EAAE,MAAM,MAAM,GAAG;AACjB,IAAI,IAAI,EAAE,SAAS;AACnB,IAAI,OAAO,EAAE,IAAI;AACjB,IAAI,UAAU,EAAE,EAAE;AAClB,IAAI,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI;AACpC;AACA,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM;AAC1B,EAAE,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM;AACrC;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,65 @@
+import { pointStart, pointEnd } from '../../../unist-util-position/lib/index.js';
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Table} Table
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `table` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Table} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function table(state, node) {
+  const rows = state.all(node);
+  const firstRow = rows.shift();
+  /** @type {Array<Element>} */
+  const tableContent = [];
+
+  if (firstRow) {
+    /** @type {Element} */
+    const head = {
+      type: 'element',
+      tagName: 'thead',
+      properties: {},
+      children: state.wrap([firstRow], true)
+    };
+    state.patch(node.children[0], head);
+    tableContent.push(head);
+  }
+
+  if (rows.length > 0) {
+    /** @type {Element} */
+    const body = {
+      type: 'element',
+      tagName: 'tbody',
+      properties: {},
+      children: state.wrap(rows, true)
+    };
+
+    const start = pointStart(node.children[1]);
+    const end = pointEnd(node.children[node.children.length - 1]);
+    if (start && end) body.position = {start, end};
+    tableContent.push(body);
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'table',
+    properties: {},
+    children: state.wrap(tableContent, true)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result)
+}
+
+export { table };
+//# sourceMappingURL=table.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sources":["../../../../../../node_modules/mdast-util-to-hast/lib/handlers/table.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Table} Table\n * @typedef {import('../state.js').State} State\n */\n\nimport {pointEnd, pointStart} from 'unist-util-position'\n\n/**\n * Turn an mdast `table` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Table} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function table(state, node) {\n  const rows = state.all(node)\n  const firstRow = rows.shift()\n  /** @type {Array<Element>} */\n  const tableContent = []\n\n  if (firstRow) {\n    /** @type {Element} */\n    const head = {\n      type: 'element',\n      tagName: 'thead',\n      properties: {},\n      children: state.wrap([firstRow], true)\n    }\n    state.patch(node.children[0], head)\n    tableContent.push(head)\n  }\n\n  if (rows.length > 0) {\n    /** @type {Element} */\n    const body = {\n      type: 'element',\n      tagName: 'tbody',\n      properties: {},\n      children: state.wrap(rows, true)\n    }\n\n    const start = pointStart(node.children[1])\n    const end = pointEnd(node.children[node.children.length - 1])\n    if (start && end) body.position = {start, end}\n    tableContent.push(body)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'table',\n    properties: {},\n    children: state.wrap(tableContent, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":[],"mappings":";;AAAA;AACA;AACA;AACA;AACA;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE;AACnC,EAAE,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI;AAC7B,EAAE,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK;AAC7B;AACA,EAAE,MAAM,YAAY,GAAG;;AAEvB,EAAE,IAAI,QAAQ,EAAE;AAChB;AACA,IAAI,MAAM,IAAI,GAAG;AACjB,MAAM,IAAI,EAAE,SAAS;AACrB,MAAM,OAAO,EAAE,OAAO;AACtB,MAAM,UAAU,EAAE,EAAE;AACpB,MAAM,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,EAAE,IAAI;AAC3C;AACA,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI;AACtC,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI;AAC1B;;AAEA,EAAE,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;AACvB;AACA,IAAI,MAAM,IAAI,GAAG;AACjB,MAAM,IAAI,EAAE,SAAS;AACrB,MAAM,OAAO,EAAE,OAAO;AACtB,MAAM,UAAU,EAAE,EAAE;AACpB,MAAM,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI;AACrC;;AAEA,IAAI,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC7C,IAAI,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;AAChE,IAAI,IAAI,KAAK,IAAI,GAAG,EAAE,IAAI,CAAC,QAAQ,GAAG,CAAC,KAAK,EAAE,GAAG;AACjD,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI;AAC1B;;AAEA;AACA,EAAE,MAAM,MAAM,GAAG;AACjB,IAAI,IAAI,EAAE,SAAS;AACnB,IAAI,OAAO,EAAE,OAAO;AACpB,IAAI,UAAU,EAAE,EAAE;AAClB,IAAI,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI;AAC3C;AACA,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM;AAC1B,EAAE,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM;AACrC;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,29 @@
+import { trimLines } from '../../../trim-lines/index.js';
+
+/**
+ * @typedef {import('hast').Element} HastElement
+ * @typedef {import('hast').Text} HastText
+ * @typedef {import('mdast').Text} MdastText
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `text` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdastText} node
+ *   mdast node.
+ * @returns {HastElement | HastText}
+ *   hast node.
+ */
+function text(state, node) {
+  /** @type {HastText} */
+  const result = {type: 'text', value: trimLines(String(node.value))};
+  state.patch(node, result);
+  return state.applyData(node, result)
+}
+
+export { text };
+//# sourceMappingURL=text.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sources":["../../../../../../node_modules/mdast-util-to-hast/lib/handlers/text.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').Text} HastText\n * @typedef {import('mdast').Text} MdastText\n * @typedef {import('../state.js').State} State\n */\n\nimport {trimLines} from 'trim-lines'\n\n/**\n * Turn an mdast `text` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastText} node\n *   mdast node.\n * @returns {HastElement | HastText}\n *   hast node.\n */\nexport function text(state, node) {\n  /** @type {HastText} */\n  const result = {type: 'text', value: trimLines(String(node.value))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":[],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE;AAClC;AACA,EAAE,MAAM,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACpE,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM;AAC1B,EAAE,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM;AACrC;;;;","x_google_ignoreList":[0]}

package/library/esm/node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js

@@ -0,0 +1,31 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').ThematicBreak} ThematicBreak
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `thematicBreak` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {ThematicBreak} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function thematicBreak(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'hr',
+    properties: {},
+    children: []
+  };
+  state.patch(node, result);
+  return state.applyData(node, result)
+}
+
+export { thematicBreak };
+//# sourceMappingURL=thematic-break.js.map

package/library/esm/node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thematic-break.js","sources":["../../../../../../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js"],"sourcesContent":["/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `thematicBreak` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ThematicBreak} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function thematicBreak(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'hr',\n    properties: {},\n    children: []\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE;AAC3C;AACA,EAAE,MAAM,MAAM,GAAG;AACjB,IAAI,IAAI,EAAE,SAAS;AACnB,IAAI,OAAO,EAAE,IAAI;AACjB,IAAI,UAAU,EAAE,EAAE;AAClB,IAAI,QAAQ,EAAE;AACd;AACA,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM;AAC1B,EAAE,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM;AACrC;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,105 @@
+import { footer } from './footer.js';
+import { createState } from './state.js';
+
+/**
+ * @typedef {import('hast').Nodes} HastNodes
+ * @typedef {import('mdast').Nodes} MdastNodes
+ * @typedef {import('./state.js').Options} Options
+ */
+
+
+/**
+ * Transform mdast to hast.
+ *
+ * ##### Notes
+ *
+ * ###### HTML
+ *
+ * Raw HTML is available in mdast as `html` nodes and can be embedded in hast
+ * as semistandard `raw` nodes.
+ * Most utilities ignore `raw` nodes but two notable ones don’t:
+ *
+ * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will
+ *     output the raw HTML.
+ *     This is typically discouraged as noted by the option name but is useful
+ *     if you completely trust authors
+ * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them
+ *     into standard hast nodes (`element`, `text`, etc).
+ *     This is a heavy task as it needs a full HTML parser, but it is the only
+ *     way to support untrusted content
+ *
+ * ###### Footnotes
+ *
+ * Many options supported here relate to footnotes.
+ * Footnotes are not specified by CommonMark, which we follow by default.
+ * They are supported by GitHub, so footnotes can be enabled in markdown with
+ * `mdast-util-gfm`.
+ *
+ * The options `footnoteBackLabel` and `footnoteLabel` define natural language
+ * that explains footnotes, which is hidden for sighted users but shown to
+ * assistive technology.
+ * When your page is not in English, you must define translated values.
+ *
+ * Back references use ARIA attributes, but the section label itself uses a
+ * heading that is hidden with an `sr-only` class.
+ * To show it to sighted users, define different attributes in
+ * `footnoteLabelProperties`.
+ *
+ * ###### Clobbering
+ *
+ * Footnotes introduces a problem, as it links footnote calls to footnote
+ * definitions on the page through `id` attributes generated from user content,
+ * which results in DOM clobbering.
+ *
+ * DOM clobbering is this:
+ *
+ * ```html
+ * <p id=x></p>
+ * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>
+ * ```
+ *
+ * Elements by their ID are made available by browsers on the `window` object,
+ * which is a security risk.
+ * Using a prefix solves this problem.
+ *
+ * More information on how to handle clobbering and the prefix is explained in
+ * Example: headings (DOM clobbering) in `rehype-sanitize`.
+ *
+ * ###### Unknown nodes
+ *
+ * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
+ * The default behavior for unknown nodes is:
+ *
+ * *   when the node has a `value` (and doesn’t have `data.hName`,
+ *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`
+ *     node
+ * *   otherwise, create a `<div>` element (which could be changed with
+ *     `data.hName`), with its children mapped from mdast to hast as well
+ *
+ * This behavior can be changed by passing an `unknownHandler`.
+ *
+ * @param {MdastNodes} tree
+ *   mdast tree.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {HastNodes}
+ *   hast tree.
+ */
+function toHast(tree, options) {
+  const state = createState(tree, options);
+  const node = state.one(tree, undefined);
+  const foot = footer(state);
+  /** @type {HastNodes} */
+  const result = Array.isArray(node)
+    ? {type: 'root', children: node}
+    : node || {type: 'root', children: []};
+
+  if (foot) {
+    result.children.push({type: 'text', value: '\n'}, foot);
+  }
+
+  return result
+}
+
+export { toHast };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../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":";;;AAAA;AACA;AACA;AACA;AACA;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE;AACtC,EAAE,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,EAAE,OAAO;AACzC,EAAE,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS;AACxC,EAAE,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK;AAC3B;AACA,EAAE,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI;AACnC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI;AACnC,MAAM,IAAI,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE;;AAEzC,EAAE,IAAI,IAAI,EAAE;AAKZ,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI;AAC1D;;AAEA,EAAE,OAAO;AACT;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,56 @@
+/**
+ * @typedef {import('hast').ElementContent} ElementContent
+ *
+ * @typedef {import('mdast').Nodes} Nodes
+ * @typedef {import('mdast').Reference} Reference
+ *
+ * @typedef {import('./state.js').State} State
+ */
+
+
+/**
+ * Return the content of a reference without definition as plain text.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Extract<Nodes, Reference>} node
+ *   Reference node (image, link).
+ * @returns {Array<ElementContent>}
+ *   hast content.
+ */
+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 { revert };
+//# sourceMappingURL=revert.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"revert.js","sources":["../../../../../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":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE;AACpC,EAAE,MAAM,OAAO,GAAG,IAAI,CAAC;AACvB,EAAE,IAAI,MAAM,GAAG;;AAEf,EAAE,IAAI,OAAO,KAAK,WAAW,EAAE;AAC/B,IAAI,MAAM,IAAI;AACd,GAAG,MAAM,IAAI,OAAO,KAAK,MAAM,EAAE;AACjC,IAAI,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG;AACtD;;AAEA,EAAE,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,EAAE;AACtC,IAAI,OAAO,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,GAAG,IAAI,CAAC,GAAG,GAAG,MAAM,CAAC;AAC3D;;AAEA,EAAE,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI;AACjC,EAAE,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC;;AAEzB,EAAE,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE;AACpC,IAAI,IAAI,CAAC,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC;AAC5B,GAAG,MAAM;AACT,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,CAAC;AAC/C;;AAEA,EAAE,MAAM,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC;;AAE3C,EAAE,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE;AACpC,IAAI,IAAI,CAAC,KAAK,IAAI;AAClB,GAAG,MAAM;AACT,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC;AAC/C;;AAEA,EAAE,OAAO;AACT;;;;","x_google_ignoreList":[0]}