@fuzdev/fuz_util 0.42.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Ryan Atkinson <mail@ryanatkn.com> <https://ryanatkn.com/>
+
+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,83 @@
+# @ryanatkn/belt
+
+[<img src="static/logo.svg" alt="a green sauropod wearing a brown utility belt" align="right" width="256" height="256">](https://belt.ryanatkn.com/)
+
+> utility belt for JS 🦕 ancient not extinct
+
+**[belt.ryanatkn.com](https://belt.ryanatkn.com)**
+
+design:
+
+- kitchen-sink utilities library - sorry, I wish it weren't so, JS made me do it
+- two optional runtime dependencies on [`zod`](https://github.com/colinhacks/zod)
+  and [`esm-env`](https://github.com/benmccann/esm-env),
+  one optional type dependency on `@types/node`
+- mix of JS module environments - browser-only, Node-only, universal
+- mostly small pure functions
+- all TypeScript, for styles and Svelte and SvelteKit
+  see <a href="https://github.com/fuz-dev/fuz">@ryanatkn/fuz</a>
+- complements the modern web platform, drops legacy quickly
+- kinda minimal in many ways but also not, treeshakes well
+
+## usage
+
+Install from [npm](https://www.npmjs.com/package/@ryanatkn/belt):
+
+```bash
+npm i -D @ryanatkn/belt
+```
+
+Import modules at their full paths:
+
+```ts
+import {type Result, unwrap} from '@ryanatkn/belt/result.js';
+import {random_int} from '@ryanatkn/belt/random.js';
+```
+
+`.ts` imports also work:
+
+```ts
+import {deep_equal} from '@ryanatkn/belt/deep_equal.ts';
+```
+
+Docs at [belt.ryanatkn.com/docs](https://belt.ryanatkn.com/docs).
+
+## build
+
+```bash
+npm run build
+# or
+gro build
+```
+
+## test
+
+For more see [`uvu`](https://github.com/lukeed/uvu)
+and [Gro's test docs](https://github.com/feltjs/gro/blob/main/src/docs/test.md).
+
+```bash
+gro test
+gro test filepattern1 filepatternB
+gro test -- uvu --forwarded_args 'to uvu'
+```
+
+## deploy
+
+[Deploy](https://github.com/feltjs/gro/blob/main/src/docs/deploy.md)
+(build, commit, and push) to the `deploy` branch, e.g. for GitHub Pages:
+
+```bash
+npm run deploy
+# or
+gro deploy
+```
+
+## credits 🐢<sub>🐢</sub><sub><sub>🐢</sub></sub>
+
+My sister Lisa helped me with the logo -
+[instagram.com/lisaeatkinson](https://www.instagram.com/lisaeatkinson/) -
+she's a designer and currently looking for work
+
+## license [🐦](https://wikipedia.org/wiki/Free_and_open-source_software)
+
+[MIT](LICENSE)

package/dist/array.d.ts

@@ -0,0 +1,15 @@
+import type { ArrayElement } from './types.js';
+export declare const EMPTY_ARRAY: Array<any>;
+/** Converts `value` to an array if it's not already. */
+export declare const to_array: <T>(value: T) => T extends ReadonlyArray<any> ? T : Array<T>;
+/**
+ * Removes an element from `array` at `index` in an unordered manner.
+ * @mutates array swaps element at index with last element, then removes last element
+ */
+export declare const remove_unordered: (array: Array<any>, index: number) => void;
+/**
+ * Returns a function that returns the next item in the `array`
+ * in a linear sequence, looping back to index 0 when it reaches the end.
+ */
+export declare const to_next: <T extends ReadonlyArray<any>>(array: T) => (() => ArrayElement<T>);
+//# sourceMappingURL=array.d.ts.map

package/dist/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,YAAY,CAAC;AAG7C,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,GAAG,CAA4B,CAAC;AAEhE,wDAAwD;AACxD,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CACxB,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,KAAK,CAAC,GAAG,CAAC,EAAE,OAAO,MAAM,KAAG,IAGnE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,KAAG,CAAC,MAAM,YAAY,CAAC,CAAC,CAAC,CAOtF,CAAC"}

package/dist/array.js

@@ -0,0 +1,25 @@
+// TODO try to cange to readonly again, see if upstream errors are tolerably fixed
+export const EMPTY_ARRAY = Object.freeze([]);
+/** Converts `value` to an array if it's not already. */
+export const to_array = (value) => Array.isArray(value) ? value : [value];
+/**
+ * Removes an element from `array` at `index` in an unordered manner.
+ * @mutates array swaps element at index with last element, then removes last element
+ */
+export const remove_unordered = (array, index) => {
+    array[index] = array[array.length - 1];
+    array.pop();
+};
+/**
+ * Returns a function that returns the next item in the `array`
+ * in a linear sequence, looping back to index 0 when it reaches the end.
+ */
+export const to_next = (array) => {
+    let i = -1;
+    return () => {
+        i++;
+        if (i >= array.length)
+            i = 0;
+        return array[i];
+    };
+};

package/dist/async.d.ts

@@ -0,0 +1,62 @@
+export type AsyncStatus = 'initial' | 'pending' | 'success' | 'failure';
+/**
+ * Waits for the given `duration` before resolving.
+ */
+export declare const wait: (duration?: number) => Promise<void>;
+/**
+ * Checks if `value` is a `Promise`.
+ */
+export declare const is_promise: (value: any) => value is Promise<any>;
+/**
+ * Creates a deferred object with a promise and its resolve/reject handlers.
+ */
+export interface Deferred<T> {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: any) => void;
+}
+/**
+ * Creates a object with a `promise` and its `resolve`/`reject` handlers.
+ */
+export declare const create_deferred: <T>() => Deferred<T>;
+/**
+ * Maps over items with controlled concurrency, preserving input order.
+ *
+ * @param items array of items to process
+ * @param fn async function to apply to each item
+ * @param concurrency maximum number of concurrent operations
+ * @returns promise resolving to array of results in same order as input
+ *
+ * @example
+ * ```ts
+ * const results = await map_concurrent(
+ *   file_paths,
+ *   async (path) => readFile(path, 'utf8'),
+ *   5, // max 5 concurrent reads
+ * );
+ * ```
+ */
+export declare const map_concurrent: <T, R>(items: Array<T>, fn: (item: T, index: number) => Promise<R>, concurrency: number) => Promise<Array<R>>;
+/**
+ * Like `map_concurrent` but collects all results/errors instead of failing fast.
+ * Returns an array of settlement objects matching the `Promise.allSettled` pattern.
+ *
+ * @param items array of items to process
+ * @param fn async function to apply to each item
+ * @param concurrency maximum number of concurrent operations
+ * @returns promise resolving to array of `PromiseSettledResult` objects in input order
+ *
+ * @example
+ * ```ts
+ * const results = await map_concurrent_settled(urls, fetch, 5);
+ * for (const [i, result] of results.entries()) {
+ *   if (result.status === 'fulfilled') {
+ *     console.log(`${urls[i]}: ${result.value.status}`);
+ *   } else {
+ *     console.error(`${urls[i]}: ${result.reason}`);
+ *   }
+ * }
+ * ```
+ */
+export declare const map_concurrent_settled: <T, R>(items: Array<T>, fn: (item: T, index: number) => Promise<R>, concurrency: number) => Promise<Array<PromiseSettledResult<R>>>;
+//# sourceMappingURL=async.d.ts.map

package/dist/async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/async.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,iBAAY,KAAG,OAAO,CAAC,IAAI,CACQ,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,GAAG,KAAG,KAAK,IAAI,OAAO,CAAC,GAAG,CAClB,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5B,MAAM,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;CAC9B;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,OAAK,QAAQ,CAAC,CAAC,CAQ/C,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,GAAU,CAAC,EAAE,CAAC,EACxC,OAAO,KAAK,CAAC,CAAC,CAAC,EACf,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAC1C,aAAa,MAAM,KACjB,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAoDlB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB,GAAU,CAAC,EAAE,CAAC,EAChD,OAAO,KAAK,CAAC,CAAC,CAAC,EACf,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAC1C,aAAa,MAAM,KACjB,OAAO,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CA6CxC,CAAC"}

package/dist/async.js

@@ -0,0 +1,147 @@
+/**
+ * Waits for the given `duration` before resolving.
+ */
+export const wait = (duration = 0) => new Promise((resolve) => setTimeout(resolve, duration));
+/**
+ * Checks if `value` is a `Promise`.
+ */
+export const is_promise = (value) => value && typeof value.then === 'function';
+/**
+ * Creates a object with a `promise` and its `resolve`/`reject` handlers.
+ */
+export const create_deferred = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+};
+/**
+ * Maps over items with controlled concurrency, preserving input order.
+ *
+ * @param items array of items to process
+ * @param fn async function to apply to each item
+ * @param concurrency maximum number of concurrent operations
+ * @returns promise resolving to array of results in same order as input
+ *
+ * @example
+ * ```ts
+ * const results = await map_concurrent(
+ *   file_paths,
+ *   async (path) => readFile(path, 'utf8'),
+ *   5, // max 5 concurrent reads
+ * );
+ * ```
+ */
+export const map_concurrent = async (items, fn, concurrency) => {
+    if (concurrency < 1) {
+        throw new Error('concurrency must be at least 1');
+    }
+    const results = new Array(items.length);
+    let next_index = 0;
+    let active_count = 0;
+    let rejected = false;
+    let reject_error;
+    return new Promise((resolve, reject) => {
+        const run_next = () => {
+            // Stop spawning if we've rejected
+            if (rejected)
+                return;
+            // Check if we're done
+            if (next_index >= items.length && active_count === 0) {
+                resolve(results);
+                return;
+            }
+            // Spawn workers up to concurrency limit
+            while (active_count < concurrency && next_index < items.length) {
+                const index = next_index++;
+                const item = items[index];
+                active_count++;
+                fn(item, index)
+                    .then((result) => {
+                    if (rejected)
+                        return;
+                    results[index] = result;
+                    active_count--;
+                    run_next();
+                })
+                    .catch((error) => {
+                    if (rejected)
+                        return;
+                    rejected = true;
+                    reject_error = error;
+                    reject(reject_error); // eslint-disable-line @typescript-eslint/prefer-promise-reject-errors
+                });
+            }
+        };
+        // Handle empty array
+        if (items.length === 0) {
+            resolve(results);
+            return;
+        }
+        run_next();
+    });
+};
+/**
+ * Like `map_concurrent` but collects all results/errors instead of failing fast.
+ * Returns an array of settlement objects matching the `Promise.allSettled` pattern.
+ *
+ * @param items array of items to process
+ * @param fn async function to apply to each item
+ * @param concurrency maximum number of concurrent operations
+ * @returns promise resolving to array of `PromiseSettledResult` objects in input order
+ *
+ * @example
+ * ```ts
+ * const results = await map_concurrent_settled(urls, fetch, 5);
+ * for (const [i, result] of results.entries()) {
+ *   if (result.status === 'fulfilled') {
+ *     console.log(`${urls[i]}: ${result.value.status}`);
+ *   } else {
+ *     console.error(`${urls[i]}: ${result.reason}`);
+ *   }
+ * }
+ * ```
+ */
+export const map_concurrent_settled = async (items, fn, concurrency) => {
+    if (concurrency < 1) {
+        throw new Error('concurrency must be at least 1');
+    }
+    const results = new Array(items.length);
+    let next_index = 0;
+    let active_count = 0;
+    return new Promise((resolve) => {
+        const run_next = () => {
+            // Check if we're done
+            if (next_index >= items.length && active_count === 0) {
+                resolve(results);
+                return;
+            }
+            // Spawn workers up to concurrency limit
+            while (active_count < concurrency && next_index < items.length) {
+                const index = next_index++;
+                const item = items[index];
+                active_count++;
+                fn(item, index)
+                    .then((value) => {
+                    results[index] = { status: 'fulfilled', value };
+                })
+                    .catch((reason) => {
+                    results[index] = { status: 'rejected', reason };
+                })
+                    .finally(() => {
+                    active_count--;
+                    run_next();
+                });
+            }
+        };
+        // Handle empty array
+        if (items.length === 0) {
+            resolve(results);
+            return;
+        }
+        run_next();
+    });
+};

package/dist/colors.d.ts

@@ -0,0 +1,41 @@
+import type { Flavored } from './types.js';
+export type Hsl = readonly [Hue, Saturation, Lightness];
+export type Hue = Flavored<number, 'Hue'>;
+export type Saturation = Flavored<number, 'Saturation'>;
+export type Lightness = Flavored<number, 'Lightness'>;
+export type Rgb = readonly [Red, Green, Blue];
+export type Red = Flavored<number, 'Red'>;
+export type Green = Flavored<number, 'Green'>;
+export type Blue = Flavored<number, 'Blue'>;
+/**
+ * Converts an RGB color to a hex color.
+ */
+export declare const rgb_to_hex: (r: number, g: number, b: number) => number;
+/**
+ * Converts a hex color to an RGB color.
+ */
+export declare const hex_to_rgb: (hex: number) => Rgb;
+export declare const hex_string_to_rgb: (hex: string) => Rgb;
+export declare const rgb_to_hex_string: (r: number, g: number, b: number) => string;
+export declare const to_hex_component: (v: number) => string;
+/**
+ * Converts an RGB color value to HSL. Conversion formula
+ * adapted from http://wikipedia.org/wiki/HSL_color_space.
+ * Values r/g/b are in the range [0,255] and
+ * returns h/s/l in the range [0,1].
+ */
+export declare const rgb_to_hsl: (r: number, g: number, b: number) => Hsl;
+/**
+ * Converts an HSL color value to RGB. Conversion formula
+ * adapted from http://wikipedia.org/wiki/HSL_color_space.
+ * Values h/s/l are in the range [0,1] and
+ * returns r/g/b in the range [0,255].
+ */
+export declare const hsl_to_rgb: (h: Hue, s: Saturation, l: Lightness) => Rgb;
+export declare const hue_to_rgb_component: (p: number, q: number, t: number) => number;
+export declare const hsl_to_hex: (h: Hue, s: Saturation, l: Lightness) => number;
+export declare const hsl_to_hex_string: (h: Hue, s: Saturation, l: Lightness) => string;
+export declare const hsl_to_string: (h: Hue, s: Saturation, l: Lightness) => string;
+export declare const hex_string_to_hsl: (hex: string) => Hsl;
+export declare const parse_hsl_string: (hsl: string) => Hsl;
+//# sourceMappingURL=colors.d.ts.map

package/dist/colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/colors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAC;AAQzC,MAAM,MAAM,GAAG,GAAG,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;AACxD,MAAM,MAAM,GAAG,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAC1C,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AACxD,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AAEtD,MAAM,MAAM,GAAG,GAAG,SAAS,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;AAC9C,MAAM,MAAM,GAAG,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAC1C,MAAM,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAC9C,MAAM,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5C;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAAkC,CAAC;AAEhG;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,GAAuD,CAAC;AAEjG,eAAO,MAAM,iBAAiB,GAAI,KAAK,MAAM,KAAG,GAI/C,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MACE,CAAC;AAEvE,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,KAAG,MAG5C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,GA2B5D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,GAAG,GAAG,EAAE,GAAG,UAAU,EAAE,GAAG,SAAS,KAAG,GAYhE,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAMtE,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,GAAG,GAAG,EAAE,GAAG,UAAU,EAAE,GAAG,SAAS,KAAG,MAGhE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,GAAG,GAAG,EAAE,GAAG,UAAU,EAAE,GAAG,SAAS,KAAG,MAGvE,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,GAAG,GAAG,EAAE,GAAG,UAAU,EAAE,GAAG,SAAS,KAAG,MACU,CAAC;AAE/E,eAAO,MAAM,iBAAiB,GAAI,KAAK,MAAM,KAAG,GAG/C,CAAC;AAIF,eAAO,MAAM,gBAAgB,GAAI,KAAK,MAAM,KAAG,GAI9C,CAAC"}

package/dist/colors.js

@@ -0,0 +1,106 @@
+import { round } from './maths.js';
+/**
+ * Converts an RGB color to a hex color.
+ */
+export const rgb_to_hex = (r, g, b) => (r << 16) + (g << 8) + b;
+/**
+ * Converts a hex color to an RGB color.
+ */
+export const hex_to_rgb = (hex) => [(hex >> 16) & 255, (hex >> 8) & 255, hex & 255];
+export const hex_string_to_rgb = (hex) => {
+    var h = hex[0] === '#' ? hex.substring(1) : hex;
+    if (h.length !== 6 && h.length !== 8)
+        throw new Error('invalid hex string');
+    return [parseInt(h[0] + h[1], 16), parseInt(h[2] + h[3], 16), parseInt(h[4] + h[5], 16)];
+};
+export const rgb_to_hex_string = (r, g, b) => '#' + to_hex_component(r) + to_hex_component(g) + to_hex_component(b);
+export const to_hex_component = (v) => {
+    var h = v.toString(16);
+    return h.length === 1 ? '0' + h : h;
+};
+/**
+ * Converts an RGB color value to HSL. Conversion formula
+ * adapted from http://wikipedia.org/wiki/HSL_color_space.
+ * Values r/g/b are in the range [0,255] and
+ * returns h/s/l in the range [0,1].
+ */
+export const rgb_to_hsl = (r, g, b) => {
+    var r2 = r / 255;
+    var g2 = g / 255;
+    var b2 = b / 255;
+    var max = Math.max(r2, g2, b2);
+    var min = Math.min(r2, g2, b2);
+    var l = (max + min) / 2;
+    var h, s;
+    if (max === min) {
+        h = s = 0; // achromatic
+    }
+    else {
+        var d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case r2:
+                h = (g2 - b2) / d + (g2 < b2 ? 6 : 0);
+                break;
+            case g2:
+                h = (b2 - r2) / d + 2;
+                break;
+            case b2:
+                h = (r2 - g2) / d + 4;
+                break;
+        }
+        h /= 6;
+    }
+    return [h, round(s, 2), round(l, 2)];
+};
+/**
+ * Converts an HSL color value to RGB. Conversion formula
+ * adapted from http://wikipedia.org/wiki/HSL_color_space.
+ * Values h/s/l are in the range [0,1] and
+ * returns r/g/b in the range [0,255].
+ */
+export const hsl_to_rgb = (h, s, l) => {
+    var r, g, b;
+    if (s === 0) {
+        r = g = b = l; // achromatic
+    }
+    else {
+        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        var p = 2 * l - q;
+        r = hue_to_rgb_component(p, q, h + 1 / 3);
+        g = hue_to_rgb_component(p, q, h);
+        b = hue_to_rgb_component(p, q, h - 1 / 3);
+    }
+    return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+};
+export const hue_to_rgb_component = (p, q, t) => {
+    var t2 = t < 0 ? t + 1 : t > 1 ? t - 1 : t;
+    if (t2 < 1 / 6)
+        return p + (q - p) * 6 * t2;
+    if (t2 < 1 / 2)
+        return q;
+    if (t2 < 2 / 3)
+        return p + (q - p) * (2 / 3 - t2) * 6;
+    return p;
+};
+export const hsl_to_hex = (h, s, l) => {
+    var rgb = hsl_to_rgb(h, s, l); // TODO could safely use the optimized variant
+    return rgb_to_hex(rgb[0], rgb[1], rgb[2]);
+};
+export const hsl_to_hex_string = (h, s, l) => {
+    var rgb = hsl_to_rgb(h, s, l); // TODO could safely use the optimized variant
+    return rgb_to_hex_string(rgb[0], rgb[1], rgb[2]);
+};
+export const hsl_to_string = (h, s, l) => `hsl(${Math.round(h * 360)} ${Math.round(s * 100)}% ${Math.round(l * 100)}%)`;
+export const hex_string_to_hsl = (hex) => {
+    var rgb = hex_string_to_rgb(hex); // TODO could safely use the optimized variant
+    return rgb_to_hsl(rgb[0], rgb[1], rgb[2]);
+};
+const HSL_STRING_MATCHER = /^(hsl\()?\s*(\d+),?\s*(\d+)%,?\s*(\d+)%/;
+export const parse_hsl_string = (hsl) => {
+    var match = HSL_STRING_MATCHER.exec(hsl);
+    if (!match)
+        throw new Error('invalid HSL string');
+    return [Number(match[2]) / 360, Number(match[3]) / 100, Number(match[4]) / 100];
+};
+// TODO either add an hsla variant or support alpha in the hsl variant

package/dist/counter.d.ts

@@ -0,0 +1,7 @@
+export type Counter = () => number;
+export type CreateCounter = (initial?: number) => Counter;
+/**
+ * Creates a counter constructor function, starting at `0`.
+ */
+export declare const create_counter: CreateCounter;
+//# sourceMappingURL=counter.d.ts.map

package/dist/counter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"counter.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/counter.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC;AAEnC,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,aAG5B,CAAC"}

package/dist/counter.js

@@ -0,0 +1,7 @@
+/**
+ * Creates a counter constructor function, starting at `0`.
+ */
+export const create_counter = (count = 0) => {
+    let c = count;
+    return () => c++;
+};

package/dist/deep_equal.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Deep equality comparison that checks both structure and type.
+ *
+ * Key behaviors:
+ *
+ * - Compares by constructor to prevent type confusion (security: `{}` ≠ `[]`, `{}` ≠ `new Map()`, `new ClassA()` ≠ `new ClassB()`)
+ * - Prevents asymmetry bugs: `deep_equal(a, b)` always equals `deep_equal(b, a)`
+ * - Compares only enumerable own properties (ignores prototypes, symbols, non-enumerable)
+ * - Special handling for: Date (timestamp), Number/Boolean (boxed primitives), Error (message/name)
+ * - Promises always return false (cannot be meaningfully compared)
+ * - Maps/Sets compare by reference for object keys/values
+ *
+ * @param a first value to compare
+ * @param b second value to compare
+ * @returns true if deeply equal, false otherwise
+ */
+export declare const deep_equal: (a: unknown, b: unknown) => boolean;
+//# sourceMappingURL=deep_equal.d.ts.map

package/dist/deep_equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep_equal.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/deep_equal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,KAAG,OA0InD,CAAC"}