{"version":3,"sources":["../../src/index.ts","../../src/is.ts","../../src/boundedMap.ts","../../src/boundedSet.ts","../../src/chunk.ts","../../src/headers.ts","../../src/d2Map.ts","../../src/string.ts","../../src/time.ts","../../src/transform.ts","../../src/types/environment.ts","../../src/types/logLevel.ts","../../src/uuidSource.ts"],"sourcesContent":["export { BoundedMap } from \"./boundedMap\";\nexport { BoundedSet } from \"./boundedSet\";\n\nexport { type Chunk, asyncChunkify, chunkify } from \"./chunk\";\n\nexport {\n  type HeaderProvider,\n  type IdentityProviderConfig,\n  IdentityProvider,\n} from \"./headers\";\n\nexport {\n  isAlpha,\n  isAlphaNumeric,\n  isArray,\n  isAsyncIterable,\n  isBigInt,\n  isBoolean,\n  isFunction,\n  isInt,\n  isIterable,\n  isNumber,\n  isObject,\n  isString,\n  isTransferable,\n} from \"./is\";\n\nexport { D2Map, d2MapDelete, d2MapGet, d2MapHas, d2MapSet } from \"./d2Map\";\n\nexport {\n  camelToPascal,\n  camelToSnake,\n  capitalize,\n  pascalToCamel,\n  pascalToSnake,\n  snakeToCamel,\n  snakeToPascal,\n  toCamelCase,\n  toPascalCase,\n  toSnakeCase,\n} from \"./string\";\n\nexport { wait, waitUntil } from \"./time\";\n\nexport {\n  camelToSnakeKeys,\n  lowercaseKeys,\n  snakeToCamelKeys,\n  toAsyncIterator,\n  uppercaseKeys,\n} from \"./transform\";\n\nexport {\n  type CamelToSnake,\n  type CamelToSnakeKeys,\n  type CamelToSnakeKeysDeep,\n  type ConstEnum,\n  Environment,\n  type Logger,\n  LogLevel,\n  type LowercaseKeys,\n  type LowercaseKeysDeep,\n  type Optional,\n  type IteratorOptions,\n  type PipeOptions,\n  type SignalOption,\n  type SnakeToCamel,\n  type SnakeToCamelKeys,\n  type SnakeToCamelKeysDeep,\n  type TypedReadable,\n  type UppercaseKeys,\n  type UppercaseKeysDeep,\n} from \"./types\";\n\nexport { type Source, UuidSource } from \"./uuidSource\";\n","import { Transferable } from \"node:worker_threads\";\n\n/**\n * Checks if a value is a string containing\n * only alphabetic characters (a-z, case-insensitive)\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is an alphabetic string, `false` otherwise\n */\nexport function isAlpha(value: unknown): value is string {\n  return isString(value) && /^[a-z]+$/gi.test(value);\n}\n\n/**\n * Checks if a value is a string containing\n * only alphanumeric characters (a-z, 0-9, case-insensitive).\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is an alphanumeric string, `false` otherwise\n */\nexport function isAlphaNumeric(value: unknown): value is string {\n  return isString(value) && /^[a-z0-9]+$/gi.test(value);\n}\n\n/**\n * Checks if a value is an array\n *\n * @template T - The expected type of array elements (defaults to `unknown`).\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is an array, `false` otherwise\n */\nexport function isArray<T>(value: unknown): value is T[] {\n  return Array.isArray(value);\n}\n\n/**\n * Checks if a value is an `AsyncIterable`\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is an `AsyncIterable`, `false` otherwise\n */\nexport function isAsyncIterable(\n  value: unknown,\n): value is AsyncIterable<unknown> {\n  return (\n    isObject(value) &&\n    Symbol.asyncIterator in value &&\n    isFunction(value[Symbol.asyncIterator])\n  );\n}\n\n/**\n * Checks if a value is a `bigint`\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is a `bigint`, `false` otherwise\n */\nexport function isBigInt(value: unknown): value is bigint {\n  return typeof value === \"bigint\";\n}\n\n/**\n * Checks if a value is a `boolean`\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is a `boolean`, `false` otherwise\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === \"boolean\";\n}\n\n/**\n * Checks if a value is a function\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is a function, `false` otherwise\n */\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nexport function isFunction(value: unknown): value is Function {\n  return typeof value === \"function\";\n}\n\n/**\n * Checks if a value is an integer number\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is an integer, `false` otherwise.\n */\nexport function isInt(value: unknown): value is number {\n  return isNumber(value) && Number.isInteger(value);\n}\n\n/**\n * Checks if a value is an `Iterable`\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is an `Iterable`, `false` otherwise\n */\nexport function isIterable(value: unknown): value is Iterable<unknown> {\n  return (\n    isObject(value) &&\n    Symbol.iterator in value &&\n    isFunction(value[Symbol.iterator])\n  );\n}\n\n/**\n * Checks if a value is a `number`\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is a `number`, `false` otherwise\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === \"number\";\n}\n\n/**\n * Checks if a value is an `object`. Excludes `null` and arrays.\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is an `object`, `false` otherwise\n */\nexport function isObject(value: unknown): value is object {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n\n/**\n * Checks if a value is a `string`\n *\n * @param value - The value to check\n *\n * @returns `true` if the value is a `string`, `false` otherwise\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === \"string\";\n}\n\n/**\n * Checks if a value is a `Transferable` object\n *\n * @param value - The value to check\n *\n * @returns `True` if the value is `Transferable`, `false` otherwise\n *\n * @todo Add a reliable check for `FileHandle`\n */\nexport function isTransferable(value: unknown): value is Transferable {\n  return (\n    value instanceof ArrayBuffer ||\n    value instanceof MessagePort ||\n    value instanceof AbortSignal ||\n    value instanceof ReadableStream ||\n    value instanceof WritableStream ||\n    value instanceof TransformStream\n  );\n}\n","import { isInt, isNumber } from \"./is\";\n\n/**\n * A `Map` with a fixed maximum capacity.\n *\n * Entries are evicted in first-in-first-out (FIFO) order\n * when capacity is exceeded. This means the oldest entry\n * is removed to make space.\n *\n * @template K The type of keys.\n * @template V The type of values.\n *\n * @example\n * const map = new FIFOMap<string, number>(3);\n * map.set(\"a\", 1); // { a: 1 }\n * map.set(\"b\", 2); // { a: 1, b: 2 }\n * map.set(\"c\", 3); // { a: 1, b: 2, c: 3 }\n * map.set(\"d\", 4); // { b: 2, c: 3, d: 4 }\n */\nexport class BoundedMap<K, V> implements Map<K, V> {\n  private _capacity: number;\n  private _map: Map<K, V>;\n\n  /**\n   * Creates a new instance with an optional capacity.\n   *\n   * @param capacity (Optional) The maximum number of entries the map can hold. Defaults to `Infinity`.\n   */\n  constructor(capacity?: number);\n  /**\n   * Creates a new instance with the entries from the given iterable and optional capacity.\n   *\n   * @param iterable (Optional) An iterable of key-value pairs to initialize the map with.\n   * @param capacity (Optional) The maximum number of entries the map can hold. Defaults to `Infinity`.\n   */\n  constructor(iterable?: Iterable<[K, V]> | null, capacity?: number);\n  /**\n   * Creates a new instance from an existing `Map` and an optional capacity.\n   *\n   * @param map (Optional) A `Map` to initialize the instance with.\n   * @param capacity (Optional) The maximum number of entries the map can hold. Defaults to `Infinity`.\n   */\n  constructor(map?: Map<K, V> | null, capacity?: number);\n  /**\n   * Internal constructor implementation that handles overloading.\n   */\n  constructor(\n    map?: Iterable<[K, V]> | Map<K, V> | null | number,\n    capacity?: number,\n  ) {\n    if (isNumber(map)) {\n      capacity = map;\n      map = undefined;\n    }\n\n    this._capacity = 0;\n    if (map == null) {\n      this._map = new Map();\n    } else if (map instanceof Map) {\n      this._map = map;\n    } else {\n      this._map = new Map(map);\n    }\n\n    this.capacity = capacity ?? Infinity;\n  }\n\n  /**\n   * The maximum number of entries the map can hold.\n   */\n  get capacity(): number {\n    return this._capacity;\n  }\n\n  /**\n   *\n   * Must be a nonnegative integer or `Infinity`.\n   *\n   * When reduced, the oldest entries are\n   * evicted until the map is within capacity.\n   *\n   * @throws {RangeError} If an invalid capacity is given.\n   */\n  set capacity(value: number) {\n    // Sanitize input\n    if (value !== Infinity && (!isInt(value) || value < 0)) {\n      throw new RangeError(\"Invalid map capacity\");\n    }\n\n    // Update capacity\n    this._capacity = value;\n\n    // Check if size violates new capacity\n    if (this.size <= this._capacity) {\n      return;\n    }\n\n    // Special case; Remove all values\n    if (value == 0) {\n      this._map.clear();\n      return;\n    }\n\n    // Reduce size to within capacity\n    const iterator = this.keys();\n    do {\n      this.delete(iterator.next().value!);\n    } while (this.size > this._capacity);\n  }\n\n  /**\n   * Removes all entries from the map.\n   */\n  clear(): void {\n    this._map.clear();\n  }\n\n  /**\n   * Removes a specified entry from the map.\n   *\n   * @param key The key of the entry to remove.\n   *\n   * @returns `true` if the entry was found and removed, `false` otherwise.\n   */\n  delete(key: K): boolean {\n    return this._map.delete(key);\n  }\n\n  /**\n   * Returns an iterable of [key, value] pairs for every entry in the map.\n   *\n   * @returns An iterable of [key, value] pairs for every entry in the map.\n   */\n  entries(): MapIterator<[K, V]> {\n    return this._map.entries();\n  }\n\n  /**\n   * Executes a provided function once for each entry in the map.\n   *\n   * @param callbackFn The function to execute.\n   *\n   * @param thisArg (Optional) The value to use as `this` when executing the function.\n   */\n  forEach(\n    callbackFn: (value: V, key: K, map: Map<K, V>) => void,\n    thisArg?: unknown,\n  ): void {\n    this._map.forEach((value, key) => {\n      callbackFn.call(thisArg, value, key, this);\n    });\n  }\n\n  /**\n   * Gets the value associated with the given key.\n   *\n   * @param key The key to check.\n   *\n   * @returns The value if the key exists, otherwise `undefined`.\n   */\n  get(key: K): V | undefined {\n    return this._map.get(key);\n  }\n\n  /**\n   * Checks whether the given key exists in the map.\n   *\n   * @param key The key to check.\n   *\n   * @returns `true` if the key exists, otherwise `false`.\n   */\n  has(key: K): boolean {\n    return this._map.has(key);\n  }\n\n  /**\n   * Returns an iterable over the keys in the map.\n   *\n   * @returns An iterable over the keys in the map.\n   */\n  keys(): MapIterator<K> {\n    return this._map.keys();\n  }\n\n  /**\n   * Adds a new key-value pair to the map.\n   *\n   * If a key already exists, it is re-inserted at the newest position.\n   *\n   * If capacity would be exceeded, the oldest entry is removed.\n   *\n   * @param key The key to set.\n   * @param value The value associated with the key.\n   *\n   * @returns The map instance.\n   */\n  set(key: K, value: V): this {\n    if (!this.delete(key) && this.size >= this._capacity) {\n      this.shift();\n    }\n    this.set(key, value);\n    return this;\n  }\n\n  /**\n   * Removes and returns the oldest entry in the map.\n   *\n   * @returns The removed key-value pair, or `undefined` if the map is empty.\n   */\n  shift(): [K, V] | undefined {\n    const iterator = this.entries();\n    const next = iterator.next();\n    if (next.done) {\n      return undefined;\n    }\n    this.delete(next.value[0]);\n    return next.value;\n  }\n\n  /**\n   * The number of entries in the map.\n   */\n  get size(): number {\n    return this._map.size;\n  }\n\n  /**\n   * Returns an iterable over the values in the map.\n   *\n   * @returns An iterable over the values in the map.\n   */\n  values(): MapIterator<V> {\n    return this._map.values();\n  }\n\n  /**\n   * Returns an iterable over the entries in the map.\n   *\n   * @returns An iterable over the entries in the map.\n   */\n  [Symbol.iterator](): MapIterator<[K, V]> {\n    return this._map[Symbol.iterator]();\n  }\n\n  /**\n   * The default string tag.\n   */\n  get [Symbol.toStringTag](): string {\n    return BoundedMap.name;\n  }\n}\n","import { isInt, isNumber } from \"./is\";\n\n/**\n * A `Set` with a fixed maximum capacity.\n *\n * Values are evicted in first-in-first-out (FIFO) order\n * when capacity is exceeded. This means the oldest value\n * is removed to make space.\n *\n * @template V The type of values.\n *\n * @example\n * const set = new FifoSet<number>(3);\n * set.add(1); // [ 1 ]\n * set.add(2); // [ 1, 2 ]\n * set.add(3); // [ 1, 2, 3 ]\n * set.add(4); // [ 2, 3, 4 ]\n */\nexport class BoundedSet<V> implements Set<V> {\n  private _capacity: number;\n  private _set: Set<V>;\n\n  /**\n   * Creates a new instance with an optional capacity.\n   *\n   * @param capacity (Optional) The maximum number of values the set can hold. Defaults to `Infinity`.\n   */\n  constructor(capacity?: number);\n  /**\n   * Creates a new instance with values from the given iterable and an optional capacity.\n   *\n   * @param iterable (Optional) An iterable of values to initialize the set with.\n   * @param capacity (Optional) The maximum number of values the set can hold. Defaults to `Infinity`.\n   */\n  constructor(iterable?: Iterable<V> | null, capacity?: number);\n  /**\n   * Creates a new instance from an existing `Set` and an optional capacity.\n   *\n   * @param set (Optional) A `Set` to initialize the instance with.\n   * @param capacity (Optional) The maximum number of values the set can hold. Defaults to `Infinity`.\n   */\n  constructor(set?: Set<V> | null, capacity?: number);\n  constructor(set?: Iterable<V> | Set<V> | null | number, capacity?: number) {\n    if (isNumber(set)) {\n      capacity = set;\n      set = undefined;\n    }\n\n    this._capacity = 0;\n    if (set == null) {\n      this._set = new Set();\n    } else if (set instanceof Set) {\n      this._set = set;\n    } else {\n      this._set = new Set(set);\n    }\n\n    this.capacity = capacity ?? Infinity;\n  }\n\n  /**\n   * Adds a new value to the set.\n   *\n   * If the value already exists, it is re-inserted at the newest position.\n   *\n   * If capacity would be exceeded, the oldest value is removed.\n   *\n   * @param value The value to add.\n   *\n   * @returns The set instance.\n   */\n  add(value: V): this {\n    if (!this.delete(value) && this.size >= this._capacity) {\n      this.shift();\n    }\n    this._set.add(value);\n    return this;\n  }\n\n  /**\n   * The maximum number of values the set can hold.\n   */\n  get capacity(): number {\n    return this._capacity;\n  }\n\n  /**\n   * Must be a nonnegative integer or `Infinity`.\n   *\n   * When reduced, the oldest values are\n   * evicted until the set is within capacity.\n   *\n   * @throws {RangeError} If an invalid capacity is given.\n   */\n  set capacity(value: number) {\n    // Sanitize input\n    if (value !== Infinity && (!isInt(value) || value < 0)) {\n      throw new RangeError(\"Invalid set capacity\");\n    }\n\n    // Update capacity\n    this._capacity = value;\n\n    // Check if size violates new capacity\n    if (this.size <= this._capacity) {\n      return;\n    }\n\n    // Special case; Remove all values\n    if (value === 0) {\n      this._set.clear();\n      return;\n    }\n\n    // Reduce size to within capacity\n    const iterator = this.keys();\n    do {\n      this.delete(iterator.next().value!);\n    } while (this.size > this._capacity);\n  }\n\n  /**\n   * Removes all values from the set.\n   */\n  clear(): void {\n    this._set.clear();\n  }\n\n  /**\n   * Removes a specified value from the set.\n   *\n   * @param value The value to remove.\n   *\n   * @returns `true` if the value was found and removed, otherwise `false`.\n   */\n  delete(value: V): boolean {\n    return this._set.delete(value);\n  }\n\n  /**\n   * @param other The other set.\n   *\n   * @param capacity (Optional) The capacity for the new set. Defaults to this set's capacity.\n   *\n   * @returns A new set containing the values that are in this set and not in `other`\n   */\n  difference<U>(other: ReadonlySetLike<U>, capacity?: number): BoundedSet<V> {\n    return new BoundedSet(\n      this._set.difference(other),\n      capacity ?? this.capacity,\n    );\n  }\n\n  /**\n   * Returns an iterable of [value, value] pairs for every value in the set.\n   *\n   * @returns An iterable of [value, value] pairs for every value in the set.\n   */\n  entries(): SetIterator<[V, V]> {\n    return this._set.entries();\n  }\n\n  /**\n   * Executes a provided function once for each value in the set.\n   *\n   * @param callbackFn The function to execute.\n   *\n   * @param thisArg (Optional) The value to use as `this` when executing the function.\n   */\n  forEach(\n    callbackFn: (value: V, value2: V, set: BoundedSet<V>) => void,\n    thisArg?: unknown,\n  ): void {\n    this._set.forEach((value, value2) => {\n      callbackFn.call(thisArg, value, value2, this);\n    });\n  }\n\n  /**\n   * Checks whether the given value exists in the set.\n   *\n   * @param value The value to check.\n   *\n   * @returns `true` if the value exists, otherwise `false`.\n   */\n  has(value: V): boolean {\n    return this._set.has(value);\n  }\n\n  /**\n   * @param other The other set.\n   *\n   * @param capacity (Optional) The capacity for the new set. Defaults to this set's capacity.\n   *\n   * @return A new set containing the values that are in both this set and `other`.\n   */\n  intersection<U>(\n    other: ReadonlySetLike<U>,\n    capacity?: number,\n  ): BoundedSet<V & U> {\n    return new BoundedSet<V & U>(\n      this._set.intersection(other),\n      capacity ?? this.capacity,\n    );\n  }\n\n  /**\n   * @param other The other set.\n   *\n   * @returns `true` if this set has no values in common with `other`, otherwise `false`.\n   */\n  isDisjointFrom(other: ReadonlySetLike<unknown>): boolean {\n    return this._set.isDisjointFrom(other);\n  }\n\n  /**\n   * @param other The other set.\n   *\n   * @returns `true` if all values in this set are in `other`, otherwise `false`.\n   */\n  isSubsetOf(other: ReadonlySetLike<unknown>): boolean {\n    return this._set.isSubsetOf(other);\n  }\n\n  /**\n   * @param other The other set.\n   *\n   * @returns `true` if all values in `other` are in this set, otherwise `false`.\n   */\n  isSupersetOf(other: ReadonlySetLike<unknown>): boolean {\n    return this._set.isSupersetOf(other);\n  }\n\n  /**\n   * Returns an iterable over the values in the set.\n   *\n   * @returns An iterable over the values in the set.\n   */\n  keys(): SetIterator<V> {\n    return this._set.keys();\n  }\n\n  /**\n   * Removes and returns the oldest value in the set.\n   *\n   * @returns The removed value, or `undefined` if the set is empty.\n   */\n  shift(): V | undefined {\n    const iterator = this.values();\n    const next = iterator.next();\n    if (next.done) {\n      return undefined;\n    }\n    this.delete(next.value);\n    return next.value;\n  }\n\n  /**\n   * @param other The other set.\n   * @param capacity (Optional) The capacity for the new set. Defaults to this set's capacity.\n   *\n   * @returns A new set containing the values that are in either this set or `other`, but not both.\n   */\n  symmetricDifference<U>(\n    other: ReadonlySetLike<U>,\n    capacity?: number,\n  ): BoundedSet<V | U> {\n    return new BoundedSet<V | U>(\n      this._set.symmetricDifference(other),\n      capacity ?? this.capacity,\n    );\n  }\n\n  /**\n   * The number of values in the set.\n   */\n  get size(): number {\n    return this._set.size;\n  }\n\n  /**\n   * @param other The other set.\n   * @param capacity (Optional) The capacity for the new set. Defaults to this set's capacity.\n   *\n   * @returns A new set containing all values in this set and `other`.\n   */\n  union<U>(other: ReadonlySetLike<U>, capacity?: number): BoundedSet<V | U> {\n    return new BoundedSet<V | U>(\n      this._set.union(other),\n      capacity ?? this.capacity,\n    );\n  }\n\n  /**\n   * Returns an iterable over the values in the set.\n   *\n   * @returns An iterable over the values in the set.\n   */\n  values(): SetIterator<V> {\n    return this._set.values();\n  }\n\n  /**\n   * Returns an iterable over the values in the set.\n   *\n   * @returns An iterable over the values in the set.\n   */\n  [Symbol.iterator](): SetIterator<V> {\n    return this._set[Symbol.iterator]();\n  }\n\n  /**\n   * The default string tag.\n   */\n  get [Symbol.toStringTag](): string {\n    return BoundedSet.name;\n  }\n}\n","/**\n * Represents a chunked segment of a sequence of values.\n *\n * @template T - The type of values in the chunk.\n */\nexport interface Chunk<T> {\n  /**\n   * The zero-based index of the chunk.\n   */\n  chunkIndex: number;\n\n  /**\n   * The zero-based index in the original\n   * sequence of the first value in the chunk.\n   */\n  startIndex: number;\n\n  /**\n   * The values contained in the chunk.\n   */\n  values: T[];\n}\n\n/**\n * Asynchronously splits an iterable into fixed-size chunks.\n *\n * @template T - The type of values in the input iterable.\n *\n * @param size - The maximum number of items per chunk. Must be a positive integer or `Infinity`.\n * @param values - The source of values to be chunked.\n *\n * @yields {Chunk<T>} An object representing the next chunk in the sequence.\n *\n * @throws {RangeError} If `size` is less than 1 or not an integer (except for `Infinity`).\n *\n * @example\n * const data = [1, 2, 3, 4, 5];\n * for await (const chunk of chunkify(2, data)) {\n *   console.log(chunk);\n * }\n * // Output:\n * // { chunkIndex: 0, startIndex: 0, values: [1, 2] }\n * // { chunkIndex: 1, startIndex: 2, values: [3, 4] }\n * // { chunkIndex: 2, startIndex: 4, values: [5] }\n */\nexport async function* asyncChunkify<T>(\n  size: number,\n  values: Iterable<T> | AsyncIterable<T>,\n): AsyncGenerator<Chunk<T>> {\n  if (size !== Infinity && (!Number.isInteger(size) || size < 1)) {\n    throw new RangeError(\"Invalid chunk length\");\n  }\n\n  let chunkIndex = 0;\n  let startIndex = 0;\n  let chunk: T[] = [];\n  for await (const value of values) {\n    if (chunk.push(value) >= size) {\n      yield { chunkIndex, startIndex, values: chunk };\n      chunk = [];\n      ++chunkIndex;\n      startIndex += chunk.length;\n    }\n  }\n\n  if (chunk.length > 0) {\n    yield { chunkIndex, startIndex, values: chunk };\n  }\n}\n\n/**\n * Splits an iterable into fixed-size chunks.\n *\n * @template T - The type of values in the input iterable.\n *\n * @param size - The maximum number of items per chunk. Must be a positive integer or `Infinity`.\n * @param values - The source of values to be chunked.\n *\n * @yields {Chunk<T>} An object representing the next chunk in the sequence.\n *\n * @throws {RangeError} If `size` is less than 1 or not an integer (except for `Infinity`).\n *\n * @example\n * const data = [1, 2, 3, 4, 5];\n * for (const chunk of chunkify(2, data)) {\n *   console.log(chunk);\n * }\n * // Output:\n * // { chunkIndex: 0, startIndex: 0, values: [1, 2] }\n * // { chunkIndex: 1, startIndex: 2, values: [3, 4] }\n * // { chunkIndex: 2, startIndex: 4, values: [5] }\n */\nexport function* chunkify<T>(\n  size: number,\n  values: Iterable<T>,\n): Generator<Chunk<T>> {\n  if (size !== Infinity && (!Number.isInteger(size) || size < 1)) {\n    throw new RangeError(\"Invalid chunk length\");\n  }\n\n  let chunkIndex = 0;\n  let startIndex = 0;\n  let chunk: T[] = [];\n  for (const value of values) {\n    if (chunk.push(value) >= size) {\n      yield { chunkIndex, startIndex, values: chunk };\n      chunk = [];\n      ++chunkIndex;\n      startIndex += chunk.length;\n    }\n  }\n\n  if (chunk.length > 0) {\n    yield { chunkIndex, startIndex, values: chunk };\n  }\n}\n","import { randomUUID } from \"node:crypto\";\n\nimport {\n  HEADER_CORRELATION_ID,\n  HEADER_ORCHARD_IDENTITY_ID,\n} from \"@theorchard/ows-headers\";\n\nexport interface HeaderProvider {\n  getHeaders(): Record<string, string> | Promise<Record<string, string>>;\n}\n\nexport interface IdentityProviderConfig {\n  identityId: string;\n}\n\nexport class IdentityProvider implements HeaderProvider {\n  identityId: string;\n\n  constructor(config: IdentityProviderConfig) {\n    this.identityId = config.identityId;\n  }\n\n  async getHeaders(): Promise<Record<string, string>> {\n    return {\n      [HEADER_CORRELATION_ID]: randomUUID(),\n      [HEADER_ORCHARD_IDENTITY_ID]: this.identityId,\n    };\n  }\n}\n","/**\n * A two-dimensional map implemented as a `Map` of `Map`s.\n *\n * Allows storing and retrieving values using a pair of keys.\n *\n * @template K1 - The type of the first-level (outer) key.\n * @template K2 - The type of the second-level (inner) key.\n * @template V - The type of the value.\n *\n * @example\n * const map = new Map2D<string, number, string>();\n * map.set([\"a\", 1], \"b\");\n * console.log(map.get([\"a\", 1])); // \"b\"\n */\nexport class D2Map<K1, K2, V> implements Map<[K1, K2], V> {\n  private _data: Map<K1, Map<K2, V>>;\n  private _size: number;\n\n  constructor(iterable?: Iterable<[[K1, K2], V]> | null) {\n    this._data = new Map();\n    this._size = 0;\n    if (iterable != null) {\n      for (const [keys, value] of iterable) {\n        this.set(keys, value);\n      }\n    }\n  }\n\n  /**\n   * Removes all entries from the map.\n   */\n  clear(): void {\n    this._data.clear();\n    this._size = 0;\n  }\n\n  /**\n   * Removes a specified entry from the map.\n   *\n   * @param keys The keys of the entry to remove.\n   *\n   * @returns `true` if the entry was found and removed, `false` otherwise.\n   */\n  delete(keys: [K1, K2]): boolean {\n    return d2MapDelete(this._data, keys[0], keys[1]);\n  }\n\n  /**\n   * Returns an iterable of [keys, value] pairs for every entry in the map.\n   *\n   * @returns An iterable of [keys, value] pairs for every entry in the map.\n   */\n  entries(): MapIterator<[[K1, K2], V]> {\n    return this[Symbol.iterator]();\n  }\n\n  /**\n   * Executes a provided function once for each entry in the map.\n   *\n   * @param callbackFn The function to execute.\n   *\n   * @param thisArg (Optional) The value to use as `this` when executing the function.\n   */\n  forEach(\n    callbackFn: (value: V, keys: [K1, K2], map: Map<[K1, K2], V>) => void,\n    thisArg?: unknown,\n  ): void {\n    for (const [keys, value] of this) {\n      callbackFn.call(thisArg, value, keys, this);\n    }\n  }\n\n  /**\n   * Gets the value associated with the given keys.\n   *\n   * @param key The keys to check.\n   *\n   * @returns The value if the keys exist, otherwise `undefined`.\n   */\n  get(keys: [K1, K2]): V | undefined {\n    return d2MapGet(this._data, keys[0], keys[1]);\n  }\n\n  /**\n   * Checks whether the given keys exist in the map.\n   *\n   * @param key The keys to check.\n   *\n   * @returns `true` if the keys exist, otherwise `false`.\n   */\n  has(keys: [K1, K2]): boolean {\n    return d2MapHas(this._data, keys[0], keys[1]);\n  }\n\n  /**\n   * Returns an iterable over the keys in the map.\n   *\n   * @returns An iterable over the keys in the map.\n   */\n  *keys(): MapIterator<[K1, K2]> {\n    for (const [key1, map] of this._data) {\n      for (const key2 of map.keys()) {\n        yield [key1, key2];\n      }\n    }\n  }\n\n  /**\n   * Adds a new keys-value pair to the map.\n   *\n   * @param key The keys to set.\n   * @param value The value associated with the keys.\n   *\n   * @returns The map instance.\n   */\n  set(keys: [K1, K2], value: V): this {\n    d2MapSet(this._data, keys[0], keys[1], value);\n    return this;\n  }\n\n  /**\n   * The number of entries in the map.\n   */\n  get size(): number {\n    return this._size;\n  }\n\n  /**\n   * Returns an iterable over the values in the map.\n   *\n   * @returns An iterable over the values in the map.\n   */\n  *values(): MapIterator<V> {\n    for (const map of this._data.values()) {\n      for (const value of map.values()) {\n        yield value;\n      }\n    }\n  }\n\n  /**\n   * Returns an iterable over the entries in the map.\n   *\n   * @returns An iterable over the entries in the map.\n   */\n  *[Symbol.iterator](): MapIterator<[[K1, K2], V]> {\n    for (const [key1, map] of this._data) {\n      for (const [key2, value] of map) {\n        yield [[key1, key2], value];\n      }\n    }\n  }\n\n  /**\n   * The default string tag.\n   */\n  get [Symbol.toStringTag](): string {\n    return D2Map.name;\n  }\n}\n\n/**\n * Removes a specified entry from the map.\n *\n * @param key1 The key for the outer map.\n * @param key2 The key for the inner map.\n *\n * @returns `true` if the entry was found and removed, `false` otherwise.\n */\nexport function d2MapDelete<K1, K2>(\n  map2d: Map<K1, Map<K2, unknown>>,\n  key1: K1,\n  key2: K2,\n): boolean {\n  const map = map2d.get(key1);\n  if (map == null || !map.delete(key2)) {\n    return false;\n  }\n  if (map.size < 1) {\n    map2d.delete(key1);\n  }\n  return true;\n}\n\n/**\n * Gets the value associated with the given keys.\n *\n * @param key1 The key for the outer map.\n * @param key2 The key for the inner map.\n *\n * @returns The value if the keys exist, otherwise `undefined`.\n */\nexport function d2MapGet<K1, K2, V>(\n  map2d: Map<K1, Map<K2, V>>,\n  key1: K1,\n  key2: K2,\n): V | undefined {\n  return map2d.get(key1)?.get(key2);\n}\n\n/**\n * Checks whether the given keys exist in the map.\n *\n * @param key1 The key for the outer map.\n * @param key2 The key for the inner map.\n *\n * @returns `true` if the keys exist, otherwise `false`.\n */\nexport function d2MapHas<K1, K2, V>(\n  map2d: Map<K1, Map<K2, V>>,\n  key1: K1,\n  key2: K2,\n): boolean {\n  return map2d.get(key1)?.has(key2) ?? false;\n}\n\n/**\n * Adds a new keys-value pair to the map.\n *\n * @param key1 The key for the outer map.\n * @param key2 The key for the inner map.\n *\n * @param value The value associated with the keys.\n */\nexport function d2MapSet<K1, K2, V>(\n  map2d: Map<K1, Map<K2, V>>,\n  key1: K1,\n  key2: K2,\n  value: V,\n): void {\n  let map1d = map2d.get(key1);\n  if (map1d == null) {\n    map1d = new Map();\n    map2d.set(key1, map1d);\n  }\n  map1d.set(key2, value);\n}\n","/**\n * Converts camelCase to PascalCase\n *\n * @param str A string in camelCase\n *\n * @returns A string in PascalCase\n */\nexport function camelToPascal(str: string): string {\n  return str.slice(0, 1).toUpperCase() + str.slice(1);\n}\n\n/**\n * Converts camelCase to snake_case\n *\n * @param str A string in camelCase\n *\n * @returns A string in snake_case\n */\nexport function camelToSnake(str: string): string {\n  return str.replace(/([a-z0-9])([A-Z])/g, \"$1_$2\").toLowerCase();\n}\n\n/**\n * Capitalized the first character in the string\n *\n * @param str A string\n *\n * @return The given string with the first character capitalized\n */\nexport function capitalize(str: string): string {\n  return str.slice(0, 1).toUpperCase() + str.slice(1);\n}\n\n/**\n * Converts PascalCase to camelCase\n *\n * @param str A string in PascalCase\n *\n * @returns A string in camelCase\n */\nexport function pascalToCamel(str: string): string {\n  return str.slice(0, 1).toLowerCase() + str.slice(1);\n}\n\n/**\n * Converts PascalCase to snake_case\n *\n * @param str A string in PascalCase\n *\n * @returns A string in snake_case\n */\nexport function pascalToSnake(str: string): string {\n  return camelToSnake(pascalToCamel(str));\n}\n\n/**\n * Converts snake_case to camelCase\n *\n * @param str A string in snake_case\n *\n * @returns A string in camelCase\n */\nexport function snakeToCamel(str: string): string {\n  return str\n    .replaceAll(/_([^_])/g, (_, char) => char.toUpperCase())\n    .replaceAll(\"_\", \"\");\n}\n\n/**\n * Converts snake_case to PascalCase\n *\n * @param str A string in snake_case\n *\n * @returns A string in PascalCase\n */\nexport function snakeToPascal(str: string): string {\n  return camelToPascal(snakeToCamel(str));\n}\n\n/**\n * Takes a string of space separated text\n * and converts to camelCase.\n *\n * @param str\n *\n * @returns A string in camelCase\n */\nexport function toCamelCase(str: string): string {\n  return str\n    .trim()\n    .toLowerCase()\n    .replaceAll(/\\s+([^\\s])/g, (_, char) => char.toUpperCase());\n}\n\n/**\n * Takes a string of space separated text\n * and converts to PascalCase.\n *\n * @param str\n *\n * @returns A string in camelCase\n */\nexport function toPascalCase(str: string): string {\n  return str\n    .trim()\n    .toLowerCase()\n    .replaceAll(/(?:^|\\s+)([^\\s])/g, (_, char) => char.toUpperCase());\n}\n\n/**\n * Takes a string of space separated text\n * and converts to snake_case.\n *\n * @param str\n *\n * @returns A string in snake_case\n */\nexport function toSnakeCase(str: string): string {\n  return str.trim().toLowerCase().replaceAll(/\\s+/g, \"_\");\n}\n","/**\n * Waits the given amount of time.\n *\n * @param ms - Time to wait in milliseconds\n */\nexport function wait(ms: number): Promise<void> {\n  return new Promise<void>((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Waits until the given timestamp.\n *\n * @param ts - Unix timestamp in milliseconds (e.g. `Date.now()`)\n */\nexport async function waitUntil(ts: number): Promise<void> {\n  for (let now = Date.now(); ts > now; now = Date.now()) {\n    await wait(ts - now);\n  }\n}\n","import { camelToSnake, snakeToCamel } from \"./string\";\nimport { CamelToSnakeKeys, SnakeToCamelKeys } from \"./types\";\nimport { LowercaseKeys, UppercaseKeys } from \"./types/string\";\n\n/**\n * Creates a new object with the same values and\n * keys transformed from camelCase to snake_case.\n *\n * @typeParam T The type of the input object\n *\n * @param obj The object whose keys will be transformed\n *\n * @returns A new object with snake_case keys\n */\nexport function camelToSnakeKeys<T extends object>(\n  obj: T,\n): CamelToSnakeKeys<T> {\n  const out = {} as Record<string, unknown>;\n  for (const key of Object.keys(obj)) {\n    const outKey = typeof key === \"string\" ? camelToSnake(key) : key;\n    out[outKey] = obj[key as keyof T];\n  }\n  return out as CamelToSnakeKeys<T>;\n}\n\n/**\n * Creates a new object with the same\n * values and keys transformed to lowercase.\n *\n * @typeParam T The type of the input object\n *\n * @param obj The object whose keys will be transformed\n *\n * @returns A new object with lowercase keys\n */\nexport function lowercaseKeys<T extends object>(obj: T): LowercaseKeys<T> {\n  const out = {} as Record<string, unknown>;\n  for (const key of Object.keys(obj)) {\n    const outKey = typeof key === \"string\" ? key.toLowerCase() : key;\n    out[outKey] = obj[key as keyof T];\n  }\n  return out as LowercaseKeys<T>;\n}\n\n/**\n * Creates a new object with the same values and\n * keys transformed from snake_case to camelCase.\n *\n * @typeParam T The type of the input object\n *\n * @param obj The object whose keys will be transformed\n *\n * @returns A new object with camelCase keys\n */\nexport function snakeToCamelKeys<T extends object>(\n  obj: T,\n): SnakeToCamelKeys<T> {\n  const out = {} as Record<string, unknown>;\n  for (const key of Object.keys(obj)) {\n    const outKey = typeof key === \"string\" ? snakeToCamel(key) : key;\n    out[outKey] = obj[key as keyof T];\n  }\n  return out as SnakeToCamelKeys<T>;\n}\n\n/**\n * Converts a synchronous or asynchronous\n * iterator into an asynchronous generator.\n *\n * Allows consistent handling of iterators\n * regardless of whether they are synchronous\n * or asynchronous.\n *\n * @typeParam T The type of values yielded by the iterator\n *\n * @param iterator - A sync / async iterator\n *\n * @returns An async generator\n */\nexport async function* toAsyncIterator<T>(\n  iterator: AsyncIterator<T> | Iterator<T>,\n): AsyncGenerator<T> {\n  let result = await iterator.next();\n  while (!result.done) {\n    yield result.value;\n    result = await iterator.next();\n  }\n}\n\n/**\n * Creates a new object with the same\n * values and keys transformed to uppercase.\n *\n * @typeParam T The type of the input object\n *\n * @param obj The object whose keys will be transformed\n *\n * @returns A new object with uppercase keys\n */\nexport function uppercaseKeys<T extends object>(obj: T): UppercaseKeys<T> {\n  const out = {} as Record<string, unknown>;\n  for (const key of Object.keys(obj)) {\n    const outKey = typeof key === \"string\" ? key.toUpperCase() : key;\n    out[outKey] = obj[key as keyof T];\n  }\n  return out as UppercaseKeys<T>;\n}\n","/**\n * Represents the possible runtime environments\n */\nexport enum Environment {\n  /**\n   * Development environment\n   */\n  Dev = \"dev\",\n\n  /**\n   * Production environment\n   */\n  Prod = \"prod\",\n\n  /**\n   * Quality assurance (QA) environment\n   */\n  QA = \"qa\",\n\n  /**\n   * Testing environment\n   */\n  Test = \"test\",\n\n  /**\n   * User acceptance testing (UAT) environment\n   */\n  UAT = \"uat\",\n}\n","/**\n * Represents the severity level of a log message.\n *\n * These levels can be used to filter or control logging output.\n */\nexport enum LogLevel {\n  /**\n   * Debug-level messages. Used for development and diagnostics.\n   */\n  Debug = \"debug\",\n\n  /**\n   * Error-level messages. Used for failures and unexpected conditions.\n   */\n  Error = \"error\",\n\n  /**\n   * Info-level messages. Used for general events.\n   */\n  Info = \"info\",\n\n  /**\n   * Disables logging\n   */\n  Off = \"off\",\n\n  /**\n   * Warning-level messages. Used for recoverable issues and unexpected non-fatal events.\n   */\n  Warning = \"warning\",\n}\n","import { randomUUID } from \"node:crypto\";\n\n/**\n * Represents a reusable source of values that supports both\n * on-demand generation via `next()` and iterable consumption.\n *\n * @template T - The type of values produced by the source.\n */\nexport interface Source<T> extends Iterable<T> {\n  /**\n   * Returns the next value from the source.\n   *\n   * This method should return a new value each time it is called.\n   */\n  next(): T;\n}\n\n/**\n * A source of infinite UUIDv4 strings.\n *\n * Implements a `next()` method for generating a single UUID\n * and an infinite iterable that yields UUIDs on demand.\n */\nexport class UuidSource implements Source<string> {\n  /**\n   * Returns a generated UUID string\n   */\n  next(): string {\n    return randomUUID();\n  }\n\n  /**\n   * Returns an infinite iterator of UUID strings\n   *\n   * @returns {Iterator<string>}\n   */\n  *[Symbol.iterator](): Iterator<string> {\n    while (true) {\n      yield this.next();\n    }\n  }\n}\n"],"mappings":"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","names":["index_exports","__export","BoundedMap","BoundedSet","D2Map","Environment","IdentityProvider","LogLevel","UuidSource","asyncChunkify","camelToPascal","camelToSnake","camelToSnakeKeys","capitalize","chunkify","d2MapDelete","d2MapGet","d2MapHas","d2MapSet","isAlpha","isAlphaNumeric","isArray","isAsyncIterable","isBigInt","isBoolean","isFunction","isInt","isIterable","isNumber","isObject","isString","isTransferable","lowercaseKeys","pascalToCamel","pascalToSnake","snakeToCamel","snakeToCamelKeys","snakeToPascal","toAsyncIterator","toCamelCase","toPascalCase","toSnakeCase","uppercaseKeys","wait","waitUntil","__toCommonJS","isAlpha","value","isString","isAlphaNumeric","isArray","isAsyncIterable","isObject","isFunction","isBigInt","isBoolean","isInt","isNumber","isIterable","isTransferable","BoundedMap","_BoundedMap","map","capacity","isNumber","value","isInt","iterator","key","callbackFn","thisArg","next","BoundedSet","_BoundedSet","set","capacity","isNumber","value","isInt","iterator","other","callbackFn","thisArg","value2","next","asyncChunkify","size","values","chunkIndex","startIndex","chunk","value","chunkify","import_node_crypto","import_ows_headers","IdentityProvider","config","D2Map","_D2Map","iterable","keys","value","d2MapDelete","callbackFn","thisArg","d2MapGet","d2MapHas","key1","map","key2","d2MapSet","map2d","map1d","camelToPascal","str","camelToSnake","capitalize","pascalToCamel","pascalToSnake","snakeToCamel","_","char","snakeToPascal","toCamelCase","toPascalCase","toSnakeCase","wait","ms","resolve","waitUntil","ts","now","camelToSnakeKeys","obj","out","key","outKey","camelToSnake","lowercaseKeys","snakeToCamelKeys","snakeToCamel","toAsyncIterator","iterator","result","uppercaseKeys","Environment","LogLevel","import_node_crypto","UuidSource"]}