@tempots/std 0.19.0 → 0.21.0

package/iterator.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Utilities for working with iterators and iterables.
+ *
+ * This module provides functional utilities for iterator manipulation,
+ * allowing for lazy evaluation and memory-efficient processing of sequences.
+ * All functions work with any iterable, including arrays, sets, maps, and custom iterators.
+ *
+ * @public
+ */
+/**
+ * Takes the first n elements from an iterable.
+ *
+ * This function creates a new array containing the first n elements
+ * from the iterable. It's useful for limiting results or sampling data.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ * const first3 = take(numbers, 3) // [1, 2, 3]
+ *
+ * const firstUsers = take(userGenerator(), 5) // First 5 users from generator
+ * ```
+ *
+ * @param iterable - The iterable to take elements from
+ * @param count - The number of elements to take
+ * @returns An array containing the first count elements
+ * @public
+ */
+export declare const take: <T>(iterable: Iterable<T>, count: number) => T[];
+/**
+ * Skips the first n elements and returns an iterable of the remaining elements.
+ *
+ * This function creates a new iterable that yields all elements after
+ * skipping the specified number of initial elements.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5]
+ * const afterFirst2 = [...skip(numbers, 2)] // [3, 4, 5]
+ *
+ * // Use with other iterator functions
+ * const result = take(skip(largeDataset, 100), 10) // Skip 100, take next 10
+ * ```
+ *
+ * @param iterable - The iterable to skip elements from
+ * @param count - The number of elements to skip
+ * @returns An iterable that yields remaining elements
+ * @public
+ */
+export declare const skip: <T>(iterable: Iterable<T>, count: number) => Iterable<T>;
+/**
+ * Filters an iterable, yielding only elements that satisfy the predicate.
+ *
+ * This function creates a new iterable that yields only elements
+ * for which the predicate returns true. It's lazy and memory-efficient.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5, 6]
+ * const evens = [...filter(numbers, n => n % 2 === 0)] // [2, 4, 6]
+ *
+ * // Chain with other operations
+ * const result = take(filter(largeDataset, isValid), 100)
+ * ```
+ *
+ * @param iterable - The iterable to filter
+ * @param predicate - Function that tests each element
+ * @returns An iterable that yields filtered elements
+ * @public
+ */
+export declare const filter: <T>(iterable: Iterable<T>, predicate: (item: T) => boolean) => Iterable<T>;
+/**
+ * Maps an iterable, transforming each element with the mapper function.
+ *
+ * This function creates a new iterable that yields transformed elements.
+ * It's lazy and memory-efficient, processing elements on-demand.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5]
+ * const doubled = [...map(numbers, n => n * 2)] // [2, 4, 6, 8, 10]
+ *
+ * const users = [{ name: 'Alice' }, { name: 'Bob' }]
+ * const names = [...map(users, user => user.name)] // ['Alice', 'Bob']
+ * ```
+ *
+ * @param iterable - The iterable to map
+ * @param mapper - Function that transforms each element
+ * @returns An iterable that yields transformed elements
+ * @public
+ */
+export declare const map: <T, U>(iterable: Iterable<T>, mapper: (item: T) => U) => Iterable<U>;
+/**
+ * Reduces an iterable to a single value using the reducer function.
+ *
+ * This function processes all elements in the iterable, accumulating
+ * a result using the reducer function and initial value.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5]
+ * const sum = reduce(numbers, (acc, n) => acc + n, 0) // 15
+ *
+ * const words = ['hello', 'world', 'foo', 'bar']
+ * const longest = reduce(words, (acc, word) => word.length > acc.length ? word : acc, '')
+ * ```
+ *
+ * @param iterable - The iterable to reduce
+ * @param reducer - Function that combines accumulator with each element
+ * @param initial - Initial value for the accumulator
+ * @returns The final accumulated value
+ * @public
+ */
+export declare const reduce: <T, U>(iterable: Iterable<T>, reducer: (acc: U, item: T) => U, initial: U) => U;
+/**
+ * Finds the first element in an iterable that satisfies the predicate.
+ *
+ * This function returns the first element for which the predicate returns true,
+ * or undefined if no such element is found.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 3, 5, 8, 9, 12]
+ * const firstEven = find(numbers, n => n % 2 === 0) // 8
+ *
+ * const users = [{ name: 'Alice', age: 25 }, { name: 'Bob', age: 30 }]
+ * const adult = find(users, user => user.age >= 18) // { name: 'Alice', age: 25 }
+ * ```
+ *
+ * @param iterable - The iterable to search
+ * @param predicate - Function that tests each element
+ * @returns The first matching element, or undefined if none found
+ * @public
+ */
+export declare const find: <T>(iterable: Iterable<T>, predicate: (item: T) => boolean) => T | undefined;
+/**
+ * Tests whether all elements in an iterable satisfy the predicate.
+ *
+ * This function returns true if the predicate returns true for all elements,
+ * or false otherwise. It short-circuits on the first false result.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [2, 4, 6, 8]
+ * const allEven = every(numbers, n => n % 2 === 0) // true
+ *
+ * const users = [{ age: 25 }, { age: 30 }, { age: 17 }]
+ * const allAdults = every(users, user => user.age >= 18) // false
+ * ```
+ *
+ * @param iterable - The iterable to test
+ * @param predicate - Function that tests each element
+ * @returns true if all elements satisfy the predicate, false otherwise
+ * @public
+ */
+export declare const every: <T>(iterable: Iterable<T>, predicate: (item: T) => boolean) => boolean;
+/**
+ * Tests whether at least one element in an iterable satisfies the predicate.
+ *
+ * This function returns true if the predicate returns true for any element,
+ * or false if no elements satisfy the predicate. It short-circuits on the first true result.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 3, 5, 8, 9]
+ * const hasEven = some(numbers, n => n % 2 === 0) // true
+ *
+ * const users = [{ age: 15 }, { age: 16 }, { age: 17 }]
+ * const hasAdult = some(users, user => user.age >= 18) // false
+ * ```
+ *
+ * @param iterable - The iterable to test
+ * @param predicate - Function that tests each element
+ * @returns true if any element satisfies the predicate, false otherwise
+ * @public
+ */
+export declare const some: <T>(iterable: Iterable<T>, predicate: (item: T) => boolean) => boolean;
+/**
+ * Converts an iterable to an array.
+ *
+ * This function creates a new array containing all elements from the iterable.
+ * It's equivalent to [...iterable] but more explicit in intent.
+ *
+ * @example
+ * ```typescript
+ * const set = new Set([1, 2, 3, 2, 1])
+ * const array = toArray(set) // [1, 2, 3]
+ *
+ * const mapped = map([1, 2, 3], n => n * 2)
+ * const result = toArray(mapped) // [2, 4, 6]
+ * ```
+ *
+ * @param iterable - The iterable to convert
+ * @returns A new array containing all elements from the iterable
+ * @public
+ */
+export declare const toArray: <T>(iterable: Iterable<T>) => T[];
+/**
+ * Chains multiple iterables into a single iterable.
+ *
+ * This function creates a new iterable that yields all elements
+ * from the input iterables in sequence.
+ *
+ * @example
+ * ```typescript
+ * const first = [1, 2, 3]
+ * const second = [4, 5, 6]
+ * const third = [7, 8, 9]
+ * const chained = [...chain(first, second, third)] // [1, 2, 3, 4, 5, 6, 7, 8, 9]
+ *
+ * // Works with different iterable types
+ * const mixed = [...chain([1, 2], new Set([3, 4]), 'ab')] // [1, 2, 3, 4, 'a', 'b']
+ * ```
+ *
+ * @param iterables - The iterables to chain
+ * @returns An iterable that yields all elements in sequence
+ * @public
+ */
+export declare const chain: <T>(...iterables: Iterable<T>[]) => Iterable<T>;

