@fuzdev/fuz_util 0.42.0

package/dist/log.js

@@ -0,0 +1,393 @@
+import { styleText } from 'node:util';
+import { DEV } from 'esm-env';
+const CHAR_ERROR = '🞩';
+const CHAR_WARN = '⚑';
+// Info logs have no character prefix - they only show the label.
+// This is by design: info is the "default" log level for standard output,
+// so it gets minimal visual noise. Error, warn, and debug have distinctive
+// prefixes to make them stand out from normal info logs.
+const CHAR_DEBUG = '┆';
+// Pre-computed method prefix strings
+const PREFIX_ERROR = `${CHAR_ERROR}error${CHAR_ERROR}`;
+const PREFIX_WARN = `${CHAR_WARN}warn${CHAR_WARN}`;
+// Info has no prefix - see CHAR_DEBUG comment above
+const PREFIX_DEBUG = `${CHAR_DEBUG}debug${CHAR_DEBUG}`;
+const LOG_LEVEL_VALUES = {
+    off: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+};
+/**
+ * Converts a log level to its numeric value for comparison.
+ * Higher numbers indicate more verbose logging.
+ * @param level The log level to convert
+ * @returns Numeric value (0-4)
+ */
+export const log_level_to_number = (level) => LOG_LEVEL_VALUES[level];
+/**
+ * Parses and validates a log level string.
+ * @param value The value to parse as a log level
+ * @returns The validated log level, or undefined if value is undefined
+ * @throws Error if value is provided but invalid
+ */
+export const log_level_parse = (value) => {
+    if (!value)
+        return undefined;
+    if (value in LOG_LEVEL_VALUES)
+        return value;
+    throw new Error(`Invalid log level: '${value}'`);
+};
+const DEFAULT_LOG_LEVEL = (typeof process === 'undefined' ? undefined : log_level_parse(process.env.PUBLIC_LOG_LEVEL)) ??
+    (process.env.VITEST ? 'off' : DEV ? 'debug' : 'info');
+// Identity function for when colors are disabled
+const NO_COLOR_ST = (_, s) => s;
+/**
+ * Simple, flexible logger with support for child loggers and automatic context.
+ *
+ * Features:
+ * - Instance-based configuration (no global state)
+ * - Child loggers with automatic label concatenation
+ * - Parent chain inheritance for level, console, and colors
+ * - Respects NO_COLOR environment variable
+ *
+ * @example
+ * ```ts
+ * // Basic logger
+ * const log = new Logger('app');
+ * log.info('starting'); // [app] ➤ starting
+ *
+ * // Child logger
+ * const db_log = log.child('db');
+ * db_log.info('connected'); // [app:db] ➤ connected
+ *
+ * // Custom configuration
+ * const verbose_log = new Logger('debug', { level: 'debug', colors: true });
+ * ```
+ */
+export class Logger {
+    label;
+    parent;
+    // Private override fields (undefined = inherit from parent)
+    #level_override;
+    #colors_override;
+    #console_override;
+    // Lazy cache for formatted prefixes (individually cached and invalidated when colors change)
+    #cached_colors;
+    #cached_st;
+    #cached_error;
+    #cached_warn;
+    #cached_info;
+    #cached_debug;
+    #cached_level_string;
+    #cached_level;
+    /**
+     * Creates a new Logger instance.
+     *
+     * @param label Optional label for this logger. Can be `undefined` for no label, or an
+     *   empty string `''` which is functionally equivalent (both produce no brackets in output).
+     *   Note: Empty strings are only allowed for root loggers - child loggers cannot have empty labels.
+     * @param options Optional configuration for level, colors, and console
+     */
+    constructor(label, options = {}) {
+        this.label = label;
+        this.parent = options.parent;
+        // Set overrides if provided (undefined = inherit from parent)
+        if (options.level !== undefined) {
+            log_level_parse(options.level); // throws if invalid
+            this.#level_override = options.level;
+        }
+        if (options.colors !== undefined) {
+            this.#colors_override = options.colors;
+        }
+        if (options.console !== undefined) {
+            this.#console_override = options.console;
+        }
+    }
+    /**
+     * Dynamic getter for level - checks override, then parent, then default.
+     */
+    get level() {
+        if (this.#level_override !== undefined) {
+            return this.#level_override;
+        }
+        if (this.parent) {
+            return this.parent.level;
+        }
+        return DEFAULT_LOG_LEVEL;
+    }
+    /**
+     * Setter for level - creates override.
+     */
+    set level(value) {
+        log_level_parse(value); // throws if invalid
+        this.#level_override = value;
+    }
+    /**
+     * Dynamic getter for colors - checks override, then parent, then environment variables.
+     *
+     * Colors are disabled if either the `NO_COLOR` or `CLAUDECODE` environment variable is set.
+     * The `CLAUDECODE` check disables colors in Claude Code environments where ANSI color codes
+     * may not render correctly in the output.
+     */
+    get colors() {
+        if (this.#colors_override !== undefined) {
+            return this.#colors_override;
+        }
+        if (this.parent) {
+            return this.parent.colors;
+        }
+        const has_no_color = typeof process !== 'undefined' &&
+            (process.env.NO_COLOR !== undefined || process.env.CLAUDECODE !== undefined);
+        return !has_no_color;
+    }
+    /**
+     * Setter for colors - creates override.
+     */
+    set colors(value) {
+        this.#colors_override = value;
+    }
+    /**
+     * Dynamic getter for console - checks override, then parent, then global console.
+     */
+    get console() {
+        if (this.#console_override !== undefined) {
+            return this.#console_override;
+        }
+        if (this.parent) {
+            return this.parent.console;
+        }
+        return console;
+    }
+    /**
+     * Setter for console - creates override.
+     */
+    set console(value) {
+        this.#console_override = value;
+    }
+    /**
+     * Gets the root logger by walking up the parent chain.
+     * Useful for setting global configuration that affects all child loggers.
+     * @returns The root logger (the one without a parent)
+     */
+    get root() {
+        let current = this; // eslint-disable-line consistent-this, @typescript-eslint/no-this-alias
+        while (current.parent) {
+            current = current.parent;
+        }
+        return current;
+    }
+    /**
+     * Clears the level override for this logger, restoring inheritance from parent.
+     * After calling this, the logger will dynamically inherit the level from its parent
+     * (or use the default level if it has no parent).
+     */
+    clear_level_override() {
+        this.#level_override = undefined;
+        this.#cached_level_string = undefined;
+        this.#cached_level = undefined;
+    }
+    /**
+     * Clears the colors override for this logger, restoring inheritance from parent.
+     * After calling this, the logger will dynamically inherit colors from its parent
+     * (or use the default colors behavior if it has no parent).
+     */
+    clear_colors_override() {
+        this.#colors_override = undefined;
+        // Invalidate prefix caches since colors affect them
+        this.#cached_colors = undefined;
+        this.#cached_error = undefined;
+        this.#cached_warn = undefined;
+        this.#cached_info = undefined;
+        this.#cached_debug = undefined;
+    }
+    /**
+     * Clears the console override for this logger, restoring inheritance from parent.
+     * After calling this, the logger will dynamically inherit the console from its parent
+     * (or use the global console if it has no parent).
+     */
+    clear_console_override() {
+        this.#console_override = undefined;
+    }
+    /**
+     * Ensures prefix cache is valid by checking if colors configuration changed.
+     * Uses pull-based invalidation: checks colors on each access and invalidates cached
+     * prefixes if colors changed. This automatically handles inheritance changes since
+     * `this.colors` getter walks the parent chain on each access.
+     *
+     * Invalidates all 4 cached prefix strings when colors change, since they all depend
+     * on the color configuration.
+     */
+    #ensure_cache_valid() {
+        const current_colors = this.colors;
+        if (this.#cached_colors !== current_colors) {
+            this.#cached_colors = current_colors;
+            this.#cached_st = current_colors ? styleText : NO_COLOR_ST;
+            this.#cached_error = undefined;
+            this.#cached_warn = undefined;
+            this.#cached_info = undefined;
+            this.#cached_debug = undefined;
+        }
+    }
+    /**
+     * Formats the label portion of log output with given styleText function.
+     * Applies color styling if enabled, otherwise returns plain bracketed label.
+     */
+    #format_label(st, colored) {
+        if (!this.label)
+            return '';
+        return colored
+            ? `${st('gray', '[')}${st('magenta', this.label)}${st('gray', ']')}`
+            : `[${this.label}]`;
+    }
+    /**
+     * Gets the formatted error prefix, lazily computing and caching if needed.
+     * Lazy computation means prefixes are only built when the corresponding log method
+     * is first called, avoiding work for unused log levels.
+     */
+    #get_error_prefix() {
+        this.#ensure_cache_valid();
+        if (this.#cached_error === undefined) {
+            const st = this.#cached_st;
+            const prefix = st('red', PREFIX_ERROR);
+            const label = this.#format_label(st, this.#cached_colors);
+            this.#cached_error = label ? `${prefix} ${label}` : prefix;
+        }
+        return this.#cached_error;
+    }
+    /**
+     * Gets the formatted warn prefix, lazily computing and caching if needed.
+     */
+    #get_warn_prefix() {
+        this.#ensure_cache_valid();
+        if (this.#cached_warn === undefined) {
+            const st = this.#cached_st;
+            const prefix = st('yellow', PREFIX_WARN);
+            const label = this.#format_label(st, this.#cached_colors);
+            this.#cached_warn = label ? `${prefix} ${label}` : prefix;
+        }
+        return this.#cached_warn;
+    }
+    /**
+     * Gets the formatted info prefix, lazily computing and caching if needed.
+     * Note: info has no colored prefix character, only the label.
+     */
+    #get_info_prefix() {
+        this.#ensure_cache_valid();
+        if (this.#cached_info === undefined) {
+            const st = this.#cached_st;
+            const label = this.#format_label(st, this.#cached_colors);
+            this.#cached_info = label || '';
+        }
+        return this.#cached_info;
+    }
+    /**
+     * Gets the formatted debug prefix, lazily computing and caching if needed.
+     */
+    #get_debug_prefix() {
+        this.#ensure_cache_valid();
+        if (this.#cached_debug === undefined) {
+            const st = this.#cached_st;
+            const prefix = st('gray', PREFIX_DEBUG);
+            const label = this.#format_label(st, this.#cached_colors);
+            this.#cached_debug = label ? `${prefix} ${label}` : prefix;
+        }
+        return this.#cached_debug;
+    }
+    /**
+     * Gets the cached numeric level value, updating cache if level changed.
+     * Called on every log method invocation to check if the message should be filtered.
+     * Caches the numeric value (from LOG_LEVEL_VALUES dictionary) to avoid repeated lookups.
+     * Uses pull-based invalidation: checks `this.level` getter which handles inheritance.
+     */
+    #get_cached_level() {
+        const current_level_string = this.level;
+        if (this.#cached_level_string !== current_level_string) {
+            this.#cached_level_string = current_level_string;
+            this.#cached_level = LOG_LEVEL_VALUES[current_level_string];
+        }
+        return this.#cached_level;
+    }
+    /**
+     * Creates a child logger with automatic label concatenation.
+     * Children inherit parent configuration unless overridden.
+     *
+     * @param label Child label (will be concatenated with parent label using `:`).
+     *   Cannot be an empty string - empty labels would result in confusing output like `parent:`
+     *   with a trailing colon. Use `undefined` or `''` only for root loggers.
+     * @param options Optional configuration overrides
+     * @returns New Logger instance with concatenated label
+     * @throws Error if label is an empty string
+     *
+     * @example
+     * ```ts
+     * const app_log = new Logger('app');
+     * const db_log = app_log.child('db'); // label: 'app:db'
+     * const query_log = db_log.child('query'); // label: 'app:db:query'
+     * ```
+     */
+    child(label, options = {}) {
+        if (label === '') {
+            throw new Error('Logger label cannot be empty when creating child');
+        }
+        const child_label = this.label ? `${this.label}:${label}` : label;
+        // Pass parent reference and all config options
+        const internal_options = {
+            ...options,
+            parent: this,
+        };
+        return new Logger(child_label, internal_options);
+    }
+    /**
+     * Logs an error message with `🞩error🞩` prefix.
+     * Only outputs if current level is `error` or higher.
+     */
+    error(...args) {
+        if (this.#get_cached_level() < LOG_LEVEL_VALUES.error)
+            return;
+        this.console.error(this.#get_error_prefix(), ...args);
+    }
+    /**
+     * Logs a warning message with `⚑warn⚑` prefix.
+     * Only outputs if current level is `warn` or higher.
+     */
+    warn(...args) {
+        if (this.#get_cached_level() < LOG_LEVEL_VALUES.warn)
+            return;
+        this.console.warn(this.#get_warn_prefix(), ...args);
+    }
+    /**
+     * Logs an informational message.
+     * Unlike error/warn/debug, info has no character prefix - only the label is shown.
+     * This keeps standard output clean since info is the default log level.
+     * Only outputs if current level is `info` or higher.
+     */
+    info(...args) {
+        if (this.#get_cached_level() < LOG_LEVEL_VALUES.info)
+            return;
+        this.console.log(this.#get_info_prefix(), ...args);
+    }
+    /**
+     * Logs a debug message with `┆debug┆` prefix.
+     * Only outputs if current level is `debug`.
+     */
+    debug(...args) {
+        if (this.#get_cached_level() < LOG_LEVEL_VALUES.debug)
+            return;
+        this.console.log(this.#get_debug_prefix(), ...args);
+    }
+    /**
+     * Logs raw output without any prefix, formatting, or level filtering.
+     * Bypasses the logger's level checking, prefix formatting, and color application entirely.
+     * Useful for outputting structured data or when you need full control over formatting.
+     *
+     * Note: This method ignores the configured log level - it always outputs regardless of
+     * whether the logger is set to 'off' or any other level.
+     *
+     * @param args Values to log directly to console
+     */
+    raw(...args) {
+        this.console.log(...args);
+    }
+}

package/dist/map.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Sorts a map by `comparator`, a function that compares two entries,
+ * defaulting to using `localCompare` and `>`.
+ */
+export declare const sort_map: <T extends Map<any, any>>(map: T, comparator?: (a: [any, any], b: [any, any]) => number) => T;
+/**
+ * Compares two map entries for sorting purposes.
+ * If the key is a string, it uses `localeCompare` for comparison.
+ * For other types, it uses `>`.
+ */
+export declare const compare_simple_map_entries: (a: [any, any], b: [any, any]) => number;
+//# sourceMappingURL=map.d.ts.map

package/dist/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/map.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,EAC/C,KAAK,CAAC,EACN,iBAQ6C,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,KAAG,MAAM,AARxC,KACrC,CAA4C,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,GAAI,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,KAAG,MAGzE,CAAC"}

package/dist/map.js

@@ -0,0 +1,14 @@
+/**
+ * Sorts a map by `comparator`, a function that compares two entries,
+ * defaulting to using `localCompare` and `>`.
+ */
+export const sort_map = (map, comparator = compare_simple_map_entries) => new Map([...map].sort(comparator));
+/**
+ * Compares two map entries for sorting purposes.
+ * If the key is a string, it uses `localeCompare` for comparison.
+ * For other types, it uses `>`.
+ */
+export const compare_simple_map_entries = (a, b) => {
+    const a_key = a[0];
+    return typeof a_key === 'string' ? a_key.localeCompare(b[0]) : a[0] > b[0] ? 1 : -1;
+};

package/dist/maths.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Returns `n` bounded to `min` and `max`.
+ */
+export declare const clamp: (n: number, min: number, max: number) => number;
+/**
+ * Linear interpolation between `a` and `b` by `amount`.
+ */
+export declare const lerp: (a: number, b: number, amount: number) => number;
+/**
+ * Rounds a number to a specified number of decimal places.
+ */
+export declare const round: (n: number, decimals: number) => number;
+/**
+ * golden ratio/mean constants, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR = 1.618033988749895;
+/**
+ * golden ratio/mean constants, `1/GR`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_i = 0.6180339887498948;
+/**
+ * golden ratio/mean constants, `GR**2`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_2 = 2.618033988749895;
+/**
+ * golden ratio/mean constants, `1/(GR**2)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_2i = 0.38196601125010515;
+/**
+ * golden ratio/mean constants, `GR**3`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_3 = 4.23606797749979;
+/**
+ * golden ratio/mean constants, `1/(GR**3)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_3i = 0.2360679774997897;
+/**
+ * golden ratio/mean constants, `GR**4`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_4 = 6.854101966249686;
+/**
+ * golden ratio/mean constants, `1/(GR**4)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_4i = 0.14589803375031543;
+/**
+ * golden ratio/mean constants, `GR**5`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_5 = 11.090169943749476;
+/**
+ * golden ratio/mean constants, `1/(GR**5)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_5i = 0.09016994374947422;
+/**
+ * golden ratio/mean constants, `GR**6`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_6 = 17.944271909999163;
+/**
+ * golden ratio/mean constants, `1/(GR**6)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_6i = 0.0557280900008412;
+/**
+ * golden ratio/mean constants, `GR**7`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_7 = 29.03444185374864;
+/**
+ * golden ratio/mean constants, `1/(GR**7)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_7i = 0.03444185374863302;
+/**
+ * golden ratio/mean constants, `GR**8`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_8 = 46.978713763747805;
+/**
+ * golden ratio/mean constants, `1/(GR**8)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_8i = 0.02128623625220818;
+/**
+ * golden ratio/mean constants, `GR**9`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_9 = 76.01315561749645;
+/**
+ * golden ratio/mean constants, `1/(GR**9)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export declare const GR_9i = 0.013155617496424835;
+//# sourceMappingURL=maths.d.ts.map

package/dist/maths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maths.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/maths.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,KAAK,GAAI,GAAG,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,MAC5B,CAAC;AAEjC;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,QAAQ,MAAM,KAAG,MAAuC,CAAC;AAEpG;;GAEG;AACH,eAAO,MAAM,KAAK,GAAI,GAAG,MAAM,EAAE,UAAU,MAAM,KAAG,MAGnD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,EAAE,oBAAoB,CAAC;AACpC;;GAEG;AACH,eAAO,MAAM,IAAI,qBAAqB,CAAC;AACvC;;GAEG;AACH,eAAO,MAAM,IAAI,oBAAoB,CAAC;AACtC;;GAEG;AACH,eAAO,MAAM,KAAK,sBAAsB,CAAC;AACzC;;GAEG;AACH,eAAO,MAAM,IAAI,mBAAmB,CAAC;AACrC;;GAEG;AACH,eAAO,MAAM,KAAK,qBAAqB,CAAC;AACxC;;GAEG;AACH,eAAO,MAAM,IAAI,oBAAoB,CAAC;AACtC;;GAEG;AACH,eAAO,MAAM,KAAK,sBAAsB,CAAC;AACzC;;GAEG;AACH,eAAO,MAAM,IAAI,qBAAqB,CAAC;AACvC;;GAEG;AACH,eAAO,MAAM,KAAK,sBAAsB,CAAC;AACzC;;GAEG;AACH,eAAO,MAAM,IAAI,qBAAqB,CAAC;AACvC;;GAEG;AACH,eAAO,MAAM,KAAK,qBAAqB,CAAC;AACxC;;GAEG;AACH,eAAO,MAAM,IAAI,oBAAoB,CAAC;AACtC;;GAEG;AACH,eAAO,MAAM,KAAK,sBAAsB,CAAC;AACzC;;GAEG;AACH,eAAO,MAAM,IAAI,qBAAqB,CAAC;AACvC;;GAEG;AACH,eAAO,MAAM,KAAK,sBAAsB,CAAC;AACzC;;GAEG;AACH,eAAO,MAAM,IAAI,oBAAoB,CAAC;AACtC;;GAEG;AACH,eAAO,MAAM,KAAK,uBAAuB,CAAC"}

package/dist/maths.js

@@ -0,0 +1,87 @@
+/**
+ * Returns `n` bounded to `min` and `max`.
+ */
+export const clamp = (n, min, max) => Math.min(Math.max(n, min), max);
+/**
+ * Linear interpolation between `a` and `b` by `amount`.
+ */
+export const lerp = (a, b, amount) => (1 - amount) * a + amount * b;
+/**
+ * Rounds a number to a specified number of decimal places.
+ */
+export const round = (n, decimals) => {
+    const mult = 10 ** decimals;
+    return Math.round(n * mult) / mult;
+};
+/**
+ * golden ratio/mean constants, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR = 1.618033988749895;
+/**
+ * golden ratio/mean constants, `1/GR`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_i = 0.6180339887498948;
+/**
+ * golden ratio/mean constants, `GR**2`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_2 = 2.618033988749895;
+/**
+ * golden ratio/mean constants, `1/(GR**2)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_2i = 0.38196601125010515;
+/**
+ * golden ratio/mean constants, `GR**3`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_3 = 4.23606797749979;
+/**
+ * golden ratio/mean constants, `1/(GR**3)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_3i = 0.2360679774997897;
+/**
+ * golden ratio/mean constants, `GR**4`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_4 = 6.854101966249686;
+/**
+ * golden ratio/mean constants, `1/(GR**4)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_4i = 0.14589803375031543;
+/**
+ * golden ratio/mean constants, `GR**5`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_5 = 11.090169943749476;
+/**
+ * golden ratio/mean constants, `1/(GR**5)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_5i = 0.09016994374947422;
+/**
+ * golden ratio/mean constants, `GR**6`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_6 = 17.944271909999163;
+/**
+ * golden ratio/mean constants, `1/(GR**6)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_6i = 0.0557280900008412;
+/**
+ * golden ratio/mean constants, `GR**7`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_7 = 29.03444185374864;
+/**
+ * golden ratio/mean constants, `1/(GR**7)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_7i = 0.03444185374863302;
+/**
+ * golden ratio/mean constants, `GR**8`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_8 = 46.978713763747805;
+/**
+ * golden ratio/mean constants, `1/(GR**8)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_8i = 0.02128623625220818;
+/**
+ * golden ratio/mean constants, `GR**9`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_9 = 76.01315561749645;
+/**
+ * golden ratio/mean constants, `1/(GR**9)`, useful for scaling: https://wikipedia.org/wiki/Golden_ratio
+ */
+export const GR_9i = 0.013155617496424835;

package/dist/object.d.ts

@@ -0,0 +1,46 @@
+import type { OmitStrict } from './types.js';
+/**
+ * Returns a boolean indicating if `value` is
+ * a plain object, possibly created with `Object.create(null)`.
+ * But warning! This fails for some obscure corner cases, use a proper library for weird things.
+ */
+export declare const is_plain_object: (value: any) => boolean;
+/**
+ * Iterated keys in `for..in` are always returned as strings,
+ * so to prevent usage errors the key type of `mapper` is always a string.
+ * Symbols are not enumerable as keys, so they're excluded.
+ */
+export declare const map_record: <T, K extends string | number, U>(obj: Record<K, T>, mapper: (value: T, key: string) => U) => Record<K, U>;
+/**
+ * Creates a new object without the specified `keys`.
+ */
+export declare const omit: <T extends Record<K, any>, K extends keyof T>(obj: T, keys: Array<K>) => OmitStrict<T, K>;
+/**
+ * Creates a new object with properties that pass the `should_pick` predicate.
+ */
+export declare const pick_by: <T extends Record<K, any>, K extends string | number>(obj: T, should_pick: (value: any, key: K) => boolean) => Partial<T>;
+/**
+ * `omit_undefined` is a commonly used form of `pick_by`.
+ * See this issue for why it's used so much:
+ * https://github.com/Microsoft/TypeScript/issues/13195
+ * @param obj
+ * @returns `obj` with all `undefined` properties removed
+ */
+export declare const omit_undefined: <T extends Record<string | number, any>>(obj: T) => T;
+/**
+ * A more explicit form of `{put_this_first: obj.put_this_first, ...obj}`.
+ */
+export declare const reorder: <T extends Record<K, any>, K extends string | number>(obj: T, keys: Array<K>) => T;
+/**
+ * Frozen empty object with no properties, good for options default values.
+ */
+export declare const EMPTY_OBJECT: Record<string | number | symbol, undefined> & object;
+/**
+ * Performs a depth-first traversal of an object's enumerable properties,
+ * calling `cb` for every key and value with the current `obj` context.
+ * @param obj - any object with enumerable properties
+ * @param cb - receives the key, value, and `obj` for every enumerable property on `obj` and its descendents
+ */
+export declare const traverse: (obj: any, cb: (key: string, value: any, obj: any) => void) => void;
+export declare const transform_empty_object_to_undefined: <T>(obj: T) => T | undefined;
+//# sourceMappingURL=object.d.ts.map

package/dist/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,YAAY,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,GAAG,KAAG,OACmC,CAAC;AAEjF;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,EACzD,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACjB,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,KAClC,MAAM,CAAC,CAAC,EAAE,CAAC,CAMb,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAC/D,KAAK,CAAC,EACN,MAAM,KAAK,CAAC,CAAC,CAAC,KACZ,UAAU,CAAC,CAAC,EAAE,CAAC,CAQjB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,EAC1E,KAAK,CAAC,EACN,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,KAAK,OAAO,KAC1C,OAAO,CAAC,CAAC,CASX,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,KAAG,CACtC,CAAC;AAE3C;;GAEG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,EAC1E,KAAK,CAAC,EACN,MAAM,KAAK,CAAC,CAAC,CAAC,KACZ,CAOF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,SAAS,CAAC,GAAG,MAA0B,CAAC;AAEpG;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,IAAI,KAAG,IAOpF,CAAC;AAEF,eAAO,MAAM,mCAAmC,GAAI,CAAC,EAAE,KAAK,CAAC,KAAG,CAAC,GAAG,SAKnE,CAAC"}