@design-edito/tools 0.2.39 → 0.2.41

package/agnostic/arrays/dedupe/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns a copy of the input array, with stripped duplicates
+ *
+ * @param arr - The array to search for duplicates.
+ * @returns The deduped array
+ */
+export declare function dedupe<T>(arr: T[]): T[];

package/agnostic/arrays/dedupe/index.js

@@ -0,0 +1,10 @@
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/arrays/dedupe/index.ts
+function dedupe(arr) {
+  const deduped = Array.from(new Set(arr));
+  return deduped;
+}
+export {
+  dedupe
+};

package/agnostic/arrays/find-duplicates/index.d.ts

@@ -1 +1,15 @@
+/**
+ * Finds duplicate elements in an array.
+ *
+ * @param arr - The array to search for duplicates.
+ * @param [stopAtFirst=false] - If `true`, returns immediately after finding the first duplicate.
+ * @returns An array of duplicate elements found in the input array.
+ */
 export declare function findDuplicates<T>(arr: T[], stopAtFirst?: boolean): T[];
+/**
+ * Finds the positions of duplicate elements in an array.
+ *
+ * @param arr - The array to search for duplicates positions.
+ * @returns An array of the positions of duplicate elements found in the input array.
+ */
+export declare function findDuplicatesPositions(arr: any[]): number[];

package/agnostic/arrays/find-duplicates/index.js

@@ -1,7 +1,26 @@
-import {
-  findDuplicates
-} from "../../../chunks/chunk-YS6WMSWC.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/arrays/find-duplicates/index.ts
+function findDuplicates(arr, stopAtFirst = false) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const item of arr) {
+    if (seen.has(item) && stopAtFirst) return [item];
+    if (seen.has(item)) duplicates.add(item);
+    seen.add(item);
+  }
+  return Array.from(duplicates);
+}
+function findDuplicatesPositions(arr) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicatesPos = [];
+  arr.forEach((item, pos) => {
+    if (seen.has(item)) return duplicatesPos.push(pos);
+    seen.add(item);
+  });
+  return duplicatesPos;
+}
 export {
-  findDuplicates
+  findDuplicates,
+  findDuplicatesPositions
 };

package/agnostic/arrays/find-duplicates/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/arrays/is-array-of/index.d.ts

@@ -1,5 +1,16 @@
-import { ConstructorFunction } from '../../misc/is-constructor-function/index.js';
-type TypeCheckerFunction<T extends any> = (input: unknown) => input is T;
-type TypeChecker<T extends any> = ConstructorFunction<T> | TypeCheckerFunction<T>;
-export declare function isArrayOf<T extends unknown = unknown>(input: unknown, _types?: TypeChecker<T> | TypeChecker<T>[]): input is T[];
+import { type ConstructorFunction } from '../../misc/is-constructor-function/index.js';
+/** Type guard function that checks if input is of type T. */
+type TypeCheckerFunction<T> = (input: unknown) => input is T;
+/** Type checker that can be either a constructor function or a type guard function. */
+type TypeChecker<T> = ConstructorFunction<T> | TypeCheckerFunction<T>;
+/** Infer the type from a TypeChecker */
+type TypeOfChecker<C> = C extends ConstructorFunction<infer U> ? U : C extends TypeCheckerFunction<infer U> ? U : never;
+/**
+ * Type guard to check if an input is an array and optionally if all elements match a type.
+ *
+ * If no type checkers are provided, only checks if the input is an array.
+ * Supports constructor functions (e.g., `Number`, `String`, `Boolean`, custom classes)
+ * and custom type guard functions.
+ */
+export declare function isArrayOf<C extends TypeChecker<any> | TypeChecker<any>[]>(input: unknown, _types?: C): input is Array<TypeOfChecker<C extends any[] ? C[number] : C>>;
 export {};

package/agnostic/arrays/is-array-of/index.js

