@yamada-ui/utils 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Hirotomo Yamada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @yamada-ui/utils
+
+> This is an internal utility, not intended for public usage.
+
+## Installation
+
+```sh
+$ pnpm add @yamada-ui/utils
+```
+
+or
+
+```sh
+$ yarn add @yamada-ui/utils
+```
+
+or
+
+```sh
+$ npm install @yamada-ui/utils
+```
+
+## Contribution
+
+Wouldn't you like to contribute? That's amazing! We have prepared a [contribution guide](https://github.com/hirotomoyamada/yamada-ui/blob/main/CONTRIBUTING.md) to assist you.
+
+## Licence
+
+This package is licensed under the terms of the
+
+[MIT license](https://github.com/hirotomoyamada/yamada-ui/blob/main/LICENSE).

package/dist/array.d.ts

@@ -0,0 +1,3 @@
+declare const filterEmpty: <T extends any[]>(array: T) => any[];
+
+export { filterEmpty };

package/dist/array.js

@@ -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);
+
+// src/array.ts
+var array_exports = {};
+__export(array_exports, {
+  filterEmpty: () => filterEmpty
+});
+module.exports = __toCommonJS(array_exports);
+var filterEmpty = (array) => array.filter((value) => value != null);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterEmpty
+});

package/dist/array.mjs

@@ -0,0 +1,6 @@
+import {
+  filterEmpty
+} from "./chunk-PURW64JE.mjs";
+export {
+  filterEmpty
+};

package/dist/assertion.d.ts

@@ -0,0 +1,16 @@
+import { Dict } from './index.types.js';
+
+declare const isNumber: (value: any) => value is number;
+declare const isNotNumber: (value: any) => boolean;
+declare const isNumeric: (value: any) => boolean;
+declare const isString: (value: any) => value is string;
+declare const isUndefined: (value: any) => value is undefined;
+declare const isNull: (value: any) => value is null;
+declare const isObject: <T extends Dict<any>>(value: any) => value is T;
+declare const isArray: <T extends any[]>(value: any) => value is T;
+declare const isEmpty: (value: any) => boolean;
+declare const isFunction: <T extends Function = Function>(value: any) => value is T;
+declare const isUnit: (value: any) => boolean;
+declare const cast: <T>(value: any) => T;
+
+export { cast, isArray, isEmpty, isFunction, isNotNumber, isNull, isNumber, isNumeric, isObject, isString, isUndefined, isUnit };

package/dist/assertion.js

@@ -0,0 +1,63 @@
+"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);
+
+// src/assertion.ts
+var assertion_exports = {};
+__export(assertion_exports, {
+  cast: () => cast,
+  isArray: () => isArray,
+  isEmpty: () => isEmpty,
+  isFunction: () => isFunction,
+  isNotNumber: () => isNotNumber,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isNumeric: () => isNumeric,
+  isObject: () => isObject,
+  isString: () => isString,
+  isUndefined: () => isUndefined,
+  isUnit: () => isUnit
+});
+module.exports = __toCommonJS(assertion_exports);
+var isNumber = (value) => typeof value === "number";
+var isNotNumber = (value) => typeof value !== "number" || Number.isNaN(value) || !Number.isFinite(value);
+var isNumeric = (value) => value != null && parseFloat(value.toString()) - parseFloat(value.toString()) + 1 >= 0;
+var isString = (value) => Object.prototype.toString.call(value) === "[object String]";
+var isUndefined = (value) => typeof value === "undefined" && value === void 0;
+var isNull = (value) => value === null;
+var isObject = (value) => value !== null && (typeof value === "object" || typeof value === "function") && !Array.isArray(value);
+var isArray = (value) => Array.isArray(value);
+var isEmpty = (value) => !Array.isArray(value) || !value.length || value.every((v) => v == null);
+var isFunction = (value) => typeof value === "function";
+var isUnit = (value) => /[0-9].*[px|rem|em|%|vw|vh]$/.test(value);
+var cast = (value) => value;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cast,
+  isArray,
+  isEmpty,
+  isFunction,
+  isNotNumber,
+  isNull,
+  isNumber,
+  isNumeric,
+  isObject,
+  isString,
+  isUndefined,
+  isUnit
+});

