@vielzeug/toolkit 1.0.12 → 1.0.14

package/dist/object/parseJSON.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parseJSON.cjs","sources":["../../src/object/parseJSON.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { isNil } from '../typed/isNil';\nimport { isString } from '../typed/isString';\n\ntype JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };\n\ninterface ParseJSONOptions<T> {\n  defaultValue?: T;\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  reviver?: (key: string, value: any) => any;\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  validator?: (value: any) => boolean;\n  silent?: boolean;\n}\n\n/**\n * Parses a JSON string and returns the resulting object.\n *\n * @example\n * ```ts\n * const json = '{\"a\":1,\"b\":2,\"c\":3}';\n * const result = parseJSON<Record<string, number>>(json, {\n *   defaultValue: { a: 0, b: 0, c: 0 },\n *   validator: (value) => Object.values(value).every(v => typeof v === 'number'),\n *   errorHandler: (err) => console.warn('Parsing failed:', err.message),\n *   silent: true\n * });\n * console.log(result); // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @template T - The expected type of the parsed JSON.\n * @param json - The JSON string to parse. If not a string, it is returned as is.\n * @param options - Configuration options for parsing.\n *\n * @returns The parsed object if successful, otherwise the default value.\n */\nexport function parseJSON<T extends JSONValue>(json: unknown, options: ParseJSONOptions<T> = {}): T | undefined {\n  const { defaultValue, reviver, validator, silent = false } = options;\n\n  if (!isString(json)) return isNil(json) ? defaultValue : (json as T);\n\n  try {\n    const parsed = JSON.parse(json as string, reviver);\n\n    if (validator && !validator(parsed)) {\n      throw new TypeError('Parsed JSON does not match the expected structure');\n    }\n\n    return parsed ?? defaultValue;\n  } catch (err) {\n    if (!silent) {\n      Logit.error('parseJSON() -> failed to parse object', err);\n    }\n\n    return defaultValue;\n  }\n}\n"],"names":["parseJSON","json","options","defaultValue","reviver","validator","silent","isString","isNil","parsed","err","Logit"],"mappings":"8LAoCO,SAASA,EAA+BC,EAAeC,EAA+B,GAAmB,CAC9G,KAAM,CAAE,aAAAC,EAAc,QAAAC,EAAS,UAAAC,EAAW,OAAAC,EAAS,IAAUJ,EAE7D,GAAI,CAACK,EAAAA,SAASN,CAAI,SAAUO,EAAAA,MAAMP,CAAI,EAAIE,EAAgBF,EAE1D,GAAI,CACF,MAAMQ,EAAS,KAAK,MAAMR,EAAgBG,CAAO,EAEjD,GAAIC,GAAa,CAACA,EAAUI,CAAM,EAChC,MAAM,IAAI,UAAU,mDAAmD,EAGzE,OAAOA,GAAUN,CACnB,OAASO,EAAK,CACZ,OAAKJ,GACHK,QAAM,MAAM,wCAAyCD,CAAG,EAGnDP,CACT,CACF"}
+{"version":3,"file":"parseJSON.cjs","sources":["../../src/object/parseJSON.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { isNil } from '../typed/isNil';\nimport { isString } from '../typed/isString';\n\ntype JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };\n\n// #region ParseJSONOptions\ntype ParseJSONOptions<T> = {\n  defaultValue?: T;\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  reviver?: (key: string, value: any) => any;\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  validator?: (value: any) => boolean;\n  silent?: boolean;\n};\n// #endregion ParseJSONOptions\n\n/**\n * Parses a JSON string and returns the resulting object.\n *\n * @example\n * ```ts\n * const json = '{\"a\":1,\"b\":2,\"c\":3}';\n * const result = parseJSON<Record<string, number>>(json, {\n *   defaultValue: { a: 0, b: 0, c: 0 },\n *   validator: (value) => Object.values(value).every(v => typeof v === 'number'),\n *   errorHandler: (err) => console.warn('Parsing failed:', err.message),\n *   silent: true\n * });\n * console.log(result); // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @template T - The expected type of the parsed JSON.\n * @param json - The JSON string to parse. If not a string, it is returned as is.\n * @param options - Configuration options for parsing.\n *\n * @returns The parsed object if successful, otherwise the default value.\n */\nexport function parseJSON<T extends JSONValue>(json: unknown, options: ParseJSONOptions<T> = {}): T | undefined {\n  const { defaultValue, reviver, validator, silent = false } = options;\n\n  if (!isString(json)) return isNil(json) ? defaultValue : (json as T);\n\n  try {\n    const parsed = JSON.parse(json as string, reviver);\n\n    if (validator && !validator(parsed)) {\n      throw new TypeError('Parsed JSON does not match the expected structure');\n    }\n\n    return parsed ?? defaultValue;\n  } catch (err) {\n    if (!silent) {\n      Logit.error('parseJSON() -> failed to parse object', err);\n    }\n\n    return defaultValue;\n  }\n}\n"],"names":["parseJSON","json","options","defaultValue","reviver","validator","silent","isString","isNil","parsed","err","Logit"],"mappings":"8LAsCO,SAASA,EAA+BC,EAAeC,EAA+B,GAAmB,CAC9G,KAAM,CAAE,aAAAC,EAAc,QAAAC,EAAS,UAAAC,EAAW,OAAAC,EAAS,IAAUJ,EAE7D,GAAI,CAACK,EAAAA,SAASN,CAAI,SAAUO,EAAAA,MAAMP,CAAI,EAAIE,EAAgBF,EAE1D,GAAI,CACF,MAAMQ,EAAS,KAAK,MAAMR,EAAgBG,CAAO,EAEjD,GAAIC,GAAa,CAACA,EAAUI,CAAM,EAChC,MAAM,IAAI,UAAU,mDAAmD,EAGzE,OAAOA,GAAUN,CACnB,OAASO,EAAK,CACZ,OAAKJ,GACHK,QAAM,MAAM,wCAAyCD,CAAG,EAGnDP,CACT,CACF"}

package/dist/object/parseJSON.js.map

@@ -1 +1 @@
-{"version":3,"file":"parseJSON.js","sources":["../../src/object/parseJSON.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { isNil } from '../typed/isNil';\nimport { isString } from '../typed/isString';\n\ntype JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };\n\ninterface ParseJSONOptions<T> {\n  defaultValue?: T;\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  reviver?: (key: string, value: any) => any;\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  validator?: (value: any) => boolean;\n  silent?: boolean;\n}\n\n/**\n * Parses a JSON string and returns the resulting object.\n *\n * @example\n * ```ts\n * const json = '{\"a\":1,\"b\":2,\"c\":3}';\n * const result = parseJSON<Record<string, number>>(json, {\n *   defaultValue: { a: 0, b: 0, c: 0 },\n *   validator: (value) => Object.values(value).every(v => typeof v === 'number'),\n *   errorHandler: (err) => console.warn('Parsing failed:', err.message),\n *   silent: true\n * });\n * console.log(result); // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @template T - The expected type of the parsed JSON.\n * @param json - The JSON string to parse. If not a string, it is returned as is.\n * @param options - Configuration options for parsing.\n *\n * @returns The parsed object if successful, otherwise the default value.\n */\nexport function parseJSON<T extends JSONValue>(json: unknown, options: ParseJSONOptions<T> = {}): T | undefined {\n  const { defaultValue, reviver, validator, silent = false } = options;\n\n  if (!isString(json)) return isNil(json) ? defaultValue : (json as T);\n\n  try {\n    const parsed = JSON.parse(json as string, reviver);\n\n    if (validator && !validator(parsed)) {\n      throw new TypeError('Parsed JSON does not match the expected structure');\n    }\n\n    return parsed ?? defaultValue;\n  } catch (err) {\n    if (!silent) {\n      Logit.error('parseJSON() -> failed to parse object', err);\n    }\n\n    return defaultValue;\n  }\n}\n"],"names":["parseJSON","json","options","defaultValue","reviver","validator","silent","isString","isNil","parsed","err","Logit"],"mappings":";;;AAoCO,SAASA,EAA+BC,GAAeC,IAA+B,IAAmB;AAC9G,QAAM,EAAE,cAAAC,GAAc,SAAAC,GAAS,WAAAC,GAAW,QAAAC,IAAS,OAAUJ;AAE7D,MAAI,CAACK,EAASN,CAAI,UAAUO,EAAMP,CAAI,IAAIE,IAAgBF;AAE1D,MAAI;AACF,UAAMQ,IAAS,KAAK,MAAMR,GAAgBG,CAAO;AAEjD,QAAIC,KAAa,CAACA,EAAUI,CAAM;AAChC,YAAM,IAAI,UAAU,mDAAmD;AAGzE,WAAOA,KAAUN;AAAA,EACnB,SAASO,GAAK;AACZ,WAAKJ,KACHK,EAAM,MAAM,yCAAyCD,CAAG,GAGnDP;AAAA,EACT;AACF;"}
+{"version":3,"file":"parseJSON.js","sources":["../../src/object/parseJSON.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { isNil } from '../typed/isNil';\nimport { isString } from '../typed/isString';\n\ntype JSONValue = string | number | boolean | null | JSONValue[] | { [key: string]: JSONValue };\n\n// #region ParseJSONOptions\ntype ParseJSONOptions<T> = {\n  defaultValue?: T;\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  reviver?: (key: string, value: any) => any;\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  validator?: (value: any) => boolean;\n  silent?: boolean;\n};\n// #endregion ParseJSONOptions\n\n/**\n * Parses a JSON string and returns the resulting object.\n *\n * @example\n * ```ts\n * const json = '{\"a\":1,\"b\":2,\"c\":3}';\n * const result = parseJSON<Record<string, number>>(json, {\n *   defaultValue: { a: 0, b: 0, c: 0 },\n *   validator: (value) => Object.values(value).every(v => typeof v === 'number'),\n *   errorHandler: (err) => console.warn('Parsing failed:', err.message),\n *   silent: true\n * });\n * console.log(result); // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @template T - The expected type of the parsed JSON.\n * @param json - The JSON string to parse. If not a string, it is returned as is.\n * @param options - Configuration options for parsing.\n *\n * @returns The parsed object if successful, otherwise the default value.\n */\nexport function parseJSON<T extends JSONValue>(json: unknown, options: ParseJSONOptions<T> = {}): T | undefined {\n  const { defaultValue, reviver, validator, silent = false } = options;\n\n  if (!isString(json)) return isNil(json) ? defaultValue : (json as T);\n\n  try {\n    const parsed = JSON.parse(json as string, reviver);\n\n    if (validator && !validator(parsed)) {\n      throw new TypeError('Parsed JSON does not match the expected structure');\n    }\n\n    return parsed ?? defaultValue;\n  } catch (err) {\n    if (!silent) {\n      Logit.error('parseJSON() -> failed to parse object', err);\n    }\n\n    return defaultValue;\n  }\n}\n"],"names":["parseJSON","json","options","defaultValue","reviver","validator","silent","isString","isNil","parsed","err","Logit"],"mappings":";;;AAsCO,SAASA,EAA+BC,GAAeC,IAA+B,IAAmB;AAC9G,QAAM,EAAE,cAAAC,GAAc,SAAAC,GAAS,WAAAC,GAAW,QAAAC,IAAS,OAAUJ;AAE7D,MAAI,CAACK,EAASN,CAAI,UAAUO,EAAMP,CAAI,IAAIE,IAAgBF;AAE1D,MAAI;AACF,UAAMQ,IAAS,KAAK,MAAMR,GAAgBG,CAAO;AAEjD,QAAIC,KAAa,CAACA,EAAUI,CAAM;AAChC,YAAM,IAAI,UAAU,mDAAmD;AAGzE,WAAOA,KAAUN;AAAA,EACnB,SAASO,GAAK;AACZ,WAAKJ,KACHK,EAAM,MAAM,yCAAyCD,CAAG,GAGnDP;AAAA,EACT;AACF;"}

