{"version":3,"file":"index.cjs","names":[],"sources":["../src/cache.ts","../src/predicate.ts","../src/type.ts","../src/collection.ts","../src/comparitors.ts","../src/function.ts","../src/number.ts","../src/object.ts","../src/string.ts","../src/time.ts","../src/value.ts"],"sourcesContent":["/**\n * A fixed-capacity `Map` that evicts the least recently used entry once it is full.\n *\n * Recency is tracked by `Map` insertion order: a read re-inserts its key so the oldest key is\n * always the map's first. Iteration (`keys`, `values`, `entries`, `forEach`, spread) therefore\n * yields entries least recently used first, and neither iterating nor {@link LRUCache.has} affects\n * recency — only {@link LRUCache.get} and {@link LRUCache.set} do.\n *\n * @typeParam TKey - Type of the cache key.\n * @typeParam TValue - Type of the cached value.\n */\nexport class LRUCache<TKey, TValue> extends Map<TKey, TValue> {\n\n    private _maxSize: number;\n\n    /** Maximum number of entries retained before a write evicts the least recently used entry. */\n    public get maxSize() {\n        return this._maxSize;\n    }\n\n    constructor(limit: number) {\n        super();\n\n        this._maxSize = Math.max(1, Math.floor(limit));\n    }\n\n    /** Reads an entry, marking it as the most recently used, or `undefined` when absent. */\n    public get(key: TKey): TValue | undefined {\n        if (!super.has(key)) {\n            return undefined;\n        }\n\n        const value = super.get(key)!;\n\n        super.delete(key);\n        super.set(key, value);\n\n        return value;\n    }\n\n    /** Writes an entry as the most recently used, evicting the least recently used entry when at capacity. */\n    public set(key: TKey, value: TValue): this {\n        super.delete(key);\n\n        if (super.size >= this._maxSize) {\n            super.delete(super.keys().next().value!);\n        }\n\n        return super.set(key, value);\n    }\n\n    // Overridden because the native upserts write through internal slots, skipping eviction entirely.\n    /** Reads an entry as the most recently used, inserting `defaultValue` first when absent. */\n    public getOrInsert(key: TKey, defaultValue: TValue): TValue {\n        if (super.has(key)) {\n            return this.get(key)!;\n        }\n\n        this.set(key, defaultValue);\n\n        return defaultValue;\n    }\n\n    /** Reads an entry as the most recently used, inserting the result of `callback` first when absent. */\n    public getOrInsertComputed(key: TKey, callback: (key: TKey) => TValue): TValue {\n        if (super.has(key)) {\n            return this.get(key)!;\n        }\n\n        const value = callback(key);\n\n        this.set(key, value);\n\n        return value;\n    }\n\n}\n\n/**\n * Creates a bounded {@link LRUCache}, evicting the single least recently used entry when a write\n * exceeds the limit.\n *\n * Preferred over an unbounded memo wherever the key space is open-ended (paint strings, resolved\n * geometry), since evicting one entry keeps every other caller's entry warm — wiping the whole\n * cache at a threshold makes the steady state a permanent miss.\n *\n * @param limit - Maximum number of entries to retain. Values below `1` are clamped to `1`.\n * @typeParam TKey - Type of the cache key.\n * @typeParam TValue - Type of the cached value.\n * @returns The cache instance.\n * @example\n * const cache = createLRUCache<string, number>(2);\n *\n * cache.set('a', 1);\n * cache.set('b', 2);\n * cache.get('a');\n * cache.set('c', 3); // evicts 'b', the least recently used\n */\nexport function createLRUCache<TKey, TValue>(limit: number): LRUCache<TKey, TValue> {\n    return new LRUCache(limit);\n}\n","/** Tests strict reference equality between two values. */\nexport function predicateIdentity(valueA: unknown, valueB: unknown): boolean {\n    return valueA === valueB;\n}\n\n/** Tests whether two objects share the same value at a given key. */\nexport function predicateKey<TValue extends Record<PropertyKey, unknown>>(valueA: TValue, valueB: TValue, key: PropertyKey): boolean {\n    return valueA[key] === valueB[key];\n}","import type {\n    AnyFunction,\n} from './types';\n\n/** Checks whether a value is an array. */\nexport function typeIsArray(value: unknown): value is unknown[] {\n    return Array.isArray(value);\n}\n\n/** Checks whether a value is a `Date` instance. */\nexport function typeIsDate(value: unknown): value is Date {\n    return value instanceof Date;\n}\n\n/** Checks whether a value is a non-null object. */\nexport function typeIsObject(value: unknown): value is object {\n    return value !== null && typeof value === 'object';\n}\n\n/** Checks whether a value is a boolean. */\nexport function typeIsBoolean(value: unknown): value is boolean {\n    return typeof value === 'boolean';\n}\n\n/** Checks whether a value is a function. */\nexport function typeIsFunction(value: unknown): value is AnyFunction {\n    return typeof value === 'function';\n}\n\n/** Checks whether a value is a number. */\nexport function typeIsNumber(value: unknown): value is number {\n    return typeof value === 'number';\n}\n\n/** Checks whether a value is a string. */\nexport function typeIsString(value: unknown): value is string {\n    return typeof value === 'string';\n}\n\n/** Checks whether a value is `null` or `undefined`. */\nexport function typeIsNil(value: unknown): value is null | undefined {\n    // eslint-disable-next-line eqeqeq\n    return value == null;\n}\n","import {\n    predicateKey,\n} from './predicate';\n\nimport {\n    typeIsFunction,\n    typeIsNil,\n} from './type';\n\nimport type {\n    Indexer,\n    Predicate,\n} from './types';\n\n/** An object whose values are unknown, suitable for generic iteration. */\nexport type IterableObject = Record<PropertyKey, unknown>;\n\n/** Callback invoked for each item in a collection, receiving the value and its index. */\nexport type CollectionIteratee<TValue, TResult = void> = (value: TValue, index: number) => TResult;\n\n/** Callback invoked for each entry in an object, receiving the key and value. */\nexport type ObjectIteratee<TKey, TValue, TResult = void> = (key: TKey, value: TValue) => TResult;\n\n/** Reducer callback for folding over object entries into an accumulated result. */\nexport type ObjectReducer<TKey, TValue, TResult = void> = (accumulator: TResult, key: TKey, value: TValue) => TResult;\n\n/** A property key or indexer function used to derive group identity from array items. */\nexport type ArrayGroupIdentity<TValue> = keyof TValue | Indexer<TValue>;\n\n/** A shared key or predicate function used to match items between two arrays in a join. */\nexport type ArrayJoinPredicate<TLeft, TRight> = keyof (TLeft & TRight) | Predicate<TLeft, TRight>;\n\n/** Result of an array join containing unmatched left items, matched pairs, and unmatched right items. */\nexport interface ArrayJoin<TLeft, TRight> {\n    /** Left items with no matching right item (entries). */\n    left: TLeft[];\n    /** Matched pairs of left and right items (updates). */\n    inner: [left: TLeft, right: TRight][];\n    /** Right items with no matching left item (exits). */\n    right: TRight[];\n}\n\n/** Creates an array of the given length by mapping each index through the iteratee. */\nexport function arrayMapRange<TResult>(length: number, iteratee: (index: number) => TResult): TResult[] {\n    const output = new Array<TResult>(length);\n\n    for (let i = 0; i < length; i++) {\n        output[i] = iteratee(i);\n    }\n\n    return output;\n}\n\nfunction arrayJoinByPredicate<TLeft, TRight>(leftInput: TLeft[], rightInput: TRight[], predicate: Predicate<TLeft, TRight>): ArrayJoin<TLeft, TRight> {\n    const left = new Set(leftInput);\n    const right = new Set(rightInput);\n    const inner = [] as [left: TLeft, right: TRight][];\n\n    leftInput.forEach(valLeft => {\n        const valRight = rightInput.find(valRight => predicate(valLeft, valRight));\n\n        if (!typeIsNil(valRight)) {\n            inner.push([valLeft, valRight]);\n            left.delete(valLeft);\n            right.delete(valRight);\n        }\n    });\n\n    return {\n        left: Array.from(left),\n        inner,\n        right: Array.from(right),\n    };\n}\n\nfunction arrayJoinByKey<TLeft, TRight>(leftInput: TLeft[], rightInput: TRight[], key: PropertyKey): ArrayJoin<TLeft, TRight> {\n    const left = new Set(leftInput);\n    const inner = [] as [left: TLeft, right: TRight][];\n    const rightIndex = new Map<unknown, TRight>();\n\n    rightInput.forEach(valRight => {\n        rightIndex.set((valRight as Record<PropertyKey, unknown>)[key], valRight);\n    });\n\n    leftInput.forEach(valLeft => {\n        const leftKey = (valLeft as Record<PropertyKey, unknown>)[key];\n        const valRight = rightIndex.get(leftKey);\n\n        if (!typeIsNil(valRight)) {\n            inner.push([valLeft, valRight]);\n            left.delete(valLeft);\n            rightIndex.delete(leftKey);\n        }\n    });\n\n    return {\n        left: Array.from(left),\n        inner,\n        right: Array.from(rightIndex.values()),\n    };\n}\n\n/** Performs a full join between two arrays, returning entries (left-only), updates (matched), and exits (right-only). */\nexport function arrayJoin<TLeft, TRight>(leftInput: TLeft[], rightInput: TRight[], predicate: ArrayJoinPredicate<TLeft, TRight>): ArrayJoin<TLeft, TRight> {\n    return typeIsFunction(predicate)\n        ? arrayJoinByPredicate(leftInput, rightInput, predicate)\n        : arrayJoinByKey(leftInput, rightInput, predicate as PropertyKey);\n}\n\n/** Groups array items by a property key or indexer function into a keyed record. */\nexport function arrayGroup<TValue>(input: TValue[], identity: ArrayGroupIdentity<TValue>): Record<PropertyKey, TValue[]> {\n    const output = {} as Record<PropertyKey, TValue[]>;\n\n    const groupIdentity = (typeIsFunction(identity)\n        ? identity\n        : (value: TValue) => value[identity]\n    ) as Indexer<TValue>;\n\n    for (let i = 0; i < input.length; i++) {\n        const value = input[i];\n        const group = groupIdentity(value);\n        (output[group] ??= []).push(value);\n    }\n\n    return output;\n}\n\nfunction resolveArrayCompare<TLeft, TRight>(predicate?: ArrayJoinPredicate<TLeft, TRight>): Predicate<TLeft, TRight> {\n    if (typeIsNil(predicate)) {\n        return (left, right) => (left as unknown) === (right as unknown);\n    }\n\n    if (typeIsFunction(predicate)) {\n        return predicate;\n    }\n\n    return (left, right) => predicateKey(left as Record<PropertyKey, unknown>, right as Record<PropertyKey, unknown>, predicate as PropertyKey);\n}\n\nfunction arrayFilterByMatch<TLeft, TRight>(leftInput: TLeft[], rightInput: TRight[], predicate: ArrayJoinPredicate<TLeft, TRight> | undefined, includeMatches: boolean): TLeft[] {\n    const output = [] as TLeft[];\n    const compare = resolveArrayCompare(predicate);\n\n    for (let i = 0; i < leftInput.length; i++) {\n        const valLeft = leftInput[i];\n        const found = rightInput.find(valRight => compare(valLeft, valRight));\n        const shouldInclude = includeMatches ? !typeIsNil(found) : typeIsNil(found);\n\n        if (shouldInclude) {\n            output.push(valLeft);\n        }\n    }\n\n    return output;\n}\n\n/** Returns items from the left array that have a matching counterpart in the right array. */\nexport function arrayIntersection<TLeft, TRight = TLeft>(leftInput: TLeft[], rightInput: TRight[], predicate?: ArrayJoinPredicate<TLeft, TRight>): TLeft[] {\n    return arrayFilterByMatch(leftInput, rightInput, predicate, true);\n}\n\n/** Returns items from the left array that have no matching counterpart in the right array. */\nexport function arrayDifference<TLeft, TRight = TLeft>(leftInput: TLeft[], rightInput: TRight[], predicate?: ArrayJoinPredicate<TLeft, TRight>): TLeft[] {\n    return arrayFilterByMatch(leftInput, rightInput, predicate, false);\n}\n\n/** Returns a new array with duplicate values removed, preserving insertion order. */\nexport function arrayDedupe<TValue>(input: TValue[]): TValue[] {\n    return [...new Set(input)];\n}\n\n/** Iterates over the enumerable properties of an object, invoking the iteratee for each key-value pair. */\nexport function objectForEach<TSource extends IterableObject>(input: TSource, iteratee: ObjectIteratee<keyof TSource, TSource[keyof TSource]>): void {\n    for (const key in input) {\n        iteratee(key, input[key]);\n    }\n}\n\n/** Maps over the enumerable properties of an object, producing a new object with transformed values. */\nexport function objectMap<TSource extends IterableObject, TResult extends Record<keyof TSource, unknown> = Record<keyof TSource, unknown>>(input: TSource, iteratee: ObjectIteratee<Extract<keyof TSource, string>, TSource[keyof TSource], unknown>): TResult {\n    const output = {} as Record<string, unknown>;\n\n    for (const key in input) {\n        output[key] = iteratee(key, input[key]);\n    }\n\n    return output as TResult;\n}\n\n/** Reduces the enumerable properties of an object into a single accumulated value. */\nexport function objectReduce<TSource extends IterableObject, TResult>(input: TSource, reducer: ObjectReducer<keyof TSource, TSource[keyof TSource], TResult>, initial: TResult): TResult {\n    let output = initial;\n\n    for (const key in input) {\n        output = reducer(output, key, input[key]);\n    }\n\n    return output;\n}\n\n/** Iterates over each value in a `Set`, invoking the iteratee with the value and a running index. */\nexport function setForEach<TValue>(input: Set<TValue>, iteratee: CollectionIteratee<TValue>): void {\n    let index = 0;\n\n    for (const value of input) {\n        iteratee(value, index++);\n    }\n}\n\n/** Maps over a `Set`, producing a new `Set` with each value transformed by the iteratee. */\nexport function setMap<TValue, TResult>(input: Set<TValue>, iteratee: CollectionIteratee<TValue, TResult>): Set<TResult> {\n    const output = new Set<TResult>();\n    let index = 0;\n\n    for (const value of input) {\n        output.add(iteratee(value, index++));\n    }\n\n    return output;\n}\n\n/** Filters a `Set`, returning a new `Set` containing only values that satisfy the predicate. */\nexport function setFilter<TValue>(input: Set<TValue>, predicate: CollectionIteratee<TValue, boolean>): Set<TValue> {\n    const output = new Set<TValue>();\n    let index = 0;\n\n    for (const value of input) {\n        if (predicate(value, index++)) {\n            output.add(value);\n        }\n    }\n\n    return output;\n}\n\n/** Searches a `Set` for the first value that satisfies the predicate. */\nexport function setFind<TValue>(input: Set<TValue>, predicate: CollectionIteratee<TValue, boolean>): TValue | undefined {\n    let index = 0;\n\n    for (const value of input) {\n        if (predicate(value, index++)) {\n            return value;\n        }\n    }\n}\n\n/** Flat-maps over a `Set`, concatenating the arrays returned by the iteratee into a new `Set`. */\nexport function setFlatMap<TValue, TResult>(input: Set<TValue>, iteratee: CollectionIteratee<TValue, TResult[]>): Set<TResult> {\n    const output = [] as TResult[];\n    let index = 0;\n\n    for (const value of input) {\n        const result = iteratee(value, index++);\n\n        for (let ri = 0; ri < result.length; ri++) {\n            output.push(result[ri]);\n        }\n    }\n\n    return new Set(output);\n}\n","/** Numeric comparator suitable for sorting numbers in ascending order. */\nexport function comparitorNumeric(valueA: number, valueB: number): number {\n    return +valueA - +valueB;\n}\n\n/** Date comparator suitable for sorting dates in ascending chronological order. */\nexport function comparitorDate(valueA: Date, valueB: Date): number {\n    return comparitorNumeric(valueA.getTime(), valueB.getTime());\n}\n\n/** Locale-aware string comparator suitable for alphabetical sorting. */\nexport function comparitorString(valueA: string, valueB: string): number {\n    return valueA.localeCompare(valueB);\n}","import {\n    typeIsFunction,\n} from './type';\n\nimport type {\n    AnyFunction,\n} from './types';\n\n/** A function wrapper that caches its result after the first invocation until explicitly invalidated. */\nexport type CachedFunction<TValue extends AnyFunction> = {\n    (...args: Parameters<TValue>): ReturnType<TValue>;\n    /** Clears the cached result so the next call recomputes it. */\n    invalidate(): void;\n};\n\n/** A function wrapper that caches results per unique key, exposing the underlying cache `Map`. */\nexport type MemoizedFunction<TValue extends AnyFunction, TKey> = {\n    (...args: Parameters<TValue>): ReturnType<TValue>;\n    /** The underlying cache mapping each unique key to its memoized result. */\n    cache: Map<TKey, ReturnType<TValue>>;\n};\n\n/** Derives a cache key from the arguments of a memoized function. */\nexport type MemoizeResolver<TValue extends AnyFunction, TKey> = (...args: Parameters<TValue>) => TKey;\n\n/** A do-nothing function, useful as a default callback or placeholder. */\nexport function functionNoop() {\n    // noop\n}\n\n/** Returns the value it receives unchanged, useful as a default transform or placeholder. */\nexport function functionIdentity<TValue>(value: TValue) {\n    return value;\n}\n\n/** Wraps a value or factory function into a consistent factory that always returns the value. */\nexport function functionProduce<TValue>(value: TValue | (() => TValue)): () => TValue {\n    return typeIsFunction(value) ? value : () => value;\n}\n\n/** Wraps a function so its result is computed once and then returned from cache on subsequent calls until `invalidate()` is called. */\nexport function functionCache<TValue extends AnyFunction>(value: TValue): CachedFunction<TValue> {\n    let valid = false;\n    let result: ReturnType<TValue>;\n\n    const output: CachedFunction<TValue> = (...args) => {\n        if (!valid) {\n            result = value(...args);\n        }\n\n        valid = true;\n\n        return result;\n    };\n\n    output.invalidate = () => valid = false;\n\n    return output;\n}\n\n/** Memoizes a function by caching results keyed by the resolver (defaults to the first argument). */\nexport function functionMemoize<TValue extends AnyFunction, TKey = Parameters<TValue>[0]>(value: TValue, resolver: MemoizeResolver<TValue, TKey> = (...args) => args[0]){\n    const cache = new Map<TKey, ReturnType<TValue>>();\n\n    const output: MemoizedFunction<TValue, TKey> = (...args) => {\n        const key = resolver(...args);\n\n        if (!cache.has(key)) {\n            cache.set(key, value(...args));\n        }\n\n        return cache.get(key)!;\n    };\n\n    output.cache = cache;\n\n    return output;\n}","import {\n    typeIsNumber,\n} from './type';\n\n/** Options for {@link numberFormat}: any `Intl.NumberFormat` option plus a locale and a precision shorthand. */\nexport interface NumberFormatOptions extends Intl.NumberFormatOptions {\n    /** BCP 47 locale tag (defaults to the runtime locale). */\n    locale?: string;\n    /** Shorthand for `maximumFractionDigits`. */\n    precision?: number;\n}\n\n// `Intl.NumberFormat` construction is expensive, so memoise by config; distinct configs are few and bounded.\nconst NUMBER_FORMATTER_CACHE = new Map<string, Intl.NumberFormat>();\n\nfunction getNumberFormatter(locale: string | undefined, options: Intl.NumberFormatOptions): Intl.NumberFormat {\n    const key = `${locale ?? ''}|${JSON.stringify(options)}`;\n\n    let formatter = NUMBER_FORMATTER_CACHE.get(key);\n\n    if (!formatter) {\n        formatter = new Intl.NumberFormat(locale, options);\n        NUMBER_FORMATTER_CACHE.set(key, formatter);\n    }\n\n    return formatter;\n}\n\n/** Constrains a value to the inclusive range between lower and upper bounds. */\nexport function numberClamp(value: number, lower: number, upper: number): number {\n    const trueLower = Math.min(lower, upper);\n    const trueUpper = Math.max(lower, upper);\n\n    return Math.min(trueUpper, Math.max(trueLower, value));\n}\n\n/** Returns the minimum numeric value extracted from an array via the accessor (`Infinity` when empty). */\nexport function numberMinOf<TValue>(values: TValue[], accessor: (value: TValue) => number) {\n    // Folded rather than spread into `Math.min`, whose argument count is capped by the stack.\n    return values.reduce((min, value) => Math.min(min, accessor(value)), Infinity);\n}\n\n/** Returns the maximum numeric value extracted from an array via the accessor (`-Infinity` when empty). */\nexport function numberMaxOf<TValue>(values: TValue[], accessor: (value: TValue) => number) {\n    return values.reduce((max, value) => Math.max(max, accessor(value)), -Infinity);\n}\n\n/** Returns the fractional part of a number (e.g. `numberFractional(3.7)` → `0.7`). */\nexport function numberFractional(value: number): number {\n    return value - Math.floor(value);\n}\n\n/** Computes the `[min, max]` extent of an array using the given numeric accessor. */\nexport function numberExtent<TValue>(values: TValue[], accessor: (value: TValue) => number): [min: number, max: number] {\n    let min = accessor(values[0]);\n    let max = accessor(values[0]);\n\n    values.forEach(item => {\n        const value = accessor(item);\n\n        min = Math.min(min, value);\n        max = Math.max(max, value);\n    });\n\n    return [\n        min,\n        max,\n    ];\n}\n\n/**\n * Computes the sum of an array of numbers, or of values mapped through an optional iteratee.\n *\n * The iteratee wins wherever one is given, so a numeric array is summed through it rather than\n * raw. Anything that does not resolve to a number — a value with no iteratee to map it, or an\n * iteratee returning `undefined` — contributes `0`.\n *\n * @typeParam TValue - The element type of the array.\n * @param values - The values to sum.\n * @param iteratee - Maps each value to the number it contributes.\n * @returns The sum, or `0` for an empty array.\n */\nexport function numberSum<TValue = number>(values: TValue[], iteratee?: (value: TValue) => number) {\n    return values.reduce((total, value) => {\n        const output = iteratee ? iteratee(value) : value;\n\n        return total + (typeIsNumber(output) ? output : 0);\n    }, 0);\n}\n\n/**\n * Rounds a number to at most `precision` decimal places, stripping any trailing zeros.\n *\n * Unlike `Number.prototype.toFixed` (which returns a fixed-width string), this returns a `number`\n * so integers stay integers (`numberRoundTo(5, 2) === 5`) and fractional values are capped\n * (`numberRoundTo(1.005, 2) === 1.01`, `numberRoundTo(3.14159, 2) === 3.14`). Non-finite values pass\n * through unchanged. Used as the default precision cap for chart labels, axes, and tooltips.\n */\nexport function numberRoundTo(value: number, precision: number = 2): number {\n    if (!Number.isFinite(value)) {\n        return value;\n    }\n\n    const factor = 10 ** Math.max(0, Math.trunc(precision));\n\n    return Math.round(value * factor) / factor;\n}\n\n/** Rounds a value to a \"nice\" human-readable number (1, 2, 5, or 10 scaled by the appropriate power of ten). */\nexport function numberNice(value: number, round: boolean = false) {\n    const exponent = Math.floor(Math.log10(value));\n    const factor = 10 ** exponent;\n    const fraction = value / factor;\n\n    let niceFraction: number;\n\n    if (round) {\n        if (fraction < 1.5) niceFraction = 1;\n        else if (fraction < 3) niceFraction = 2;\n        else if (fraction < 7) niceFraction = 5;\n        else niceFraction = 10;\n    } else if (fraction <= 1) {\n        niceFraction = 1;\n    } else if (fraction <= 2) {\n        niceFraction = 2;\n    } else if (fraction <= 5) {\n        niceFraction = 5;\n    } else {\n        niceFraction = 10;\n    }\n\n    return niceFraction * factor;\n}\n\n/**\n * Returns the smallest power of `base` that is greater than or equal to `minimum`, starting from `1`.\n *\n * A `minimum` of `1` or less (including `0` and negatives) returns `1`. Useful for growing pooled\n * buffers or capacities in exponential steps.\n */\nexport function numberNextPowerOfN(minimum: number, base = 2): number {\n    let capacity = 1;\n\n    while (capacity < minimum) {\n        capacity *= base;\n    }\n\n    return capacity;\n}\n\n/**\n * Formats a number as a locale-aware string. Supports decimal, `percent`, and `currency` styles;\n * `compact`/`scientific`/`engineering` notation; grouping; and fraction-digit control (with\n * `precision` as a shorthand for `maximumFractionDigits`). Non-numeric values fall back to `String`.\n *\n * This is a standalone utility; it is passed values explicitly by axes, legends, and tooltips, and\n * is intentionally never bound to a scale.\n */\nexport function numberFormat(value: unknown, options: NumberFormatOptions = {}): string {\n    if (!typeIsNumber(value)) {\n        return String(value);\n    }\n\n    const {\n        locale,\n        precision,\n        ...intlOptions\n    } = options;\n\n    if (precision !== undefined && intlOptions.maximumFractionDigits === undefined) {\n        intlOptions.maximumFractionDigits = precision;\n    }\n\n    return getNumberFormatter(locale, intlOptions).format(value);\n}\n","/** Creates a shallow frozen copy of the given object. */\nexport function objectFreeze<TValue extends object>(value: TValue) {\n    return Object.freeze({ ...value });\n}","/** Generates a cryptographically random hexadecimal string of the specified length (default 8 characters / 32 bits). */\nexport function stringUniqueId(length: number = 8): string {\n    const container = new Uint8Array(length / 2);\n    globalThis.crypto.getRandomValues(container);\n\n    return Array.from(container, value => value.toString(16).padStart(2, '0')).join('');\n}\n\n/** Case-insensitive string equality check. */\nexport function stringEquals(valueA: string, valueB: string) {\n    return valueA.toLowerCase() === valueB.toLowerCase();\n}","import {\n    typeIsDate,\n} from './type';\n\n/** Options for {@link timeFormat}: any `Intl.DateTimeFormat` option plus a locale. */\nexport interface TimeFormatOptions extends Intl.DateTimeFormatOptions {\n    /** BCP 47 locale tag (defaults to the runtime locale). */\n    locale?: string;\n}\n\nconst DEFAULT_DATE_OPTIONS: Intl.DateTimeFormatOptions = {\n    year: 'numeric',\n    month: 'short',\n    day: 'numeric',\n};\n\nconst DATE_FORMATTER_CACHE = new Map<string, Intl.DateTimeFormat>();\n\nfunction getDateFormatter(locale: string | undefined, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat {\n    const key = `${locale ?? ''}|${JSON.stringify(options)}`;\n\n    let formatter = DATE_FORMATTER_CACHE.get(key);\n\n    if (!formatter) {\n        formatter = new Intl.DateTimeFormat(locale, options);\n        DATE_FORMATTER_CACHE.set(key, formatter);\n    }\n\n    return formatter;\n}\n\n/**\n * Formats a `Date` (or epoch millisecond value) as a locale-aware string via `Intl.DateTimeFormat`.\n * With no field options a short year/month/day format is used. Passed values explicitly by axes and\n * tooltips; never bound to a scale.\n */\nexport function timeFormat(value: Date | number, options: TimeFormatOptions = {}): string {\n    const date = typeIsDate(value) ? value : new Date(value);\n\n    const {\n        locale,\n        ...intlOptions\n    } = options;\n\n    const resolved = Object.keys(intlOptions).length ? intlOptions : DEFAULT_DATE_OPTIONS;\n\n    return getDateFormatter(locale, resolved).format(date);\n}\n","import type {\n    OneOrMore,\n} from './types';\n\n/** Normalizes a single value or array into a guaranteed array. */\nexport function valueOneOrMore<TValue>(value: OneOrMore<TValue>): TValue[] {\n    return ([] as TValue[]).concat(value);\n}"],"mappings":"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"}