package/dist/assertion.mjs

@@ -0,0 +1,28 @@
+import {
+  cast,
+  isArray,
+  isEmpty,
+  isFunction,
+  isNotNumber,
+  isNull,
+  isNumber,
+  isNumeric,
+  isObject,
+  isString,
+  isUndefined,
+  isUnit
+} from "./chunk-IVGIIDMV.mjs";
+export {
+  cast,
+  isArray,
+  isEmpty,
+  isFunction,
+  isNotNumber,
+  isNull,
+  isNumber,
+  isNumeric,
+  isObject,
+  isString,
+  isUndefined,
+  isUnit
+};

package/dist/calc.d.ts

@@ -0,0 +1,17 @@
+type Operand = string | number;
+type Calc = {
+    add: (...args: Operand[]) => Calc;
+    subtract: (...args: Operand[]) => Calc;
+    multiply: (...args: Operand[]) => Calc;
+    divide: (...args: Operand[]) => Calc;
+    negate: () => Calc;
+};
+declare const calc: ((x: Operand) => Calc) & {
+    add: (...args: Operand[]) => string;
+    subtract: (...args: Operand[]) => string;
+    multiply: (...args: Operand[]) => string;
+    divide: (...args: Operand[]) => string;
+    negate: (value: Operand) => string;
+};
+
+export { Operand, calc };

package/dist/calc.js

@@ -0,0 +1,55 @@
+"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);
+
+// src/calc.ts
+var calc_exports = {};
+__export(calc_exports, {
+  calc: () => calc
+});
+module.exports = __toCommonJS(calc_exports);
+var toExpression = (operator, ...args) => args.join(` ${operator} `).replace(/calc/g, "");
+var add = (...args) => `calc(${toExpression("+", ...args)})`;
+var subtract = (...args) => `calc(${toExpression("-", ...args)})`;
+var multiply = (...args) => `calc(${toExpression("*", ...args)})`;
+var divide = (...args) => `calc(${toExpression("/", ...args)})`;
+var negate = (value) => {
+  if (value != null && !isNaN(parseFloat(value.toString())))
+    return String(value).startsWith("-") ? String(value).slice(1) : `-${value}`;
+  return multiply(value, -1);
+};
+var calc = Object.assign(
+  (x) => ({
+    add: (...args) => calc(add(x, ...args)),
+    subtract: (...args) => calc(subtract(x, ...args)),
+    multiply: (...args) => calc(multiply(x, ...args)),
+    divide: (...args) => calc(divide(x, ...args)),
+    negate: () => calc(negate(x))
+  }),
+  {
+    add,
+    subtract,
+    multiply,
+    divide,
+    negate
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calc
+});

package/dist/calc.mjs

@@ -0,0 +1,6 @@
+import {
+  calc
+} from "./chunk-R5OUKGQ5.mjs";
+export {
+  calc
+};

package/dist/chunk-A6J4FUU7.mjs