package/dist/object/path.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"path.cjs","sources":["../../src/object/path.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\nimport { IS_OBJECT_ERROR_MSG, isObject } from '../typed/isObject';\nimport type { Obj } from '../types';\n\ntype PathValue<T, P extends string> = P extends `${infer Key}.${infer Rest}`\n  ? Key extends keyof T\n    ? PathValue<T[Key], Rest>\n    : undefined\n  : P extends keyof T\n    ? T[P]\n    : undefined;\n\ntype PathOptions = {\n  throwOnMissing?: boolean;\n  allowArrayIndex?: boolean;\n};\n\n/**\n * Retrieves the value at a given path of the object. If the value is undefined, the default value is returned.\n *\n * @example\n * ```ts\n * const obj = { a: { b: { c: 3 } }, d: [1, 2, 3] };\n *\n * getValue(obj, 'a.b.c'); // 3\n * getValue(obj, 'a.b.d', 'default'); // 'default'\n * getValue(obj, 'd[1]', undefined, { allowArrayIndex: true }); // 2\n * getValue(obj, 'e.f.g', 'default', { throwOnMissing: true }); // throws Error\n * ```\n *\n * @template T - The type of the object to query.\n * @template P - The type of the path string.\n * @param item - The object to query.\n * @param path - The path of the property to get.\n * @param [defaultValue] - The value returned for undefined resolved values.\n * @param [options] - Additional options for value retrieval.\n *\n * @returns The resolved value.\n *\n * @throws If throwOnMissing is true and the path doesn't exist.\n */\nexport function path<T extends Obj, P extends string>(\n  item: T,\n  path: P,\n  defaultValue?: unknown,\n  options: PathOptions = {},\n): PathValue<T, P> | undefined {\n  assert(isObject(item), IS_OBJECT_ERROR_MSG, { args: { item }, type: TypeError });\n\n  const { throwOnMissing = false, allowArrayIndex = false } = options;\n\n  const fragments = path.split(/[.[\\]]+/).filter(Boolean);\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  let current: any = item;\n\n  for (const fragment of fragments) {\n    if (isNil(current) || typeof current !== 'object') {\n      return handleError(`Cannot read property '${fragment}' of ${current}`, throwOnMissing, defaultValue);\n    }\n\n    current =\n      allowArrayIndex && isArray(current) && /^\\d+$/.test(fragment) ? current[Number(fragment)] : current[fragment];\n\n    if (current === undefined) {\n      return handleError(`Property '${fragment}' does not exist`, throwOnMissing, defaultValue);\n    }\n  }\n\n  return current as PathValue<T, P>;\n}\n\nfunction handleError<T extends Obj, P extends string>(\n  message: string,\n  throwOnMissing: boolean,\n  defaultValue?: unknown,\n): PathValue<T, P> | undefined {\n  if (throwOnMissing) throw new Error(message);\n  return defaultValue as PathValue<T, P>;\n}\n"],"names":["path","item","defaultValue","options","assert","isObject","IS_OBJECT_ERROR_MSG","throwOnMissing","allowArrayIndex","fragments","current","fragment","isNil","handleError","isArray","message"],"mappings":"+NA2CO,SAASA,EACdC,EACAD,EACAE,EACAC,EAAuB,CAAA,EACM,CAC7BC,EAAAA,OAAOC,EAAAA,SAASJ,CAAI,EAAGK,sBAAqB,CAAE,KAAM,CAAE,KAAAL,CAAA,EAAQ,KAAM,UAAW,EAE/E,KAAM,CAAE,eAAAM,EAAiB,GAAO,gBAAAC,EAAkB,IAAUL,EAEtDM,EAAYT,EAAK,MAAM,SAAS,EAAE,OAAO,OAAO,EAEtD,IAAIU,EAAeT,EAEnB,UAAWU,KAAYF,EAAW,CAChC,GAAIG,EAAAA,MAAMF,CAAO,GAAK,OAAOA,GAAY,SACvC,OAAOG,EAAY,yBAAyBF,CAAQ,QAAQD,CAAO,GAAIH,EAAgBL,CAAY,EAMrG,GAHAQ,EACEF,GAAmBM,EAAAA,QAAQJ,CAAO,GAAK,QAAQ,KAAKC,CAAQ,EAAID,EAAQ,OAAOC,CAAQ,CAAC,EAAID,EAAQC,CAAQ,EAE1GD,IAAY,OACd,OAAOG,EAAY,aAAaF,CAAQ,mBAAoBJ,EAAgBL,CAAY,CAE5F,CAEA,OAAOQ,CACT,CAEA,SAASG,EACPE,EACAR,EACAL,EAC6B,CAC7B,GAAIK,EAAgB,MAAM,IAAI,MAAMQ,CAAO,EAC3C,OAAOb,CACT"}
+{"version":3,"file":"path.cjs","sources":["../../src/object/path.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\nimport { IS_OBJECT_ERROR_MSG, isObject } from '../typed/isObject';\nimport type { Obj } from '../types';\n\ntype PathValue<T, P extends string> = P extends `${infer Key}.${infer Rest}`\n  ? Key extends keyof T\n    ? PathValue<T[Key], Rest>\n    : undefined\n  : P extends keyof T\n    ? T[P]\n    : undefined;\n\n// #region PathOptions\ntype PathOptions = {\n  throwOnMissing?: boolean;\n  allowArrayIndex?: boolean;\n};\n// #endregion PathOptions\n\n/**\n * Retrieves the value at a given path of the object. If the value is undefined, the default value is returned.\n *\n * @example\n * ```ts\n * const obj = { a: { b: { c: 3 } }, d: [1, 2, 3] };\n *\n * getValue(obj, 'a.b.c'); // 3\n * getValue(obj, 'a.b.d', 'default'); // 'default'\n * getValue(obj, 'd[1]', undefined, { allowArrayIndex: true }); // 2\n * getValue(obj, 'e.f.g', 'default', { throwOnMissing: true }); // throws Error\n * ```\n *\n * @template T - The type of the object to query.\n * @template P - The type of the path string.\n * @param item - The object to query.\n * @param path - The path of the property to get.\n * @param [defaultValue] - The value returned for undefined resolved values.\n * @param [options] - Additional options for value retrieval.\n *\n * @returns The resolved value.\n *\n * @throws If throwOnMissing is true and the path doesn't exist.\n */\nexport function path<T extends Obj, P extends string>(\n  item: T,\n  path: P,\n  defaultValue?: unknown,\n  options: PathOptions = {},\n): PathValue<T, P> | undefined {\n  assert(isObject(item), IS_OBJECT_ERROR_MSG, { args: { item }, type: TypeError });\n\n  const { throwOnMissing = false, allowArrayIndex = false } = options;\n\n  const fragments = path.split(/[.[\\]]+/).filter(Boolean);\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  let current: any = item;\n\n  for (const fragment of fragments) {\n    if (isNil(current) || typeof current !== 'object') {\n      return handleError(`Cannot read property '${fragment}' of ${current}`, throwOnMissing, defaultValue);\n    }\n\n    current =\n      allowArrayIndex && isArray(current) && /^\\d+$/.test(fragment) ? current[Number(fragment)] : current[fragment];\n\n    if (current === undefined) {\n      return handleError(`Property '${fragment}' does not exist`, throwOnMissing, defaultValue);\n    }\n  }\n\n  return current as PathValue<T, P>;\n}\n\nfunction handleError<T extends Obj, P extends string>(\n  message: string,\n  throwOnMissing: boolean,\n  defaultValue?: unknown,\n): PathValue<T, P> | undefined {\n  if (throwOnMissing) throw new Error(message);\n  return defaultValue as PathValue<T, P>;\n}\n"],"names":["path","item","defaultValue","options","assert","isObject","IS_OBJECT_ERROR_MSG","throwOnMissing","allowArrayIndex","fragments","current","fragment","isNil","handleError","isArray","message"],"mappings":"+NA6CO,SAASA,EACdC,EACAD,EACAE,EACAC,EAAuB,CAAA,EACM,CAC7BC,EAAAA,OAAOC,EAAAA,SAASJ,CAAI,EAAGK,sBAAqB,CAAE,KAAM,CAAE,KAAAL,CAAA,EAAQ,KAAM,UAAW,EAE/E,KAAM,CAAE,eAAAM,EAAiB,GAAO,gBAAAC,EAAkB,IAAUL,EAEtDM,EAAYT,EAAK,MAAM,SAAS,EAAE,OAAO,OAAO,EAEtD,IAAIU,EAAeT,EAEnB,UAAWU,KAAYF,EAAW,CAChC,GAAIG,EAAAA,MAAMF,CAAO,GAAK,OAAOA,GAAY,SACvC,OAAOG,EAAY,yBAAyBF,CAAQ,QAAQD,CAAO,GAAIH,EAAgBL,CAAY,EAMrG,GAHAQ,EACEF,GAAmBM,EAAAA,QAAQJ,CAAO,GAAK,QAAQ,KAAKC,CAAQ,EAAID,EAAQ,OAAOC,CAAQ,CAAC,EAAID,EAAQC,CAAQ,EAE1GD,IAAY,OACd,OAAOG,EAAY,aAAaF,CAAQ,mBAAoBJ,EAAgBL,CAAY,CAE5F,CAEA,OAAOQ,CACT,CAEA,SAASG,EACPE,EACAR,EACAL,EAC6B,CAC7B,GAAIK,EAAgB,MAAM,IAAI,MAAMQ,CAAO,EAC3C,OAAOb,CACT"}

package/dist/object/path.js.map

@@ -1 +1 @@
-{"version":3,"file":"path.js","sources":["../../src/object/path.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\nimport { IS_OBJECT_ERROR_MSG, isObject } from '../typed/isObject';\nimport type { Obj } from '../types';\n\ntype PathValue<T, P extends string> = P extends `${infer Key}.${infer Rest}`\n  ? Key extends keyof T\n    ? PathValue<T[Key], Rest>\n    : undefined\n  : P extends keyof T\n    ? T[P]\n    : undefined;\n\ntype PathOptions = {\n  throwOnMissing?: boolean;\n  allowArrayIndex?: boolean;\n};\n\n/**\n * Retrieves the value at a given path of the object. If the value is undefined, the default value is returned.\n *\n * @example\n * ```ts\n * const obj = { a: { b: { c: 3 } }, d: [1, 2, 3] };\n *\n * getValue(obj, 'a.b.c'); // 3\n * getValue(obj, 'a.b.d', 'default'); // 'default'\n * getValue(obj, 'd[1]', undefined, { allowArrayIndex: true }); // 2\n * getValue(obj, 'e.f.g', 'default', { throwOnMissing: true }); // throws Error\n * ```\n *\n * @template T - The type of the object to query.\n * @template P - The type of the path string.\n * @param item - The object to query.\n * @param path - The path of the property to get.\n * @param [defaultValue] - The value returned for undefined resolved values.\n * @param [options] - Additional options for value retrieval.\n *\n * @returns The resolved value.\n *\n * @throws If throwOnMissing is true and the path doesn't exist.\n */\nexport function path<T extends Obj, P extends string>(\n  item: T,\n  path: P,\n  defaultValue?: unknown,\n  options: PathOptions = {},\n): PathValue<T, P> | undefined {\n  assert(isObject(item), IS_OBJECT_ERROR_MSG, { args: { item }, type: TypeError });\n\n  const { throwOnMissing = false, allowArrayIndex = false } = options;\n\n  const fragments = path.split(/[.[\\]]+/).filter(Boolean);\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  let current: any = item;\n\n  for (const fragment of fragments) {\n    if (isNil(current) || typeof current !== 'object') {\n      return handleError(`Cannot read property '${fragment}' of ${current}`, throwOnMissing, defaultValue);\n    }\n\n    current =\n      allowArrayIndex && isArray(current) && /^\\d+$/.test(fragment) ? current[Number(fragment)] : current[fragment];\n\n    if (current === undefined) {\n      return handleError(`Property '${fragment}' does not exist`, throwOnMissing, defaultValue);\n    }\n  }\n\n  return current as PathValue<T, P>;\n}\n\nfunction handleError<T extends Obj, P extends string>(\n  message: string,\n  throwOnMissing: boolean,\n  defaultValue?: unknown,\n): PathValue<T, P> | undefined {\n  if (throwOnMissing) throw new Error(message);\n  return defaultValue as PathValue<T, P>;\n}\n"],"names":["path","item","defaultValue","options","assert","isObject","IS_OBJECT_ERROR_MSG","throwOnMissing","allowArrayIndex","fragments","current","fragment","isNil","handleError","isArray","message"],"mappings":";;;;AA2CO,SAASA,EACdC,GACAD,GACAE,GACAC,IAAuB,CAAA,GACM;AAC7B,EAAAC,EAAOC,EAASJ,CAAI,GAAGK,GAAqB,EAAE,MAAM,EAAE,MAAAL,EAAA,GAAQ,MAAM,WAAW;AAE/E,QAAM,EAAE,gBAAAM,IAAiB,IAAO,iBAAAC,IAAkB,OAAUL,GAEtDM,IAAYT,EAAK,MAAM,SAAS,EAAE,OAAO,OAAO;AAEtD,MAAIU,IAAeT;AAEnB,aAAWU,KAAYF,GAAW;AAChC,QAAIG,EAAMF,CAAO,KAAK,OAAOA,KAAY;AACvC,aAAOG,EAAY,yBAAyBF,CAAQ,QAAQD,CAAO,IAAIH,GAAgBL,CAAY;AAMrG,QAHAQ,IACEF,KAAmBM,EAAQJ,CAAO,KAAK,QAAQ,KAAKC,CAAQ,IAAID,EAAQ,OAAOC,CAAQ,CAAC,IAAID,EAAQC,CAAQ,GAE1GD,MAAY;AACd,aAAOG,EAAY,aAAaF,CAAQ,oBAAoBJ,GAAgBL,CAAY;AAAA,EAE5F;AAEA,SAAOQ;AACT;AAEA,SAASG,EACPE,GACAR,GACAL,GAC6B;AAC7B,MAAIK,EAAgB,OAAM,IAAI,MAAMQ,CAAO;AAC3C,SAAOb;AACT;"}
+{"version":3,"file":"path.js","sources":["../../src/object/path.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { isArray } from '../typed/isArray';\nimport { isNil } from '../typed/isNil';\nimport { IS_OBJECT_ERROR_MSG, isObject } from '../typed/isObject';\nimport type { Obj } from '../types';\n\ntype PathValue<T, P extends string> = P extends `${infer Key}.${infer Rest}`\n  ? Key extends keyof T\n    ? PathValue<T[Key], Rest>\n    : undefined\n  : P extends keyof T\n    ? T[P]\n    : undefined;\n\n// #region PathOptions\ntype PathOptions = {\n  throwOnMissing?: boolean;\n  allowArrayIndex?: boolean;\n};\n// #endregion PathOptions\n\n/**\n * Retrieves the value at a given path of the object. If the value is undefined, the default value is returned.\n *\n * @example\n * ```ts\n * const obj = { a: { b: { c: 3 } }, d: [1, 2, 3] };\n *\n * getValue(obj, 'a.b.c'); // 3\n * getValue(obj, 'a.b.d', 'default'); // 'default'\n * getValue(obj, 'd[1]', undefined, { allowArrayIndex: true }); // 2\n * getValue(obj, 'e.f.g', 'default', { throwOnMissing: true }); // throws Error\n * ```\n *\n * @template T - The type of the object to query.\n * @template P - The type of the path string.\n * @param item - The object to query.\n * @param path - The path of the property to get.\n * @param [defaultValue] - The value returned for undefined resolved values.\n * @param [options] - Additional options for value retrieval.\n *\n * @returns The resolved value.\n *\n * @throws If throwOnMissing is true and the path doesn't exist.\n */\nexport function path<T extends Obj, P extends string>(\n  item: T,\n  path: P,\n  defaultValue?: unknown,\n  options: PathOptions = {},\n): PathValue<T, P> | undefined {\n  assert(isObject(item), IS_OBJECT_ERROR_MSG, { args: { item }, type: TypeError });\n\n  const { throwOnMissing = false, allowArrayIndex = false } = options;\n\n  const fragments = path.split(/[.[\\]]+/).filter(Boolean);\n  // biome-ignore lint/suspicious/noExplicitAny: -\n  let current: any = item;\n\n  for (const fragment of fragments) {\n    if (isNil(current) || typeof current !== 'object') {\n      return handleError(`Cannot read property '${fragment}' of ${current}`, throwOnMissing, defaultValue);\n    }\n\n    current =\n      allowArrayIndex && isArray(current) && /^\\d+$/.test(fragment) ? current[Number(fragment)] : current[fragment];\n\n    if (current === undefined) {\n      return handleError(`Property '${fragment}' does not exist`, throwOnMissing, defaultValue);\n    }\n  }\n\n  return current as PathValue<T, P>;\n}\n\nfunction handleError<T extends Obj, P extends string>(\n  message: string,\n  throwOnMissing: boolean,\n  defaultValue?: unknown,\n): PathValue<T, P> | undefined {\n  if (throwOnMissing) throw new Error(message);\n  return defaultValue as PathValue<T, P>;\n}\n"],"names":["path","item","defaultValue","options","assert","isObject","IS_OBJECT_ERROR_MSG","throwOnMissing","allowArrayIndex","fragments","current","fragment","isNil","handleError","isArray","message"],"mappings":";;;;AA6CO,SAASA,EACdC,GACAD,GACAE,GACAC,IAAuB,CAAA,GACM;AAC7B,EAAAC,EAAOC,EAASJ,CAAI,GAAGK,GAAqB,EAAE,MAAM,EAAE,MAAAL,EAAA,GAAQ,MAAM,WAAW;AAE/E,QAAM,EAAE,gBAAAM,IAAiB,IAAO,iBAAAC,IAAkB,OAAUL,GAEtDM,IAAYT,EAAK,MAAM,SAAS,EAAE,OAAO,OAAO;AAEtD,MAAIU,IAAeT;AAEnB,aAAWU,KAAYF,GAAW;AAChC,QAAIG,EAAMF,CAAO,KAAK,OAAOA,KAAY;AACvC,aAAOG,EAAY,yBAAyBF,CAAQ,QAAQD,CAAO,IAAIH,GAAgBL,CAAY;AAMrG,QAHAQ,IACEF,KAAmBM,EAAQJ,CAAO,KAAK,QAAQ,KAAKC,CAAQ,IAAID,EAAQ,OAAOC,CAAQ,CAAC,IAAID,EAAQC,CAAQ,GAE1GD,MAAY;AACd,aAAOG,EAAY,aAAaF,CAAQ,oBAAoBJ,GAAgBL,CAAY;AAAA,EAE5F;AAEA,SAAOQ;AACT;AAEA,SAASG,EACPE,GACAR,GACAL,GAC6B;AAC7B,MAAIK,EAAgB,OAAM,IAAI,MAAMQ,CAAO;AAC3C,SAAOb;AACT;"}

