@choice-ui/react 1.3.10

package/dist/esm/_vendor/property-information/lib-util-schema.js

@@ -0,0 +1,25 @@
+class Schema {
+  /**
+   * @param {SchemaType['property']} property
+   *   Property.
+   * @param {SchemaType['normal']} normal
+   *   Normal.
+   * @param {Space | undefined} [space]
+   *   Space.
+   * @returns
+   *   Schema.
+   */
+  constructor(property, normal, space) {
+    this.normal = normal;
+    this.property = property;
+    if (space) {
+      this.space = space;
+    }
+  }
+}
+Schema.prototype.normal = {};
+Schema.prototype.property = {};
+Schema.prototype.space = void 0;
+export {
+  Schema
+};

package/dist/esm/_vendor/property-information/lib-util-types.js

@@ -0,0 +1,20 @@
+let powers = 0;
+const boolean = increment();
+const booleanish = increment();
+const overloadedBoolean = increment();
+const number = increment();
+const spaceSeparated = increment();
+const commaSeparated = increment();
+const commaOrSpaceSeparated = increment();
+function increment() {
+  return 2 ** ++powers;
+}
+export {
+  boolean,
+  booleanish,
+  commaOrSpaceSeparated,
+  commaSeparated,
+  number,
+  overloadedBoolean,
+  spaceSeparated
+};

package/dist/esm/_vendor/property-information/lib-xlink.js

@@ -0,0 +1,19 @@
+import { create } from "./lib-util-create.js";
+const xlink = create({
+  properties: {
+    xLinkActuate: null,
+    xLinkArcRole: null,
+    xLinkHref: null,
+    xLinkRole: null,
+    xLinkShow: null,
+    xLinkTitle: null,
+    xLinkType: null
+  },
+  space: "xlink",
+  transform(_, property) {
+    return "xlink:" + property.slice(5).toLowerCase();
+  }
+});
+export {
+  xlink
+};

package/dist/esm/_vendor/property-information/lib-xml.js

@@ -0,0 +1,11 @@
+import { create } from "./lib-util-create.js";
+const xml = create({
+  properties: { xmlBase: null, xmlLang: null, xmlSpace: null },
+  space: "xml",
+  transform(_, property) {
+    return "xml:" + property.slice(3).toLowerCase();
+  }
+});
+export {
+  xml
+};

package/dist/esm/_vendor/property-information/lib-xmlns.js

@@ -0,0 +1,11 @@
+import { create } from "./lib-util-create.js";
+import { caseInsensitiveTransform } from "./lib-util-case-insensitive-transform.js";
+const xmlns = create({
+  attributes: { xmlnsxlink: "xmlns:xlink" },
+  properties: { xmlnsXLink: null, xmlns: null },
+  space: "xmlns",
+  transform: caseInsensitiveTransform
+});
+export {
+  xmlns
+};

package/dist/esm/_vendor/react-markdown/index.js

@@ -0,0 +1,7 @@
+import { MarkdownAsync, MarkdownHooks, Markdown, defaultUrlTransform } from "./lib-index.js";
+export {
+  MarkdownAsync,
+  MarkdownHooks,
+  Markdown as default,
+  defaultUrlTransform
+};

package/dist/esm/_vendor/react-markdown/lib-index.js