@@ -0,0 +1,401 @@
+import {
+  isArray,
+  isFunction,
+  isNumber,
+  isObject,
+  isString
+} from "./chunk-IVGIIDMV.mjs";
+
+// src/function.ts
+var noop = () => {
+};
+var runIfFunc = (valOrFunc, ...args) => isFunction(valOrFunc) ? valOrFunc(...args) : valOrFunc;
+var handlerAll = (...funcs) => (event) => {
+  funcs.some((func) => {
+    func == null ? void 0 : func(event);
+    return event == null ? void 0 : event.defaultPrevented;
+  });
+};
+var funcAll = (...funcs) => (arg) => funcs.forEach((func) => func == null ? void 0 : func(arg));
+
+// src/react.tsx
+import * as React from "react";
+var createContext2 = ({
+  strict = true,
+  errorMessage = "useContext: `context` is undefined. Seems you forgot to wrap component within the Provider",
+  name
+} = {}) => {
+  const Context = React.createContext(void 0);
+  Context.displayName = name;
+  const useContext2 = () => {
+    var _a;
+    const context = React.useContext(Context);
+    if (!context && strict) {
+      const error = new Error(errorMessage);
+      error.name = "ContextError";
+      (_a = Error.captureStackTrace) == null ? void 0 : _a.call(Error, error, useContext2);
+      throw error;
+    }
+    return context;
+  };
+  return [Context.Provider, useContext2, Context];
+};
+var useSafeLayoutEffect = Boolean(globalThis == null ? void 0 : globalThis.document) ? React.useLayoutEffect : React.useEffect;
+var useUnmountEffect = (callback) => (
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  React.useEffect(() => () => callback(), [])
+);
+var useIsMounted = () => {
+  const isMounted = React.useRef(false);
+  useSafeLayoutEffect(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+  return isMounted;
+};
+var getValidChildren = (children) => React.Children.toArray(children).filter(
+  (child) => React.isValidElement(child)
+);
+var isValidElement2 = (child) => React.isValidElement(child) || isString(child) || isNumber(child);
+var findChildren = (children, ...types) => children.find((child) => types.some((type) => child.type === type)) ? children.sort(
+  (a, b) => types.some((type) => a.type === type) ? -1 : types.some((type) => b.type === type) ? 1 : 0
+) : [void 0, ...children];
+var includesChildren = (children, ...types) => children.some((child) => {
+  if (types.some((type) => child.type === type))
+    return true;
+  const children2 = getValidChildren(child.props.children);
+  return children2.length ? includesChildren(children2, ...types) : false;
+});
+var omitChildren = (children, ...types) => children.filter((child) => types.every((type) => child.type !== type));
+var pickChildren = (children, ...types) => children.filter((child) => types.every((type) => child.type === type));
+var cx = (...classNames) => classNames.filter(Boolean).join(" ");
+var isRefObject = (val) => "current" in val;
+var assignRef = (ref, value) => {
+  if (ref == null)
+    return;
+  if (typeof ref === "function") {
+    ref(value);
+    return;
+  }
+  try {
+    ref.current = value;
+  } catch (error) {
+    throw new Error(`Cannot assign value '${value}' to ref '${ref}'`);
+  }
+};
+var mergeRefs = (...refs) => (node) => {
+  refs.forEach((ref) => {
+    assignRef(ref, node);
+  });
+};
+var useMergeRefs = (...refs) => React.useMemo(() => mergeRefs(...refs), [refs]);
+var useCallbackRef = (callback, deps = []) => {
+  const callbackRef = React.useRef(callback);
+  React.useEffect(() => {
+    callbackRef.current = callback;
+  });
+  return React.useCallback((...args) => {
+    var _a;
+    return (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, ...args);
+  }, deps);
+};
+var useUpdateEffect = (callback, deps) => {
+  const renderCycleRef = React.useRef(false);
+  const effectCycleRef = React.useRef(false);
+  React.useEffect(() => {
+    const mounted = renderCycleRef.current;
+    const run = mounted && effectCycleRef.current;
+    if (run)
+      return callback();
+    effectCycleRef.current = true;
+  }, deps);
+  React.useEffect(() => {
+    renderCycleRef.current = true;
+    return () => {
+      renderCycleRef.current = false;
+    };
+  }, []);
+};
+
+// src/color.ts
+import { TinyColor } from "@ctrl/tinycolor";
+var getColor = (color, fallback) => (theme, colorMode) => {
+  const hex = getMemoizedObject(
+    theme,
+    `colors.${color}`,
+    color
+  );
+  if (isArray(hex)) {
+    const [lightHex, darkHex] = hex;
+    const { isValid, originalInput } = new TinyColor(colorMode !== "dark" ? lightHex : darkHex);
+    return isValid ? originalInput : fallback;
+  } else {
+    const { isValid, originalInput } = new TinyColor(hex);
+    return isValid ? originalInput : fallback;
+  }
+};
+var lightenColor = (color, amount) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new TinyColor(raw).lighten(amount).toRgbString();
+};
+var darkenColor = (color, amount) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new TinyColor(raw).darken(amount).toRgbString();
+};
+var brightenColor = (color, amount) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new TinyColor(raw).brighten(amount).toRgbString();
+};
+var tintColor = (color, amount) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new TinyColor(raw).tint(amount).toRgbString();
+};
+var shadeColor = (color, amount) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new TinyColor(raw).shade(amount).toRgbString();
+};
+var transparentizeColor = (color, alpha) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new TinyColor(raw).setAlpha(alpha).toRgbString();
+};
+var toneColor = (color, l) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  if (l < 0 || 900 < l)
+    return color;
+  let n = (l - 500) / 10;
+  const isLighten = n <= 0;
+  if (isLighten)
+    n *= -1;
+  if (n !== 0)
+    n = n - 5 * (isLighten ? 1 : -1);
+  return new TinyColor(raw)[isLighten ? "lighten" : "shade"](n).toString();
+};
+var randomColor = ({ string, colors } = {}) => {
+  const fallback = randomHex();
+  if (string && colors)
+    return randomColorFromList(string, colors);
+  if (string && !colors)
+    return randomColorFromString(string);
+  if (colors && !string)
+    return randomFromList(colors);
+  return fallback;
+};
+var randomHex = () => `#${Math.floor(Math.random() * 16777215).toString(16).padEnd(6, "0")}`;
+var randomColorFromString = (str) => {
+  let hash = 0;
+  if (str.length === 0)
+    return hash.toString();
+  for (let i = 0; i < str.length; i += 1) {
+    hash = str.charCodeAt(i) + ((hash << 5) - hash);
+    hash = hash & hash;
+  }
+  let color = "#";
+  for (let j = 0; j < 3; j += 1) {
+    const value = hash >> j * 8 & 255;
+    color += `00${value.toString(16)}`.substr(-2);
+  }
+  return color;
+};
+var randomColorFromList = (str, list) => {
+  let index = 0;
+  if (str.length === 0)
+    return list[0];
+  for (let i = 0; i < str.length; i += 1) {
+    index = str.charCodeAt(i) + ((index << 5) - index);
+    index = index & index;
+  }
+  index = (index % list.length + list.length) % list.length;
+  return list[index];
+};
+var randomFromList = (list) => list[Math.floor(Math.random() * list.length)];
+var isLight = (color) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new TinyColor(raw).isLight();
+};
+var isDark = (color) => (theme, colorMode) => {
+  const raw = getColor(color)(theme, colorMode);
+  return new TinyColor(raw).isDark();
+};
+
+// src/object.ts
+var omitObject = (obj, keys) => {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    if (keys.includes(key))
+      return;
+    result[key] = obj[key];
+  });
+  return result;
+};
+var pickObject = (obj, keys) => {
+  const result = {};
+  keys.forEach((key) => {
+    if (key in obj)
+      result[key] = obj[key];
+  });
+  return result;
+};
+var splitObject = (obj, keys) => {
+  const picked = {};
+  const omitted = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (keys.includes(key)) {
+      picked[key] = value;
+    } else {
+      omitted[key] = value;
+    }
+  }
+  return [picked, omitted];
+};
+var filterObject = (obj, func) => {
+  const result = {};
+  Object.entries(obj).forEach(([key, value]) => {
+    const shouldPass = func(key, value, obj);
+    if (shouldPass)
+      result[key] = value;
+  });
+  return result;
+};
+var filterUndefined = (obj) => filterObject(obj, (_, val) => val !== null && val !== void 0);
+var merge = (target, source, overrideArray = false) => {
+  let result = Object.assign({}, target);
+  if (isObject(target) && isObject(source)) {
+    for (const [sourceKey, sourceValue] of Object.entries(source)) {
+      const targetValue = target[sourceKey];
+      if (overrideArray && Array.isArray(sourceValue) && Array.isArray(targetValue)) {
+        result[sourceKey] = targetValue.concat(...sourceValue);
+      } else if (!isFunction(sourceValue) && isObject(sourceValue) && target.hasOwnProperty(sourceKey)) {
+        result[sourceKey] = merge(targetValue, sourceValue, overrideArray);
+      } else {
+        Object.assign(result, { [sourceKey]: sourceValue });
+      }
+    }
+  }
+  return result;
+};
+var flattenObject = (obj, maxDepth = Infinity) => {
+  if (!isObject(obj) && !isArray(obj) || !maxDepth)
+    return obj;
+  return Object.entries(obj).reduce((result, [key, value]) => {
+    if (isObject(value)) {
+      Object.entries(flattenObject(value, maxDepth - 1)).forEach(([childKey, childValue]) => {
+        result[`${key}.${childKey}`] = childValue;
+      });
+    } else {
+      result[key] = value;
+    }
+    return result;
+  }, {});
+};
+var objectFromEntries = (entries) => entries.reduce((result, [key, value]) => {
+  result[key] = value;
+  return result;
+}, {});
+var keysFormObject = (obj) => Object.keys(obj);
+var replaceObject = (objOrArray, callBack) => {
+  if (isArray(objOrArray)) {
+    return objOrArray.map(callBack);
+  } else if (isObject(objOrArray)) {
+    return Object.entries(objOrArray).reduce((obj, [key, value]) => {
+      obj[key] = callBack(value);
+      return obj;
+    }, {});
+  } else {
+    return callBack(objOrArray);
+  }
+};
+var getObject = (obj, path, fallback, i) => {
+  const k = typeof path === "string" ? path.split(".") : [path];
+  for (i = 0; i < k.length; i += 1) {
+    if (!obj)
+      break;
+    obj = obj[k[i]];
+  }
+  return obj === void 0 ? fallback : obj;
+};
+var memoizeObject = (func) => {
+  const cache = /* @__PURE__ */ new WeakMap();
+  const memoizedFunc = (obj, path, fallback, i) => {
+    if (typeof obj === "undefined") {
+      return func(obj, path, fallback);
+    }
+    if (!cache.has(obj))
+      cache.set(obj, /* @__PURE__ */ new Map());
+    const map = cache.get(obj);
+    if (map.has(path))
+      return map.get(path);
+    const value = func(obj, path, fallback, i);
+    map.set(path, value);
+    return value;
+  };
+  return memoizedFunc;
+};
+var getMemoizedObject = memoizeObject(getObject);
+var assignAfter = (target, ...sources) => {
+  if (target == null)
+    throw new TypeError("Cannot convert undefined or null to object");
+  const result = { ...target };
+  for (const nextSource of sources) {
+    if (nextSource == null)
+      continue;
+    for (const nextKey in nextSource) {
+      if (!Object.prototype.hasOwnProperty.call(nextSource, nextKey))
+        continue;
+      if (nextKey in result)
+        delete result[nextKey];
+      result[nextKey] = nextSource[nextKey];
+    }
+  }
+  return result;
+};
+
+export {
+  omitObject,
+  pickObject,
+  splitObject,
+  filterObject,
+  filterUndefined,
+  merge,
+  flattenObject,
+  objectFromEntries,
+  keysFormObject,
+  replaceObject,
+  getObject,
+  memoizeObject,
+  getMemoizedObject,
+  assignAfter,
+  noop,
+  runIfFunc,
+  handlerAll,
+  funcAll,
+  createContext2 as createContext,
+  useSafeLayoutEffect,
+  useUnmountEffect,
+  useIsMounted,
+  getValidChildren,
+  isValidElement2 as isValidElement,
+  findChildren,
+  includesChildren,
+  omitChildren,
+  pickChildren,
+  cx,
+  isRefObject,
+  assignRef,
+  mergeRefs,
+  useMergeRefs,
+  useCallbackRef,
+  useUpdateEffect,
+  getColor,
+  lightenColor,
+  darkenColor,
+  brightenColor,
+  tintColor,
+  shadeColor,
+  transparentizeColor,
+  toneColor,
+  randomColor,
+  isLight,
+  isDark
+};

package/dist/chunk-BZAW2D6U.mjs

@@ -0,0 +1,6 @@
+// src/string.ts
+var escape = (value, replaceValue = "") => value.replace(/\s+/g, replaceValue);
+
+export {
+  escape
+};