package/iterator.js

@@ -0,0 +1,69 @@
+const i = (t, e) => {
+  if (e <= 0)
+    return [];
+  const r = [];
+  let o = 0;
+  for (const n of t) {
+    if (o >= e)
+      break;
+    r.push(n), o++;
+  }
+  return r;
+}, f = (t, e) => ({
+  *[Symbol.iterator]() {
+    let r = 0;
+    for (const o of t) {
+      if (r < e) {
+        r++;
+        continue;
+      }
+      yield o;
+    }
+  }
+}), s = (t, e) => ({
+  *[Symbol.iterator]() {
+    for (const r of t)
+      e(r) && (yield r);
+  }
+}), c = (t, e) => ({
+  *[Symbol.iterator]() {
+    for (const r of t)
+      yield e(r);
+  }
+}), u = (t, e, r) => {
+  let o = r;
+  for (const n of t)
+    o = e(o, n);
+  return o;
+}, l = (t, e) => {
+  for (const r of t)
+    if (e(r))
+      return r;
+}, a = (t, e) => {
+  for (const r of t)
+    if (!e(r))
+      return !1;
+  return !0;
+}, m = (t, e) => {
+  for (const r of t)
+    if (e(r))
+      return !0;
+  return !1;
+}, y = (t) => Array.from(t), d = (...t) => ({
+  *[Symbol.iterator]() {
+    for (const e of t)
+      yield* e;
+  }
+});
+export {
+  d as chain,
+  a as every,
+  s as filter,
+  l as find,
+  c as map,
+  u as reduce,
+  f as skip,
+  m as some,
+  i as take,
+  y as toArray
+};