@@ -0,0 +1,200 @@
+import { unreachable } from "../devlop/lib-default.js";
+import { Fragment, jsxs, jsx } from "react/jsx-runtime";
+import { useState, useEffect, createElement } from "react";
+import { unified } from "../unified/lib-index.js";
+import remarkParse from "../remark-parse/lib-index.js";
+import remarkRehype from "../remark-rehype/lib-index.js";
+import { VFile } from "../vfile/lib-index.js";
+import { visit } from "../unist-util-visit/lib-index.js";
+import { toJsxRuntime } from "../hast-util-to-jsx-runtime/lib-index.js";
+import { urlAttributes } from "../html-url-attributes/lib-index.js";
+const changelog = "https://github.com/remarkjs/react-markdown/blob/main/changelog.md";
+const emptyPlugins = [];
+const emptyRemarkRehypeOptions = { allowDangerousHtml: true };
+const safeProtocol = /^(https?|ircs?|mailto|xmpp)$/i;
+const deprecations = [
+  { from: "astPlugins", id: "remove-buggy-html-in-markdown-parser" },
+  { from: "allowDangerousHtml", id: "remove-buggy-html-in-markdown-parser" },
+  {
+    from: "allowNode",
+    id: "replace-allownode-allowedtypes-and-disallowedtypes",
+    to: "allowElement"
+  },
+  {
+    from: "allowedTypes",
+    id: "replace-allownode-allowedtypes-and-disallowedtypes",
+    to: "allowedElements"
+  },
+  {
+    from: "disallowedTypes",
+    id: "replace-allownode-allowedtypes-and-disallowedtypes",
+    to: "disallowedElements"
+  },
+  { from: "escapeHtml", id: "remove-buggy-html-in-markdown-parser" },
+  { from: "includeElementIndex", id: "#remove-includeelementindex" },
+  {
+    from: "includeNodeIndex",
+    id: "change-includenodeindex-to-includeelementindex"
+  },
+  { from: "linkTarget", id: "remove-linktarget" },
+  { from: "plugins", id: "change-plugins-to-remarkplugins", to: "remarkPlugins" },
+  { from: "rawSourcePos", id: "#remove-rawsourcepos" },
+  { from: "renderers", id: "change-renderers-to-components", to: "components" },
+  { from: "source", id: "change-source-to-children", to: "children" },
+  { from: "sourcePos", id: "#remove-sourcepos" },
+  { from: "transformImageUri", id: "#add-urltransform", to: "urlTransform" },
+  { from: "transformLinkUri", id: "#add-urltransform", to: "urlTransform" }
+];
+function Markdown(options) {
+  const processor = createProcessor(options);
+  const file = createFile(options);
+  return post(processor.runSync(processor.parse(file), file), options);
+}
+async function MarkdownAsync(options) {
+  const processor = createProcessor(options);
+  const file = createFile(options);
+  const tree = await processor.run(processor.parse(file), file);
+  return post(tree, options);
+}
+function MarkdownHooks(options) {
+  const processor = createProcessor(options);
+  const [error, setError] = useState(
+    /** @type {Error | undefined} */
+    void 0
+  );
+  const [tree, setTree] = useState(
+    /** @type {Root | undefined} */
+    void 0
+  );
+  useEffect(
+    /* c8 ignore next 7 -- hooks are client-only. */
+    function() {
+      const file = createFile(options);
+      processor.run(processor.parse(file), file, function(error2, tree2) {
+        setError(error2);
+        setTree(tree2);
+      });
+    },
+    [
+      options.children,
+      options.rehypePlugins,
+      options.remarkPlugins,
+      options.remarkRehypeOptions
+    ]
+  );
+  if (error) throw error;
+  return tree ? post(tree, options) : createElement(Fragment);
+}
+function createProcessor(options) {
+  const rehypePlugins = options.rehypePlugins || emptyPlugins;
+  const remarkPlugins = options.remarkPlugins || emptyPlugins;
+  const remarkRehypeOptions = options.remarkRehypeOptions ? { ...options.remarkRehypeOptions, ...emptyRemarkRehypeOptions } : emptyRemarkRehypeOptions;
+  const processor = unified().use(remarkParse).use(remarkPlugins).use(remarkRehype, remarkRehypeOptions).use(rehypePlugins);
+  return processor;
+}
+function createFile(options) {
+  const children = options.children || "";
+  const file = new VFile();
+  if (typeof children === "string") {
+    file.value = children;
+  }
+  return file;
+}
+function post(tree, options) {
+  const allowedElements = options.allowedElements;
+  const allowElement = options.allowElement;
+  const components = options.components;
+  const disallowedElements = options.disallowedElements;
+  const skipHtml = options.skipHtml;
+  const unwrapDisallowed = options.unwrapDisallowed;
+  const urlTransform = options.urlTransform || defaultUrlTransform;
+  for (const deprecation of deprecations) {
+    if (Object.hasOwn(options, deprecation.from)) {
+      unreachable(
+        "Unexpected `" + deprecation.from + "` prop, " + (deprecation.to ? "use `" + deprecation.to + "` instead" : "remove it") + " (see <" + changelog + "#" + deprecation.id + "> for more info)"
+      );
+    }
+  }
+  if (options.className) {
+    tree = {
+      type: "element",
+      tagName: "div",
+      properties: { className: options.className },
+      // Assume no doctypes.
+      children: (
+        /** @type {Array<ElementContent>} */
+        tree.type === "root" ? tree.children : [tree]
+      )
+    };
+  }
+  visit(tree, transform);
+  return toJsxRuntime(tree, {
+    Fragment,
+    // @ts-expect-error
+    // React components are allowed to return numbers,
+    // but not according to the types in hast-util-to-jsx-runtime
+    components,
+    ignoreInvalidStyle: true,
+    jsx,
+    jsxs,
+    passKeys: true,
+    passNode: true
+  });
+  function transform(node, index, parent) {
+    if (node.type === "raw" && parent && typeof index === "number") {
+      if (skipHtml) {
+        parent.children.splice(index, 1);
+      } else {
+        parent.children[index] = { type: "text", value: node.value };
+      }
+      return index;
+    }
+    if (node.type === "element") {
+      let key;
+      for (key in urlAttributes) {
+        if (Object.hasOwn(urlAttributes, key) && Object.hasOwn(node.properties, key)) {
+          const value = node.properties[key];
+          const test = urlAttributes[key];
+          if (test === null || test.includes(node.tagName)) {
+            node.properties[key] = urlTransform(String(value || ""), key, node);
+          }
+        }
+      }
+    }
+    if (node.type === "element") {
+      let remove = allowedElements ? !allowedElements.includes(node.tagName) : disallowedElements ? disallowedElements.includes(node.tagName) : false;
+      if (!remove && allowElement && typeof index === "number") {
+        remove = !allowElement(node, index, parent);
+      }
+      if (remove && parent && typeof index === "number") {
+        if (unwrapDisallowed && node.children) {
+          parent.children.splice(index, 1, ...node.children);
+        } else {
+          parent.children.splice(index, 1);
+        }
+        return index;
+      }
+    }
+  }
+}
+function defaultUrlTransform(value) {
+  const colon = value.indexOf(":");
+  const questionMark = value.indexOf("?");
+  const numberSign = value.indexOf("#");
+  const slash = value.indexOf("/");
+  if (
+    // If there is no protocol, it’s relative.
+    colon === -1 || // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.
+    slash !== -1 && colon > slash || questionMark !== -1 && colon > questionMark || numberSign !== -1 && colon > numberSign || // It is a protocol, it should be allowed.
+    safeProtocol.test(value.slice(0, colon))
+  ) {
+    return value;
+  }
+  return "";
+}
+export {
+  Markdown,
+  MarkdownAsync,
+  MarkdownHooks,
+  defaultUrlTransform
+};

