@choice-ui/react 1.3.10

package/dist/cjs/_vendor/mdast-util-math/lib-index.cjs

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _default = require("../devlop/lib-default.cjs");
+const index = require("../longest-streak/index.cjs");
+function mathFromMarkdown() {
+  return {
+    enter: {
+      mathFlow: enterMathFlow,
+      mathFlowFenceMeta: enterMathFlowMeta,
+      mathText: enterMathText
+    },
+    exit: {
+      mathFlow: exitMathFlow,
+      mathFlowFence: exitMathFlowFence,
+      mathFlowFenceMeta: exitMathFlowMeta,
+      mathFlowValue: exitMathData,
+      mathText: exitMathText,
+      mathTextData: exitMathData
+    }
+  };
+  function enterMathFlow(token) {
+    const code = {
+      type: "element",
+      tagName: "code",
+      properties: { className: ["language-math", "math-display"] },
+      children: []
+    };
+    this.enter(
+      {
+        type: "math",
+        meta: null,
+        value: "",
+        data: { hName: "pre", hChildren: [code] }
+      },
+      token
+    );
+  }
+  function enterMathFlowMeta() {
+    this.buffer();
+  }
+  function exitMathFlowMeta() {
+    const data = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    _default.ok(node.type === "math");
+    node.meta = data;
+  }
+  function exitMathFlowFence() {
+    if (this.data.mathFlowInside) return;
+    this.buffer();
+    this.data.mathFlowInside = true;
+  }
+  function exitMathFlow(token) {
+    const data = this.resume().replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, "");
+    const node = this.stack[this.stack.length - 1];
+    _default.ok(node.type === "math");
+    this.exit(token);
+    node.value = data;
+    const code = (
+      /** @type {HastElement} */
+      node.data.hChildren[0]
+    );
+    _default.ok(code.type === "element");
+    _default.ok(code.tagName === "code");
+    code.children.push({ type: "text", value: data });
+    this.data.mathFlowInside = void 0;
+  }
+  function enterMathText(token) {
+    this.enter(
+      {
+        type: "inlineMath",
+        value: "",
+        data: {
+          hName: "code",
+          hProperties: { className: ["language-math", "math-inline"] },
+          hChildren: []
+        }
+      },
+      token
+    );
+    this.buffer();
+  }
+  function exitMathText(token) {
+    const data = this.resume();
+    const node = this.stack[this.stack.length - 1];
+    _default.ok(node.type === "inlineMath");
+    this.exit(token);
+    node.value = data;
+    const children = (
+      /** @type {Array<HastElementContent>} */
+      // @ts-expect-error: we defined it in `enterMathFlow`.
+      node.data.hChildren
+    );
+    children.push({ type: "text", value: data });
+  }
+  function exitMathData(token) {
+    this.config.enter.data.call(this, token);
+    this.config.exit.data.call(this, token);
+  }
+}
+function mathToMarkdown(options) {
+  let single = (options || {}).singleDollarTextMath;
+  if (single === null || single === void 0) {
+    single = true;
+  }
+  inlineMath.peek = inlineMathPeek;
+  return {
+    unsafe: [
+      { character: "\r", inConstruct: "mathFlowMeta" },
+      { character: "\n", inConstruct: "mathFlowMeta" },
+      {
+        character: "$",
+        after: single ? void 0 : "\\$",
+        inConstruct: "phrasing"
+      },
+      { character: "$", inConstruct: "mathFlowMeta" },
+      { atBreak: true, character: "$", after: "\\$" }
+    ],
+    handlers: { math, inlineMath }
+  };
+  function math(node, _, state, info) {
+    const raw = node.value || "";
+    const tracker = state.createTracker(info);
+    const sequence = "$".repeat(Math.max(index.longestStreak(raw, "$") + 1, 2));
+    const exit = state.enter("mathFlow");
+    let value = tracker.move(sequence);
+    if (node.meta) {
+      const subexit = state.enter("mathFlowMeta");
+      value += tracker.move(
+        state.safe(node.meta, {
+          after: "\n",
+          before: value,
+          encode: ["$"],
+          ...tracker.current()
+        })
+      );
+      subexit();
+    }
+    value += tracker.move("\n");
+    if (raw) {
+      value += tracker.move(raw + "\n");
+    }
+    value += tracker.move(sequence);
+    exit();
+    return value;
+  }
+  function inlineMath(node, _, state) {
+    let value = node.value || "";
+    let size = 1;
+    if (!single) size++;
+    while (new RegExp("(^|[^$])" + "\\$".repeat(size) + "([^$]|$)").test(value)) {
+      size++;
+    }
+    const sequence = "$".repeat(size);
+    if (
+      // Contains non-space.
+      /[^ \r\n]/.test(value) && // Starts with space and ends with space.
+      (/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value) || // Starts or ends with dollar.
+      /^\$|\$$/.test(value))
+    ) {
+      value = " " + value + " ";
+    }
+    let index2 = -1;
+    while (++index2 < state.unsafe.length) {
+      const pattern = state.unsafe[index2];
+      if (!pattern.atBreak) continue;
+      const expression = state.compilePattern(pattern);
+      let match;
+      while (match = expression.exec(value)) {
+        let position = match.index;
+        if (value.codePointAt(position) === 10 && value.codePointAt(position - 1) === 13) {
+          position--;
+        }
+        value = value.slice(0, position) + " " + value.slice(match.index + 1);
+      }
+    }
+    return sequence + value + sequence;
+  }
+  function inlineMathPeek() {
+    return "$";
+  }
+}
+exports.mathFromMarkdown = mathFromMarkdown;
+exports.mathToMarkdown = mathToMarkdown;