package/dist/object/seek.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("../function/assert.cjs"),c=require("../string/similarity.cjs"),s=require("../typed/is.cjs"),o=require("../typed/isWithin.cjs");function a(e,t,i=1){return f.assert(o.isWithin(i,0,1),o.IS_WITHIN_ERROR_MSG,{args:{max:1,min:0,tone:i},type:TypeError}),s.is("string",e)||s.is("number",e)?c.similarity(e,t)>=i:Object.values(e).some(r=>s.is("nil",r)?!1:s.is("array",r)?r.some(n=>s.is("object",n)?a(n,t,i):c.similarity(n,t)>=i):s.is("object",r)?a(r,t,i):c.similarity(r,t)>=i)}exports.seek=a;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("../function/assert.cjs"),l=require("../string/similarity.cjs"),s=require("../typed/is.cjs"),a=require("../typed/isWithin.cjs");function t(r,n,i=1){return u.assert(a.isWithin(i,0,1),a.IS_WITHIN_ERROR_MSG,{args:{max:1,min:0,tone:i},type:TypeError}),s.is("nil",r)?!1:s.is("string",r)||s.is("number",r)?l.similarity(r,n)>=i:s.is("array",r)?r.some(e=>t(e,n,i)):s.is("object",r)?Object.values(r).some(e=>s.is("nil",e)?!1:t(e,n,i)):!1}exports.seek=t;
 //# sourceMappingURL=seek.cjs.map

package/dist/object/seek.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"seek.cjs","sources":["../../src/object/seek.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { similarity } from '../string/similarity';\nimport { is } from '../typed/is';\nimport { IS_WITHIN_ERROR_MSG, isWithin } from '../typed/isWithin';\n\n/**\n * Recursively checks if an object contains a value similar to the search string.\n *\n * @example\n * ```ts\n * const obj = { a: 'hello', b: { c: 'world' }, d: [1, 2, 3] };\n *\n * seek(obj, 'hello'); // true\n * seek(obj, 'world'); // true\n * seek(obj, 'foo'); // false\n * seek(obj, 'hello', 0.5); // true\n * seek(obj, 'hello', 0.8); // true\n * seek(obj, 'hello', 1); // true\n * seek(obj, 'hello', 1.5); // false\n * seek(obj, 'hello', -1); // false\n * seek(obj, 'hello', 0); // false\n * ```\n *\n * @param item - The object to search within.\n * @param query - The search string.\n * @param [tone=1] - The similarity threshold.\n *\n * @returns Whether the object contains a matching value.\n */\nexport function seek<T>(item: T, query: string, tone = 1): boolean {\n  assert(isWithin(tone, 0, 1), IS_WITHIN_ERROR_MSG, { args: { max: 1, min: 0, tone }, type: TypeError });\n\n  if (is('string', item) || is('number', item)) {\n    // Lowercase both sides for case-insensitive comparison\n    return similarity(item, query) >= tone;\n  }\n\n  return Object.values(item as Record<string, unknown>).some((value) => {\n    if (is('nil', value)) return false;\n\n    if (is('array', value)) {\n      return value.some((v) => (is('object', v) ? seek(v, query, tone) : similarity(v, query) >= tone));\n    }\n\n    if (is('object', value)) {\n      return seek(value, query, tone);\n    }\n\n    return similarity(value, query) >= tone;\n  });\n}\n"],"names":["seek","item","query","tone","assert","isWithin","IS_WITHIN_ERROR_MSG","is","similarity","value","v"],"mappings":"gOA6BO,SAASA,EAAQC,EAASC,EAAeC,EAAO,EAAY,CAGjE,OAFAC,EAAAA,OAAOC,EAAAA,SAASF,EAAM,EAAG,CAAC,EAAGG,EAAAA,oBAAqB,CAAE,KAAM,CAAE,IAAK,EAAG,IAAK,EAAG,KAAAH,GAAQ,KAAM,UAAW,EAEjGI,EAAAA,GAAG,SAAUN,CAAI,GAAKM,EAAAA,GAAG,SAAUN,CAAI,EAElCO,aAAWP,EAAMC,CAAK,GAAKC,EAG7B,OAAO,OAAOF,CAA+B,EAAE,KAAMQ,GACtDF,KAAG,MAAOE,CAAK,EAAU,GAEzBF,EAAAA,GAAG,QAASE,CAAK,EACZA,EAAM,KAAMC,GAAOH,EAAAA,GAAG,SAAUG,CAAC,EAAIV,EAAKU,EAAGR,EAAOC,CAAI,EAAIK,EAAAA,WAAWE,EAAGR,CAAK,GAAKC,CAAK,EAG9FI,EAAAA,GAAG,SAAUE,CAAK,EACbT,EAAKS,EAAOP,EAAOC,CAAI,EAGzBK,aAAWC,EAAOP,CAAK,GAAKC,CACpC,CACH"}
+{"version":3,"file":"seek.cjs","sources":["../../src/object/seek.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { similarity } from '../string/similarity';\nimport { is } from '../typed/is';\nimport { IS_WITHIN_ERROR_MSG, isWithin } from '../typed/isWithin';\n\n/**\n * Recursively checks if an object contains a value similar to the search string.\n *\n * @example\n * ```ts\n * const obj = { a: 'hello', b: { c: 'world' }, d: [1, 2, 3] };\n *\n * seek(obj, 'hello'); // true\n * seek(obj, 'world'); // true\n * seek(obj, 'foo'); // false\n * seek(obj, 'hello', 0.5); // true\n * seek(obj, 'hello', 0.8); // true\n * seek(obj, 'hello', 1); // true\n * seek(obj, 'hello', 1.5); // false\n * seek(obj, 'hello', -1); // false\n * seek(obj, 'hello', 0); // false\n * ```\n *\n * @param item - The object to search within.\n * @param query - The search string.\n * @param [tone=1] - The similarity threshold.\n *\n * @returns Whether the object contains a matching value.\n */\nexport function seek<T>(item: T, query: string, tone = 1): boolean {\n  assert(isWithin(tone, 0, 1), IS_WITHIN_ERROR_MSG, { args: { max: 1, min: 0, tone }, type: TypeError });\n\n  if (is('nil', item)) return false;\n\n  if (is('string', item) || is('number', item)) {\n    // Lowercase both sides for case-insensitive comparison\n    return similarity(item, query) >= tone;\n  }\n\n  // Handle arrays\n  if (is('array', item)) {\n    return (item as unknown[]).some((value) => seek(value, query, tone));\n  }\n\n  // Handle objects but skip dates/regex/etc which are technically objects\n  if (is('object', item)) {\n    return Object.values(item as Record<string, unknown>).some((value) =>\n      is('nil', value) ? false : seek(value, query, tone),\n    );\n  }\n\n  return false;\n}\n"],"names":["seek","item","query","tone","assert","isWithin","IS_WITHIN_ERROR_MSG","is","similarity","value"],"mappings":"gOA6BO,SAASA,EAAQC,EAASC,EAAeC,EAAO,EAAY,CAGjE,OAFAC,EAAAA,OAAOC,EAAAA,SAASF,EAAM,EAAG,CAAC,EAAGG,EAAAA,oBAAqB,CAAE,KAAM,CAAE,IAAK,EAAG,IAAK,EAAG,KAAAH,GAAQ,KAAM,UAAW,EAEjGI,KAAG,MAAON,CAAI,EAAU,GAExBM,EAAAA,GAAG,SAAUN,CAAI,GAAKM,EAAAA,GAAG,SAAUN,CAAI,EAElCO,aAAWP,EAAMC,CAAK,GAAKC,EAIhCI,EAAAA,GAAG,QAASN,CAAI,EACVA,EAAmB,KAAMQ,GAAUT,EAAKS,EAAOP,EAAOC,CAAI,CAAC,EAIjEI,EAAAA,GAAG,SAAUN,CAAI,EACZ,OAAO,OAAOA,CAA+B,EAAE,KAAMQ,GAC1DF,KAAG,MAAOE,CAAK,EAAI,GAAQT,EAAKS,EAAOP,EAAOC,CAAI,CAAA,EAI/C,EACT"}

package/dist/object/seek.js

@@ -1,11 +1,13 @@
-import { assert as p } from "../function/assert.js";
-import { similarity as o } from "../string/similarity.js";
+import { assert as n } from "../function/assert.js";
+import { similarity as m } from "../string/similarity.js";
 import { is as s } from "../typed/is.js";
-import { IS_WITHIN_ERROR_MSG as b, isWithin as c } from "../typed/isWithin.js";
-function n(t, m, r = 1) {
-  return p(c(r, 0, 1), b, { args: { max: 1, min: 0, tone: r }, type: TypeError }), s("string", t) || s("number", t) ? o(t, m) >= r : Object.values(t).some((i) => s("nil", i) ? !1 : s("array", i) ? i.some((f) => s("object", f) ? n(f, m, r) : o(f, m) >= r) : s("object", i) ? n(i, m, r) : o(i, m) >= r);
+import { IS_WITHIN_ERROR_MSG as p, isWithin as t } from "../typed/isWithin.js";
+function a(r, o, i = 1) {
+  return n(t(i, 0, 1), p, { args: { max: 1, min: 0, tone: i }, type: TypeError }), s("nil", r) ? !1 : s("string", r) || s("number", r) ? m(r, o) >= i : s("array", r) ? r.some((f) => a(f, o, i)) : s("object", r) ? Object.values(r).some(
+    (f) => s("nil", f) ? !1 : a(f, o, i)
+  ) : !1;
 }
 export {
-  n as seek
+  a as seek
 };
 //# sourceMappingURL=seek.js.map

package/dist/object/seek.js.map

@@ -1 +1 @@
-{"version":3,"file":"seek.js","sources":["../../src/object/seek.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { similarity } from '../string/similarity';\nimport { is } from '../typed/is';\nimport { IS_WITHIN_ERROR_MSG, isWithin } from '../typed/isWithin';\n\n/**\n * Recursively checks if an object contains a value similar to the search string.\n *\n * @example\n * ```ts\n * const obj = { a: 'hello', b: { c: 'world' }, d: [1, 2, 3] };\n *\n * seek(obj, 'hello'); // true\n * seek(obj, 'world'); // true\n * seek(obj, 'foo'); // false\n * seek(obj, 'hello', 0.5); // true\n * seek(obj, 'hello', 0.8); // true\n * seek(obj, 'hello', 1); // true\n * seek(obj, 'hello', 1.5); // false\n * seek(obj, 'hello', -1); // false\n * seek(obj, 'hello', 0); // false\n * ```\n *\n * @param item - The object to search within.\n * @param query - The search string.\n * @param [tone=1] - The similarity threshold.\n *\n * @returns Whether the object contains a matching value.\n */\nexport function seek<T>(item: T, query: string, tone = 1): boolean {\n  assert(isWithin(tone, 0, 1), IS_WITHIN_ERROR_MSG, { args: { max: 1, min: 0, tone }, type: TypeError });\n\n  if (is('string', item) || is('number', item)) {\n    // Lowercase both sides for case-insensitive comparison\n    return similarity(item, query) >= tone;\n  }\n\n  return Object.values(item as Record<string, unknown>).some((value) => {\n    if (is('nil', value)) return false;\n\n    if (is('array', value)) {\n      return value.some((v) => (is('object', v) ? seek(v, query, tone) : similarity(v, query) >= tone));\n    }\n\n    if (is('object', value)) {\n      return seek(value, query, tone);\n    }\n\n    return similarity(value, query) >= tone;\n  });\n}\n"],"names":["seek","item","query","tone","assert","isWithin","IS_WITHIN_ERROR_MSG","is","similarity","value","v"],"mappings":";;;;AA6BO,SAASA,EAAQC,GAASC,GAAeC,IAAO,GAAY;AAGjE,SAFAC,EAAOC,EAASF,GAAM,GAAG,CAAC,GAAGG,GAAqB,EAAE,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,MAAAH,KAAQ,MAAM,WAAW,GAEjGI,EAAG,UAAUN,CAAI,KAAKM,EAAG,UAAUN,CAAI,IAElCO,EAAWP,GAAMC,CAAK,KAAKC,IAG7B,OAAO,OAAOF,CAA+B,EAAE,KAAK,CAACQ,MACtDF,EAAG,OAAOE,CAAK,IAAU,KAEzBF,EAAG,SAASE,CAAK,IACZA,EAAM,KAAK,CAACC,MAAOH,EAAG,UAAUG,CAAC,IAAIV,EAAKU,GAAGR,GAAOC,CAAI,IAAIK,EAAWE,GAAGR,CAAK,KAAKC,CAAK,IAG9FI,EAAG,UAAUE,CAAK,IACbT,EAAKS,GAAOP,GAAOC,CAAI,IAGzBK,EAAWC,GAAOP,CAAK,KAAKC,CACpC;AACH;"}
+{"version":3,"file":"seek.js","sources":["../../src/object/seek.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { similarity } from '../string/similarity';\nimport { is } from '../typed/is';\nimport { IS_WITHIN_ERROR_MSG, isWithin } from '../typed/isWithin';\n\n/**\n * Recursively checks if an object contains a value similar to the search string.\n *\n * @example\n * ```ts\n * const obj = { a: 'hello', b: { c: 'world' }, d: [1, 2, 3] };\n *\n * seek(obj, 'hello'); // true\n * seek(obj, 'world'); // true\n * seek(obj, 'foo'); // false\n * seek(obj, 'hello', 0.5); // true\n * seek(obj, 'hello', 0.8); // true\n * seek(obj, 'hello', 1); // true\n * seek(obj, 'hello', 1.5); // false\n * seek(obj, 'hello', -1); // false\n * seek(obj, 'hello', 0); // false\n * ```\n *\n * @param item - The object to search within.\n * @param query - The search string.\n * @param [tone=1] - The similarity threshold.\n *\n * @returns Whether the object contains a matching value.\n */\nexport function seek<T>(item: T, query: string, tone = 1): boolean {\n  assert(isWithin(tone, 0, 1), IS_WITHIN_ERROR_MSG, { args: { max: 1, min: 0, tone }, type: TypeError });\n\n  if (is('nil', item)) return false;\n\n  if (is('string', item) || is('number', item)) {\n    // Lowercase both sides for case-insensitive comparison\n    return similarity(item, query) >= tone;\n  }\n\n  // Handle arrays\n  if (is('array', item)) {\n    return (item as unknown[]).some((value) => seek(value, query, tone));\n  }\n\n  // Handle objects but skip dates/regex/etc which are technically objects\n  if (is('object', item)) {\n    return Object.values(item as Record<string, unknown>).some((value) =>\n      is('nil', value) ? false : seek(value, query, tone),\n    );\n  }\n\n  return false;\n}\n"],"names":["seek","item","query","tone","assert","isWithin","IS_WITHIN_ERROR_MSG","is","similarity","value"],"mappings":";;;;AA6BO,SAASA,EAAQC,GAASC,GAAeC,IAAO,GAAY;AAGjE,SAFAC,EAAOC,EAASF,GAAM,GAAG,CAAC,GAAGG,GAAqB,EAAE,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,MAAAH,KAAQ,MAAM,WAAW,GAEjGI,EAAG,OAAON,CAAI,IAAU,KAExBM,EAAG,UAAUN,CAAI,KAAKM,EAAG,UAAUN,CAAI,IAElCO,EAAWP,GAAMC,CAAK,KAAKC,IAIhCI,EAAG,SAASN,CAAI,IACVA,EAAmB,KAAK,CAACQ,MAAUT,EAAKS,GAAOP,GAAOC,CAAI,CAAC,IAIjEI,EAAG,UAAUN,CAAI,IACZ,OAAO,OAAOA,CAA+B,EAAE;AAAA,IAAK,CAACQ,MAC1DF,EAAG,OAAOE,CAAK,IAAI,KAAQT,EAAKS,GAAOP,GAAOC,CAAI;AAAA,EAAA,IAI/C;AACT;"}

package/dist/random/uuid.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function o(){return crypto?.randomUUID()??[12,6,6,6,18].map(t=>Math.floor(Math.random()*10**t).toString(36)).join("-")}exports.uuid=o;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function t(){return typeof crypto<"u"&&crypto.randomUUID?crypto.randomUUID():"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".replace(/x/g,r=>{const x=Math.random()*16|0;return(r==="x"?x:x&3|8).toString(16)})}exports.uuid=t;
 //# sourceMappingURL=uuid.cjs.map

package/dist/random/uuid.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"uuid.cjs","sources":["../../src/random/uuid.ts"],"sourcesContent":["/**\n * Generates a unique identifier.\n *\n * @example\n * ```ts\n * uuid(); // a unique identifier, e.g., '22a746d0-08be-4aff-bbc2-4deddf0914e0'\n * ```\n *\n * @returns A unique identifier.\n */\nexport function uuid(): string {\n  return (\n    crypto?.randomUUID() ?? [12, 6, 6, 6, 18].map((val) => Math.floor(Math.random() * 10 ** val).toString(36)).join('-')\n  );\n}\n"],"names":["uuid","val"],"mappings":"gFAUO,SAASA,GAAe,CAC7B,OACE,QAAQ,cAAgB,CAAC,GAAI,EAAG,EAAG,EAAG,EAAE,EAAE,IAAKC,GAAQ,KAAK,MAAM,KAAK,OAAA,EAAW,IAAMA,CAAG,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,GAAG,CAEvH"}
+{"version":3,"file":"uuid.cjs","sources":["../../src/random/uuid.ts"],"sourcesContent":["/**\n * Generates a unique identifier.\n *\n * @example\n * ```ts\n * uuid(); // a unique identifier, e.g., '22a746d0-08be-4aff-bbc2-4deddf0914e0'\n * ```\n *\n * @returns A unique identifier.\n */\nexport function uuid(): string {\n  if (typeof crypto !== 'undefined' && crypto.randomUUID) {\n    return crypto.randomUUID();\n  }\n\n  return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/x/g, (c) => {\n    const r = (Math.random() * 16) | 0;\n    const v = c === 'x' ? r : (r & 0x3) | 0x8;\n    return v.toString(16);\n  });\n}\n"],"names":["uuid","c","r"],"mappings":"gFAUO,SAASA,GAAe,CAC7B,OAAI,OAAO,OAAW,KAAe,OAAO,WACnC,OAAO,WAAA,EAGT,uCAAuC,QAAQ,KAAOC,GAAM,CACjE,MAAMC,EAAK,KAAK,OAAA,EAAW,GAAM,EAEjC,OADUD,IAAM,IAAMC,EAAKA,EAAI,EAAO,GAC7B,SAAS,EAAE,CACtB,CAAC,CACH"}