package/json.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./result-CdwVhaAc.cjs"),s=r=>typeof r=="object"&&!Array.isArray(r)&&r!=null,i=r=>Array.isArray(r),o=r=>typeof r=="string"||typeof r=="boolean"||typeof r=="number"||r==null,n=r=>{try{return t.Result.success(JSON.parse(r))}catch(e){return t.Result.failure(e)}};exports.isJSONArray=i;exports.isJSONObject=s;exports.isJSONPrimitive=o;exports.parseJSON=n;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./result-CdwVhaAc.cjs"),e=r=>typeof r=="object"&&!Array.isArray(r)&&r!=null&&Object.values(r).every(t),i=r=>Array.isArray(r)&&r.every(t),t=r=>o(r)||e(r)||i(r),o=r=>typeof r=="string"||typeof r=="boolean"||typeof r=="number"||r==null,n=r=>{try{return s.Result.success(JSON.parse(r))}catch(c){return s.Result.failure(c)}};exports.isJSON=t;exports.isJSONArray=i;exports.isJSONObject=e;exports.isJSONPrimitive=o;exports.parseJSON=n;

package/json.d.ts

@@ -32,13 +32,51 @@ export type JSONValue = JSONPrimitive | JSONObject | JSONArray;
  */
 export declare const isJSONObject: (value: JSONValue) => value is JSONObject;
 /**
- * Checks if the value is a JSON array.
+ * Checks if the value is a JSON array with recursive validation.
+ *
+ * This function provides more thorough validation than `Array.isArray()` by
+ * recursively checking that all elements in the array are valid JSON values.
+ * This is essential for ensuring data can be safely serialized to JSON.
+ *
+ * @example
+ * ```typescript
+ * isJSONArray([1, 2, 3]) // true
+ * isJSONArray(['hello', 'world']) // true
+ * isJSONArray([1, 'hello', true, null]) // true
+ * isJSONArray([1, 2, undefined]) // false (undefined is not JSON-serializable)
+ * isJSONArray([1, 2, () => {}]) // false (functions are not JSON-serializable)
+ * ```
  *
  * @param value - The value to check.
- * @returns `true` if the value is a JSON array; otherwise, `false`.
+ * @returns `true` if the value is a JSON array with all valid JSON elements; otherwise, `false`.
  * @public
  */
 export declare const isJSONArray: (value: JSONValue) => value is JSONArray;