package/dist/esm/_vendor/rehype-harden/dist-index.js

@@ -0,0 +1,190 @@
+import { visit } from "../unist-util-visit/lib-index.js";
+import { CONTINUE, SKIP } from "../unist-util-visit-parents/lib-index.js";
+function harden({ defaultOrigin = "", allowedLinkPrefixes = [], allowedImagePrefixes = [], allowDataImages = false, allowedProtocols = [], blockedImageClass = "inline-block bg-gray-200 dark:bg-gray-700 text-gray-600 dark:text-gray-400 px-3 py-1 rounded text-sm", blockedLinkClass = "text-gray-500" }) {
+  const hasSpecificLinkPrefixes = allowedLinkPrefixes.length && !allowedLinkPrefixes.every((p) => p === "*");
+  const hasSpecificImagePrefixes = allowedImagePrefixes.length && !allowedImagePrefixes.every((p) => p === "*");
+  if (!defaultOrigin && (hasSpecificLinkPrefixes || hasSpecificImagePrefixes)) {
+    throw new Error("defaultOrigin is required when allowedLinkPrefixes or allowedImagePrefixes are provided");
+  }
+  return (tree) => {
+    const visitor = createVisitor(defaultOrigin, allowedLinkPrefixes, allowedImagePrefixes, allowDataImages, allowedProtocols, blockedImageClass, blockedLinkClass);
+    visit(tree, visitor);
+  };
+}
+function parseUrl(url, defaultOrigin) {
+  if (typeof url !== "string")
+    return null;
+  try {
+    return new URL(url);
+  } catch {
+    if (defaultOrigin) {
+      try {
+        return new URL(url, defaultOrigin);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+function isPathRelativeUrl(url) {
+  if (typeof url !== "string")
+    return false;
+  return url.startsWith("/");
+}
+const safeProtocols = /* @__PURE__ */ new Set([
+  "https:",
+  "http:",
+  "irc:",
+  "ircs:",
+  "mailto:",
+  "xmpp:",
+  "blob:"
+]);
+const blockedProtocols = /* @__PURE__ */ new Set([
+  "javascript:",
+  "data:",
+  "file:",
+  "vbscript:"
+]);
+function transformUrl(url, allowedPrefixes, defaultOrigin, allowDataImages = false, isImage = false, allowedProtocols = []) {
+  if (!url)
+    return null;
+  if (typeof url === "string" && url.startsWith("#") && !isImage) {
+    try {
+      const testUrl = new URL(url, "http://example.com");
+      if (testUrl.hash === url) {
+        return url;
+      }
+    } catch {
+    }
+  }
+  if (typeof url === "string" && url.startsWith("data:")) {
+    if (isImage && allowDataImages && url.startsWith("data:image/")) {
+      return url;
+    }
+    return null;
+  }
+  if (typeof url === "string" && url.startsWith("blob:")) {
+    try {
+      const blobUrl = new URL(url);
+      if (blobUrl.protocol === "blob:" && url.length > 5) {
+        const afterProtocol = url.substring(5);
+        if (afterProtocol && afterProtocol.length > 0 && afterProtocol !== "invalid") {
+          return url;
+        }
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  const parsedUrl = parseUrl(url, defaultOrigin);
+  if (!parsedUrl)
+    return null;
+  if (blockedProtocols.has(parsedUrl.protocol)) {
+    return null;
+  }
+  const isProtocolAllowed = safeProtocols.has(parsedUrl.protocol) || allowedProtocols.includes(parsedUrl.protocol) || allowedProtocols.includes("*");
+  if (!isProtocolAllowed)
+    return null;
+  if (parsedUrl.protocol === "mailto:" || !parsedUrl.protocol.match(/^https?:$/)) {
+    return parsedUrl.href;
+  }
+  const inputWasRelative = isPathRelativeUrl(url);
+  if (parsedUrl && allowedPrefixes.some((prefix) => {
+    const parsedPrefix = parseUrl(prefix, defaultOrigin);
+    if (!parsedPrefix) {
+      return false;
+    }
+    if (parsedPrefix.origin !== parsedUrl.origin) {
+      return false;
+    }
+    return parsedUrl.href.startsWith(parsedPrefix.href);
+  })) {
+    if (inputWasRelative) {
+      return parsedUrl.pathname + parsedUrl.search + parsedUrl.hash;
+    }
+    return parsedUrl.href;
+  }
+  if (allowedPrefixes.includes("*")) {
+    if (parsedUrl.protocol !== "https:" && parsedUrl.protocol !== "http:") {
+      return null;
+    }
+    if (inputWasRelative) {
+      return parsedUrl.pathname + parsedUrl.search + parsedUrl.hash;
+    }
+    return parsedUrl.href;
+  }
+  return null;
+}
+const SEEN = Symbol("node-seen");
+const createVisitor = (defaultOrigin, allowedLinkPrefixes, allowedImagePrefixes, allowDataImages, allowedProtocols, blockedImageClass, blockedLinkClass) => {
+  const visitor = (node, index, parent) => {
+    if (node.type !== "element" || // @ts-expect-error
+    node[SEEN]) {
+      return CONTINUE;
+    }
+    if (node.tagName === "a") {
+      const transformedUrl = transformUrl(node.properties.href, allowedLinkPrefixes, defaultOrigin, false, false, allowedProtocols);
+      if (transformedUrl === null) {
+        node[SEEN] = true;
+        visit(node, visitor);
+        if (parent && typeof index === "number") {
+          parent.children[index] = {
+            type: "element",
+            tagName: "span",
+            properties: {
+              title: "Blocked URL: " + String(node.properties.href),
+              class: blockedLinkClass
+            },
+            children: [
+              ...node.children,
+              {
+                type: "text",
+                value: " [blocked]"
+              }
+            ]
+          };
+        }
+        return SKIP;
+      } else {
+        node.properties.href = transformedUrl;
+        node.properties.target = "_blank";
+        node.properties.rel = "noopener noreferrer";
+        return CONTINUE;
+      }
+    }
+    if (node.tagName === "img") {
+      const transformedUrl = transformUrl(node.properties.src, allowedImagePrefixes, defaultOrigin, allowDataImages, true, allowedProtocols);
+      if (transformedUrl === null) {
+        node[SEEN] = true;
+        visit(node, visitor);
+        if (parent && typeof index === "number") {
+          parent.children[index] = {
+            type: "element",
+            tagName: "span",
+            properties: {
+              class: blockedImageClass
+            },
+            children: [
+              {
+                type: "text",
+                value: "[Image blocked: " + String(node.properties.alt || "No description") + "]"
+              }
+            ]
+          };
+        }
+        return SKIP;
+      } else {
+        node.properties.src = transformedUrl;
+        return CONTINUE;
+      }
+    }
+    return CONTINUE;
+  };
+  return visitor;
+};
+export {
+  harden
+};

package/dist/esm/_vendor/remark-breaks/lib-index.js

@@ -0,0 +1,9 @@
+import { newlineToBreak } from "../mdast-util-newline-to-break/lib-index.js";
+function remarkBreaks() {
+  return function(tree) {
+    newlineToBreak(tree);
+  };
+}
+export {
+  remarkBreaks as default
+};

package/dist/esm/_vendor/remark-gfm/lib-index.js

@@ -0,0 +1,20 @@
+import { gfm } from "../micromark-extension-gfm/index.js";
+import { gfmFromMarkdown, gfmToMarkdown } from "../mdast-util-gfm/lib-index.js";
+const emptyOptions = {};
+function remarkGfm(options) {
+  const self = (
+    /** @type {Processor<Root>} */
+    this
+  );
+  const settings = options || emptyOptions;
+  const data = self.data();
+  const micromarkExtensions = data.micromarkExtensions || (data.micromarkExtensions = []);
+  const fromMarkdownExtensions = data.fromMarkdownExtensions || (data.fromMarkdownExtensions = []);
+  const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
+  micromarkExtensions.push(gfm(settings));
+  fromMarkdownExtensions.push(gfmFromMarkdown());
+  toMarkdownExtensions.push(gfmToMarkdown(settings));
+}
+export {
+  remarkGfm as default
+};

package/dist/esm/_vendor/remark-math/lib-index.js

@@ -0,0 +1,20 @@
+import { math } from "../micromark-extension-math/lib-syntax.js";
+import { mathFromMarkdown, mathToMarkdown } from "../mdast-util-math/lib-index.js";
+const emptyOptions = {};
+function remarkMath(options) {
+  const self = (
+    /** @type {Processor} */
+    this
+  );
+  const settings = options || emptyOptions;
+  const data = self.data();
+  const micromarkExtensions = data.micromarkExtensions || (data.micromarkExtensions = []);
+  const fromMarkdownExtensions = data.fromMarkdownExtensions || (data.fromMarkdownExtensions = []);
+  const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
+  micromarkExtensions.push(math(settings));
+  fromMarkdownExtensions.push(mathFromMarkdown());
+  toMarkdownExtensions.push(mathToMarkdown(settings));
+}
+export {
+  remarkMath as default
+};

package/dist/esm/_vendor/remark-parse/lib-index.js

@@ -0,0 +1,19 @@
+import { fromMarkdown } from "../mdast-util-from-markdown/lib-index.js";
+function remarkParse(options) {
+  const self = this;
+  self.parser = parser;
+  function parser(doc) {
+    return fromMarkdown(doc, {
+      ...self.data("settings"),
+      ...options,
+      // Note: these options are not in the readme.
+      // The goal is for them to be set by plugins on `data` instead of being
+      // passed by users.
+      extensions: self.data("micromarkExtensions") || [],
+      mdastExtensions: self.data("fromMarkdownExtensions") || []
+    });
+  }
+}
+export {
+  remarkParse as default
+};

package/dist/esm/_vendor/remark-rehype/lib-index.js

@@ -0,0 +1,21 @@
+import { toHast } from "../mdast-util-to-hast/lib-index.js";
+function remarkRehype(destination, options) {
+  if (destination && "run" in destination) {
+    return async function(tree, file) {
+      const hastTree = (
+        /** @type {HastRoot} */
+        toHast(tree, { file, ...options })
+      );
+      await destination.run(hastTree, file);
+    };
+  }
+  return function(tree, file) {
+    return (
+      /** @type {HastRoot} */
+      toHast(tree, { file, ...destination || options })
+    );
+  };
+}
+export {
+  remarkRehype as default
+};

package/dist/esm/_vendor/space-separated-tokens/index.js

@@ -0,0 +1,6 @@
+function stringify(values) {
+  return values.join(" ").trim();
+}
+export {
+  stringify
+};

package/dist/esm/_vendor/style-to-js/cjs-index.js

@@ -0,0 +1,28 @@
+import { getDefaultExportFromCjs, commonjsGlobal } from "../../_virtual/_commonjsHelpers.js";
+import "../style-to-object/cjs-index.js";
+import "./cjs-utilities.js";
+import { __exports as utilities } from "../../_virtual/utilities.js";
+import { __exports as cjs$1 } from "../../_virtual/index5.js";
+var __importDefault = commonjsGlobal && commonjsGlobal.__importDefault || function(mod) {
+  return mod && mod.__esModule ? mod : { "default": mod };
+};
+var style_to_object_1 = __importDefault(cjs$1);
+var utilities_1 = utilities;
+function StyleToJS(style, options) {
+  var output = {};
+  if (!style || typeof style !== "string") {
+    return output;
+  }
+  (0, style_to_object_1.default)(style, function(property, value) {
+    if (property && value) {
+      output[(0, utilities_1.camelCase)(property, options)] = value;
+    }
+  });
+  return output;
+}
+StyleToJS.default = StyleToJS;
+var cjs = StyleToJS;
+const styleToJs = /* @__PURE__ */ getDefaultExportFromCjs(cjs);
+export {
+  styleToJs as default
+};

package/dist/esm/_vendor/style-to-js/cjs-utilities.js

@@ -0,0 +1,36 @@
+import { __exports as utilities } from "../../_virtual/utilities.js";
+Object.defineProperty(utilities, "__esModule", { value: true });
+utilities.camelCase = void 0;
+var CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9_-]+$/;
+var HYPHEN_REGEX = /-([a-z])/g;
+var NO_HYPHEN_REGEX = /^[^-]+$/;
+var VENDOR_PREFIX_REGEX = /^-(webkit|moz|ms|o|khtml)-/;
+var MS_VENDOR_PREFIX_REGEX = /^-(ms)-/;
+var skipCamelCase = function(property) {
+  return !property || NO_HYPHEN_REGEX.test(property) || CUSTOM_PROPERTY_REGEX.test(property);
+};
+var capitalize = function(match, character) {
+  return character.toUpperCase();
+};
+var trimHyphen = function(match, prefix) {
+  return "".concat(prefix, "-");
+};
+var camelCase = function(property, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  if (skipCamelCase(property)) {
+    return property;
+  }
+  property = property.toLowerCase();
+  if (options.reactCompat) {
+    property = property.replace(MS_VENDOR_PREFIX_REGEX, trimHyphen);
+  } else {
+    property = property.replace(VENDOR_PREFIX_REGEX, trimHyphen);
+  }
+  return property.replace(HYPHEN_REGEX, capitalize);
+};
+utilities.camelCase = camelCase;
+export {
+  utilities as default
+};