@@ -1,8 +1,27 @@
 import {
-  isArrayOf
-} from "../../../chunks/chunk-6RGDWX4A.js";
-import "../../../chunks/chunk-RCO57B6F.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+  isConstructorFunction
+} from "../../../chunks/chunk-RCO57B6F.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/arrays/is-array-of/index.ts
+function isArrayOf(input, _types) {
+  if (!Array.isArray(input)) return false;
+  if (!_types) return true;
+  const types = Array.isArray(_types) ? _types : [_types];
+  const primitiveTypeMap = /* @__PURE__ */ new Map([
+    [Number, "number"],
+    [String, "string"],
+    [Boolean, "boolean"]
+  ]);
+  return input.every(
+    (entry) => types.some((typeChecker) => {
+      if (!isConstructorFunction(typeChecker)) return typeChecker(entry);
+      const primitiveType = primitiveTypeMap.get(typeChecker);
+      if (primitiveType) return typeof entry === primitiveType;
+      return entry instanceof typeChecker;
+    })
+  );
+}
 export {
   isArrayOf
 };

package/agnostic/arrays/is-array-of/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/arrays/make/index.d.ts

@@ -1,3 +1,11 @@
+/** Function that generates a value for each array position. */
 type Filler<T = any> = (pos?: number) => T;
+/**
+ * Creates an array of a specified length using a filler function.
+ *
+ * @param filler - Function called for each position to generate the array element.
+ * @param length - Desired length of the array.
+ * @returns A new array with elements generated by the filler function.
+ */
 export declare function make<T>(filler: Filler<T>, length: number): T[];
 export {};

package/agnostic/arrays/make/index.js

@@ -1,7 +1,9 @@
-import {
-  make
-} from "../../../chunks/chunk-RLAZR3NL.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/arrays/make/index.ts
+function make(filler, length) {
+  return new Array(length).fill(null).map((_, pos) => filler(pos));
+}
 export {
   make
 };

package/agnostic/arrays/make/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/arrays/random-pick/index.d.ts

@@ -1,2 +1,22 @@
+/**
+ * Picks a random element from an array, optionally excluding certain elements.
+ *
+ * @param arr - The array to pick from.
+ * @param [exclude] - Array of elements to exclude from selection.
+ * @returns A randomly selected element from the array.
+ * @throws Throws an error if no elements are available after exclusions.
+ */
 export declare function randomPick<T>(arr: T[], exclude?: T[]): T;
+/**
+ * Picks multiple random elements from an array without replacement.
+ *
+ * Each picked element is removed from the pool before the next selection, ensuring
+ * no duplicates in the result.
+ *
+ * @param howMuch - Number of elements to pick.
+ * @param arr - The array to pick from.
+ * @param [exclude] - Array of elements to exclude from selection.
+ * @returns An array of randomly selected elements.
+ * @throws Propagates the error thrown by `randomPick` if not enough elements are available.
+ */
 export declare function randomPickMany<T>(howMuch: number, arr: T[], exclude?: T[]): T[];

package/agnostic/arrays/random-pick/index.js

@@ -1,16 +1,8 @@
 import {
   randomPick,
   randomPickMany
-} from "../../../chunks/chunk-AQBJ6HNB.js";
-import "../../../chunks/chunk-TIER4TF4.js";
-import "../../../chunks/chunk-FR5H2OCV.js";
-import "../../../chunks/chunk-S2NMAH7K.js";
-import "../../../chunks/chunk-LV2VMOWR.js";
-import "../../../chunks/chunk-RLJOYG64.js";
-import "../../../chunks/chunk-WH6BPDAC.js";
-import "../../../chunks/chunk-QHLQVR3E.js";
-import "../../../chunks/chunk-FENXVJYO.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+} from "../../../chunks/chunk-K5UF634H.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   randomPick,
   randomPickMany

package/agnostic/arrays/random-pick/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/arrays/shuffle/index.d.ts

@@ -1 +1,9 @@
+/**
+ * Shuffles an array using the Fisher-Yates algorithm.
+ *
+ * Creates a new array with the same elements in random order. The original array is not modified.
+ *
+ * @param array - The array to shuffle.
+ * @returns A new array with shuffled elements.
+ */
 export declare function shuffle<T extends readonly unknown[] | unknown[]>(array: T): Array<T[number]>;