+/**
+ * Checks if the value is a valid JSON value with comprehensive validation.
+ *
+ * This function provides thorough validation that goes beyond basic type checking
+ * by recursively validating nested objects and arrays to ensure the entire
+ * structure can be safely serialized to JSON.
+ *
+ * @example
+ * ```typescript
+ * isJSON('hello') // true
+ * isJSON(42) // true
+ * isJSON(true) // true
+ * isJSON(null) // true
+ * isJSON({ name: 'Alice', age: 30 }) // true
+ * isJSON([1, 2, { nested: true }]) // true
+ * isJSON(undefined) // false
+ * isJSON(() => {}) // false
+ * isJSON({ func: () => {} }) // false (contains non-JSON value)
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a completely valid JSON value; otherwise, `false`.
+ * @public
+ */
+export declare const isJSON: (value: JSONValue) => value is JSONValue;
 /**
  * Checks if the value is a JSON primitive.
  *

package/json.js

@@ -1,14 +1,15 @@
 import { R as t } from "./result-CGd0jCdl.js";
-const e = (r) => typeof r == "object" && !Array.isArray(r) && r != null, i = (r) => Array.isArray(r), n = (r) => typeof r == "string" || typeof r == "boolean" || typeof r == "number" || r == null, c = (r) => {
+const e = (r) => typeof r == "object" && !Array.isArray(r) && r != null && Object.values(r).every(s), c = (r) => Array.isArray(r) && r.every(s), s = (r) => i(r) || e(r) || c(r), i = (r) => typeof r == "string" || typeof r == "boolean" || typeof r == "number" || r == null, y = (r) => {
   try {
     return t.success(JSON.parse(r));
-  } catch (s) {
-    return t.failure(s);
+  } catch (o) {
+    return t.failure(o);
   }
 };
 export {
-  i as isJSONArray,
+  s as isJSON,
+  c as isJSONArray,
   e as isJSONObject,
-  n as isJSONPrimitive,
-  c as parseJSON
+  i as isJSONPrimitive,
+  y as parseJSON
 };

package/map.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=e=>new Map(e),p=e=>{const o={};for(const[t,s]of e)o[t]=s;return o},m=(e,o)=>{const t=new Map;for(const[s,r]of e)o(r,s)&&t.set(s,r);return t},c=(e,o)=>{const t=new Map;for(const[s,r]of e)t.set(s,o(r,s));return t},u=(...e)=>{const o=new Map;for(const t of e)for(const[s,r]of t)o.set(s,r);return o},f=(e,o)=>{const t=new Map;for(const s of e){const r=o(s),n=t.get(r);n?n.push(s):t.set(r,[s])}return t},l=e=>e.size===0,y=e=>Array.from(e.keys()),i=e=>Array.from(e.values()),M=e=>Array.from(e.entries());exports.mapEntries=M;exports.mapFilter=m;exports.mapFromEntries=a;exports.mapGroupBy=f;exports.mapIsEmpty=l;exports.mapKeys=y;exports.mapMap=c;exports.mapMerge=u;exports.mapToObject=p;exports.mapValues=i;

package/map.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Utilities for working with Map objects.
+ *
+ * This module provides functional utilities for Map manipulation that go beyond
+ * the native Map methods, offering type-safe operations for filtering, mapping,
+ * merging, and converting Maps.
+ *
+ * @public
+ */
+/**
+ * Creates a Map from an array of key-value pairs.
+ *
+ * This function provides better type inference than the Map constructor
+ * when working with typed key-value pairs.
+ *
+ * @example
+ * ```typescript
+ * const entries: [string, number][] = [['a', 1], ['b', 2], ['c', 3]]
+ * const map = mapFromEntries(entries)
+ * // Result: Map { 'a' => 1, 'b' => 2, 'c' => 3 }
+ * ```
+ *
+ * @param entries - Array of key-value pairs
+ * @returns A new Map containing the entries
+ * @public
+ */
+export declare const mapFromEntries: <K, V>(entries: readonly [K, V][]) => Map<K, V>;
+/**
+ * Converts a Map with string keys to a plain object.
+ *
+ * This is useful for serialization or when you need to work with APIs
+ * that expect plain objects instead of Maps.
+ *
+ * @example
+ * ```typescript
+ * const map = new Map([['name', 'Alice'], ['age', '30']])
+ * const obj = mapToObject(map)
+ * // Result: { name: 'Alice', age: '30' }
+ * ```
+ *
+ * @param map - The Map to convert
+ * @returns A plain object with the same key-value pairs
+ * @public
+ */
+export declare const mapToObject: <V>(map: Map<string, V>) => Record<string, V>;
+/**
+ * Creates a new Map containing only entries that satisfy the predicate.
+ *
+ * This provides a functional approach to filtering Maps, similar to
+ * Array.prototype.filter but for Map objects.
+ *
+ * @example
+ * ```typescript
+ * const map = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4]])
+ * const evenValues = mapFilter(map, (value) => value % 2 === 0)
+ * // Result: Map { 'b' => 2, 'd' => 4 }
+ * ```
+ *
+ * @param map - The Map to filter
+ * @param predicate - Function that tests each entry
+ * @returns A new Map with entries that satisfy the predicate
+ * @public
+ */
+export declare const mapFilter: <K, V>(map: Map<K, V>, predicate: (value: V, key: K) => boolean) => Map<K, V>;
+/**
+ * Creates a new Map with values transformed by the mapper function.
+ *
+ * This provides a functional approach to transforming Map values,
+ * similar to Array.prototype.map but for Map objects.
+ *
+ * @example
+ * ```typescript
+ * const map = new Map([['a', 1], ['b', 2], ['c', 3]])
+ * const doubled = mapMap(map, (value) => value * 2)
+ * // Result: Map { 'a' => 2, 'b' => 4, 'c' => 6 }
+ * ```
+ *
+ * @param map - The Map to transform
+ * @param mapper - Function that transforms each value
+ * @returns A new Map with transformed values
+ * @public
+ */
+export declare const mapMap: <K, V, U>(map: Map<K, V>, mapper: (value: V, key: K) => U) => Map<K, U>;
+/**
+ * Merges multiple Maps into a single Map.
+ *
+ * Later Maps take precedence over earlier ones for duplicate keys.
+ * This is useful for combining configuration objects or merging data.
+ *
+ * @example
+ * ```typescript
+ * const map1 = new Map([['a', 1], ['b', 2]])
+ * const map2 = new Map([['b', 3], ['c', 4]])
+ * const merged = mapMerge(map1, map2)
+ * // Result: Map { 'a' => 1, 'b' => 3, 'c' => 4 }
+ * ```
+ *
+ * @param maps - Maps to merge
+ * @returns A new Map containing all entries from input Maps
+ * @public
+ */
+export declare const mapMerge: <K, V>(...maps: Map<K, V>[]) => Map<K, V>;
+/**
+ * Groups an array of items by a key function into a Map.
+ *
+ * This is more flexible than object-based grouping as it supports
+ * any key type, not just strings and symbols.
+ *
+ * @example
+ * ```typescript
+ * const users = [
+ *   { name: 'Alice', department: 'Engineering' },
+ *   { name: 'Bob', department: 'Engineering' },
+ *   { name: 'Carol', department: 'Marketing' }
+ * ]
+ * const byDepartment = mapGroupBy(users, user => user.department)
+ * // Result: Map {
+ * //   'Engineering' => [{ name: 'Alice', ... }, { name: 'Bob', ... }],
+ * //   'Marketing' => [{ name: 'Carol', ... }]
+ * // }
+ * ```
+ *
+ * @param array - Array of items to group
+ * @param keyFn - Function that extracts the grouping key from each item
+ * @returns A Map where keys are group identifiers and values are arrays of items
+ * @public
+ */
+export declare const mapGroupBy: <T, K>(array: readonly T[], keyFn: (item: T) => K) => Map<K, T[]>;
+/**
+ * Checks if a Map is empty.
+ *
+ * This provides a semantic way to check for empty Maps,
+ * making code more readable than checking size === 0.
+ *
+ * @example
+ * ```typescript
+ * const emptyMap = new Map()
+ * const nonEmptyMap = new Map([['a', 1]])
+ *
+ * mapIsEmpty(emptyMap) // true
+ * mapIsEmpty(nonEmptyMap) // false
+ * ```
+ *
+ * @param map - The Map to check
+ * @returns true if the Map has no entries, false otherwise
+ * @public
+ */
+export declare const mapIsEmpty: <K, V>(map: Map<K, V>) => boolean;
+/**
+ * Gets all keys from a Map as an array.
+ *
+ * This provides a convenient way to get Map keys as an array
+ * for further processing with array methods.
+ *
+ * @example
+ * ```typescript
+ * const map = new Map([['a', 1], ['b', 2], ['c', 3]])
+ * const keys = mapKeys(map)
+ * // Result: ['a', 'b', 'c']
+ * ```
+ *
+ * @param map - The Map to extract keys from
+ * @returns An array of all keys in the Map
+ * @public
+ */
+export declare const mapKeys: <K, V>(map: Map<K, V>) => K[];
+/**
+ * Gets all values from a Map as an array.
+ *
+ * This provides a convenient way to get Map values as an array
+ * for further processing with array methods.
+ *
+ * @example
+ * ```typescript
+ * const map = new Map([['a', 1], ['b', 2], ['c', 3]])
+ * const values = mapValues(map)
+ * // Result: [1, 2, 3]
+ * ```
+ *
+ * @param map - The Map to extract values from
+ * @returns An array of all values in the Map
+ * @public
+ */
+export declare const mapValues: <K, V>(map: Map<K, V>) => V[];
+/**
+ * Gets all entries from a Map as an array of key-value pairs.
+ *
+ * This provides a convenient way to get Map entries as an array
+ * for further processing or serialization.
+ *
+ * @example
+ * ```typescript
+ * const map = new Map([['a', 1], ['b', 2], ['c', 3]])
+ * const entries = mapEntries(map)
+ * // Result: [['a', 1], ['b', 2], ['c', 3]]
+ * ```
+ *
+ * @param map - The Map to extract entries from
+ * @returns An array of all key-value pairs in the Map
+ * @public
+ */
+export declare const mapEntries: <K, V>(map: Map<K, V>) => [K, V][];

