@octanejs/base-ui 0.1.30 → 0.1.32

package/dist/cjs/utils/inertValue.cjs

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inertValue_exports = {};
+__export(inertValue_exports, {
+  inertValue: () => inertValue
+});
+module.exports = __toCommonJS(inertValue_exports);
+function inertValue(value) {
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inertValue
+});

package/dist/cjs/utils/matchesFocusVisible.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var matchesFocusVisible_exports = {};
+__export(matchesFocusVisible_exports, {
+  matchesFocusVisible: () => matchesFocusVisible
+});
+module.exports = __toCommonJS(matchesFocusVisible_exports);
+const isJSDOM = typeof navigator !== "undefined" && /jsdom/i.test(navigator.userAgent);
+function matchesFocusVisible(element) {
+  if (!element || isJSDOM) {
+    return true;
+  }
+  try {
+    return element.matches(":focus-visible");
+  } catch {
+    return true;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  matchesFocusVisible
+});

package/dist/cjs/utils/mergeCleanups.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mergeCleanups_exports = {};
+__export(mergeCleanups_exports, {
+  mergeCleanups: () => mergeCleanups
+});
+module.exports = __toCommonJS(mergeCleanups_exports);
+function mergeCleanups(...cleanups) {
+  return () => {
+    for (let i = 0; i < cleanups.length; i += 1) {
+      const cleanup = cleanups[i];
+      if (cleanup) {
+        cleanup();
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeCleanups
+});

package/dist/cjs/utils/mergeObjects.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mergeObjects_exports = {};
+__export(mergeObjects_exports, {
+  mergeObjects: () => mergeObjects
+});
+module.exports = __toCommonJS(mergeObjects_exports);
+function mergeObjects(a, b) {
+  if (a && !b) {
+    return a;
+  }
+  if (!a && b) {
+    return b;
+  }
+  if (a || b) {
+    return { ...a, ...b };
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeObjects
+});

package/dist/cjs/utils/mergeProps.cjs

@@ -0,0 +1,182 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mergeProps_exports = {};
+__export(mergeProps_exports, {
+  makeEventPreventable: () => makeEventPreventable,
+  mergeClassNames: () => mergeClassNames,
+  mergeProps: () => mergeProps,
+  mergePropsN: () => mergePropsN
+});
+module.exports = __toCommonJS(mergeProps_exports);
+var import_mergeObjects = require("./mergeObjects.cjs");
+const EMPTY_PROPS = {};
+function mergeProps(a, b, c, d, e) {
+  if (!c && !d && !e && !a) {
+    return createInitialMergedProps(b);
+  }
+  let merged = createInitialMergedProps(a);
+  if (b) {
+    merged = mergeInto(merged, b);
+  }
+  if (c) {
+    merged = mergeInto(merged, c);
+  }
+  if (d) {
+    merged = mergeInto(merged, d);
+  }
+  if (e) {
+    merged = mergeInto(merged, e);
+  }
+  return merged;
+}
+function mergePropsN(props) {
+  if (props.length === 0) {
+    return EMPTY_PROPS;
+  }
+  if (props.length === 1) {
+    return createInitialMergedProps(props[0]);
+  }
+  let merged = createInitialMergedProps(props[0]);
+  for (let i = 1; i < props.length; i += 1) {
+    merged = mergeInto(merged, props[i]);
+  }
+  return merged;
+}
+function createInitialMergedProps(inputProps) {
+  if (isPropsGetter(inputProps)) {
+    return { ...resolvePropsGetter(inputProps, EMPTY_PROPS) };
+  }
+  return copyInitialProps(inputProps);
+}
+function mergeInto(merged, inputProps) {
+  if (isPropsGetter(inputProps)) {
+    return resolvePropsGetter(inputProps, merged);
+  }
+  return mutablyMergeInto(merged, inputProps);
+}
+function copyInitialProps(inputProps) {
+  const copiedProps = { ...inputProps };
+  for (const propName in copiedProps) {
+    const propValue = copiedProps[propName];
+    if (isEventHandler(propName, propValue)) {
+      copiedProps[propName] = wrapEventHandler(propValue);
+    }
+  }
+  return copiedProps;
+}
+function mutablyMergeInto(mergedProps, externalProps) {
+  if (!externalProps) {
+    return mergedProps;
+  }
+  for (const propName in externalProps) {
+    const externalPropValue = externalProps[propName];
+    switch (propName) {
+      case "style": {
+        mergedProps[propName] = (0, import_mergeObjects.mergeObjects)(mergedProps.style, externalPropValue);
+        break;
+      }
+      case "className": {
+        mergedProps[propName] = mergeClassNames(mergedProps.className, externalPropValue);
+        break;
+      }
+      default: {
+        if (isEventHandler(propName, externalPropValue)) {
+          mergedProps[propName] = mergeEventHandlers(mergedProps[propName], externalPropValue);
+        } else {
+          mergedProps[propName] = externalPropValue;
+        }
+      }
+    }
+  }
+  return mergedProps;
+}
+function isEventHandler(key, value) {
+  const code0 = key.charCodeAt(0);
+  const code1 = key.charCodeAt(1);
+  const code2 = key.charCodeAt(2);
+  return code0 === 111 && code1 === 110 && code2 >= 65 && code2 <= 90 && (typeof value === "function" || typeof value === "undefined");
+}
+function isPropsGetter(inputProps) {
+  return typeof inputProps === "function";
+}
+function resolvePropsGetter(inputProps, previousProps) {
+  if (isPropsGetter(inputProps)) {
+    return inputProps(previousProps);
+  }
+  return inputProps ?? EMPTY_PROPS;
+}
+function isPreventableEvent(event) {
+  return event != null && typeof event === "object";
+}
+function mergeEventHandlers(ourHandler, theirHandler) {
+  if (!theirHandler) {
+    return ourHandler;
+  }
+  if (!ourHandler) {
+    return wrapEventHandler(theirHandler);
+  }
+  return (...args) => {
+    const event = args[0];
+    if (isPreventableEvent(event)) {
+      makeEventPreventable(event);
+      const result2 = theirHandler(...args);
+      if (!event.baseUIHandlerPrevented) {
+        ourHandler(...args);
+      }
+      return result2;
+    }
+    const result = theirHandler(...args);
+    ourHandler(...args);
+    return result;
+  };
+}
+function wrapEventHandler(handler) {
+  if (!handler) {
+    return handler;
+  }
+  return (...args) => {
+    const event = args[0];
+    if (isPreventableEvent(event)) {
+      makeEventPreventable(event);
+    }
+    return handler(...args);
+  };
+}
+function makeEventPreventable(event) {
+  event.preventBaseUIHandler = () => {
+    event.baseUIHandlerPrevented = true;
+  };
+  return event;
+}
+function mergeClassNames(ourClassName, theirClassName) {
+  if (theirClassName) {
+    if (ourClassName) {
+      return theirClassName + " " + ourClassName;
+    }
+    return theirClassName;
+  }
+  return ourClassName;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeEventPreventable,
+  mergeClassNames,
+  mergeProps,
+  mergePropsN
+});

package/dist/cjs/utils/noop.cjs

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var noop_exports = {};
+__export(noop_exports, {
+  NOOP: () => NOOP
+});
+module.exports = __toCommonJS(noop_exports);
+function NOOP() {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NOOP
+});