package/agnostic/arrays/shuffle/index.js

@@ -1,7 +1,14 @@
-import {
-  shuffle
-} from "../../../chunks/chunk-VJJIYJMY.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/arrays/shuffle/index.ts
+function shuffle(array) {
+  const shuffled = [...array];
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  }
+  return shuffled;
+}
 export {
   shuffle
 };

package/agnostic/arrays/shuffle/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/booleans/is-falsy/index.d.ts

@@ -1,7 +1,24 @@
 import { Nullish } from '../../misc/is-nullish/index.js';
+/** Union type representing all falsy values in JavaScript. */
 export type Falsy = Nullish | false | '' | 0 | -0 | typeof NaN | 0n;
+/** Type that excludes falsy values from T (except numbers, which may be 0). */
 export type NotFalsy<T> = Exclude<T, Exclude<Falsy, number>>;
+/** Array containing all falsy values for comparison. */
 declare const falsyValues: Falsy[];
 export { falsyValues };
+/**
+ * Type guard to check if a value is falsy.
+ *
+ * Checks if the value is one of: null, undefined, false, empty string, 0, -0, NaN, or 0n.
+ *
+ * @param val - The value to check.
+ * @returns `true` if the value is falsy, `false` otherwise.
+ */
 export declare function isFalsy<T>(val: T | Falsy): val is Falsy;
+/**
+ * Type guard to check if a value is not falsy.
+ *
+ * @param val - The value to check.
+ * @returns `true` if the value is not falsy, `false` otherwise.
+ */
 export declare function isNotFalsy<T>(val: T): val is NotFalsy<T>;

package/agnostic/booleans/is-falsy/index.js

@@ -4,7 +4,7 @@ import {
   isNotFalsy
 } from "../../../chunks/chunk-QXAJXTXV.js";
 import "../../../chunks/chunk-HC6ZOHCS.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   falsyValues,
   isFalsy,

package/agnostic/booleans/is-falsy/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/colors/channels/index.d.ts

@@ -1,5 +1,39 @@
 import { Color, TransformedColor, Channel } from '../types.js';
+/**
+ * Sets a specific color channel to an absolute value.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to modify.
+ * @param {Channel} channel - The channel to set.
+ * @param {number} value - The new value for the channel.
+ * @returns {TransformedColor<C>} The color with the updated channel, in the original format.
+ */
 export declare function setChannel<C extends Color>(color: C, channel: Channel, value: number): TransformedColor<C>;
+/**
+ * Gets the value of a specific color channel.
+ *
+ * @param {Color} color - The color to read from.
+ * @param {Channel} channel - The channel to retrieve.
+ * @returns {number} The value of the specified channel.
+ */
 export declare function getChannel(color: Color, channel: Channel): number;
+/**
+ * Adds a value to a specific color channel.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to modify.
+ * @param {Channel} channel - The channel to modify.
+ * @param {number} amount - The amount to add to the channel.
+ * @returns {TransformedColor<C>} The color with the updated channel, in the original format.
+ */
 export declare function addChannel<C extends Color>(color: C, channel: Channel, amount: number): TransformedColor<C>;
+/**
+ * Multiplies a specific color channel by a factor.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to modify.
+ * @param {Channel} channel - The channel to modify.
+ * @param {number} factor - The multiplication factor.
+ * @returns {TransformedColor<C>} The color with the updated channel, in the original format.
+ */
 export declare function multChannel<C extends Color>(color: C, channel: Channel, factor: number): TransformedColor<C>;

package/agnostic/colors/channels/index.js

@@ -3,14 +3,14 @@ import {
   getChannel,
   multChannel,
   setChannel
-} from "../../../chunks/chunk-NCYE5WML.js";
-import "../../../chunks/chunk-FNQAF6CQ.js";
+} from "../../../chunks/chunk-MSAAQTCE.js";
+import "../../../chunks/chunk-RNXRHCHQ.js";
 import "../../../chunks/chunk-DNIOWD7K.js";
 import "../../../chunks/chunk-OSAXBA7G.js";