package/map.js

@@ -0,0 +1,41 @@
+const a = (e) => new Map(e), c = (e) => {
+  const o = {};
+  for (const [t, s] of e)
+    o[t] = s;
+  return o;
+}, p = (e, o) => {
+  const t = /* @__PURE__ */ new Map();
+  for (const [s, r] of e)
+    o(r, s) && t.set(s, r);
+  return t;
+}, u = (e, o) => {
+  const t = /* @__PURE__ */ new Map();
+  for (const [s, r] of e)
+    t.set(s, o(r, s));
+  return t;
+}, f = (...e) => {
+  const o = /* @__PURE__ */ new Map();
+  for (const t of e)
+    for (const [s, r] of t)
+      o.set(s, r);
+  return o;
+}, m = (e, o) => {
+  const t = /* @__PURE__ */ new Map();
+  for (const s of e) {
+    const r = o(s), n = t.get(r);
+    n ? n.push(s) : t.set(r, [s]);
+  }
+  return t;
+}, l = (e) => e.size === 0, y = (e) => Array.from(e.keys()), i = (e) => Array.from(e.values()), M = (e) => Array.from(e.entries());
+export {
+  M as mapEntries,
+  p as mapFilter,
+  a as mapFromEntries,
+  m as mapGroupBy,
+  l as mapIsEmpty,
+  y as mapKeys,
+  u as mapMap,
+  f as mapMerge,
+  c as mapToObject,
+  i as mapValues
+};