package/dist/cjs/utils/number/constants.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  CHANGE_VALUE_TICK_DELAY: () => CHANGE_VALUE_TICK_DELAY,
+  SCROLLING_POINTER_MOVE_DISTANCE: () => SCROLLING_POINTER_MOVE_DISTANCE,
+  START_AUTO_CHANGE_DELAY: () => START_AUTO_CHANGE_DELAY
+});
+module.exports = __toCommonJS(constants_exports);
+const CHANGE_VALUE_TICK_DELAY = 60;
+const START_AUTO_CHANGE_DELAY = 400;
+const SCROLLING_POINTER_MOVE_DISTANCE = 8;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CHANGE_VALUE_TICK_DELAY,
+  SCROLLING_POINTER_MOVE_DISTANCE,
+  START_AUTO_CHANGE_DELAY
+});

package/dist/cjs/utils/number/parse.cjs

@@ -0,0 +1,258 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parse_exports = {};
+__export(parse_exports, {
+  ANY_MINUS_DETECT_RE: () => ANY_MINUS_DETECT_RE,
+  ANY_MINUS_RE: () => ANY_MINUS_RE,
+  ANY_PLUS_DETECT_RE: () => ANY_PLUS_DETECT_RE,
+  ANY_PLUS_RE: () => ANY_PLUS_RE,
+  ARABIC_DETECT_RE: () => ARABIC_DETECT_RE,
+  ARABIC_NUMERALS: () => ARABIC_NUMERALS,
+  ARABIC_RE: () => ARABIC_RE,
+  BASE_NON_NUMERIC_SYMBOLS: () => BASE_NON_NUMERIC_SYMBOLS,
+  FULLWIDTH_DECIMAL: () => FULLWIDTH_DECIMAL,
+  FULLWIDTH_DETECT_RE: () => FULLWIDTH_DETECT_RE,
+  FULLWIDTH_GROUP: () => FULLWIDTH_GROUP,
+  FULLWIDTH_NUMERALS: () => FULLWIDTH_NUMERALS,
+  FULLWIDTH_RE: () => FULLWIDTH_RE,
+  HAN_DETECT_RE: () => HAN_DETECT_RE,
+  HAN_NUMERALS: () => HAN_NUMERALS,
+  HAN_NUMERAL_TO_DIGIT: () => HAN_NUMERAL_TO_DIGIT,
+  HAN_RE: () => HAN_RE,
+  MINUS_SIGNS_WITH_ASCII: () => MINUS_SIGNS_WITH_ASCII,
+  PERCENTAGES: () => PERCENTAGES,
+  PERCENT_RE: () => PERCENT_RE,
+  PERMILLE: () => PERMILLE,
+  PERMILLE_RE: () => PERMILLE_RE,
+  PERSIAN_DETECT_RE: () => PERSIAN_DETECT_RE,
+  PERSIAN_NUMERALS: () => PERSIAN_NUMERALS,
+  PERSIAN_RE: () => PERSIAN_RE,
+  PLUS_SIGNS_WITH_ASCII: () => PLUS_SIGNS_WITH_ASCII,
+  SPACE_SEPARATOR_RE: () => SPACE_SEPARATOR_RE,
+  UNICODE_MINUS_SIGNS: () => UNICODE_MINUS_SIGNS,
+  UNICODE_PLUS_SIGNS: () => UNICODE_PLUS_SIGNS,
+  getNumberLocaleDetails: () => getNumberLocaleDetails,
+  isNumeralChar: () => isNumeralChar,
+  parseNumber: () => parseNumber
+});
+module.exports = __toCommonJS(parse_exports);
+var import_formatNumber = require("../formatNumber.cjs");
+const HAN_NUMERALS = ["\u96F6", "\u3007", "\u4E00", "\u4E8C", "\u4E09", "\u56DB", "\u4E94", "\u516D", "\u4E03", "\u516B", "\u4E5D"];
+const HAN_NUMERAL_TO_DIGIT = {
+  \u96F6: "0",
+  "\u3007": "0",
+  \u4E00: "1",
+  \u4E8C: "2",
+  \u4E09: "3",
+  \u56DB: "4",
+  \u4E94: "5",
+  \u516D: "6",
+  \u4E03: "7",
+  \u516B: "8",
+  \u4E5D: "9"
+};
+const ARABIC_NUMERALS = ["\u0660", "\u0661", "\u0662", "\u0663", "\u0664", "\u0665", "\u0666", "\u0667", "\u0668", "\u0669"];
+const PERSIAN_NUMERALS = ["\u06F0", "\u06F1", "\u06F2", "\u06F3", "\u06F4", "\u06F5", "\u06F6", "\u06F7", "\u06F8", "\u06F9"];
+const FULLWIDTH_NUMERALS = ["\uFF10", "\uFF11", "\uFF12", "\uFF13", "\uFF14", "\uFF15", "\uFF16", "\uFF17", "\uFF18", "\uFF19"];
+const PERCENTAGES = ["%", "\u066A", "\uFF05", "\uFE6A"];
+const PERMILLE = ["\u2030", "\u0609"];
+const UNICODE_MINUS_SIGNS = ["\u2212", "\uFF0D", "\u2012", "\u2013", "\u2014", "\uFE63"];
+const UNICODE_PLUS_SIGNS = ["\uFF0B", "\uFE62"];
+const FULLWIDTH_DECIMAL = "\uFF0E";
+const FULLWIDTH_GROUP = "\uFF0C";
+const ARABIC_RE = new RegExp(`[${ARABIC_NUMERALS.join("")}]`, "g");
+const PERSIAN_RE = new RegExp(`[${PERSIAN_NUMERALS.join("")}]`, "g");
+const FULLWIDTH_RE = new RegExp(`[${FULLWIDTH_NUMERALS.join("")}]`, "g");
+const HAN_RE = new RegExp(`[${HAN_NUMERALS.join("")}]`, "g");
+const PERCENT_RE = new RegExp(`[${PERCENTAGES.join("")}]`);
+const PERMILLE_RE = new RegExp(`[${PERMILLE.join("")}]`);
+const PERCENT_GLOBAL_RE = new RegExp(PERCENT_RE.source, "g");
+const PERMILLE_GLOBAL_RE = new RegExp(PERMILLE_RE.source, "g");
+const ARABIC_DETECT_RE = new RegExp(`[${ARABIC_NUMERALS.join("")}]`);
+const PERSIAN_DETECT_RE = new RegExp(`[${PERSIAN_NUMERALS.join("")}]`);
+const HAN_DETECT_RE = new RegExp(`[${HAN_NUMERALS.join("")}]`);
+const FULLWIDTH_DETECT_RE = new RegExp(`[${FULLWIDTH_NUMERALS.join("")}]`);
+function isNumeralChar(char) {
+  return char >= "0" && char <= "9" || ARABIC_DETECT_RE.test(char) || PERSIAN_DETECT_RE.test(char) || HAN_DETECT_RE.test(char) || FULLWIDTH_DETECT_RE.test(char);
+}
+const BASE_NON_NUMERIC_SYMBOLS = [
+  ".",
+  ",",
+  FULLWIDTH_DECIMAL,
+  FULLWIDTH_GROUP,
+  "\u066B",
+  "\u066C"
+];
+const SPACE_SEPARATOR_RE = new RegExp("\\p{Zs}", "u");
+const PLUS_SIGNS_WITH_ASCII = ["+", ...UNICODE_PLUS_SIGNS];
+const MINUS_SIGNS_WITH_ASCII = ["-", ...UNICODE_MINUS_SIGNS];
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const escapeClassChar = (s) => s.replace(/[-\\\]^]/g, (m) => `\\${m}`);
+function shiftDecimal(value, exponentDelta) {
+  const [coefficient, exponent = "0"] = String(value).split("e");
+  return Number(`${coefficient}e${Number(exponent) + exponentDelta}`);
+}
+const charClassFrom = (chars) => `[${chars.map(escapeClassChar).join("")}]`;
+const ANY_MINUS_CLASS = charClassFrom(["-"].concat(UNICODE_MINUS_SIGNS));
+const ANY_PLUS_CLASS = charClassFrom(["+"].concat(UNICODE_PLUS_SIGNS));
+const ANY_MINUS_RE = new RegExp(ANY_MINUS_CLASS, "gu");
+const ANY_PLUS_RE = new RegExp(ANY_PLUS_CLASS, "gu");
+const ANY_MINUS_DETECT_RE = new RegExp(ANY_MINUS_CLASS);
+const ANY_PLUS_DETECT_RE = new RegExp(ANY_PLUS_CLASS);
+function getNumberLocaleDetails(locale, options) {
+  const parts = (0, import_formatNumber.getFormatter)(locale, options).formatToParts(11111.1);
+  const result = {};
+  parts.forEach((part) => {
+    result[part.type] = part.value;
+  });
+  (0, import_formatNumber.getFormatter)(locale).formatToParts(0.1).forEach((part) => {
+    if (part.type === "decimal") {
+      result[part.type] = part.value;
+    }
+  });
+  return result;
+}
+function parseNumber(formattedNumber, locale, options) {
+  if (formattedNumber == null) {
+    return null;
+  }
+  let input = String(formattedNumber).replace(new RegExp("\\p{Cf}", "gu"), "").trim();
+  input = input.replace(ANY_MINUS_RE, "-").replace(ANY_PLUS_RE, "+");
+  let isNegative = false;
+  const trailing = input.match(/([+-])\s*$/);
+  if (trailing) {
+    if (trailing[1] === "-") {
+      isNegative = true;
+    }
+    input = input.replace(/([+-])\s*$/, "");
+  }
+  const leading = input.match(/^\s*([+-])/);
+  if (leading) {
+    if (leading[1] === "-") {
+      isNegative = true;
+    }
+    input = input.replace(/^\s*[+-]/, "");
+  }
+  let computedLocale = locale;
+  if (computedLocale === void 0) {
+    if (ARABIC_DETECT_RE.test(input) || PERSIAN_DETECT_RE.test(input)) {
+      computedLocale = "ar";
+    } else if (HAN_DETECT_RE.test(input)) {
+      computedLocale = "zh";
+    }
+  }
+  const { group, decimal, currency, exponentSeparator } = getNumberLocaleDetails(
+    computedLocale,
+    options
+  );
+  const unitParts = (0, import_formatNumber.getFormatter)(computedLocale, options).formatToParts(1).filter((p) => p.type === "unit").map((p) => escapeRegExp(p.value));
+  const unitRegex = unitParts.length ? new RegExp(unitParts.join("|"), "g") : null;
+  let groupRegex = null;
+  if (group) {
+    const isSpaceGroup = new RegExp("\\p{Zs}", "u").test(group);
+    const isApostropheGroup = group === "'" || group === "\u2019";
+    if (isSpaceGroup) {
+      groupRegex = new RegExp("\\p{Zs}", "gu");
+    } else if (isApostropheGroup) {
+      groupRegex = /['’]/g;
+    } else {
+      groupRegex = new RegExp(escapeRegExp(group), "g");
+    }
+  }
+  const replacements = [
+    { regex: groupRegex, replacement: "" },
+    { regex: decimal ? new RegExp(escapeRegExp(decimal), "g") : null, replacement: "." },
+    { regex: /．/g, replacement: "." },
+    { regex: /，/g, replacement: "" },
+    { regex: /٫/g, replacement: "." },
+    { regex: /٬/g, replacement: "" },
+    { regex: currency ? new RegExp(escapeRegExp(currency), "g") : null, replacement: "" },
+    { regex: unitRegex, replacement: "" },
+    { regex: PERCENT_GLOBAL_RE, replacement: "" },
+    { regex: PERMILLE_GLOBAL_RE, replacement: "" },
+    {
+      regex: exponentSeparator ? new RegExp(escapeRegExp(exponentSeparator), "g") : null,
+      replacement: "e"
+    },
+    { regex: ARABIC_RE, replacement: (ch) => String(ARABIC_NUMERALS.indexOf(ch)) },
+    { regex: PERSIAN_RE, replacement: (ch) => String(PERSIAN_NUMERALS.indexOf(ch)) },
+    { regex: FULLWIDTH_RE, replacement: (ch) => String(FULLWIDTH_NUMERALS.indexOf(ch)) },
+    { regex: HAN_RE, replacement: (ch) => HAN_NUMERAL_TO_DIGIT[ch] }
+  ];
+  let unformatted = replacements.reduce((acc, { regex, replacement }) => {
+    return regex ? acc.replace(regex, replacement) : acc;
+  }, input);
+  const lastDot = unformatted.lastIndexOf(".");
+  if (lastDot !== -1) {
+    unformatted = `${unformatted.slice(0, lastDot).replace(/\./g, "")}.${unformatted.slice(lastDot + 1).replace(/\./g, "")}`;
+  }
+  if (/^[-+]?Infinity$/i.test(input) || input.includes("\u221E")) {
+    return null;
+  }
+  const parseTarget = (isNegative ? "-" : "") + unformatted;
+  let num = parseFloat(parseTarget);
+  const style = options?.style;
+  const isUnitPercent = style === "unit" && options?.unit === "percent";
+  const hasPercentSymbol = PERCENT_RE.test(formattedNumber) || style === "percent";
+  const hasPermilleSymbol = PERMILLE_RE.test(formattedNumber);
+  if (hasPermilleSymbol) {
+    num = shiftDecimal(num, -3);
+  } else if (!isUnitPercent && hasPercentSymbol) {
+    num = shiftDecimal(num, -2);
+  }
+  if (!Number.isFinite(num)) {
+    return null;
+  }
+  return num;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANY_MINUS_DETECT_RE,
+  ANY_MINUS_RE,
+  ANY_PLUS_DETECT_RE,
+  ANY_PLUS_RE,
+  ARABIC_DETECT_RE,
+  ARABIC_NUMERALS,
+  ARABIC_RE,
+  BASE_NON_NUMERIC_SYMBOLS,
+  FULLWIDTH_DECIMAL,
+  FULLWIDTH_DETECT_RE,
+  FULLWIDTH_GROUP,
+  FULLWIDTH_NUMERALS,
+  FULLWIDTH_RE,
+  HAN_DETECT_RE,
+  HAN_NUMERALS,
+  HAN_NUMERAL_TO_DIGIT,
+  HAN_RE,
+  MINUS_SIGNS_WITH_ASCII,
+  PERCENTAGES,
+  PERCENT_RE,
+  PERMILLE,
+  PERMILLE_RE,
+  PERSIAN_DETECT_RE,
+  PERSIAN_NUMERALS,
+  PERSIAN_RE,
+  PLUS_SIGNS_WITH_ASCII,
+  SPACE_SEPARATOR_RE,
+  UNICODE_MINUS_SIGNS,
+  UNICODE_PLUS_SIGNS,
+  getNumberLocaleDetails,
+  isNumeralChar,
+  parseNumber
+});

package/dist/cjs/utils/number/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);