package/dist/random/uuid.js

@@ -1,7 +1,10 @@
-function r() {
-  return crypto?.randomUUID() ?? [12, 6, 6, 6, 18].map((o) => Math.floor(Math.random() * 10 ** o).toString(36)).join("-");
+function n() {
+  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".replace(/x/g, (r) => {
+    const x = Math.random() * 16 | 0;
+    return (r === "x" ? x : x & 3 | 8).toString(16);
+  });
 }
 export {
-  r as uuid
+  n as uuid
 };
 //# sourceMappingURL=uuid.js.map

package/dist/random/uuid.js.map

@@ -1 +1 @@
-{"version":3,"file":"uuid.js","sources":["../../src/random/uuid.ts"],"sourcesContent":["/**\n * Generates a unique identifier.\n *\n * @example\n * ```ts\n * uuid(); // a unique identifier, e.g., '22a746d0-08be-4aff-bbc2-4deddf0914e0'\n * ```\n *\n * @returns A unique identifier.\n */\nexport function uuid(): string {\n  return (\n    crypto?.randomUUID() ?? [12, 6, 6, 6, 18].map((val) => Math.floor(Math.random() * 10 ** val).toString(36)).join('-')\n  );\n}\n"],"names":["uuid","val"],"mappings":"AAUO,SAASA,IAAe;AAC7B,SACE,QAAQ,gBAAgB,CAAC,IAAI,GAAG,GAAG,GAAG,EAAE,EAAE,IAAI,CAACC,MAAQ,KAAK,MAAM,KAAK,OAAA,IAAW,MAAMA,CAAG,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,GAAG;AAEvH;"}
+{"version":3,"file":"uuid.js","sources":["../../src/random/uuid.ts"],"sourcesContent":["/**\n * Generates a unique identifier.\n *\n * @example\n * ```ts\n * uuid(); // a unique identifier, e.g., '22a746d0-08be-4aff-bbc2-4deddf0914e0'\n * ```\n *\n * @returns A unique identifier.\n */\nexport function uuid(): string {\n  if (typeof crypto !== 'undefined' && crypto.randomUUID) {\n    return crypto.randomUUID();\n  }\n\n  return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/x/g, (c) => {\n    const r = (Math.random() * 16) | 0;\n    const v = c === 'x' ? r : (r & 0x3) | 0x8;\n    return v.toString(16);\n  });\n}\n"],"names":["uuid","c","r"],"mappings":"AAUO,SAASA,IAAe;AAC7B,SAAI,OAAO,SAAW,OAAe,OAAO,aACnC,OAAO,WAAA,IAGT,uCAAuC,QAAQ,MAAM,CAACC,MAAM;AACjE,UAAMC,IAAK,KAAK,OAAA,IAAW,KAAM;AAEjC,YADUD,MAAM,MAAMC,IAAKA,IAAI,IAAO,GAC7B,SAAS,EAAE;AAAA,EACtB,CAAC;AACH;"}

package/dist/string/camelCase.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./_caseUtils.cjs");function t(a){return s.normalizeCase(a," ").replace(/(?:^|\s)(\w)/g,(e,r)=>r.toUpperCase()).replace(/\s+/g,"").replace(/^./,e=>e.toLowerCase())}exports.camelCase=t;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./_caseUtils.cjs");function o(a){return t.normalizeCase(a," ").replace(/[^a-zA-Z0-9]+(.)/g,(e,r)=>r.toUpperCase()).replace(/^./,e=>e.toLowerCase())}exports.camelCase=o;
 //# sourceMappingURL=camelCase.cjs.map

package/dist/string/camelCase.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"camelCase.cjs","sources":["../../src/string/camelCase.ts"],"sourcesContent":["import { normalizeCase } from './_caseUtils';\n\n/**\n * Converts a string to camel case.\n *\n * @example\n * ```ts\n * const text = 'hello world';\n * camelCase(text); // 'helloWorld'\n * ```\n *\n * @param str - The string to convert.\n * @returns The converted string.\n */\nexport function camelCase(str: string): string {\n  return normalizeCase(str, ' ')\n    .replace(/(?:^|\\s)(\\w)/g, (_, char) => char.toUpperCase())\n    .replace(/\\s+/g, '')\n    .replace(/^./, (char) => char.toLowerCase());\n}\n"],"names":["camelCase","str","normalizeCase","_","char"],"mappings":"oHAcO,SAASA,EAAUC,EAAqB,CAC7C,OAAOC,EAAAA,cAAcD,EAAK,GAAG,EAC1B,QAAQ,gBAAiB,CAACE,EAAGC,IAASA,EAAK,YAAA,CAAa,EACxD,QAAQ,OAAQ,EAAE,EAClB,QAAQ,KAAOA,GAASA,EAAK,aAAa,CAC/C"}
+{"version":3,"file":"camelCase.cjs","sources":["../../src/string/camelCase.ts"],"sourcesContent":["import { normalizeCase } from './_caseUtils';\n\n/**\n * Converts a string to camel case.\n *\n * @example\n * ```ts\n * const text = 'hello world';\n * camelCase(text); // 'helloWorld'\n * ```\n *\n * @param str - The string to convert.\n * @returns The converted string.\n */\nexport function camelCase(str: string): string {\n  return normalizeCase(str, ' ')\n    .replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase()) // Basic split by non-alphanumeric\n    .replace(/^./, (char) => char.toLowerCase());\n}\n"],"names":["camelCase","str","normalizeCase","_","char"],"mappings":"oHAcO,SAASA,EAAUC,EAAqB,CAC7C,OAAOC,EAAAA,cAAcD,EAAK,GAAG,EAC1B,QAAQ,oBAAqB,CAACE,EAAGC,IAASA,EAAK,YAAA,CAAa,EAC5D,QAAQ,KAAOA,GAASA,EAAK,aAAa,CAC/C"}

package/dist/string/camelCase.js

@@ -1,8 +1,8 @@
 import { normalizeCase as o } from "./_caseUtils.js";
-function s(r) {
-  return o(r, " ").replace(/(?:^|\s)(\w)/g, (e, a) => a.toUpperCase()).replace(/\s+/g, "").replace(/^./, (e) => e.toLowerCase());
+function t(r) {
+  return o(r, " ").replace(/[^a-zA-Z0-9]+(.)/g, (e, a) => a.toUpperCase()).replace(/^./, (e) => e.toLowerCase());
 }
 export {
-  s as camelCase
+  t as camelCase
 };
 //# sourceMappingURL=camelCase.js.map

package/dist/string/camelCase.js.map

@@ -1 +1 @@
-{"version":3,"file":"camelCase.js","sources":["../../src/string/camelCase.ts"],"sourcesContent":["import { normalizeCase } from './_caseUtils';\n\n/**\n * Converts a string to camel case.\n *\n * @example\n * ```ts\n * const text = 'hello world';\n * camelCase(text); // 'helloWorld'\n * ```\n *\n * @param str - The string to convert.\n * @returns The converted string.\n */\nexport function camelCase(str: string): string {\n  return normalizeCase(str, ' ')\n    .replace(/(?:^|\\s)(\\w)/g, (_, char) => char.toUpperCase())\n    .replace(/\\s+/g, '')\n    .replace(/^./, (char) => char.toLowerCase());\n}\n"],"names":["camelCase","str","normalizeCase","_","char"],"mappings":";AAcO,SAASA,EAAUC,GAAqB;AAC7C,SAAOC,EAAcD,GAAK,GAAG,EAC1B,QAAQ,iBAAiB,CAACE,GAAGC,MAASA,EAAK,YAAA,CAAa,EACxD,QAAQ,QAAQ,EAAE,EAClB,QAAQ,MAAM,CAACA,MAASA,EAAK,aAAa;AAC/C;"}
+{"version":3,"file":"camelCase.js","sources":["../../src/string/camelCase.ts"],"sourcesContent":["import { normalizeCase } from './_caseUtils';\n\n/**\n * Converts a string to camel case.\n *\n * @example\n * ```ts\n * const text = 'hello world';\n * camelCase(text); // 'helloWorld'\n * ```\n *\n * @param str - The string to convert.\n * @returns The converted string.\n */\nexport function camelCase(str: string): string {\n  return normalizeCase(str, ' ')\n    .replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase()) // Basic split by non-alphanumeric\n    .replace(/^./, (char) => char.toLowerCase());\n}\n"],"names":["camelCase","str","normalizeCase","_","char"],"mappings":";AAcO,SAASA,EAAUC,GAAqB;AAC7C,SAAOC,EAAcD,GAAK,GAAG,EAC1B,QAAQ,qBAAqB,CAACE,GAAGC,MAASA,EAAK,YAAA,CAAa,EAC5D,QAAQ,MAAM,CAACA,MAASA,EAAK,aAAa;AAC/C;"}

package/dist/string/similarity.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const g=require("../function/assert.cjs");function u(a,c){g.assert(["string","number"].includes(typeof a)&&["string","number"].includes(typeof c),"Invalid arguments",{args:{str1:a,str2:c},type:TypeError});const r=String(a).toLowerCase(),i=String(c).toLowerCase();if(r===i)return 1;if(!r.length||!i.length)return 0;const o=r.length,s=i.length,n=Array.from({length:o+1},(t,e)=>[e]);for(let t=0;t<=s;t++)n[0][t]=t;for(let t=1;t<=o;t++)for(let e=1;e<=s;e++){const l=r[t-1]===i[e-1]?0:1;n[t][e]=Math.min(n[t-1][e]+1,n[t][e-1]+1,n[t-1][e-1]+l)}return 1-n[o][s]/Math.max(o,s)}exports.similarity=u;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("../function/assert.cjs");function y(l,g){f.assert(["string","number"].includes(typeof l)&&["string","number"].includes(typeof g),"Invalid arguments",{args:{str1:l,str2:g},type:TypeError});const n=String(l).toLowerCase(),t=String(g).toLowerCase();if(n===t)return 1;if(n.length===0)return t.length===0?1:0;if(t.length===0)return 0;const[a,c]=n.length<t.length?[n,t]:[t,n],s=a.length,h=c.length;let r=Array.from({length:s+1},(i,e)=>e),o=new Array(s+1);for(let i=1;i<=h;i++){o[0]=i;for(let e=1;e<=s;e++){const u=c[i-1]===a[e-1]?0:1;o[e]=Math.min(o[e-1]+1,r[e]+1,r[e-1]+u)}[r,o]=[o,r]}return 1-r[s]/Math.max(n.length,t.length)}exports.similarity=y;
 //# sourceMappingURL=similarity.cjs.map

package/dist/string/similarity.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"similarity.cjs","sources":["../../src/string/similarity.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Calculate the similarity between two strings using the Levenshtein distance algorithm.\n *\n * @example\n * ```ts\n * similarity('abc', 'abc') // 1\n * similarity('a', 'b') // 0\n * similarity('ab', 'ac') // 0.5\n * similarity('doe', 'John Doe') // 0.25\n * similarity('abc', 'axc') // 0.6666666666666667\n * similarity('kitten', 'sitting') // 0.5714285714285714\n * ```\n *\n * @param str1 - The first string.\n * @param str2 - The second string.\n *\n * @returns A number between 0 and 1 representing the similarity between the two strings.\n */\nexport function similarity(str1: unknown, str2: unknown): number {\n  assert(\n    ['string', 'number'].includes(typeof str1) && ['string', 'number'].includes(typeof str2),\n    'Invalid arguments',\n    {\n      args: { str1, str2 },\n      type: TypeError,\n    },\n  );\n\n  const a = String(str1).toLowerCase();\n  const b = String(str2).toLowerCase();\n\n  if (a === b) return 1;\n  if (!a.length || !b.length) return 0;\n\n  const aLength = a.length;\n  const bLength = b.length;\n\n  // Initialize matrix with first row and column\n  const matrix: number[][] = Array.from({ length: aLength + 1 }, (_, i) => [i]);\n  for (let j = 0; j <= bLength; j++) {\n    matrix[0][j] = j;\n  }\n\n  // Calculate Levenshtein distance\n  for (let i = 1; i <= aLength; i++) {\n    for (let j = 1; j <= bLength; j++) {\n      const cost = a[i - 1] === b[j - 1] ? 0 : 1;\n      matrix[i][j] = Math.min(\n        matrix[i - 1][j] + 1, // deletion\n        matrix[i][j - 1] + 1, // insertion\n        matrix[i - 1][j - 1] + cost, // substitution\n      );\n    }\n  }\n\n  const distance = matrix[aLength][bLength];\n\n  return 1 - distance / Math.max(aLength, bLength);\n}\n"],"names":["similarity","str1","str2","assert","a","b","aLength","bLength","matrix","_","i","j","cost"],"mappings":"0HAoBO,SAASA,EAAWC,EAAeC,EAAuB,CAC/DC,EAAAA,OACE,CAAC,SAAU,QAAQ,EAAE,SAAS,OAAOF,CAAI,GAAK,CAAC,SAAU,QAAQ,EAAE,SAAS,OAAOC,CAAI,EACvF,oBACA,CACE,KAAM,CAAE,KAAAD,EAAM,KAAAC,CAAA,EACd,KAAM,SAAA,CACR,EAGF,MAAME,EAAI,OAAOH,CAAI,EAAE,YAAA,EACjBI,EAAI,OAAOH,CAAI,EAAE,YAAA,EAEvB,GAAIE,IAAMC,EAAG,MAAO,GACpB,GAAI,CAACD,EAAE,QAAU,CAACC,EAAE,OAAQ,MAAO,GAEnC,MAAMC,EAAUF,EAAE,OACZG,EAAUF,EAAE,OAGZG,EAAqB,MAAM,KAAK,CAAE,OAAQF,EAAU,CAAA,EAAK,CAACG,EAAGC,IAAM,CAACA,CAAC,CAAC,EAC5E,QAASC,EAAI,EAAGA,GAAKJ,EAASI,IAC5BH,EAAO,CAAC,EAAEG,CAAC,EAAIA,EAIjB,QAASD,EAAI,EAAGA,GAAKJ,EAASI,IAC5B,QAASC,EAAI,EAAGA,GAAKJ,EAASI,IAAK,CACjC,MAAMC,EAAOR,EAAEM,EAAI,CAAC,IAAML,EAAEM,EAAI,CAAC,EAAI,EAAI,EACzCH,EAAOE,CAAC,EAAEC,CAAC,EAAI,KAAK,IAClBH,EAAOE,EAAI,CAAC,EAAEC,CAAC,EAAI,EACnBH,EAAOE,CAAC,EAAEC,EAAI,CAAC,EAAI,EACnBH,EAAOE,EAAI,CAAC,EAAEC,EAAI,CAAC,EAAIC,CAAA,CAE3B,CAKF,MAAO,GAFUJ,EAAOF,CAAO,EAAEC,CAAO,EAElB,KAAK,IAAID,EAASC,CAAO,CACjD"}
+{"version":3,"file":"similarity.cjs","sources":["../../src/string/similarity.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Calculate the similarity between two strings using the Levenshtein distance algorithm.\n *\n * @example\n * ```ts\n * similarity('abc', 'abc') // 1\n * similarity('a', 'b') // 0\n * similarity('ab', 'ac') // 0.5\n * similarity('doe', 'John Doe') // 0.25\n * similarity('abc', 'axc') // 0.6666666666666667\n * similarity('kitten', 'sitting') // 0.5714285714285714\n * ```\n *\n * @param str1 - The first string.\n * @param str2 - The second string.\n *\n * @returns A number between 0 and 1 representing the similarity between the two strings.\n */\nexport function similarity(str1: unknown, str2: unknown): number {\n  assert(\n    ['string', 'number'].includes(typeof str1) && ['string', 'number'].includes(typeof str2),\n    'Invalid arguments',\n    {\n      args: { str1, str2 },\n      type: TypeError,\n    },\n  );\n\n  const a = String(str1).toLowerCase();\n  const b = String(str2).toLowerCase();\n\n  if (a === b) return 1;\n  if (a.length === 0) return b.length === 0 ? 1 : 0;\n  if (b.length === 0) return 0;\n\n  // Swap to ensure we use the smaller string for columns (O(min(A,B)) space)\n  const [shorter, longer] = a.length < b.length ? [a, b] : [b, a];\n  const shorterLength = shorter.length;\n  const longerLength = longer.length;\n\n  let prevRow = Array.from({ length: shorterLength + 1 }, (_, i) => i);\n  let currRow = new Array(shorterLength + 1);\n\n  for (let i = 1; i <= longerLength; i++) {\n    currRow[0] = i;\n    for (let j = 1; j <= shorterLength; j++) {\n      const cost = longer[i - 1] === shorter[j - 1] ? 0 : 1;\n      currRow[j] = Math.min(\n        currRow[j - 1] + 1, // insertion\n        prevRow[j] + 1, // deletion\n        prevRow[j - 1] + cost, // substitution\n      );\n    }\n    // Swap rows for the next iteration (avoid allocation)\n    [prevRow, currRow] = [currRow, prevRow];\n  }\n\n  // After the loop, a result is in prevRow because of the swap\n  const distance = prevRow[shorterLength];\n\n  return 1 - distance / Math.max(a.length, b.length);\n}\n"],"names":["similarity","str1","str2","assert","a","b","shorter","longer","shorterLength","longerLength","prevRow","_","i","currRow","j","cost"],"mappings":"0HAoBO,SAASA,EAAWC,EAAeC,EAAuB,CAC/DC,EAAAA,OACE,CAAC,SAAU,QAAQ,EAAE,SAAS,OAAOF,CAAI,GAAK,CAAC,SAAU,QAAQ,EAAE,SAAS,OAAOC,CAAI,EACvF,oBACA,CACE,KAAM,CAAE,KAAAD,EAAM,KAAAC,CAAA,EACd,KAAM,SAAA,CACR,EAGF,MAAME,EAAI,OAAOH,CAAI,EAAE,YAAA,EACjBI,EAAI,OAAOH,CAAI,EAAE,YAAA,EAEvB,GAAIE,IAAMC,EAAG,MAAO,GACpB,GAAID,EAAE,SAAW,SAAUC,EAAE,SAAW,EAAI,EAAI,EAChD,GAAIA,EAAE,SAAW,EAAG,MAAO,GAG3B,KAAM,CAACC,EAASC,CAAM,EAAIH,EAAE,OAASC,EAAE,OAAS,CAACD,EAAGC,CAAC,EAAI,CAACA,EAAGD,CAAC,EACxDI,EAAgBF,EAAQ,OACxBG,EAAeF,EAAO,OAE5B,IAAIG,EAAU,MAAM,KAAK,CAAE,OAAQF,EAAgB,GAAK,CAACG,EAAGC,IAAMA,CAAC,EAC/DC,EAAU,IAAI,MAAML,EAAgB,CAAC,EAEzC,QAAS,EAAI,EAAG,GAAKC,EAAc,IAAK,CACtCI,EAAQ,CAAC,EAAI,EACb,QAASC,EAAI,EAAGA,GAAKN,EAAeM,IAAK,CACvC,MAAMC,EAAOR,EAAO,EAAI,CAAC,IAAMD,EAAQQ,EAAI,CAAC,EAAI,EAAI,EACpDD,EAAQC,CAAC,EAAI,KAAK,IAChBD,EAAQC,EAAI,CAAC,EAAI,EACjBJ,EAAQI,CAAC,EAAI,EACbJ,EAAQI,EAAI,CAAC,EAAIC,CAAA,CAErB,CAEA,CAACL,EAASG,CAAO,EAAI,CAACA,EAASH,CAAO,CACxC,CAKA,MAAO,GAFUA,EAAQF,CAAa,EAEhB,KAAK,IAAIJ,EAAE,OAAQC,EAAE,MAAM,CACnD"}