package/dist/cjs/_vendor/mdast-util-newline-to-break/lib-index.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../mdast-util-find-and-replace/lib-index.cjs");
+function newlineToBreak(tree) {
+  index.findAndReplace(tree, [/\r?\n|\r/g, replace]);
+}
+function replace() {
+  return { type: "break" };
+}
+exports.newlineToBreak = newlineToBreak;

package/dist/cjs/_vendor/mdast-util-phrasing/lib-index.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../unist-util-is/lib-index.cjs");
+const phrasing = (
+  /** @type {(node?: unknown) => node is Exclude<PhrasingContent, Html>} */
+  index.convert([
+    "break",
+    "delete",
+    "emphasis",
+    // To do: next major: removed since footnotes were added to GFM.
+    "footnote",
+    "footnoteReference",
+    "image",
+    "imageReference",
+    "inlineCode",
+    // Enabled by `mdast-util-math`:
+    "inlineMath",
+    "link",
+    "linkReference",
+    // Enabled by `mdast-util-mdx`:
+    "mdxJsxTextElement",
+    // Enabled by `mdast-util-mdx`:
+    "mdxTextExpression",
+    "strong",
+    "text",
+    // Enabled by `mdast-util-directive`:
+    "textDirective"
+  ])
+);
+exports.phrasing = phrasing;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-footer.cjs

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index$1 = require("../@ungap/structured-clone/esm-index.cjs");
+const index = require("../micromark-util-sanitize-uri/index.cjs");
+function defaultFootnoteBackContent(_, rereferenceIndex) {
+  const result = [{ type: "text", value: "↩" }];
+  if (rereferenceIndex > 1) {
+    result.push({
+      type: "element",
+      tagName: "sup",
+      properties: {},
+      children: [{ type: "text", value: String(rereferenceIndex) }]
+    });
+  }
+  return result;
+}
+function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {
+  return "Back to reference " + (referenceIndex + 1) + (rereferenceIndex > 1 ? "-" + rereferenceIndex : "");
+}
+function footer(state) {
+  const clobberPrefix = typeof state.options.clobberPrefix === "string" ? state.options.clobberPrefix : "user-content-";
+  const footnoteBackContent = state.options.footnoteBackContent || defaultFootnoteBackContent;
+  const footnoteBackLabel = state.options.footnoteBackLabel || defaultFootnoteBackLabel;
+  const footnoteLabel = state.options.footnoteLabel || "Footnotes";
+  const footnoteLabelTagName = state.options.footnoteLabelTagName || "h2";
+  const footnoteLabelProperties = state.options.footnoteLabelProperties || {
+    className: ["sr-only"]
+  };
+  const listItems = [];
+  let referenceIndex = -1;
+  while (++referenceIndex < state.footnoteOrder.length) {
+    const definition = state.footnoteById.get(
+      state.footnoteOrder[referenceIndex]
+    );
+    if (!definition) {
+      continue;
+    }
+    const content = state.all(definition);
+    const id = String(definition.identifier).toUpperCase();
+    const safeId = index.normalizeUri(id.toLowerCase());
+    let rereferenceIndex = 0;
+    const backReferences = [];
+    const counts = state.footnoteCounts.get(id);
+    while (counts !== void 0 && ++rereferenceIndex <= counts) {
+      if (backReferences.length > 0) {
+        backReferences.push({ type: "text", value: " " });
+      }
+      let children = typeof footnoteBackContent === "string" ? footnoteBackContent : footnoteBackContent(referenceIndex, rereferenceIndex);
+      if (typeof children === "string") {
+        children = { type: "text", value: children };
+      }
+      backReferences.push({
+        type: "element",
+        tagName: "a",
+        properties: {
+          href: "#" + clobberPrefix + "fnref-" + safeId + (rereferenceIndex > 1 ? "-" + rereferenceIndex : ""),
+          dataFootnoteBackref: "",
+          ariaLabel: typeof footnoteBackLabel === "string" ? footnoteBackLabel : footnoteBackLabel(referenceIndex, rereferenceIndex),
+          className: ["data-footnote-backref"]
+        },
+        children: Array.isArray(children) ? children : [children]
+      });
+    }
+    const tail = content[content.length - 1];
+    if (tail && tail.type === "element" && tail.tagName === "p") {
+      const tailTail = tail.children[tail.children.length - 1];
+      if (tailTail && tailTail.type === "text") {
+        tailTail.value += " ";
+      } else {
+        tail.children.push({ type: "text", value: " " });
+      }
+      tail.children.push(...backReferences);
+    } else {
+      content.push(...backReferences);
+    }
+    const listItem = {
+      type: "element",
+      tagName: "li",
+      properties: { id: clobberPrefix + "fn-" + safeId },
+      children: state.wrap(content, true)
+    };
+    state.patch(definition, listItem);
+    listItems.push(listItem);
+  }
+  if (listItems.length === 0) {
+    return;
+  }
+  return {
+    type: "element",
+    tagName: "section",
+    properties: { dataFootnotes: true, className: ["footnotes"] },
+    children: [
+      {
+        type: "element",
+        tagName: footnoteLabelTagName,
+        properties: {
+          ...index$1.default(footnoteLabelProperties),
+          id: "footnote-label"
+        },
+        children: [{ type: "text", value: footnoteLabel }]
+      },
+      { type: "text", value: "\n" },
+      {
+        type: "element",
+        tagName: "ol",
+        properties: {},
+        children: state.wrap(listItems, true)
+      },
+      { type: "text", value: "\n" }
+    ]
+  };
+}
+exports.defaultFootnoteBackContent = defaultFootnoteBackContent;
+exports.defaultFootnoteBackLabel = defaultFootnoteBackLabel;
+exports.footer = footer;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-blockquote.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function blockquote(state, node) {
+  const result = {
+    type: "element",
+    tagName: "blockquote",
+    properties: {},
+    children: state.wrap(state.all(node), true)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+exports.blockquote = blockquote;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-break.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function hardBreak(state, node) {
+  const result = { type: "element", tagName: "br", properties: {}, children: [] };
+  state.patch(node, result);
+  return [state.applyData(node, result), { type: "text", value: "\n" }];
+}
+exports.hardBreak = hardBreak;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-code.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function code(state, node) {
+  const value = node.value ? node.value + "\n" : "";
+  const properties = {};
+  const language = node.lang ? node.lang.split(/\s+/) : [];
+  if (language.length > 0) {
+    properties.className = ["language-" + language[0]];
+  }
+  let result = {
+    type: "element",
+    tagName: "code",
+    properties,
+    children: [{ type: "text", value }]
+  };
+  if (node.meta) {
+    result.data = { meta: node.meta };
+  }
+  state.patch(node, result);
+  result = state.applyData(node, result);
+  result = { type: "element", tagName: "pre", properties: {}, children: [result] };
+  state.patch(node, result);
+  return result;
+}
+exports.code = code;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-delete.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function strikethrough(state, node) {
+  const result = {
+    type: "element",
+    tagName: "del",
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+exports.strikethrough = strikethrough;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-emphasis.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function emphasis(state, node) {
+  const result = {
+    type: "element",
+    tagName: "em",
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+exports.emphasis = emphasis;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-footnote-reference.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../micromark-util-sanitize-uri/index.cjs");
+function footnoteReference(state, node) {
+  const clobberPrefix = typeof state.options.clobberPrefix === "string" ? state.options.clobberPrefix : "user-content-";
+  const id = String(node.identifier).toUpperCase();
+  const safeId = index.normalizeUri(id.toLowerCase());
+  const index$1 = state.footnoteOrder.indexOf(id);
+  let counter;
+  let reuseCounter = state.footnoteCounts.get(id);
+  if (reuseCounter === void 0) {
+    reuseCounter = 0;
+    state.footnoteOrder.push(id);
+    counter = state.footnoteOrder.length;
+  } else {
+    counter = index$1 + 1;
+  }
+  reuseCounter += 1;
+  state.footnoteCounts.set(id, reuseCounter);
+  const link = {
+    type: "element",
+    tagName: "a",
+    properties: {
+      href: "#" + clobberPrefix + "fn-" + safeId,
+      id: clobberPrefix + "fnref-" + safeId + (reuseCounter > 1 ? "-" + reuseCounter : ""),
+      dataFootnoteRef: true,
+      ariaDescribedBy: ["footnote-label"]
+    },
+    children: [{ type: "text", value: String(counter) }]
+  };
+  state.patch(node, link);
+  const sup = {
+    type: "element",
+    tagName: "sup",
+    properties: {},
+    children: [link]
+  };
+  state.patch(node, sup);
+  return state.applyData(node, sup);
+}
+exports.footnoteReference = footnoteReference;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-heading.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function heading(state, node) {
+  const result = {
+    type: "element",
+    tagName: "h" + node.depth,
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+exports.heading = heading;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-html.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function html(state, node) {
+  if (state.options.allowDangerousHtml) {
+    const result = { type: "raw", value: node.value };
+    state.patch(node, result);
+    return state.applyData(node, result);
+  }
+  return void 0;
+}
+exports.html = html;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-image-reference.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../micromark-util-sanitize-uri/index.cjs");
+const revert = require("./lib-revert.cjs");
+function imageReference(state, node) {
+  const id = String(node.identifier).toUpperCase();
+  const definition = state.definitionById.get(id);
+  if (!definition) {
+    return revert.revert(state, node);
+  }
+  const properties = { src: index.normalizeUri(definition.url || ""), alt: node.alt };
+  if (definition.title !== null && definition.title !== void 0) {
+    properties.title = definition.title;
+  }
+  const result = { type: "element", tagName: "img", properties, children: [] };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+exports.imageReference = imageReference;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-image.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../micromark-util-sanitize-uri/index.cjs");
+function image(state, node) {
+  const properties = { src: index.normalizeUri(node.url) };
+  if (node.alt !== null && node.alt !== void 0) {
+    properties.alt = node.alt;
+  }
+  if (node.title !== null && node.title !== void 0) {
+    properties.title = node.title;
+  }
+  const result = { type: "element", tagName: "img", properties, children: [] };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+exports.image = image;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-index.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const blockquote = require("./lib-handlers-blockquote.cjs");
+const _break = require("./lib-handlers-break.cjs");
+const code = require("./lib-handlers-code.cjs");
+const _delete = require("./lib-handlers-delete.cjs");
+const emphasis = require("./lib-handlers-emphasis.cjs");
+const footnoteReference = require("./lib-handlers-footnote-reference.cjs");
+const heading = require("./lib-handlers-heading.cjs");
+const html = require("./lib-handlers-html.cjs");
+const imageReference = require("./lib-handlers-image-reference.cjs");
+const image = require("./lib-handlers-image.cjs");
+const inlineCode = require("./lib-handlers-inline-code.cjs");
+const linkReference = require("./lib-handlers-link-reference.cjs");
+const link = require("./lib-handlers-link.cjs");
+const listItem = require("./lib-handlers-list-item.cjs");
+const list = require("./lib-handlers-list.cjs");
+const paragraph = require("./lib-handlers-paragraph.cjs");
+const root = require("./lib-handlers-root.cjs");
+const strong = require("./lib-handlers-strong.cjs");
+const table = require("./lib-handlers-table.cjs");
+const tableRow = require("./lib-handlers-table-row.cjs");
+const tableCell = require("./lib-handlers-table-cell.cjs");
+const text = require("./lib-handlers-text.cjs");
+const thematicBreak = require("./lib-handlers-thematic-break.cjs");
+const handlers = {
+  blockquote: blockquote.blockquote,
+  break: _break.hardBreak,
+  code: code.code,
+  delete: _delete.strikethrough,
+  emphasis: emphasis.emphasis,
+  footnoteReference: footnoteReference.footnoteReference,
+  heading: heading.heading,
+  html: html.html,
+  imageReference: imageReference.imageReference,
+  image: image.image,
+  inlineCode: inlineCode.inlineCode,
+  linkReference: linkReference.linkReference,
+  link: link.link,
+  listItem: listItem.listItem,
+  list: list.list,
+  paragraph: paragraph.paragraph,
+  // @ts-expect-error: root is different, but hard to type.
+  root: root.root,
+  strong: strong.strong,
+  table: table.table,
+  tableCell: tableCell.tableCell,
+  tableRow: tableRow.tableRow,
+  text: text.text,
+  thematicBreak: thematicBreak.thematicBreak,
+  toml: ignore,
+  yaml: ignore,
+  definition: ignore,
+  footnoteDefinition: ignore
+};
+function ignore() {
+  return void 0;
+}
+exports.handlers = handlers;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-inline-code.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function inlineCode(state, node) {
+  const text = { type: "text", value: node.value.replace(/\r?\n|\r/g, " ") };
+  state.patch(node, text);
+  const result = {
+    type: "element",
+    tagName: "code",
+    properties: {},
+    children: [text]
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+exports.inlineCode = inlineCode;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-link-reference.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../micromark-util-sanitize-uri/index.cjs");
+const revert = require("./lib-revert.cjs");
+function linkReference(state, node) {
+  const id = String(node.identifier).toUpperCase();
+  const definition = state.definitionById.get(id);
+  if (!definition) {
+    return revert.revert(state, node);
+  }
+  const properties = { href: index.normalizeUri(definition.url || "") };
+  if (definition.title !== null && definition.title !== void 0) {
+    properties.title = definition.title;
+  }
+  const result = {
+    type: "element",
+    tagName: "a",
+    properties,
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+exports.linkReference = linkReference;

package/dist/cjs/_vendor/mdast-util-to-hast/lib-handlers-link.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../micromark-util-sanitize-uri/index.cjs");
+function link(state, node) {
+  const properties = { href: index.normalizeUri(node.url) };
+  if (node.title !== null && node.title !== void 0) {
+    properties.title = node.title;
+  }
+  const result = {
+    type: "element",
+    tagName: "a",
+    properties,
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+exports.link = link;