-import "../../../chunks/chunk-67V4BGOB.js";
+import "../../../chunks/chunk-JDINERKY.js";
 import "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-7UGMWTP5.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-KRYJVBO5.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   addChannel,
   getChannel,

package/agnostic/colors/channels/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/colors/contrast/index.d.ts

@@ -1,2 +1,10 @@
 import { Color, ContrastMethod } from '../types.js';
+/**
+ * Calculates the contrast ratio between two colors using the specified method.
+ *
+ * @param {Color} c1 - The first color.
+ * @param {Color} c2 - The second color.
+ * @param {ContrastMethod} [method='wcag'] - The calculation method to use.
+ * @returns {number} The contrast ratio. For WCAG, values range from 1 (no contrast) to 21 (maximum contrast).
+ */
 export declare function contrast(c1: Color, c2: Color, method?: ContrastMethod): number;

package/agnostic/colors/contrast/index.js

@@ -1,14 +1,33 @@
 import {
-  contrast
-} from "../../../chunks/chunk-5CTAKAIP.js";
-import "../../../chunks/chunk-3LCD73SB.js";
-import "../../../chunks/chunk-FNQAF6CQ.js";
+  luminance
+} from "../../../chunks/chunk-UR5BUIPU.js";
+import {
+  toRgb
+} from "../../../chunks/chunk-RNXRHCHQ.js";
 import "../../../chunks/chunk-DNIOWD7K.js";
 import "../../../chunks/chunk-OSAXBA7G.js";
-import "../../../chunks/chunk-67V4BGOB.js";
+import "../../../chunks/chunk-JDINERKY.js";
 import "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-7UGMWTP5.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-KRYJVBO5.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/colors/contrast/index.ts
+function contrastWcag(c1, c2) {
+  const L1 = luminance(c1, "rgb");
+  const L2 = luminance(c2, "rgb");
+  const lighter = Math.max(L1, L2);
+  const darker = Math.min(L1, L2);
+  const numerator = lighter + 0.05;
+  const denominator = darker + 0.05;
+  const ratio = numerator / denominator;
+  return ratio;
+}
+function contrast(c1, c2, method = "wcag") {
+  switch (method) {
+    case "wcag":
+      return contrastWcag(toRgb(c1), toRgb(c2));
+  }
+}
 export {
   contrast
 };

package/agnostic/colors/contrast/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/colors/convert/index.d.ts

@@ -1,20 +1,164 @@
 import { Color, Hex, Rgba, Hsla, Hsba, Laba, Lcha, Cmyka, Xyza, CssColor, TransformedColor, Srgba } from '../types.js';
+/**
+ * Converts any supported color format to RGBA.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Rgba} The color in RGBA format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function toRgb(color: Color): Rgba;
+/**
+ * Converts any supported color format to CIE XYZ.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Xyza} The color in CIE XYZ format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function toXyz(color: Color): Xyza;
+/**
+ * Converts any supported color format to CIELAB.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Laba} The color in CIELAB format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function toLab(color: Color): Laba;
+/**
+ * Converts any supported color format to CIELCh.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Lcha} The color in CIELCh format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function toLch(color: Color): Lcha;
+/**
+ * Converts any supported color format to HSLA.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Hsla} The color in HSLA format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function toHsl(color: Color): Hsla;
+/**
+ * Converts any supported color format to HSBA (HSB/HSV).
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Hsba} The color in HSBA format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function toHsb(color: Color): Hsba;
+/**
+ * Converts any supported color format to CMYK.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Cmyka} The color in CMYK format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function toCmyk(color: Color): Cmyka;
+/**
+ * Converts any supported color format to a CSS named color.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {CssColor | undefined} The CSS named color if an exact match exists, otherwise undefined.
+ */
 export declare function toCss(color: CssColor): CssColor;
 export declare function toCss(color: Color): CssColor | undefined;