package/number.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const p=require("./string.cjs"),s=1e-9,l=(e,t,n=360)=>{let r=(t-e)%n;return r<0&&(r+=n),r>n/2&&(r-=n),r},f=(e,t)=>{const n=Math.pow(10,t);return Math.ceil(e*n)/n},c=(e,t,n)=>Math.min(Math.max(e,t),n),g=(e,t,n)=>Math.trunc(c(e,t,n)),u=(e,t)=>c(e,-t,t),M=(e,t)=>e<t?-1:e>t?1:0,h=(e,t)=>{const n=Math.pow(10,t);return Math.floor(e*n)/n},A=(e,t=0)=>p.lpad(e.toString(16),"0",t),i=(e,t,n)=>(t-e)*n+e,d=(e,t,n,r=360)=>o(i(e,e+l(e,t,r),n),r),a=(e,t,n=360)=>{let r=(t-e)%n;return r<0&&(r+=n),r>n/2&&(r-=n),r},w=(e,t,n,r=360)=>o(i(e,e+a(e,t,r),n),r),N=(e,t,n,r=360)=>(e=o(e,r),t=o(t,r),t<e&&(t+=r),o(i(e,t,n),r)),m=(e,t,n,r=360)=>(e=o(e,r),t=o(t,r),t>e&&(t-=r),o(i(e,t,n),r)),C=(e,t,n=s)=>isFinite(e)?isFinite(t)?Math.abs(e-t)<=n:!1:isNaN(e)?isNaN(t):isNaN(t)||isFinite(t)?!1:e>0==t>0,S=(e,t,n=360,r=s)=>Math.abs(l(e,t,n))<=r,T=(e,t=s)=>Math.abs(e)<=t,E=(e,t)=>Math.pow(e,1/t),W=(e,t)=>{const n=Math.pow(10,t);return Math.round(e*n)/n},q=e=>e<0?-1:1,y=(e,t,n)=>{const r=n-t+1;return e<t&&(e+=r*((t-e)/r+1)),t+(e-t)%r},o=(e,t)=>(e=e%t,e<0&&(e+=t),e);exports.EPSILON=s;exports.angleDifference=l;exports.ceilTo=f;exports.clamp=c;exports.clampInt=g;exports.clampSym=u;exports.compareNumbers=M;exports.floorTo=h;exports.interpolate=i;exports.interpolateAngle=d;exports.interpolateAngleCCW=m;exports.interpolateAngleCW=N;exports.interpolateWidestAngle=w;exports.nearEqual=C;exports.nearEqualAngles=S;exports.nearZero=T;exports.root=E;exports.roundTo=W;exports.sign=q;exports.toHex=A;exports.widestAngleDifference=a;exports.wrap=y;exports.wrapCircular=o;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const p=require("./string.cjs"),l=1e-9,s=(e,t,r=360)=>{let n=(t-e)%r;return n<0&&(n+=r),n>r/2&&(n-=r),n},f=(e,t)=>{const r=Math.pow(10,t);return Math.ceil(e*r)/r},a=(e,t,r)=>Math.min(Math.max(e,t),r),u=(e,t,r)=>Math.trunc(a(e,t,r)),g=(e,t)=>a(e,-t,t),M=(e,t)=>e<t?-1:e>t?1:0,h=(e,t)=>{const r=Math.pow(10,t);return Math.floor(e*r)/r},A=(e,t=0)=>p.lpad(e.toString(16),"0",t),i=(e,t,r)=>(t-e)*r+e,N=(e,t,r,n=360)=>o(i(e,e+s(e,t,n),r),n),c=(e,t,r=360)=>{let n=(t-e)%r;return n<0&&(n+=r),n>r/2&&(n-=r),n},d=(e,t,r,n=360)=>o(i(e,e+c(e,t,n),r),n),w=(e,t,r,n=360)=>(e=o(e,n),t=o(t,n),t<e&&(t+=n),o(i(e,t,r),n)),m=(e,t,r,n=360)=>(e=o(e,n),t=o(t,n),t>e&&(t-=n),o(i(e,t,r),n)),C=(e,t,r=l)=>isFinite(e)?isFinite(t)?Math.abs(e-t)<=r:!1:isNaN(e)&&isNaN(t)?!0:isNaN(e)||isNaN(t)||isFinite(t)?!1:e>0==t>0,S=(e,t,r=360,n=l)=>Math.abs(s(e,t,r))<=n,T=(e,t=l)=>Math.abs(e)<=t,E=(e,t)=>Math.pow(e,1/t),W=(e,t)=>{const r=Math.pow(10,t);return Math.round(e*r)/r},q=(e,t,r)=>{const n=r-t+1;return e<t&&(e+=n*((t-e)/n+1)),t+(e-t)%n},o=(e,t)=>(e=e%t,e<0&&(e+=t),e);exports.EPSILON=l;exports.angleDifference=s;exports.ceilTo=f;exports.clamp=a;exports.clampInt=u;exports.clampSym=g;exports.compareNumbers=M;exports.floorTo=h;exports.interpolate=i;exports.interpolateAngle=N;exports.interpolateAngleCCW=m;exports.interpolateAngleCW=w;exports.interpolateWidestAngle=d;exports.nearEqual=C;exports.nearEqualAngles=S;exports.nearZero=T;exports.root=E;exports.roundTo=W;exports.toHex=A;exports.widestAngleDifference=c;exports.wrap=q;exports.wrapCircular=o;