package/dist/string/similarity.js

@@ -1,34 +1,37 @@
-import { assert as l } from "../function/assert.js";
-function h(a, c) {
-  l(
-    ["string", "number"].includes(typeof a) && ["string", "number"].includes(typeof c),
+import { assert as f } from "../function/assert.js";
+function y(i, s) {
+  f(
+    ["string", "number"].includes(typeof i) && ["string", "number"].includes(typeof s),
     "Invalid arguments",
     {
-      args: { str1: a, str2: c },
+      args: { str1: i, str2: s },
       type: TypeError
     }
   );
-  const r = String(a).toLowerCase(), o = String(c).toLowerCase();
-  if (r === o) return 1;
-  if (!r.length || !o.length) return 0;
-  const i = r.length, s = o.length, e = Array.from({ length: i + 1 }, (t, n) => [n]);
-  for (let t = 0; t <= s; t++)
-    e[0][t] = t;
-  for (let t = 1; t <= i; t++)
-    for (let n = 1; n <= s; n++) {
-      const g = r[t - 1] === o[n - 1] ? 0 : 1;
-      e[t][n] = Math.min(
-        e[t - 1][n] + 1,
-        // deletion
-        e[t][n - 1] + 1,
+  const n = String(i).toLowerCase(), e = String(s).toLowerCase();
+  if (n === e) return 1;
+  if (n.length === 0) return e.length === 0 ? 1 : 0;
+  if (e.length === 0) return 0;
+  const [h, a] = n.length < e.length ? [n, e] : [e, n], l = h.length, c = a.length;
+  let r = Array.from({ length: l + 1 }, (g, t) => t), o = new Array(l + 1);
+  for (let g = 1; g <= c; g++) {
+    o[0] = g;
+    for (let t = 1; t <= l; t++) {
+      const u = a[g - 1] === h[t - 1] ? 0 : 1;
+      o[t] = Math.min(
+        o[t - 1] + 1,
         // insertion
-        e[t - 1][n - 1] + g
+        r[t] + 1,
+        // deletion
+        r[t - 1] + u
         // substitution
       );
     }
-  return 1 - e[i][s] / Math.max(i, s);
+    [r, o] = [o, r];
+  }
+  return 1 - r[l] / Math.max(n.length, e.length);
 }
 export {
-  h as similarity
+  y as similarity
 };
 //# sourceMappingURL=similarity.js.map

package/dist/string/similarity.js.map

@@ -1 +1 @@
-{"version":3,"file":"similarity.js","sources":["../../src/string/similarity.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Calculate the similarity between two strings using the Levenshtein distance algorithm.\n *\n * @example\n * ```ts\n * similarity('abc', 'abc') // 1\n * similarity('a', 'b') // 0\n * similarity('ab', 'ac') // 0.5\n * similarity('doe', 'John Doe') // 0.25\n * similarity('abc', 'axc') // 0.6666666666666667\n * similarity('kitten', 'sitting') // 0.5714285714285714\n * ```\n *\n * @param str1 - The first string.\n * @param str2 - The second string.\n *\n * @returns A number between 0 and 1 representing the similarity between the two strings.\n */\nexport function similarity(str1: unknown, str2: unknown): number {\n  assert(\n    ['string', 'number'].includes(typeof str1) && ['string', 'number'].includes(typeof str2),\n    'Invalid arguments',\n    {\n      args: { str1, str2 },\n      type: TypeError,\n    },\n  );\n\n  const a = String(str1).toLowerCase();\n  const b = String(str2).toLowerCase();\n\n  if (a === b) return 1;\n  if (!a.length || !b.length) return 0;\n\n  const aLength = a.length;\n  const bLength = b.length;\n\n  // Initialize matrix with first row and column\n  const matrix: number[][] = Array.from({ length: aLength + 1 }, (_, i) => [i]);\n  for (let j = 0; j <= bLength; j++) {\n    matrix[0][j] = j;\n  }\n\n  // Calculate Levenshtein distance\n  for (let i = 1; i <= aLength; i++) {\n    for (let j = 1; j <= bLength; j++) {\n      const cost = a[i - 1] === b[j - 1] ? 0 : 1;\n      matrix[i][j] = Math.min(\n        matrix[i - 1][j] + 1, // deletion\n        matrix[i][j - 1] + 1, // insertion\n        matrix[i - 1][j - 1] + cost, // substitution\n      );\n    }\n  }\n\n  const distance = matrix[aLength][bLength];\n\n  return 1 - distance / Math.max(aLength, bLength);\n}\n"],"names":["similarity","str1","str2","assert","a","b","aLength","bLength","matrix","_","i","j","cost"],"mappings":";AAoBO,SAASA,EAAWC,GAAeC,GAAuB;AAC/D,EAAAC;AAAA,IACE,CAAC,UAAU,QAAQ,EAAE,SAAS,OAAOF,CAAI,KAAK,CAAC,UAAU,QAAQ,EAAE,SAAS,OAAOC,CAAI;AAAA,IACvF;AAAA,IACA;AAAA,MACE,MAAM,EAAE,MAAAD,GAAM,MAAAC,EAAA;AAAA,MACd,MAAM;AAAA,IAAA;AAAA,EACR;AAGF,QAAME,IAAI,OAAOH,CAAI,EAAE,YAAA,GACjBI,IAAI,OAAOH,CAAI,EAAE,YAAA;AAEvB,MAAIE,MAAMC,EAAG,QAAO;AACpB,MAAI,CAACD,EAAE,UAAU,CAACC,EAAE,OAAQ,QAAO;AAEnC,QAAMC,IAAUF,EAAE,QACZG,IAAUF,EAAE,QAGZG,IAAqB,MAAM,KAAK,EAAE,QAAQF,IAAU,EAAA,GAAK,CAACG,GAAGC,MAAM,CAACA,CAAC,CAAC;AAC5E,WAASC,IAAI,GAAGA,KAAKJ,GAASI;AAC5B,IAAAH,EAAO,CAAC,EAAEG,CAAC,IAAIA;AAIjB,WAASD,IAAI,GAAGA,KAAKJ,GAASI;AAC5B,aAASC,IAAI,GAAGA,KAAKJ,GAASI,KAAK;AACjC,YAAMC,IAAOR,EAAEM,IAAI,CAAC,MAAML,EAAEM,IAAI,CAAC,IAAI,IAAI;AACzC,MAAAH,EAAOE,CAAC,EAAEC,CAAC,IAAI,KAAK;AAAA,QAClBH,EAAOE,IAAI,CAAC,EAAEC,CAAC,IAAI;AAAA;AAAA,QACnBH,EAAOE,CAAC,EAAEC,IAAI,CAAC,IAAI;AAAA;AAAA,QACnBH,EAAOE,IAAI,CAAC,EAAEC,IAAI,CAAC,IAAIC;AAAA;AAAA,MAAA;AAAA,IAE3B;AAKF,SAAO,IAFUJ,EAAOF,CAAO,EAAEC,CAAO,IAElB,KAAK,IAAID,GAASC,CAAO;AACjD;"}
+{"version":3,"file":"similarity.js","sources":["../../src/string/similarity.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Calculate the similarity between two strings using the Levenshtein distance algorithm.\n *\n * @example\n * ```ts\n * similarity('abc', 'abc') // 1\n * similarity('a', 'b') // 0\n * similarity('ab', 'ac') // 0.5\n * similarity('doe', 'John Doe') // 0.25\n * similarity('abc', 'axc') // 0.6666666666666667\n * similarity('kitten', 'sitting') // 0.5714285714285714\n * ```\n *\n * @param str1 - The first string.\n * @param str2 - The second string.\n *\n * @returns A number between 0 and 1 representing the similarity between the two strings.\n */\nexport function similarity(str1: unknown, str2: unknown): number {\n  assert(\n    ['string', 'number'].includes(typeof str1) && ['string', 'number'].includes(typeof str2),\n    'Invalid arguments',\n    {\n      args: { str1, str2 },\n      type: TypeError,\n    },\n  );\n\n  const a = String(str1).toLowerCase();\n  const b = String(str2).toLowerCase();\n\n  if (a === b) return 1;\n  if (a.length === 0) return b.length === 0 ? 1 : 0;\n  if (b.length === 0) return 0;\n\n  // Swap to ensure we use the smaller string for columns (O(min(A,B)) space)\n  const [shorter, longer] = a.length < b.length ? [a, b] : [b, a];\n  const shorterLength = shorter.length;\n  const longerLength = longer.length;\n\n  let prevRow = Array.from({ length: shorterLength + 1 }, (_, i) => i);\n  let currRow = new Array(shorterLength + 1);\n\n  for (let i = 1; i <= longerLength; i++) {\n    currRow[0] = i;\n    for (let j = 1; j <= shorterLength; j++) {\n      const cost = longer[i - 1] === shorter[j - 1] ? 0 : 1;\n      currRow[j] = Math.min(\n        currRow[j - 1] + 1, // insertion\n        prevRow[j] + 1, // deletion\n        prevRow[j - 1] + cost, // substitution\n      );\n    }\n    // Swap rows for the next iteration (avoid allocation)\n    [prevRow, currRow] = [currRow, prevRow];\n  }\n\n  // After the loop, a result is in prevRow because of the swap\n  const distance = prevRow[shorterLength];\n\n  return 1 - distance / Math.max(a.length, b.length);\n}\n"],"names":["similarity","str1","str2","assert","a","b","shorter","longer","shorterLength","longerLength","prevRow","_","i","currRow","j","cost"],"mappings":";AAoBO,SAASA,EAAWC,GAAeC,GAAuB;AAC/D,EAAAC;AAAA,IACE,CAAC,UAAU,QAAQ,EAAE,SAAS,OAAOF,CAAI,KAAK,CAAC,UAAU,QAAQ,EAAE,SAAS,OAAOC,CAAI;AAAA,IACvF;AAAA,IACA;AAAA,MACE,MAAM,EAAE,MAAAD,GAAM,MAAAC,EAAA;AAAA,MACd,MAAM;AAAA,IAAA;AAAA,EACR;AAGF,QAAME,IAAI,OAAOH,CAAI,EAAE,YAAA,GACjBI,IAAI,OAAOH,CAAI,EAAE,YAAA;AAEvB,MAAIE,MAAMC,EAAG,QAAO;AACpB,MAAID,EAAE,WAAW,UAAUC,EAAE,WAAW,IAAI,IAAI;AAChD,MAAIA,EAAE,WAAW,EAAG,QAAO;AAG3B,QAAM,CAACC,GAASC,CAAM,IAAIH,EAAE,SAASC,EAAE,SAAS,CAACD,GAAGC,CAAC,IAAI,CAACA,GAAGD,CAAC,GACxDI,IAAgBF,EAAQ,QACxBG,IAAeF,EAAO;AAE5B,MAAIG,IAAU,MAAM,KAAK,EAAE,QAAQF,IAAgB,KAAK,CAACG,GAAGC,MAAMA,CAAC,GAC/DC,IAAU,IAAI,MAAML,IAAgB,CAAC;AAEzC,WAASI,IAAI,GAAGA,KAAKH,GAAcG,KAAK;AACtC,IAAAC,EAAQ,CAAC,IAAID;AACb,aAASE,IAAI,GAAGA,KAAKN,GAAeM,KAAK;AACvC,YAAMC,IAAOR,EAAOK,IAAI,CAAC,MAAMN,EAAQQ,IAAI,CAAC,IAAI,IAAI;AACpD,MAAAD,EAAQC,CAAC,IAAI,KAAK;AAAA,QAChBD,EAAQC,IAAI,CAAC,IAAI;AAAA;AAAA,QACjBJ,EAAQI,CAAC,IAAI;AAAA;AAAA,QACbJ,EAAQI,IAAI,CAAC,IAAIC;AAAA;AAAA,MAAA;AAAA,IAErB;AAEA,KAACL,GAASG,CAAO,IAAI,CAACA,GAASH,CAAO;AAAA,EACxC;AAKA,SAAO,IAFUA,EAAQF,CAAa,IAEhB,KAAK,IAAIJ,EAAE,QAAQC,EAAE,MAAM;AACnD;"}

package/dist/string/truncate.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function f(e,t=25,r=!1,u="…"){if(e.length<=t)return e;const n=r?e.substring(0,t).lastIndexOf(" "):t,c=n>0?n:t;return`${e.substring(0,c).trim()}${u}`}exports.truncate=f;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../function/assert.cjs");function o(t,e=25,s=!1,u="…"){if(n.assert(typeof t=="string","First argument must be a string",{args:{str:t},type:TypeError}),n.assert(typeof e=="number"&&e>=0&&Number.isFinite(e),"Limit must be a non-negative finite number",{args:{limit:e},type:TypeError}),t.length<=e)return t;const r=s?t.substring(0,e).lastIndexOf(" "):e,a=r>0?r:e;return`${t.substring(0,a).trim()}${u}`}exports.truncate=o;
 //# sourceMappingURL=truncate.cjs.map

package/dist/string/truncate.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"truncate.cjs","sources":["../../src/string/truncate.ts"],"sourcesContent":["/**\n * Truncates a string if it is longer than the given maximum string length. The last characters of the truncated string are replaced with the ellipsis sign \"…\".\n *\n * @example\n * ```ts\n * const text = 'Hello World';\n * truncate(text, 5); // 'Hello…'\n * truncate(text, 3, true); // 'Hello…'\n * truncate(text, 5, true, '...'); // 'Hello...'\n * ```\n *\n * @param str - The string to truncate.\n * @param limit - The maximum string length.\n * @param completeWords - If true, the string is truncated to the nearest word, instead of character.\n * @param ellipsis - The characters to end the truncated string with.\n *\n * @returns The truncated string.\n */\nexport function truncate(str: string, limit = 25, completeWords = false, ellipsis = '…'): string {\n  if (str.length <= limit) return str;\n\n  const _limit = completeWords ? str.substring(0, limit).lastIndexOf(' ') : limit;\n  const effectiveLimit = _limit > 0 ? _limit : limit;\n\n  return `${str.substring(0, effectiveLimit).trim()}${ellipsis}`;\n}\n"],"names":["truncate","str","limit","completeWords","ellipsis","_limit","effectiveLimit"],"mappings":"gFAkBO,SAASA,EAASC,EAAaC,EAAQ,GAAIC,EAAgB,GAAOC,EAAW,IAAa,CAC/F,GAAIH,EAAI,QAAUC,EAAO,OAAOD,EAEhC,MAAMI,EAASF,EAAgBF,EAAI,UAAU,EAAGC,CAAK,EAAE,YAAY,GAAG,EAAIA,EACpEI,EAAiBD,EAAS,EAAIA,EAASH,EAE7C,MAAO,GAAGD,EAAI,UAAU,EAAGK,CAAc,EAAE,KAAA,CAAM,GAAGF,CAAQ,EAC9D"}
+{"version":3,"file":"truncate.cjs","sources":["../../src/string/truncate.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Truncates a string if it is longer than the given maximum string length. The last characters of the truncated string are replaced with the ellipsis sign \"…\".\n *\n * @example\n * ```ts\n * const text = 'Hello World';\n * truncate(text, 5); // 'Hello…'\n * truncate(text, 3, true); // 'Hello…'\n * truncate(text, 5, true, '...'); // 'Hello...'\n * ```\n *\n * @param str - The string to truncate.\n * @param limit - The maximum string length.\n * @param completeWords - If true, the string is truncated to the nearest word, instead of character.\n * @param ellipsis - The characters to end the truncated string with.\n *\n * @returns The truncated string.\n *\n * @throws {TypeError} If str is not a string or limit is not a positive number.\n */\nexport function truncate(str: string, limit = 25, completeWords = false, ellipsis = '…'): string {\n  assert(typeof str === 'string', 'First argument must be a string', {\n    args: { str },\n    type: TypeError,\n  });\n  assert(\n    typeof limit === 'number' && limit >= 0 && Number.isFinite(limit),\n    'Limit must be a non-negative finite number',\n    { args: { limit }, type: TypeError },\n  );\n\n  if (str.length <= limit) {\n    return str;\n  }\n\n  const _limit = completeWords ? str.substring(0, limit).lastIndexOf(' ') : limit;\n  const effectiveLimit = _limit > 0 ? _limit : limit;\n\n  return `${str.substring(0, effectiveLimit).trim()}${ellipsis}`;\n}\n"],"names":["truncate","str","limit","completeWords","ellipsis","assert","_limit","effectiveLimit"],"mappings":"0HAsBO,SAASA,EAASC,EAAaC,EAAQ,GAAIC,EAAgB,GAAOC,EAAW,IAAa,CAW/F,GAVAC,EAAAA,OAAO,OAAOJ,GAAQ,SAAU,kCAAmC,CACjE,KAAM,CAAE,IAAAA,CAAA,EACR,KAAM,SAAA,CACP,EACDI,EAAAA,OACE,OAAOH,GAAU,UAAYA,GAAS,GAAK,OAAO,SAASA,CAAK,EAChE,6CACA,CAAE,KAAM,CAAE,MAAAA,CAAA,EAAS,KAAM,SAAA,CAAU,EAGjCD,EAAI,QAAUC,EAChB,OAAOD,EAGT,MAAMK,EAASH,EAAgBF,EAAI,UAAU,EAAGC,CAAK,EAAE,YAAY,GAAG,EAAIA,EACpEK,EAAiBD,EAAS,EAAIA,EAASJ,EAE7C,MAAO,GAAGD,EAAI,UAAU,EAAGM,CAAc,EAAE,KAAA,CAAM,GAAGH,CAAQ,EAC9D"}

package/dist/string/truncate.js

@@ -1,9 +1,18 @@
-function c(n, e = 25, f = !1, r = "…") {
-  if (n.length <= e) return n;
-  const t = f ? n.substring(0, e).lastIndexOf(" ") : e, u = t > 0 ? t : e;
-  return `${n.substring(0, u).trim()}${r}`;
+import { assert as t } from "../function/assert.js";
+function f(r, e = 25, s = !1, u = "…") {
+  if (t(typeof r == "string", "First argument must be a string", {
+    args: { str: r },
+    type: TypeError
+  }), t(
+    typeof e == "number" && e >= 0 && Number.isFinite(e),
+    "Limit must be a non-negative finite number",
+    { args: { limit: e }, type: TypeError }
+  ), r.length <= e)
+    return r;
+  const n = s ? r.substring(0, e).lastIndexOf(" ") : e, o = n > 0 ? n : e;
+  return `${r.substring(0, o).trim()}${u}`;
 }
 export {
-  c as truncate
+  f as truncate
 };
 //# sourceMappingURL=truncate.js.map

package/dist/string/truncate.js.map

@@ -1 +1 @@
-{"version":3,"file":"truncate.js","sources":["../../src/string/truncate.ts"],"sourcesContent":["/**\n * Truncates a string if it is longer than the given maximum string length. The last characters of the truncated string are replaced with the ellipsis sign \"…\".\n *\n * @example\n * ```ts\n * const text = 'Hello World';\n * truncate(text, 5); // 'Hello…'\n * truncate(text, 3, true); // 'Hello…'\n * truncate(text, 5, true, '...'); // 'Hello...'\n * ```\n *\n * @param str - The string to truncate.\n * @param limit - The maximum string length.\n * @param completeWords - If true, the string is truncated to the nearest word, instead of character.\n * @param ellipsis - The characters to end the truncated string with.\n *\n * @returns The truncated string.\n */\nexport function truncate(str: string, limit = 25, completeWords = false, ellipsis = '…'): string {\n  if (str.length <= limit) return str;\n\n  const _limit = completeWords ? str.substring(0, limit).lastIndexOf(' ') : limit;\n  const effectiveLimit = _limit > 0 ? _limit : limit;\n\n  return `${str.substring(0, effectiveLimit).trim()}${ellipsis}`;\n}\n"],"names":["truncate","str","limit","completeWords","ellipsis","_limit","effectiveLimit"],"mappings":"AAkBO,SAASA,EAASC,GAAaC,IAAQ,IAAIC,IAAgB,IAAOC,IAAW,KAAa;AAC/F,MAAIH,EAAI,UAAUC,EAAO,QAAOD;AAEhC,QAAMI,IAASF,IAAgBF,EAAI,UAAU,GAAGC,CAAK,EAAE,YAAY,GAAG,IAAIA,GACpEI,IAAiBD,IAAS,IAAIA,IAASH;AAE7C,SAAO,GAAGD,EAAI,UAAU,GAAGK,CAAc,EAAE,KAAA,CAAM,GAAGF,CAAQ;AAC9D;"}
+{"version":3,"file":"truncate.js","sources":["../../src/string/truncate.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Truncates a string if it is longer than the given maximum string length. The last characters of the truncated string are replaced with the ellipsis sign \"…\".\n *\n * @example\n * ```ts\n * const text = 'Hello World';\n * truncate(text, 5); // 'Hello…'\n * truncate(text, 3, true); // 'Hello…'\n * truncate(text, 5, true, '...'); // 'Hello...'\n * ```\n *\n * @param str - The string to truncate.\n * @param limit - The maximum string length.\n * @param completeWords - If true, the string is truncated to the nearest word, instead of character.\n * @param ellipsis - The characters to end the truncated string with.\n *\n * @returns The truncated string.\n *\n * @throws {TypeError} If str is not a string or limit is not a positive number.\n */\nexport function truncate(str: string, limit = 25, completeWords = false, ellipsis = '…'): string {\n  assert(typeof str === 'string', 'First argument must be a string', {\n    args: { str },\n    type: TypeError,\n  });\n  assert(\n    typeof limit === 'number' && limit >= 0 && Number.isFinite(limit),\n    'Limit must be a non-negative finite number',\n    { args: { limit }, type: TypeError },\n  );\n\n  if (str.length <= limit) {\n    return str;\n  }\n\n  const _limit = completeWords ? str.substring(0, limit).lastIndexOf(' ') : limit;\n  const effectiveLimit = _limit > 0 ? _limit : limit;\n\n  return `${str.substring(0, effectiveLimit).trim()}${ellipsis}`;\n}\n"],"names":["truncate","str","limit","completeWords","ellipsis","assert","_limit","effectiveLimit"],"mappings":";AAsBO,SAASA,EAASC,GAAaC,IAAQ,IAAIC,IAAgB,IAAOC,IAAW,KAAa;AAW/F,MAVAC,EAAO,OAAOJ,KAAQ,UAAU,mCAAmC;AAAA,IACjE,MAAM,EAAE,KAAAA,EAAA;AAAA,IACR,MAAM;AAAA,EAAA,CACP,GACDI;AAAA,IACE,OAAOH,KAAU,YAAYA,KAAS,KAAK,OAAO,SAASA,CAAK;AAAA,IAChE;AAAA,IACA,EAAE,MAAM,EAAE,OAAAA,EAAA,GAAS,MAAM,UAAA;AAAA,EAAU,GAGjCD,EAAI,UAAUC;AAChB,WAAOD;AAGT,QAAMK,IAASH,IAAgBF,EAAI,UAAU,GAAGC,CAAK,EAAE,YAAY,GAAG,IAAIA,GACpEK,IAAiBD,IAAS,IAAIA,IAASJ;AAE7C,SAAO,GAAGD,EAAI,UAAU,GAAGM,CAAc,EAAE,KAAA,CAAM,GAAGH,CAAQ;AAC9D;"}

package/dist/typed/is.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./ge.cjs"),n=require("./gt.cjs"),o=require("./isDefined.cjs"),c=require("./isEmpty.cjs"),r=require("./isEqual.cjs"),u=require("./isEven.cjs"),q=require("./isMatch.cjs"),l=require("./isNegative.cjs"),d=require("./isNil.cjs"),g=require("./isOdd.cjs"),a=require("./isPositive.cjs"),v=require("./isRegex.cjs"),p=require("./isWithin.cjs"),f=require("./isZero.cjs"),m=require("./le.cjs"),E=require("./lt.cjs"),h=require("./typeOf.cjs");function y(i,s){if(!i)throw new Error("Type must be provided");return{defined:o.isDefined,empty:c.isEmpty,eq:e=>r.isEqual(...e),even:u.isEven,ge:e=>t.ge(...e),gt:e=>n.gt(...e),le:e=>m.le(...e),lt:e=>E.lt(...e),match:e=>q.isMatch(...e),ne:e=>!r.isEqual(...e),negative:l.isNegative,nil:d.isNil,odd:g.isOdd,positive:a.isPositive,regex:v.isRegex,within:e=>p.isWithin(...e),zero:f.isZero}[i]?.(s)??h.typeOf(s)===i}exports.is=y;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("../function/assert.cjs"),n=require("./ge.cjs"),o=require("./gt.cjs"),c=require("./isDefined.cjs"),u=require("./isEmpty.cjs"),r=require("./isEqual.cjs"),q=require("./isEven.cjs"),a=require("./isMatch.cjs"),l=require("./isNegative.cjs"),d=require("./isNil.cjs"),g=require("./isOdd.cjs"),v=require("./isPositive.cjs"),p=require("./isRegex.cjs"),m=require("./isWithin.cjs"),E=require("./isZero.cjs"),f=require("./le.cjs"),h=require("./lt.cjs"),y=require("./typeOf.cjs");function O(i,s){return t.assert(!!i,"Type must be provided",{args:{type:i},type:Error}),{defined:c.isDefined,empty:u.isEmpty,eq:e=>r.isEqual(...e),even:q.isEven,ge:e=>n.ge(...e),gt:e=>o.gt(...e),le:e=>f.le(...e),lt:e=>h.lt(...e),match:e=>a.isMatch(...e),ne:e=>!r.isEqual(...e),negative:l.isNegative,nil:d.isNil,odd:g.isOdd,positive:v.isPositive,regex:p.isRegex,within:e=>m.isWithin(...e),zero:E.isZero}[i]?.(s)??y.typeOf(s)===i}exports.is=O;
 //# sourceMappingURL=is.cjs.map

package/dist/typed/is.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is.cjs","sources":["../../src/typed/is.ts"],"sourcesContent":["import { ge } from './ge';\nimport { gt } from './gt';\nimport { isDefined } from './isDefined';\nimport { isEmpty } from './isEmpty';\nimport { isEqual } from './isEqual';\nimport { isEven } from './isEven';\nimport { isMatch } from './isMatch';\nimport { isNegative } from './isNegative';\nimport { isNil } from './isNil';\nimport { isOdd } from './isOdd';\nimport { isPositive } from './isPositive';\nimport { isRegex } from './isRegex';\nimport { isWithin } from './isWithin';\nimport { isZero } from './isZero';\nimport { le } from './le';\nimport { lt } from './lt';\nimport { type ArgType, typeOf } from './typeOf';\n\ntype isType =\n  | ArgType\n  | 'defined'\n  | 'empty'\n  | 'eq'\n  | 'even'\n  | 'ge'\n  | 'gt'\n  | 'le'\n  | 'lt'\n  | 'match'\n  | 'ne'\n  | 'negative'\n  | 'nil'\n  | 'odd'\n  | 'positive'\n  | 'regex'\n  | 'within'\n  | 'zero';\n\n/**\n * @description\n * Checks if the value type of argument.\n *\n * @example\n * ```ts\n * is('array', []);\n * is('boolean', true);\n * is('date', new Date());\n * is('defined', 123);\n * is('empty', []);\n * is('even', 2);\n * is('function', () => {});\n * is('match', { a: 1, b: 2 }, { a: 1 });\n * is('nan', Number.NaN);\n * is('negative', -123);\n * is('nil', null);\n * is('null', null);\n * is('number', 123);\n * is('object', {});\n * is('odd', 3);\n * is('positive', 123);\n * is('string', 'hello');\n * is('symbol', Symbol('test'));\n * is('regex', /abc/);\n * is('string', 'hello world');\n * is('undefined', undefined);\n * is('within', 1, 2, 3);\n * is('zero', 0);\n * is('eq', [1, 2, 3], [1, 2, 3]);\n * is('ne', [1, 2, 3], [1, 2]);\n * is('ge', 5, 5);\n * is('gt', 5, 3);\n * is('le', 5, 5);\n * is('lt', 3, 5);\n * ```\n *\n * @param type - The type to check against.\n * @param args - The argument to be checked.\n *\n * @returns `true` if the value is of the specified type, else `false`.\n */\nexport function is(type: 'within', ...args: Parameters<typeof isWithin>): boolean;\nexport function is(type: 'eq', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'ne', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'gt', ...args: Parameters<typeof gt>): boolean;\nexport function is(type: 'ge', ...args: Parameters<typeof ge>): boolean;\nexport function is(type: 'lt', ...args: Parameters<typeof lt>): boolean;\nexport function is(type: 'le', ...args: Parameters<typeof le>): boolean;\nexport function is(type: 'match', ...args: Parameters<typeof isMatch>): boolean;\nexport function is(type: 'empty', ...args: Parameters<typeof isEmpty>): boolean;\nexport function is(type: 'array', arg: unknown): arg is Array<unknown>;\nexport function is(type: 'string', arg: unknown): arg is string;\nexport function is(type: 'number', arg: unknown): arg is number;\nexport function is(type: 'object', arg: unknown): arg is object;\nexport function is(type: 'nil', arg: unknown): arg is null | undefined;\nexport function is(type: 'primitive', arg: unknown): arg is string | number | boolean;\nexport function is(type: isType, arg: unknown): boolean;\nexport function is(type: string, arg: unknown): boolean {\n  if (!type) {\n    throw new Error('Type must be provided');\n  }\n\n  const compare = {\n    defined: isDefined,\n    empty: isEmpty,\n    eq: (args: Parameters<typeof isEqual>) => isEqual(...args),\n    even: isEven,\n    ge: (args: Parameters<typeof ge>) => ge(...args),\n    gt: (args: Parameters<typeof gt>) => gt(...args),\n    le: (args: Parameters<typeof le>) => le(...args),\n    lt: (args: Parameters<typeof lt>) => lt(...args),\n    match: (args: Parameters<typeof isMatch>) => isMatch(...args),\n    ne: (args: Parameters<typeof isEqual>) => !isEqual(...args),\n    negative: isNegative,\n    nil: isNil,\n    odd: isOdd,\n    positive: isPositive,\n    regex: isRegex,\n    within: (args: Parameters<typeof isWithin>) => isWithin(...args),\n    zero: isZero,\n  };\n\n  return compare[type as keyof typeof compare]?.(arg) ?? typeOf(arg) === type;\n}\n"],"names":["is","type","arg","isDefined","isEmpty","args","isEqual","isEven","ge","gt","le","lt","isMatch","isNegative","isNil","isOdd","isPositive","isRegex","isWithin","isZero","typeOf"],"mappings":"+gBAgGO,SAASA,EAAGC,EAAcC,EAAuB,CACtD,GAAI,CAACD,EACH,MAAM,IAAI,MAAM,uBAAuB,EAuBzC,MApBgB,CACd,QAASE,EAAAA,UACT,MAAOC,EAAAA,QACP,GAAKC,GAAqCC,EAAAA,QAAQ,GAAGD,CAAI,EACzD,KAAME,EAAAA,OACN,GAAKF,GAAgCG,EAAAA,GAAG,GAAGH,CAAI,EAC/C,GAAKA,GAAgCI,EAAAA,GAAG,GAAGJ,CAAI,EAC/C,GAAKA,GAAgCK,EAAAA,GAAG,GAAGL,CAAI,EAC/C,GAAKA,GAAgCM,EAAAA,GAAG,GAAGN,CAAI,EAC/C,MAAQA,GAAqCO,EAAAA,QAAQ,GAAGP,CAAI,EAC5D,GAAKA,GAAqC,CAACC,EAAAA,QAAQ,GAAGD,CAAI,EAC1D,SAAUQ,EAAAA,WACV,IAAKC,EAAAA,MACL,IAAKC,EAAAA,MACL,SAAUC,EAAAA,WACV,MAAOC,EAAAA,QACP,OAASZ,GAAsCa,EAAAA,SAAS,GAAGb,CAAI,EAC/D,KAAMc,EAAAA,MAAA,EAGOlB,CAA4B,IAAIC,CAAG,GAAKkB,EAAAA,OAAOlB,CAAG,IAAMD,CACzE"}
+{"version":3,"file":"is.cjs","sources":["../../src/typed/is.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { ge } from './ge';\nimport { gt } from './gt';\nimport { isDefined } from './isDefined';\nimport { isEmpty } from './isEmpty';\nimport { isEqual } from './isEqual';\nimport { isEven } from './isEven';\nimport { isMatch } from './isMatch';\nimport { isNegative } from './isNegative';\nimport { isNil } from './isNil';\nimport { isOdd } from './isOdd';\nimport { isPositive } from './isPositive';\nimport { isRegex } from './isRegex';\nimport { isWithin } from './isWithin';\nimport { isZero } from './isZero';\nimport { le } from './le';\nimport { lt } from './lt';\nimport { type ArgType, typeOf } from './typeOf';\n\ntype isType =\n  | ArgType\n  | 'defined'\n  | 'empty'\n  | 'eq'\n  | 'even'\n  | 'ge'\n  | 'gt'\n  | 'le'\n  | 'lt'\n  | 'match'\n  | 'ne'\n  | 'negative'\n  | 'nil'\n  | 'odd'\n  | 'positive'\n  | 'regex'\n  | 'within'\n  | 'zero';\n\n/**\n * @description\n * Checks if the value type of argument.\n *\n * @example\n * ```ts\n * is('array', []);\n * is('boolean', true);\n * is('date', new Date());\n * is('defined', 123);\n * is('empty', []);\n * is('even', 2);\n * is('function', () => {});\n * is('match', { a: 1, b: 2 }, { a: 1 });\n * is('nan', Number.NaN);\n * is('negative', -123);\n * is('nil', null);\n * is('null', null);\n * is('number', 123);\n * is('object', {});\n * is('odd', 3);\n * is('positive', 123);\n * is('string', 'hello');\n * is('symbol', Symbol('test'));\n * is('regex', /abc/);\n * is('string', 'hello world');\n * is('undefined', undefined);\n * is('within', 1, 2, 3);\n * is('zero', 0);\n * is('eq', [1, 2, 3], [1, 2, 3]);\n * is('ne', [1, 2, 3], [1, 2]);\n * is('ge', 5, 5);\n * is('gt', 5, 3);\n * is('le', 5, 5);\n * is('lt', 3, 5);\n * ```\n *\n * @param type - The type to check against.\n * @param args - The argument to be checked.\n *\n * @returns `true` if the value is of the specified type, else `false`.\n */\nexport function is(type: 'within', ...args: Parameters<typeof isWithin>): boolean;\nexport function is(type: 'eq', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'ne', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'gt', ...args: Parameters<typeof gt>): boolean;\nexport function is(type: 'ge', ...args: Parameters<typeof ge>): boolean;\nexport function is(type: 'lt', ...args: Parameters<typeof lt>): boolean;\nexport function is(type: 'le', ...args: Parameters<typeof le>): boolean;\nexport function is(type: 'match', ...args: Parameters<typeof isMatch>): boolean;\nexport function is(type: 'empty', ...args: Parameters<typeof isEmpty>): boolean;\nexport function is(type: 'array', arg: unknown): arg is Array<unknown>;\nexport function is(type: 'string', arg: unknown): arg is string;\nexport function is(type: 'number', arg: unknown): arg is number;\nexport function is(type: 'object', arg: unknown): arg is object;\nexport function is(type: 'nil', arg: unknown): arg is null | undefined;\nexport function is(type: 'primitive', arg: unknown): arg is string | number | boolean;\nexport function is(type: isType, arg: unknown): boolean;\nexport function is(type: string, arg: unknown): boolean {\n  assert(Boolean(type), 'Type must be provided', { args: { type }, type: Error });\n\n  const compare = {\n    defined: isDefined,\n    empty: isEmpty,\n    eq: (args: Parameters<typeof isEqual>) => isEqual(...args),\n    even: isEven,\n    ge: (args: Parameters<typeof ge>) => ge(...args),\n    gt: (args: Parameters<typeof gt>) => gt(...args),\n    le: (args: Parameters<typeof le>) => le(...args),\n    lt: (args: Parameters<typeof lt>) => lt(...args),\n    match: (args: Parameters<typeof isMatch>) => isMatch(...args),\n    ne: (args: Parameters<typeof isEqual>) => !isEqual(...args),\n    negative: isNegative,\n    nil: isNil,\n    odd: isOdd,\n    positive: isPositive,\n    regex: isRegex,\n    within: (args: Parameters<typeof isWithin>) => isWithin(...args),\n    zero: isZero,\n  };\n\n  return compare[type as keyof typeof compare]?.(arg) ?? typeOf(arg) === type;\n}\n"],"names":["is","type","arg","assert","isDefined","isEmpty","args","isEqual","isEven","ge","gt","le","lt","isMatch","isNegative","isNil","isOdd","isPositive","isRegex","isWithin","isZero","typeOf"],"mappings":"mjBAiGO,SAASA,EAAGC,EAAcC,EAAuB,CACtDC,OAAAA,EAAAA,OAAO,EAAQF,EAAO,wBAAyB,CAAE,KAAM,CAAE,KAAAA,CAAA,EAAQ,KAAM,MAAO,EAE9D,CACd,QAASG,EAAAA,UACT,MAAOC,EAAAA,QACP,GAAKC,GAAqCC,EAAAA,QAAQ,GAAGD,CAAI,EACzD,KAAME,EAAAA,OACN,GAAKF,GAAgCG,EAAAA,GAAG,GAAGH,CAAI,EAC/C,GAAKA,GAAgCI,EAAAA,GAAG,GAAGJ,CAAI,EAC/C,GAAKA,GAAgCK,EAAAA,GAAG,GAAGL,CAAI,EAC/C,GAAKA,GAAgCM,EAAAA,GAAG,GAAGN,CAAI,EAC/C,MAAQA,GAAqCO,EAAAA,QAAQ,GAAGP,CAAI,EAC5D,GAAKA,GAAqC,CAACC,EAAAA,QAAQ,GAAGD,CAAI,EAC1D,SAAUQ,EAAAA,WACV,IAAKC,EAAAA,MACL,IAAKC,EAAAA,MACL,SAAUC,EAAAA,WACV,MAAOC,EAAAA,QACP,OAASZ,GAAsCa,EAAAA,SAAS,GAAGb,CAAI,EAC/D,KAAMc,EAAAA,MAAA,EAGOnB,CAA4B,IAAIC,CAAG,GAAKmB,EAAAA,OAAOnB,CAAG,IAAMD,CACzE"}

package/dist/typed/is.js

@@ -1,44 +1,43 @@
-import { ge as t } from "./ge.js";
-import { gt as e } from "./gt.js";
-import { isDefined as p } from "./isDefined.js";
-import { isEmpty as f } from "./isEmpty.js";
+import { assert as t } from "../function/assert.js";
+import { ge as e } from "./ge.js";
+import { gt as p } from "./gt.js";
+import { isDefined as f } from "./isDefined.js";
+import { isEmpty as s } from "./isEmpty.js";
 import { isEqual as m } from "./isEqual.js";
-import { isEven as s } from "./isEven.js";
-import { isMatch as n } from "./isMatch.js";
+import { isEven as n } from "./isEven.js";
+import { isMatch as a } from "./isMatch.js";
 import { isNegative as d } from "./isNegative.js";
 import { isNil as g } from "./isNil.js";
 import { isOdd as l } from "./isOdd.js";
 import { isPositive as v } from "./isPositive.js";
-import { isRegex as a } from "./isRegex.js";
-import { isWithin as c } from "./isWithin.js";
-import { isZero as h } from "./isZero.js";
-import { le as u } from "./le.js";
-import { lt as E } from "./lt.js";
-import { typeOf as w } from "./typeOf.js";
-function C(o, r) {
-  if (!o)
-    throw new Error("Type must be provided");
-  return {
-    defined: p,
-    empty: f,
-    eq: (i) => m(...i),
-    even: s,
-    ge: (i) => t(...i),
-    gt: (i) => e(...i),
-    le: (i) => u(...i),
-    lt: (i) => E(...i),
-    match: (i) => n(...i),
-    ne: (i) => !m(...i),
+import { isRegex as c } from "./isRegex.js";
+import { isWithin as h } from "./isWithin.js";
+import { isZero as u } from "./isZero.js";
+import { le as E } from "./le.js";
+import { lt as x } from "./lt.js";
+import { typeOf as q } from "./typeOf.js";
+function G(r, i) {
+  return t(!!r, "Type must be provided", { args: { type: r }, type: Error }), {
+    defined: f,
+    empty: s,
+    eq: (o) => m(...o),
+    even: n,
+    ge: (o) => e(...o),
+    gt: (o) => p(...o),
+    le: (o) => E(...o),
+    lt: (o) => x(...o),
+    match: (o) => a(...o),
+    ne: (o) => !m(...o),
     negative: d,
     nil: g,
     odd: l,
     positive: v,
-    regex: a,
-    within: (i) => c(...i),
-    zero: h
-  }[o]?.(r) ?? w(r) === o;
+    regex: c,
+    within: (o) => h(...o),
+    zero: u
+  }[r]?.(i) ?? q(i) === r;
 }
 export {
-  C as is
+  G as is
 };
 //# sourceMappingURL=is.js.map

package/dist/typed/is.js.map

@@ -1 +1 @@
-{"version":3,"file":"is.js","sources":["../../src/typed/is.ts"],"sourcesContent":["import { ge } from './ge';\nimport { gt } from './gt';\nimport { isDefined } from './isDefined';\nimport { isEmpty } from './isEmpty';\nimport { isEqual } from './isEqual';\nimport { isEven } from './isEven';\nimport { isMatch } from './isMatch';\nimport { isNegative } from './isNegative';\nimport { isNil } from './isNil';\nimport { isOdd } from './isOdd';\nimport { isPositive } from './isPositive';\nimport { isRegex } from './isRegex';\nimport { isWithin } from './isWithin';\nimport { isZero } from './isZero';\nimport { le } from './le';\nimport { lt } from './lt';\nimport { type ArgType, typeOf } from './typeOf';\n\ntype isType =\n  | ArgType\n  | 'defined'\n  | 'empty'\n  | 'eq'\n  | 'even'\n  | 'ge'\n  | 'gt'\n  | 'le'\n  | 'lt'\n  | 'match'\n  | 'ne'\n  | 'negative'\n  | 'nil'\n  | 'odd'\n  | 'positive'\n  | 'regex'\n  | 'within'\n  | 'zero';\n\n/**\n * @description\n * Checks if the value type of argument.\n *\n * @example\n * ```ts\n * is('array', []);\n * is('boolean', true);\n * is('date', new Date());\n * is('defined', 123);\n * is('empty', []);\n * is('even', 2);\n * is('function', () => {});\n * is('match', { a: 1, b: 2 }, { a: 1 });\n * is('nan', Number.NaN);\n * is('negative', -123);\n * is('nil', null);\n * is('null', null);\n * is('number', 123);\n * is('object', {});\n * is('odd', 3);\n * is('positive', 123);\n * is('string', 'hello');\n * is('symbol', Symbol('test'));\n * is('regex', /abc/);\n * is('string', 'hello world');\n * is('undefined', undefined);\n * is('within', 1, 2, 3);\n * is('zero', 0);\n * is('eq', [1, 2, 3], [1, 2, 3]);\n * is('ne', [1, 2, 3], [1, 2]);\n * is('ge', 5, 5);\n * is('gt', 5, 3);\n * is('le', 5, 5);\n * is('lt', 3, 5);\n * ```\n *\n * @param type - The type to check against.\n * @param args - The argument to be checked.\n *\n * @returns `true` if the value is of the specified type, else `false`.\n */\nexport function is(type: 'within', ...args: Parameters<typeof isWithin>): boolean;\nexport function is(type: 'eq', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'ne', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'gt', ...args: Parameters<typeof gt>): boolean;\nexport function is(type: 'ge', ...args: Parameters<typeof ge>): boolean;\nexport function is(type: 'lt', ...args: Parameters<typeof lt>): boolean;\nexport function is(type: 'le', ...args: Parameters<typeof le>): boolean;\nexport function is(type: 'match', ...args: Parameters<typeof isMatch>): boolean;\nexport function is(type: 'empty', ...args: Parameters<typeof isEmpty>): boolean;\nexport function is(type: 'array', arg: unknown): arg is Array<unknown>;\nexport function is(type: 'string', arg: unknown): arg is string;\nexport function is(type: 'number', arg: unknown): arg is number;\nexport function is(type: 'object', arg: unknown): arg is object;\nexport function is(type: 'nil', arg: unknown): arg is null | undefined;\nexport function is(type: 'primitive', arg: unknown): arg is string | number | boolean;\nexport function is(type: isType, arg: unknown): boolean;\nexport function is(type: string, arg: unknown): boolean {\n  if (!type) {\n    throw new Error('Type must be provided');\n  }\n\n  const compare = {\n    defined: isDefined,\n    empty: isEmpty,\n    eq: (args: Parameters<typeof isEqual>) => isEqual(...args),\n    even: isEven,\n    ge: (args: Parameters<typeof ge>) => ge(...args),\n    gt: (args: Parameters<typeof gt>) => gt(...args),\n    le: (args: Parameters<typeof le>) => le(...args),\n    lt: (args: Parameters<typeof lt>) => lt(...args),\n    match: (args: Parameters<typeof isMatch>) => isMatch(...args),\n    ne: (args: Parameters<typeof isEqual>) => !isEqual(...args),\n    negative: isNegative,\n    nil: isNil,\n    odd: isOdd,\n    positive: isPositive,\n    regex: isRegex,\n    within: (args: Parameters<typeof isWithin>) => isWithin(...args),\n    zero: isZero,\n  };\n\n  return compare[type as keyof typeof compare]?.(arg) ?? typeOf(arg) === type;\n}\n"],"names":["is","type","arg","isDefined","isEmpty","args","isEqual","isEven","ge","gt","le","lt","isMatch","isNegative","isNil","isOdd","isPositive","isRegex","isWithin","isZero","typeOf"],"mappings":";;;;;;;;;;;;;;;;;AAgGO,SAASA,EAAGC,GAAcC,GAAuB;AACtD,MAAI,CAACD;AACH,UAAM,IAAI,MAAM,uBAAuB;AAuBzC,SApBgB;AAAA,IACd,SAASE;AAAA,IACT,OAAOC;AAAA,IACP,IAAI,CAACC,MAAqCC,EAAQ,GAAGD,CAAI;AAAA,IACzD,MAAME;AAAA,IACN,IAAI,CAACF,MAAgCG,EAAG,GAAGH,CAAI;AAAA,IAC/C,IAAI,CAACA,MAAgCI,EAAG,GAAGJ,CAAI;AAAA,IAC/C,IAAI,CAACA,MAAgCK,EAAG,GAAGL,CAAI;AAAA,IAC/C,IAAI,CAACA,MAAgCM,EAAG,GAAGN,CAAI;AAAA,IAC/C,OAAO,CAACA,MAAqCO,EAAQ,GAAGP,CAAI;AAAA,IAC5D,IAAI,CAACA,MAAqC,CAACC,EAAQ,GAAGD,CAAI;AAAA,IAC1D,UAAUQ;AAAA,IACV,KAAKC;AAAA,IACL,KAAKC;AAAA,IACL,UAAUC;AAAA,IACV,OAAOC;AAAA,IACP,QAAQ,CAACZ,MAAsCa,EAAS,GAAGb,CAAI;AAAA,IAC/D,MAAMc;AAAA,EAAA,EAGOlB,CAA4B,IAAIC,CAAG,KAAKkB,EAAOlB,CAAG,MAAMD;AACzE;"}
+{"version":3,"file":"is.js","sources":["../../src/typed/is.ts"],"sourcesContent":["import { assert } from '../function/assert';\nimport { ge } from './ge';\nimport { gt } from './gt';\nimport { isDefined } from './isDefined';\nimport { isEmpty } from './isEmpty';\nimport { isEqual } from './isEqual';\nimport { isEven } from './isEven';\nimport { isMatch } from './isMatch';\nimport { isNegative } from './isNegative';\nimport { isNil } from './isNil';\nimport { isOdd } from './isOdd';\nimport { isPositive } from './isPositive';\nimport { isRegex } from './isRegex';\nimport { isWithin } from './isWithin';\nimport { isZero } from './isZero';\nimport { le } from './le';\nimport { lt } from './lt';\nimport { type ArgType, typeOf } from './typeOf';\n\ntype isType =\n  | ArgType\n  | 'defined'\n  | 'empty'\n  | 'eq'\n  | 'even'\n  | 'ge'\n  | 'gt'\n  | 'le'\n  | 'lt'\n  | 'match'\n  | 'ne'\n  | 'negative'\n  | 'nil'\n  | 'odd'\n  | 'positive'\n  | 'regex'\n  | 'within'\n  | 'zero';\n\n/**\n * @description\n * Checks if the value type of argument.\n *\n * @example\n * ```ts\n * is('array', []);\n * is('boolean', true);\n * is('date', new Date());\n * is('defined', 123);\n * is('empty', []);\n * is('even', 2);\n * is('function', () => {});\n * is('match', { a: 1, b: 2 }, { a: 1 });\n * is('nan', Number.NaN);\n * is('negative', -123);\n * is('nil', null);\n * is('null', null);\n * is('number', 123);\n * is('object', {});\n * is('odd', 3);\n * is('positive', 123);\n * is('string', 'hello');\n * is('symbol', Symbol('test'));\n * is('regex', /abc/);\n * is('string', 'hello world');\n * is('undefined', undefined);\n * is('within', 1, 2, 3);\n * is('zero', 0);\n * is('eq', [1, 2, 3], [1, 2, 3]);\n * is('ne', [1, 2, 3], [1, 2]);\n * is('ge', 5, 5);\n * is('gt', 5, 3);\n * is('le', 5, 5);\n * is('lt', 3, 5);\n * ```\n *\n * @param type - The type to check against.\n * @param args - The argument to be checked.\n *\n * @returns `true` if the value is of the specified type, else `false`.\n */\nexport function is(type: 'within', ...args: Parameters<typeof isWithin>): boolean;\nexport function is(type: 'eq', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'ne', ...args: Parameters<typeof isEqual>): boolean;\nexport function is(type: 'gt', ...args: Parameters<typeof gt>): boolean;\nexport function is(type: 'ge', ...args: Parameters<typeof ge>): boolean;\nexport function is(type: 'lt', ...args: Parameters<typeof lt>): boolean;\nexport function is(type: 'le', ...args: Parameters<typeof le>): boolean;\nexport function is(type: 'match', ...args: Parameters<typeof isMatch>): boolean;\nexport function is(type: 'empty', ...args: Parameters<typeof isEmpty>): boolean;\nexport function is(type: 'array', arg: unknown): arg is Array<unknown>;\nexport function is(type: 'string', arg: unknown): arg is string;\nexport function is(type: 'number', arg: unknown): arg is number;\nexport function is(type: 'object', arg: unknown): arg is object;\nexport function is(type: 'nil', arg: unknown): arg is null | undefined;\nexport function is(type: 'primitive', arg: unknown): arg is string | number | boolean;\nexport function is(type: isType, arg: unknown): boolean;\nexport function is(type: string, arg: unknown): boolean {\n  assert(Boolean(type), 'Type must be provided', { args: { type }, type: Error });\n\n  const compare = {\n    defined: isDefined,\n    empty: isEmpty,\n    eq: (args: Parameters<typeof isEqual>) => isEqual(...args),\n    even: isEven,\n    ge: (args: Parameters<typeof ge>) => ge(...args),\n    gt: (args: Parameters<typeof gt>) => gt(...args),\n    le: (args: Parameters<typeof le>) => le(...args),\n    lt: (args: Parameters<typeof lt>) => lt(...args),\n    match: (args: Parameters<typeof isMatch>) => isMatch(...args),\n    ne: (args: Parameters<typeof isEqual>) => !isEqual(...args),\n    negative: isNegative,\n    nil: isNil,\n    odd: isOdd,\n    positive: isPositive,\n    regex: isRegex,\n    within: (args: Parameters<typeof isWithin>) => isWithin(...args),\n    zero: isZero,\n  };\n\n  return compare[type as keyof typeof compare]?.(arg) ?? typeOf(arg) === type;\n}\n"],"names":["is","type","arg","assert","isDefined","isEmpty","args","isEqual","isEven","ge","gt","le","lt","isMatch","isNegative","isNil","isOdd","isPositive","isRegex","isWithin","isZero","typeOf"],"mappings":";;;;;;;;;;;;;;;;;;AAiGO,SAASA,EAAGC,GAAcC,GAAuB;AACtD,SAAAC,EAAO,EAAQF,GAAO,yBAAyB,EAAE,MAAM,EAAE,MAAAA,EAAA,GAAQ,MAAM,OAAO,GAE9D;AAAA,IACd,SAASG;AAAA,IACT,OAAOC;AAAA,IACP,IAAI,CAACC,MAAqCC,EAAQ,GAAGD,CAAI;AAAA,IACzD,MAAME;AAAA,IACN,IAAI,CAACF,MAAgCG,EAAG,GAAGH,CAAI;AAAA,IAC/C,IAAI,CAACA,MAAgCI,EAAG,GAAGJ,CAAI;AAAA,IAC/C,IAAI,CAACA,MAAgCK,EAAG,GAAGL,CAAI;AAAA,IAC/C,IAAI,CAACA,MAAgCM,EAAG,GAAGN,CAAI;AAAA,IAC/C,OAAO,CAACA,MAAqCO,EAAQ,GAAGP,CAAI;AAAA,IAC5D,IAAI,CAACA,MAAqC,CAACC,EAAQ,GAAGD,CAAI;AAAA,IAC1D,UAAUQ;AAAA,IACV,KAAKC;AAAA,IACL,KAAKC;AAAA,IACL,UAAUC;AAAA,IACV,OAAOC;AAAA,IACP,QAAQ,CAACZ,MAAsCa,EAAS,GAAGb,CAAI;AAAA,IAC/D,MAAMc;AAAA,EAAA,EAGOnB,CAA4B,IAAIC,CAAG,KAAKmB,EAAOnB,CAAG,MAAMD;AACzE;"}

package/dist/typed/isEmpty.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./isArray.cjs"),i=require("./isNil.cjs"),s=require("./isObject.cjs");function n(e){return i.isNil(e)||e===""||t.isArray(e)&&e.length===0||s.isObject(e)&&Object.keys(e).length===0}const c="Expected an empty value";exports.IS_EMPTY_ERROR_MSG=c;exports.isEmpty=n;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./isArray.cjs"),i=require("./isNil.cjs"),n=require("./isObject.cjs");function s(e){return i.isNil(e)||e===""?!0:t.isArray(e)?e.length===0:e instanceof Map||e instanceof Set?e.size===0:n.isObject(e)?Object.keys(e).length===0:!1}const r="Expected an empty value";exports.IS_EMPTY_ERROR_MSG=r;exports.isEmpty=s;
 //# sourceMappingURL=isEmpty.cjs.map