{"version":3,"file":"helpers.mjs","names":[],"sources":["../src/runtime-flags.ts","../src/func.ts","../src/number.ts","../src/delay.ts","../src/promise.ts","../src/string.ts","../src/set.ts","../src/map.ts","../src/regexp.ts","../src/array.ts","../src/object.ts","../src/object-id.ts","../src/buffer.ts","../src/date.ts","../src/general.ts","../src/defaults.ts"],"sourcesContent":["/**\n * A {@link Window} instance exists globally at runtime\n */\nexport const IN_WINDOW: boolean = typeof window !== 'undefined';\n\n/**\n * A {@link Document} instance exists globally at runtime\n */\nexport const IN_DOCUMENT: boolean = typeof document !== 'undefined';\n","/* eslint-disable @typescript-eslint/no-unsafe-function-type */\n/**\n * If the specified type is a function, the function type is returned; otherwise, the function type with the specified return type is returned.\n */\nexport type NormalizeFuncType<T> = T extends (...args: any) => any\n  ? T\n  : () => T;\n\n/**\n * Value types that can be replaced with functions\n */\nexport type FunctionableValue<T, ARGS extends any[]> = T extends Function\n  ? never\n  : T | ((...args: ARGS) => T);\n\n/**\n * Resolve functions and replaceable values as values\n * @param source - Value types that can be replaced with functions\n * @param args - List of arguments required by the function\n * @returns Resolved Value\n */\nexport function resolveFunctionableValue<T, ARGS extends any[]>(\n  source: FunctionableValue<T, ARGS>,\n  ...args: ARGS\n): T extends Function ? never : T {\n  return typeof source === 'function' ? source(...args) : (source as any);\n}\n\n/**\n * Generate a resolver function to resolve values that can be replaced with functions\n * @param args - List of arguments required by the function\n * @returns Resolver function\n */\nresolveFunctionableValue.build = function build<ARGS extends any[]>(\n  ...args: ARGS\n): <T>(source: FunctionableValue<T, ARGS>) => T extends Function ? never : T {\n  return (source) => resolveFunctionableValue(source, ...args);\n};\n","/**\n * Returns an integer of the given value\n *\n * @param value - Numbers or their strings\n * @returns Integer\n */\nexport function toInt(value: string | number): number {\n  return typeof value === 'number' ? Math.trunc(value) : parseInt(value, 10);\n}\n\n/**\n * Returns a floating-point value of the given value\n *\n * @param value - Numbers or their strings\n * @returns floating-point value\n */\nexport function toFloat(value: string | number): number {\n  return typeof value === 'number' ? value : parseFloat(value);\n}\n\n/**\n * Returns the specified value normalized to number\n *\n * @param value - Numbers or their strings\n * @returns number\n */\nexport function toNumber(source: any): number {\n  return typeof source === 'number' ? source : Number(source);\n}\n","/**\n * Obtains a Promise instance that will be resolved after the specified time\n * @param milliseconds - Delay time(millisecond)\n * @returns Promise Instance\n */\nexport function delay(milliseconds: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, milliseconds));\n}\n","/**\n * Verify that the specified value is an object compatible with Promise\n *\n * @param source - Value to be tested\n * @returns `true` if compatible with Promise\n */\nexport function isPromise<T = any>(obj: any): obj is Promise<T> {\n  return (\n    !!obj &&\n    (typeof obj === 'object' || typeof obj === 'function') &&\n    typeof obj.then === 'function'\n  );\n}\n","/** Checks if value is string */\nexport function isString(source: unknown): source is string {\n  return typeof source === 'string' || source instanceof String;\n}\n\n/** Escapes empty-like values (`null`, `undefined`) to empty string */\nexport function nilToEmptyString(source?: string | null): string {\n  return source == null ? '' : source;\n}\n\nconst FULL_WIDTH_SYMBOL_RE = /[！-～]/g;\n\nconst FULL_WIDTH_SPACE_RE = /　/g;\n\nconst REMOVE_SPACE_RE = /[\\s\\t]/g;\n\n/**\n * Remove all spaces and tab characters\n *\n * @param source - String to be converted\n * @returns A string with spaces removed.\n */\nexport const removeSpace = (source: string | null | undefined): string =>\n  nilToEmptyString(source).replace(REMOVE_SPACE_RE, '');\n\n/**\n * Convert string to lowercase\n *\n * The target includes full-width alphanumeric characters, symbols, and whitespace characters.\n *\n * @param source - String to be converted\n * @returns Converted string\n */\nexport function toHalfWidth(source: string | null | undefined) {\n  return nilToEmptyString(source)\n    .replace(FULL_WIDTH_SYMBOL_RE, (_source) =>\n      String.fromCharCode(_source.charCodeAt(0) - 0xfee0),\n    )\n    .replace(FULL_WIDTH_SPACE_RE, ' ');\n}\n\n/**\n * Convert all consecutive spaces to single space\n * @param source - String to be converted\n * @returns Converted string\n */\nexport function toSingleSpace(source: string | null | undefined) {\n  return nilToEmptyString(source).replace(/([\\s]+)/g, (m) => m.charAt(0));\n}\n\n/**\n * Obtains a string with the first letter of the specified string capitalized\n *\n * - `\"helloWorld\"` -&gt; `\"HelloWorld\"`\n *\n * @param str - String of conversion source\n * @returns String with first letter converted to uppercase\n */\nexport function capitalize<T extends string>(str: T): Capitalize<T> {\n  return (str.charAt(0).toUpperCase() + str.slice(1)) as Capitalize<T>;\n}\n\n/**\n * Obtains a string with the first letter of the specified string in lowercase.\n *\n * - `\"HelloWorld\"` -&gt; `\"helloWorld\"`\n *\n * @param str - String of conversion source\n * @returns String with first letter converted to lowercase\n */\nexport function uncapitalize<T extends string>(str: T): Uncapitalize<T> {\n  return (str.charAt(0).toLowerCase() + str.slice(1)) as Uncapitalize<T>;\n}\n\nconst INDENT_MATCH_RE = /^[ \\t]*(?=\\S)/gm;\n\n/**\n * Ignore blank lines and get the number of indent characters in the line with the lowest number of leading spaces\n *\n * @param str - String to get indentation\n * @returns Minimum indent character count\n */\nexport function minIndent(str: string): number {\n  const match = str.match(INDENT_MATCH_RE);\n\n  if (!match) {\n    return 0;\n  }\n\n  return match.reduce((r, a) => Math.min(r, a.length), Infinity);\n}\n\nconst STRIP_INDENT_UNNECESSARY_LINE_MATCH_RE = /(^\\n+|\\n\\s+$)/g;\n\n/**\n * Obtain a string with the minimum number of indent characters removed\n *\n * @remarks This method trims unnecessary lines (newlines, whitespace only) before and after. This process can be disabled with `retainUnnecessaryLines`\n *\n * @param str - String to remove indentation\n * @param retainUnnecessaryLines - Retain unnecessary lines\n * @returns String with normalized indentation\n */\nexport function stripIndent(\n  str: string,\n  retainUnnecessaryLines?: boolean,\n): string {\n  if (!retainUnnecessaryLines) {\n    str = str.replace(STRIP_INDENT_UNNECESSARY_LINE_MATCH_RE, '');\n  }\n\n  const indent = minIndent(str);\n\n  if (indent === 0) {\n    return str;\n  }\n\n  const regex = new RegExp(`^[ \\\\t]{${indent}}`, 'gm');\n\n  return str.replace(regex, '');\n}\n\n/**\n * Converts a string to camelCase.\n *\n * @param str - Any input string\n * @returns The string converted to camelCase\n */\nexport function toCamelCase(str: string): string {\n  return str\n    .toLowerCase()\n    .replace(/[^a-z0-9]+(.)/g, (_, chr) => chr.toUpperCase());\n}\n\n/**\n * Converts a string to kebab-case (hyphen-separated lowercase)\n *\n * @param str - Any input string\n * @returns The string converted to kebab-case\n */\nexport function toKebabCase(str: string): string {\n  return (\n    str\n      // Convert camelCase to hyphen-separated\n      .replace(/([a-z0-9])([A-Z])/g, '$1-$2')\n      // Replace spaces and underscores with hyphens\n      .replace(/[\\s_]+/g, '-')\n      // Convert the entire string to lowercase\n      .toLowerCase()\n  );\n}\n","const HAS_SET = typeof Set !== 'undefined';\n\n/**\n * Checks if the given value is a `Set` instance\n * @param source - Value to be tested\n * @returns `true` if it is an instance of `Set`.\n */\nexport function isSet<T>(source: unknown): source is Set<T> {\n  return HAS_SET && source instanceof Set;\n}\n","const HAS_MAP = typeof Map !== 'undefined';\n\n/**\n * Checks if the given value is a `Map` instance\n * @param source - Value to be tested\n * @returns `true` if it is an instance of `Map`.\n */\nexport function isMap<K, V>(source: unknown): source is Map<K, V> {\n  return HAS_MAP && source instanceof Map;\n}\n","/** Escapes regular expression control chars */\nexport function escapeRegExp(str: string): string {\n  return str.replace(/([.*+?^=!:${}()|[\\]/\\\\])/g, '\\\\$1');\n}\n","import { RecursiveArray } from '@fastkit/ts-type-utils';\n\n/**\n * Converting a recursive array to a flat array\n *\n * @param source - Recursive Arrays\n * @returns - Flattened array\n */\nexport function flattenRecursiveArray<T>(source: RecursiveArray<T>): T[] {\n  const results: T[] = [];\n  if (!Array.isArray(source)) {\n    results.push(source);\n  } else {\n    for (const row of source) {\n      results.push(...flattenRecursiveArray(row));\n    }\n  }\n  return results;\n}\n\n/**\n * Remove any element from an array\n *\n * @mutable\n *\n * @param array - Array\n * @param entry - Element to be deleted\n */\nexport function arrayRemove<T>(array: T[], entry: T) {\n  const index = array.indexOf(entry);\n  if (index !== -1) {\n    array.splice(index, 1);\n  }\n}\n\n/**\n * Generate a range array with a specified number of ranges\n *\n * @param length - number of elements\n * @param offset - starting value\n * @returns range array\n */\nexport function range(length: number, offset = 0): number[] {\n  return Array.from(Array(length), (v, k) => k + offset);\n}\n\n/**\n * Obtain a unique array with duplicate values removed from the specified array\n *\n * @param array - Array\n * @returns Array with duplicates removed\n */\nexport function arrayUnique<T>(array: T[]): T[] {\n  return Array.from(new Set(array));\n}\n","import { arrayUnique } from './array';\n\n/**\n * Checks if the specified variable is a not Nullable.\n *\n * @param value - Variables to be examined\n *\n * @returns\n *  - `null` -&gt; `false`\n *  - `undefined` -&gt; `false`\n *  - `0` -&gt; `true`\n *  - `1` -&gt; `true`\n *  - `\"\"` -&gt; `true`\n *  - `\"0\"` -&gt; `true`\n *  - `{}` -&gt; `true`\n *  - `[]` -&gt; `true`\n */\nexport function inNonNullable<T>(\n  value: T,\n): value is Exclude<T, null | undefined> {\n  return value != null;\n}\n\n/**\n * Checks if the specified variable is a NonNull object.\n *\n * @param value - Variables to be examined\n *\n * @returns\n *  - `null` -&gt; `false`\n *  - `1` -&gt; `false`\n *  - `\"1\"` -&gt; `false`\n *  - `{}` -&gt; `true`\n *  - `[]` -&gt; `true`\n *  - `new Date()` -&gt; `true`\n *  - `new RegExp()` -&gt; `true`\n *  - `new SomeClass()` -&gt; `true`\n */\nexport function isNonNullObject<\n  T extends Record<string, unknown> = Record<string, unknown>,\n>(value: unknown): value is T {\n  return !!value && typeof value === 'object';\n}\n\n/**\n * Checks if the specified variable is a derived instance of the `Object` class.\n *\n * @param value - Variables to be examined\n * @returns\n *  - `null` -&gt; `false`\n *  - `1` -&gt; `false`\n *  - `\"1\"` -&gt; `false`\n *  - `{}` -&gt; `true`\n *  - `[]` -&gt; `false`\n *  - `new Date()` -&gt; `false`\n *  - `new RegExp()` -&gt; `false`\n *  - `new SomeClass()` -&gt; `true`\n *  - `new (class SomeClass extends ParentClass {})()` -&gt; `true`\n *  - `new (class SomeClass extends Array {})()` -&gt; `false`\n */\nexport function isObject<\n  T extends Record<string, unknown> = Record<string, unknown>,\n>(value: unknown): value is T {\n  return Object.prototype.toString.call(value) === '[object Object]';\n}\n\n/**\n * Checks if the specified variable is a direct instance of the `Object` class.\n *\n * @param value - Variables to be examined\n * @returns\n *  - `null` -&gt; `false`\n *  - `1` -&gt; `false`\n *  - `\"1\"` -&gt; `false`\n *  - `{}` -&gt; `true`\n *  - `[]` -&gt; `false`\n *  - `new Date()` -&gt; `false`\n *  - `new RegExp()` -&gt; `false`\n *  - `new SomeClass()` -&gt; `false`\n */\nexport function isPlainObject<\n  T extends Record<string, unknown> = Record<string, unknown>,\n>(value: unknown): value is T {\n  if (!isObject(value)) return false;\n\n  // If has modified constructor\n  const ctor = value.constructor;\n  if (value.constructor === undefined) return true;\n\n  // If has modified prototype\n  const prot = ctor.prototype;\n  if (isObject(prot) === false) return false;\n\n  // If constructor does not have an Object-specific method\n\n  if (prot.hasOwnProperty('isPrototypeOf') === false) {\n    return false;\n  }\n\n  // Most likely a plain Object\n  return true;\n}\n\n// cloned from https://github.com/epoberezkin/fast-deep-equal with small changes\nexport function objectIncludes(b: any, a: any): boolean {\n  if (a === b) return true;\n\n  const arrA = Array.isArray(a);\n  const arrB = Array.isArray(b);\n  let i: number;\n\n  if (arrA && arrB) {\n    if (a.length != b.length) return false;\n    for (i = 0; i < a.length; i++)\n      if (!objectIncludes(a[i], b[i])) return false;\n    return true;\n  }\n\n  if (arrA != arrB) return false;\n\n  if (a && b && typeof a === 'object' && typeof b === 'object') {\n    const dateA = a instanceof Date;\n    const dateB = b instanceof Date;\n\n    if (dateA && dateB) return a.getTime() == b.getTime();\n\n    if (dateA != dateB) return false;\n\n    const regexpA = a instanceof RegExp;\n    const regexpB = b instanceof RegExp;\n\n    if (regexpA && regexpB) return a.toString() == b.toString();\n\n    if (regexpA != regexpB) return false;\n\n    const keys = Object.keys(a);\n    // if (keys.length !== Object.keys(b).length) return false;\n\n    for (i = 0; i < keys.length; i++)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = 0; i < keys.length; i++)\n      if (!objectIncludes(b[keys[i]], a[keys[i]])) return false;\n\n    return true;\n  }\n  if (a && b && typeof a === 'function' && typeof b === 'function') {\n    return a.toString() === b.toString();\n  }\n\n  return false;\n}\n\n/**\n * Returns `true` if it is a iterable object\n * */\nexport function isIterableObject<T = any>(source?: any): source is Iterable<T> {\n  return (\n    Array.isArray(source) ||\n    (source &&\n      typeof source === 'object' &&\n      source.constructor.name === 'Object') ||\n    false\n  );\n}\n\n/**\n * @see https://github.com/vuejs/vue-router/blob/c69ff7bd60228fb79acd764c3fdae91015a49103/src/util/route.js#L96\n */\n\nexport function isObjectEqual<T>(a: T = {} as T, b: unknown): b is T {\n  // handle null value #1566\n  if (!a || !b) return a === b;\n  if (!isObject(b)) return false;\n  const aKeys = Object.keys(a as any);\n  const bKeys = Object.keys(b);\n  if (aKeys.length !== bKeys.length) {\n    return false;\n  }\n  return aKeys.every((key) => {\n    const aVal = (a as any)[key];\n    const bVal = b[key];\n    // query values can be null and undefined\n    if (aVal == null || bVal == null) return aVal === bVal;\n    // check nested equality\n    if (typeof aVal === 'object' && typeof bVal === 'object') {\n      return isObjectEqual(aVal, bVal);\n    }\n    return String(aVal) === String(bVal);\n  });\n}\n\nexport function objectFromArray<R, K extends string | number | symbol, T>(\n  rows: R[] | readonly R[],\n  cb: (row: R, index: number) => [K, T],\n): Record<K, T> {\n  const entries = new Map(rows.map((row, index) => cb(row, index)));\n  return Object.fromEntries(entries) as Record<K, T>;\n}\n\nobjectFromArray.build =\n  <R, T>(rows: R[] | readonly R[]) =>\n  <K extends string | number | symbol, T>(\n    cb: (row: R, index: number) => [K, T],\n  ) =>\n    objectFromArray(rows, cb);\n\n/**\n * To obtain an object with all undefined properties completely removed from the specified object.\n *\n * @param obj - object\n * @param deep - Recursively delete undefined properties\n * @returns Objects with undefined properties already deleted\n */\nexport function removeUndef<T extends Record<string, any>>(\n  obj: T,\n  deep = false,\n): T {\n  return Object.keys(obj).reduce((result, key) => {\n    let value: any = obj[key];\n    if (value !== undefined) {\n      if (deep && value && typeof value === 'object') {\n        value = removeUndef(value, true);\n      }\n      (result as any)[key] = value;\n    }\n    return result;\n  }, {}) as T;\n}\n\nexport function mapFromObjectArray<\n  T extends Record<keyof any, any>,\n  K extends keyof T,\n>(array: T[], key: K): Record<T[K], T> {\n  return array.reduce(\n    (prev, current) => {\n      prev[current[key]] = current;\n      return prev;\n    },\n    {} as Record<T[K], T>,\n  );\n}\n\n/**\n * To obtain a new object that extracts properties corresponding to specified keys from the given object\n *\n * @param obj - Source object for extraction\n * @param props - List of property names to extract\n * @param includesUndefined - Extract `undefined` values as well?\n * @returns Extracted objects\n */\nexport function pickProperties<\n  T extends Record<keyof any, any>,\n  K extends keyof T,\n>(obj: T, props: K[], includesUndefined?: boolean): Pick<T, K> {\n  const results = {} as Pick<T, K>;\n  for (const prop of props) {\n    const value = obj[prop];\n    if (includesUndefined || value !== undefined) {\n      results[prop] = value;\n    }\n  }\n  return results;\n}\n\n/**\n * Retrieve a new object by removing the property corresponding to the specified key from the given object\n *\n * @param obj - Source object\n * @param props - List of property names to be removed\n * @param excludeUndefined - After performing the removal, further undefined properties can be removed or\n * @returns Objects with specified properties already removed\n */\nexport function omitProperties<\n  T extends Record<keyof any, any>,\n  K extends keyof T,\n>(obj: T, props: K[], excludeUndefined?: boolean): Omit<T, K> {\n  const results = {\n    ...obj,\n  } as Omit<T, K>;\n  for (const prop of props) {\n    delete (results as any)[prop];\n  }\n  return excludeUndefined ? removeUndef(results) : results;\n}\n\nexport type Mixin<T extends object, U extends object> = Omit<T, keyof U> & U;\n\n/**\n * Returns a Proxy instance that mixes in the specified trait object for the given base object\n *\n * @param base - Base object\n * @param trait - trait object\n * @returns Mixed-in Proxy\n */\nexport function mixin<T extends object, U extends object>(\n  base: T,\n  trait: U,\n): Mixin<T, U> {\n  const proxy = new Proxy(base, {\n    get: (_target, propertyKey, receiver) => {\n      const target = Reflect.has(trait, propertyKey) ? trait : _target;\n      return Reflect.get(target, propertyKey, receiver);\n    },\n    set: (_target, propertyKey, newValue, receiver) => {\n      const target = Reflect.has(trait, propertyKey) ? trait : _target;\n      return Reflect.set(target, propertyKey, newValue, receiver);\n    },\n    has: (target, propertyKey) =>\n      Reflect.has(trait, propertyKey) || Reflect.has(target, propertyKey),\n    ownKeys: (target) =>\n      arrayUnique([...Reflect.ownKeys(target), ...Reflect.ownKeys(trait)]),\n    getOwnPropertyDescriptor: (target, propertyKey) =>\n      Reflect.getOwnPropertyDescriptor(trait, propertyKey) ||\n      Reflect.getOwnPropertyDescriptor(base, propertyKey),\n  }) as any;\n  return proxy;\n}\n\ntype UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never;\n\nexport type Mixins<T extends object, R> =\n  R extends Array<infer U>\n    ? Mixins<T, UnionToIntersection<U>>\n    : R extends object\n      ? Mixin<T, R>\n      : never;\n\n/**\n * Obtain a Proxy instance mixed with multiple objects as mixins.\n *\n * @param base - Base object\n * @param traits - trait objects\n * @returns Mixed-in Proxy\n */\nexport function mixins<T extends object, R extends object[]>(\n  base: T,\n  ...traits: R\n): Mixins<T, R> {\n  const targets = [base, ...traits].reverse();\n  const proxy = new Proxy(base, {\n    get: (_target, propertyKey, receiver) => {\n      const target =\n        targets.find((t) => Reflect.has(t, propertyKey)) || _target;\n      return Reflect.get(target, propertyKey, receiver);\n    },\n    set: (_target, propertyKey, newValue, receiver) => {\n      const target =\n        targets.find((t) => Reflect.has(t, propertyKey)) || _target;\n      return Reflect.set(target, propertyKey, newValue, receiver);\n    },\n    has: (_target, propertyKey) =>\n      targets.some((target) => Reflect.has(target, propertyKey)),\n    ownKeys: (_target) =>\n      arrayUnique(targets.map((target) => Reflect.ownKeys(target)).flat()),\n    getOwnPropertyDescriptor: (_target, propertyKey) => {\n      for (const target of targets) {\n        const descriptor = Reflect.getOwnPropertyDescriptor(\n          target,\n          propertyKey,\n        );\n        if (descriptor) return descriptor;\n      }\n    },\n  }) as any;\n  return proxy;\n}\n","import { IN_WINDOW } from './runtime-flags';\n\nlet _currentId = 0;\n\nconst _getNextId = (): number => {\n  _currentId++;\n  if (_currentId > Number.MAX_SAFE_INTEGER) {\n    _currentId = 1;\n  }\n  return _currentId;\n};\n\nconst _cache = new WeakMap<WeakKey, number>();\n\n/**\n * Retrieve a temporary ID for a given object reference.\n *\n * This function creates an ID that corresponds to a given object reference.\n * The ID is not guaranteed to be globally unique and may have duplicates if\n * a large number of IDs are generated within a single process.\n *\n * @param obj - The object for which the temporary ID is generated.\n * @param onlyClient - If `true` is specified, it will return undefined in the server environment.\n * @returns A temporary ID corresponding to the object reference.\n */\nexport function temporaryObjectID<OnlyClient extends boolean = false>(\n  obj: WeakKey,\n  onlyClient?: OnlyClient,\n): OnlyClient extends true ? number | undefined : number {\n  if (onlyClient && !IN_WINDOW) return undefined as any;\n\n  let id = _cache.get(obj);\n  if (id === undefined) {\n    id = _getNextId();\n    _cache.set(obj, id);\n  }\n  return id;\n}\n","/** Does the Buffer class exist in the Global space? */\nconst HAS_BUFFER = typeof Buffer !== 'undefined';\n\n/** Does the ArrayBuffer class exist in the Global space? */\nconst HAS_ARRAY_BUFFER = typeof ArrayBuffer !== 'undefined';\n\n/**\n * Check if the argument value is a Buffer instance\n * @param source - Value to be checked\n * @returns true if it is a Buffer instance\n */\nexport function isBuffer(source: unknown): source is Buffer {\n  return HAS_BUFFER && source instanceof Buffer;\n}\n\n/**\n * Check if the argument value is a ArrayBufferView instance\n * @param source - Value to be checked\n * @returns true if it is a ArrayBufferView instance\n */\nexport function isArrayBufferView(source: unknown): source is ArrayBufferView {\n  return HAS_ARRAY_BUFFER && ArrayBuffer.isView(source);\n}\n\n/**\n * Buffer, and duplicate the ArrayBufferView to get a new Buffer\n * @param cur - Buffer from which to duplicate\n * @returns Copied buffer\n */\nexport function copyBuffer(cur: Buffer | ArrayBufferView): Buffer {\n  if (isBuffer(cur)) {\n    return Buffer.from(cur as unknown as ArrayBuffer);\n  }\n  return Buffer.from(cur.buffer.slice(0), cur.byteOffset, cur.byteLength);\n}\n","/**\n * Type of value that can be a source value to create a Date instance.\n */\nexport type DateSource = number | string | Date;\n\n/**\n * Date, or get epoch milliseconds from its source value\n * @param source - {@link DateSource Date source}\n * @returns epoch millisecond\n */\nexport function safeGetTimeByDateSource(source: DateSource) {\n  if (typeof source === 'number') return source;\n  if (typeof source === 'string') {\n    source = new Date(source);\n  }\n  return source.getTime();\n}\n\n/**\n * Date, or normalize its source value to Date\n * @param source - {@link DateSource Date source}\n * @returns Date Instance\n */\nexport function toDate(source: number | string | Date): Date {\n  return source instanceof Date ? source : new Date(source);\n}\n\n/**\n * List of date input precision\n */\nexport const DATE_INPUT_PRECISIONS = [\n  'month',\n  'date',\n  'datetime-local',\n] as const;\n\n/**\n * Date input precision\n * @see {@link DATE_INPUT_PRECISIONS}\n */\nexport type DateInputPrecision = (typeof DATE_INPUT_PRECISIONS)[number];\n\nexport const DATE_INPUT_PARSE_RE =\n  /^(\\d{4})-(\\d{2})(-(\\d{2})(T(\\d{2}):(\\d{2}))?)?$/;\n\n/**\n * Date input parse results\n */\nexport type ParseDateInputResult =\n  | {\n      precision: 'datetime-local';\n      year: string;\n      month: string;\n      date: string;\n      hours: string;\n      minutes: string;\n      source: string;\n    }\n  | {\n      precision: 'date';\n      year: string;\n      month: string;\n      date: string;\n      hours?: undefined;\n      minutes?: undefined;\n      source: string;\n    }\n  | {\n      precision: 'month';\n      year: string;\n      month: string;\n      date?: undefined;\n      hours?: undefined;\n      minutes?: undefined;\n      source: string;\n    };\n\n/**\n * Parse a date/time string to obtain individual values\n *\n * @param source - {@link DATE_INPUT_PARSE_RE ISO 8601-like date/time string}\n * @returns Date input parse results (null if not parsed)\n *\n * @see {@link ParseDateInputResult}\n */\nexport function parseDateInput(source: string): ParseDateInputResult | null {\n  let result: ParseDateInputResult | null = null;\n  const matched = source.match(DATE_INPUT_PARSE_RE);\n  if (matched) {\n    const year = matched[1];\n    const month = matched[2];\n    const date = matched[4];\n    const hours = matched[6];\n    const minutes = matched[7];\n    if (hours && minutes) {\n      result = {\n        precision: 'datetime-local',\n        year,\n        month,\n        date,\n        hours,\n        minutes,\n        source,\n      };\n    } else if (date) {\n      result = {\n        precision: 'date',\n        year,\n        month,\n        date,\n        source,\n      };\n    } else if (year && month) {\n      result = {\n        precision: 'month',\n        year,\n        month,\n        source,\n      };\n    }\n  }\n  return result;\n}\n","/**\n * Checks if the specified value is empty-like\n *\n * - For arrays, check length\n * - `false`, `null`, `undefined`, `\"\"` is considered value is empty\n */\nexport function isEmpty(value: any): boolean {\n  if (typeof value === 'function') return false;\n  return value == null || value === false || value.length === 0;\n}\n\n/**\n * Get the first non-empty-like value from the specified array\n *\n * @param args - Array to be searched\n */\nexport function notEmptyValue<T>(args: T[]): NonNullable<T> | undefined;\n\n/**\n * Get the first non-empty-like value from the specified array\n * @param args - Array to be searched\n * @param defaultValue - Default value if value not found\n */\nexport function notEmptyValue<T>(\n  args: T[],\n  defaultValue: NonNullable<T>,\n): NonNullable<T>;\n\nexport function notEmptyValue<T>(args: T[], defaultValue?: NonNullable<T>) {\n  for (const arg of args) {\n    if (!isEmpty(arg)) {\n      return arg;\n    }\n  }\n  return defaultValue;\n}\n","import { WritableKeysOf } from '@fastkit/ts-type-utils';\nimport { isNonNullObject } from './object';\n\ninterface AnyObject {\n  [key: string | number | symbol]: any;\n}\n\nexport type DefaultsSchemeSource<V> =\n  V extends Array<infer U>\n    ? U extends AnyObject\n      ? | [DefaultsScheme<U>]\n        | [DefaultsScheme<U>, (notObject: unknown) => Partial<U> | void]\n      : [() => U[]]\n    : V extends AnyObject\n      ? DefaultsScheme<V>\n      : () => V;\n\nexport type DefaultsScheme<T> = {\n  [K in WritableKeysOf<T>]?: DefaultsSchemeSource<T[K]>;\n};\n\nexport const MERGE_DEFAULTS_INDEX_SIGNATURE_SYMBOL = Symbol(\n  'MERGE_DEFAULTS_INDEX_SIGNATURE',\n);\n\nfunction getIndexSignatureScheme(\n  scheme: unknown,\n): DefaultsSchemeSource<any> | undefined {\n  if (!scheme || Array.isArray(scheme) || typeof scheme !== 'object') {\n    return;\n  }\n\n  const symbols = Object.getOwnPropertySymbols(scheme);\n  if (symbols.some((s) => s === MERGE_DEFAULTS_INDEX_SIGNATURE_SYMBOL)) {\n    return (scheme as any)[MERGE_DEFAULTS_INDEX_SIGNATURE_SYMBOL];\n  }\n}\n\nexport function createIndexSignatureDefaultsScheme<T>(\n  scheme: DefaultsSchemeSource<T>,\n) {\n  return {\n    [MERGE_DEFAULTS_INDEX_SIGNATURE_SYMBOL]: scheme,\n  };\n}\n\nexport function mergeDefaults<T>(base: T, scheme: DefaultsScheme<T>): T {\n  const indexSignatureScheme = getIndexSignatureScheme(scheme);\n  if (indexSignatureScheme) {\n    const baseKeys = Object.keys(base as any); // @FIXME\n    const _scheme: any = {};\n    baseKeys.forEach((key) => {\n      _scheme[key] = indexSignatureScheme;\n    });\n    return mergeDefaults(base, _scheme as any);\n  }\n\n  const keys = Object.keys(scheme) as (keyof T)[];\n  for (const key of keys) {\n    const source = (scheme as any)[key];\n    if (!source) {\n      continue;\n    }\n    if (typeof source === 'function') {\n      if (base[key] === undefined) {\n        base[key] = source() as T[typeof key];\n      }\n    } else if (Array.isArray(source)) {\n      const schemeOrFn = source[0] as DefaultsScheme<any> | (() => any);\n      if (!base[key] || !Array.isArray(base[key])) {\n        base[key] = [] as any;\n      }\n\n      const bucket = base[key] as unknown as any[];\n\n      if (typeof schemeOrFn === 'function' && !bucket.length) {\n        bucket.push(...schemeOrFn());\n      }\n\n      if (typeof schemeOrFn === 'object') {\n        const fallbackFn = (source as any)[1] as unknown as\n          ((notObject: unknown) => any) | undefined;\n        const newItems: any[] = [];\n        bucket.forEach((row) => {\n          if (!row || typeof row !== 'object') {\n            if (fallbackFn) {\n              row = fallbackFn(row);\n              if (row === undefined) {\n                return;\n              }\n            } else {\n              return;\n            }\n          }\n          newItems.push(mergeDefaults(row, schemeOrFn));\n        });\n        base[key] = newItems as any;\n      }\n    } else {\n      if (!isNonNullObject(base[key])) {\n        base[key] = {} as any;\n      }\n      base[key] = mergeDefaults(base[key], source as any);\n    }\n  }\n  return base;\n}\n"],"mappings":"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"}