+/**
+ * Converts any supported color format to hexadecimal.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Hex} The color in hexadecimal format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function toHex(color: Color): Hex;
+/**
+ * Transforms a color by converting it to RGBA, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(rgb: Rgba) => Rgba} transformer - Function that transforms the RGBA representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function viaRgb<C extends Color>(color: C, transformer: (rgb: Rgba) => Rgba): TransformedColor<C>;
+/**
+ * Transforms a color by converting it to HSLA, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(hsl: Hsla) => Hsla} transformer - Function that transforms the HSLA representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function viaHsl<C extends Color>(color: C, transformer: (hsl: Hsla) => Hsla): TransformedColor<C>;
+/**
+ * Transforms a color by converting it to HSBA, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(hsb: Hsba) => Hsba} transformer - Function that transforms the HSBA representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function viaHsb<C extends Color>(color: C, transformer: (hsb: Hsba) => Hsba): TransformedColor<C>;
+/**
+ * Transforms a color by converting it to CMYK, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(cmyk: Cmyka) => Cmyka} transformer - Function that transforms the CMYK representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function viaCmyk<C extends Color>(color: C, transformer: (cmyk: Cmyka) => Cmyka): TransformedColor<C>;
+/**
+ * Transforms a color by converting it to CIE XYZ, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(xyz: Xyza) => Xyza} transformer - Function that transforms the XYZ representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function viaXyz<C extends Color>(color: C, transformer: (xyz: Xyza) => Xyza): TransformedColor<C>;
+/**
+ * Transforms a color by converting it to CIELAB, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(lab: Laba) => Laba} transformer - Function that transforms the CIELAB representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function viaLab<C extends Color>(color: C, transformer: (lab: Laba) => Laba): TransformedColor<C>;
+/**
+ * Transforms a color by converting it to CIELCh, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(lch: Lcha) => Lcha} transformer - Function that transforms the CIELCh representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
 export declare function viaLch<C extends Color>(color: C, transformer: (lch: Lcha) => Lcha): TransformedColor<C>;
+/**
+ * Converts an RGBA color to linear sRGB color space by applying inverse gamma correction.
+ *
+ * @param {Rgba} rgb - The RGBA color to linearize.
+ * @returns {Srgba} The linearized color in sRGB color space.
+ */
 export declare function linearizeToSRgb(rgb: Rgba): Srgba;
+/**
+ * Converts a linear sRGB color to RGBA by applying gamma correction.
+ *
+ * @param {Srgba} srgb - The linear sRGB color to delinearize.
+ * @returns {Rgba} The delinearized color in RGBA format.
+ */
 export declare function delinearizeToRgb(srgb: Srgba): Rgba;

package/agnostic/colors/convert/index.js

@@ -17,13 +17,13 @@ import {
   viaLch,
   viaRgb,
   viaXyz
-} from "../../../chunks/chunk-FNQAF6CQ.js";
+} from "../../../chunks/chunk-RNXRHCHQ.js";
 import "../../../chunks/chunk-DNIOWD7K.js";
 import "../../../chunks/chunk-OSAXBA7G.js";
-import "../../../chunks/chunk-67V4BGOB.js";
+import "../../../chunks/chunk-JDINERKY.js";
 import "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-7UGMWTP5.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-KRYJVBO5.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   delinearizeToRgb,
   linearizeToSRgb,

package/agnostic/colors/convert/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/colors/distance/index.d.ts

@@ -1,2 +1,10 @@
 import { Color, DistanceMethod } from '../types.js';
+/**
+ * Calculates the perceptual distance between two colors using the specified method.
+ *
+ * @param {Color} c1 - The first color.
+ * @param {Color} c2 - The second color.
+ * @param {DistanceMethod} [method='ciede2000'] - The calculation method to use.
+ * @returns {number} The perceptual distance between the colors. Lower values indicate more similar colors.
+ */
 export declare function distance(c1: Color, c2: Color, method?: DistanceMethod): number;