massaman 0.0.1-rc.0

package/dist/object/index.mjs

@@ -0,0 +1,2 @@
+import { _ as toSnakeCaseKeys, a as flattenObject, c as mapValues, d as omit, f as omitBy, g as toMerged, h as toCamelCaseKeys, i as findKey, l as merge, m as pickBy, n as cloneDeep, o as invert, p as pick, r as cloneDeepWith, s as mapKeys, t as clone, u as mergeWith, v as evolve } from "../object-BHnp9Sr9.mjs";
+export { clone, cloneDeep, cloneDeepWith, evolve, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, toCamelCaseKeys, toMerged, toSnakeCaseKeys };

package/dist/object-BHnp9Sr9.mjs

@@ -0,0 +1,27 @@
+import { clone, cloneDeep, cloneDeepWith, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, toCamelCaseKeys, toMerged, toSnakeCaseKeys } from "es-toolkit/object";
+//#region src/object/evolve.ts
+/**
+* Applies a spec of transformation functions to matching keys of an object,
+* returning a new object. Keys not in the spec are copied as-is.
+*
+* @example
+* ```ts
+* evolve({ name: '  Alice  ', age: 29, role: 'admin' }, {
+*   name: (s) => s.trim(),
+*   age: (n) => n + 1,
+* })
+* // { name: 'Alice', age: 30, role: 'admin' }
+* ```
+*/
+function evolve(obj, spec) {
+	const result = { ...obj };
+	for (const key of Object.keys(spec)) {
+		const transform = spec[key];
+		if (transform != null && key in result) result[key] = transform(result[key]);
+	}
+	return result;
+}
+//#endregion
+export { toSnakeCaseKeys as _, flattenObject as a, mapValues as c, omit as d, omitBy as f, toMerged as g, toCamelCaseKeys as h, findKey as i, merge as l, pickBy as m, cloneDeep as n, invert as o, pick as p, cloneDeepWith as r, mapKeys as s, clone as t, mergeWith as u, evolve as v };
+
+//# sourceMappingURL=object-BHnp9Sr9.mjs.map

package/dist/object-BHnp9Sr9.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-BHnp9Sr9.mjs","names":[],"sources":["../src/object/evolve.ts"],"sourcesContent":["/* oxlint-disable security/detect-object-injection -- keys sourced from Object.keys(spec), not user input */\n\n/**\n * Applies a spec of transformation functions to matching keys of an object,\n * returning a new object. Keys not in the spec are copied as-is.\n *\n * @example\n * ```ts\n * evolve({ name: '  Alice  ', age: 29, role: 'admin' }, {\n *   name: (s) => s.trim(),\n *   age: (n) => n + 1,\n * })\n * // { name: 'Alice', age: 30, role: 'admin' }\n * ```\n */\nexport function evolve<T extends Record<string, unknown>>(\n  obj: T,\n  spec: { [K in keyof T]?: (value: T[K]) => T[K] }\n): T {\n  const result = { ...obj }\n  for (const key of Object.keys(spec) as Array<keyof T>) {\n    const transform = spec[key]\n    if (transform != null && key in result) {\n      result[key] = transform(result[key])\n    }\n  }\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;AAeA,SAAgB,OACd,KACA,MACG;CACH,MAAM,SAAS,EAAE,GAAG,KAAK;CACzB,KAAK,MAAM,OAAO,OAAO,KAAK,KAAK,EAAoB;EACrD,MAAM,YAAY,KAAK;EACvB,IAAI,aAAa,QAAQ,OAAO,QAC9B,OAAO,OAAO,UAAU,OAAO,KAAK;;CAGxC,OAAO"}

package/dist/pattern/index.d.mts

@@ -0,0 +1,2 @@
+import { NonExhaustiveError, P, Pattern, isMatching, match } from "ts-pattern";
+export { NonExhaustiveError, P, Pattern, isMatching, match };

package/dist/pattern/index.mjs

@@ -0,0 +1,2 @@
+import { NonExhaustiveError, P, Pattern, isMatching, match } from "ts-pattern";
+export { NonExhaustiveError, P, Pattern, isMatching, match };

package/dist/predicate/index.d.mts

@@ -0,0 +1,2 @@
+import { A as isSymbol, B as isNotEmpty, C as isNumber, D as isRegExp, E as isPromise, F as isArray, G as either, H as allPass, I as isEmpty, L as isFiniteNumber, M as isUndefined, N as isWeakMap, O as isSet, P as isWeakSet, R as isInteger, S as isNull, T as isPrimitive, U as anyPass, V as isObject, W as both, _ as isLength, a as isBuffer, b as isNode, c as isEqual, d as isFile, f as isFunction, g as isJSONValue, h as isJSONObject, i as isBrowser, j as isTypedArray, k as isString, l as isEqualWith, m as isJSONArray, n as isBlob, o as isDate, p as isJSON, r as isBoolean, s as isEmptyObject, t as isArrayBuffer, u as isError, v as isMap, w as isPlainObject, x as isNotNil, y as isNil, z as isNaN } from "../index-BuBpCB73.mjs";
+export { allPass, anyPass, both, either, isArray, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmpty, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFiniteNumber, isFunction, isInteger, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNaN, isNil, isNode, isNotEmpty, isNotNil, isNull, isNumber, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };

package/dist/predicate/index.mjs

@@ -0,0 +1,2 @@
+import { A as isSymbol, B as isNotEmpty, C as isNumber, D as isRegExp, E as isPromise, F as isArray, G as either, H as allPass, I as isEmpty, L as isFiniteNumber, M as isUndefined, N as isWeakMap, O as isSet, P as isWeakSet, R as isInteger, S as isNull, T as isPrimitive, U as anyPass, V as isObject, W as both, _ as isLength, a as isBuffer, b as isNode, c as isEqual, d as isFile, f as isFunction, g as isJSONValue, h as isJSONObject, i as isBrowser, j as isTypedArray, k as isString, l as isEqualWith, m as isJSONArray, n as isBlob, o as isDate, p as isJSON, r as isBoolean, s as isEmptyObject, t as isArrayBuffer, u as isError, v as isMap, w as isPlainObject, x as isNotNil, y as isNil, z as isNaN } from "../predicate-CYzSOMLW.mjs";
+export { allPass, anyPass, both, either, isArray, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmpty, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFiniteNumber, isFunction, isInteger, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNaN, isNil, isNode, isNotEmpty, isNotNil, isNull, isNumber, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };

package/dist/predicate-CYzSOMLW.mjs

@@ -0,0 +1,108 @@
+import { isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError as isError$1, isFile, isFunction, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap as isMap$1, isNil as isNil$1, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive as isPrimitive$1, isPromise, isRegExp, isSet as isSet$1, isString as isString$1, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet } from "es-toolkit/predicate";
+//#region src/predicate/combinators.ts
+function allPass(predicates) {
+	return (value) => predicates.every((pred) => pred(value));
+}
+function anyPass(predicates) {
+	return (value) => predicates.some((pred) => pred(value));
+}
+function both(f, g) {
+	return (value) => f(value) && g(value);
+}
+function either(f, g) {
+	return (value) => f(value) || g(value);
+}
+//#endregion
+//#region src/predicate/guards.ts
+/**
+* Checks if a value is an array.
+*
+* @example
+* ```ts
+* isArray([1, 2]) // true
+* isArray('hello') // false
+* ```
+*/
+const isArray = Array.isArray;
+/**
+* Checks if a value is a non-null object.
+*
+* Returns `true` for plain objects, arrays, class instances, etc.
+* Returns `false` for `null`, primitives, and functions.
+*
+* @example
+* ```ts
+* isObject({}) // true
+* isObject(null) // false
+* ```
+*/
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+/**
+* Checks if a value is empty.
+*
+* - Strings: `''`
+* - Arrays: `length === 0`
+* - Maps/Sets: `size === 0`
+* - Objects: no own enumerable keys
+*
+* @example
+* ```ts
+* isEmpty('') // true
+* isEmpty([]) // true
+* isEmpty({}) // true
+* isEmpty(new Map()) // true
+* ```
+*/
+function isEmpty(value) {
+	if (typeof value === "string" || Array.isArray(value)) return value.length === 0;
+	if (value instanceof Map || value instanceof Set) return value.size === 0;
+	return Object.keys(value).length === 0;
+}
+/**
+* Checks if a value is not empty. Complement of {@link isEmpty}.
+*
+* @example
+* ```ts
+* isNotEmpty('hello') // true
+* isNotEmpty([]) // false
+* ```
+*/
+function isNotEmpty(value) {
+	return !isEmpty(value);
+}
+/**
+* Checks if a value is a finite number.
+*
+* @example
+* ```ts
+* isFiniteNumber(42) // true
+* isFiniteNumber(Infinity) // false
+* ```
+*/
+const isFiniteNumber = Number.isFinite;
+/**
+* Checks if a value is an integer.
+*
+* @example
+* ```ts
+* isInteger(42) // true
+* isInteger(4.2) // false
+* ```
+*/
+const isInteger = Number.isInteger;
+/**
+* Checks if a value is NaN.
+*
+* @example
+* ```ts
+* isNaN(NaN) // true
+* isNaN(42) // false
+* ```
+*/
+const isNaN = Number.isNaN;
+//#endregion
+export { isSymbol as A, isNotEmpty as B, isNumber as C, isRegExp as D, isPromise as E, isArray as F, either as G, allPass as H, isEmpty as I, isFiniteNumber as L, isUndefined as M, isWeakMap as N, isSet$1 as O, isWeakSet as P, isInteger as R, isNull as S, isPrimitive$1 as T, anyPass as U, isObject as V, both as W, isLength as _, isBuffer as a, isNode as b, isEqual as c, isFile as d, isFunction as f, isJSONValue as g, isJSONObject as h, isBrowser as i, isTypedArray as j, isString$1 as k, isEqualWith as l, isJSONArray as m, isBlob as n, isDate as o, isJSON as p, isBoolean as r, isEmptyObject as s, isArrayBuffer as t, isError$1 as u, isMap$1 as v, isPlainObject as w, isNotNil as x, isNil$1 as y, isNaN as z };
+
+//# sourceMappingURL=predicate-CYzSOMLW.mjs.map

package/dist/predicate-CYzSOMLW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-CYzSOMLW.mjs","names":[],"sources":["../src/predicate/combinators.ts","../src/predicate/guards.ts"],"sourcesContent":["import type { DangerouslyAllowAny } from '../types/internal.js'\n\n/**\n * Extracts the narrowed target type from a type-guard predicate.\n * Returns `never` for plain `boolean` predicates so they don't pollute\n * the union/intersection downstream.\n *\n * `DangerouslyAllowAny` is required here: this conditional needs to match\n * predicate signatures with arbitrary input types (`(n: number) => …`,\n * `(s: string) => …`, etc.). `unknown` would reject those by contravariance.\n */\ntype Guarded<P> = P extends ((value: DangerouslyAllowAny) => value is infer X) ? X : never\n\n/**\n * Extracts the input type from a tuple of predicates. Uses `infer V` in\n * contravariant position so multiple predicates with the same input type\n * collapse to that type. Return-position is `unknown` (covariant, accepts\n * any return value).\n */\ntype InferInput<Ps> = Ps extends ReadonlyArray<(value: infer V) => unknown> ? V : never\n\n/**\n * Converts a union `A | B | C` to an intersection `A & B & C`.\n * Standard contravariant-position trick.\n */\ntype UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (\n  k: infer I\n) => void\n  ? I\n  : never\n\n/**\n * Returns a predicate that checks if a value satisfies ALL predicates.\n *\n * When every input is a type guard, the result narrows to the intersection\n * of every guard's target type. Plain `boolean` predicates contribute nothing\n * to the narrowing (they fall back to no-op).\n *\n * @example\n * ```ts\n * const isPositiveEven = allPass([(n: number) => n > 0, (n: number) => n % 2 === 0])\n * isPositiveEven(4) // true\n *\n * const isNonEmptyString = allPass([isString, isNotEmpty])\n * if (isNonEmptyString(x)) {\n *   // x is narrowed to string here\n * }\n * ```\n */\nexport function allPass<T>(predicates: readonly []): (value: T) => true\nexport function allPass<Ps extends ReadonlyArray<(value: DangerouslyAllowAny) => boolean>>(\n  predicates: Ps\n): (value: InferInput<Ps>) => value is InferInput<Ps> & UnionToIntersection<Guarded<Ps[number]>>\nexport function allPass(\n  predicates: ReadonlyArray<(value: unknown) => boolean>\n): (value: unknown) => boolean {\n  return (value: unknown) => predicates.every((pred) => pred(value))\n}\n\n/**\n * Returns a predicate that checks if a value satisfies ANY predicate.\n *\n * When every input is a type guard, the result narrows to the union of every\n * guard's target type (since only one needs to match).\n *\n * @example\n * ```ts\n * const isAdminOrOwner = anyPass([isAdmin, isOwner])\n * isAdminOrOwner(user)\n *\n * const isStringOrNumber = anyPass([isString, isNumber])\n * if (isStringOrNumber(x)) {\n *   // x is narrowed to string | number here\n * }\n * ```\n */\nexport function anyPass<T>(predicates: readonly []): (value: T) => false\nexport function anyPass<Ps extends ReadonlyArray<(value: DangerouslyAllowAny) => boolean>>(\n  predicates: Ps\n): (value: InferInput<Ps>) => value is InferInput<Ps> & Guarded<Ps[number]>\nexport function anyPass(\n  predicates: ReadonlyArray<(value: unknown) => boolean>\n): (value: unknown) => boolean {\n  return (value: unknown) => predicates.some((pred) => pred(value))\n}\n\n/**\n * Returns a predicate that checks if a value satisfies both predicates.\n *\n * Binary AND combinator — shorthand for `allPass([f, g])`. When both inputs\n * are type guards, the result narrows to the intersection of their target types.\n *\n * @example\n * ```ts\n * const isPositiveEven = both((n: number) => n > 0, (n: number) => n % 2 === 0)\n * isPositiveEven(4)\n * ```\n */\nexport function both<T, A extends T, B extends T>(\n  f: (value: T) => value is A,\n  g: (value: T) => value is B\n): (value: T) => value is A & B\nexport function both<T>(f: (value: T) => boolean, g: (value: T) => boolean): (value: T) => boolean\nexport function both<T>(f: (value: T) => boolean, g: (value: T) => boolean): (value: T) => boolean {\n  return (value: T) => f(value) && g(value)\n}\n\n/**\n * Returns a predicate that checks if a value satisfies either predicate.\n *\n * Binary OR combinator — shorthand for `anyPass([f, g])`. When both inputs\n * are type guards, the result narrows to the union of their target types.\n *\n * @example\n * ```ts\n * const isNilOrEmpty = either(isNil, (s: string) => s === '')\n * isNilOrEmpty(null)\n * ```\n */\nexport function either<T, A extends T, B extends T>(\n  f: (value: T) => value is A,\n  g: (value: T) => value is B\n): (value: T) => value is A | B\nexport function either<T>(f: (value: T) => boolean, g: (value: T) => boolean): (value: T) => boolean\nexport function either<T>(\n  f: (value: T) => boolean,\n  g: (value: T) => boolean\n): (value: T) => boolean {\n  return (value: T) => f(value) || g(value)\n}\n","/**\n * Checks if a value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2]) // true\n * isArray('hello') // false\n * ```\n */\nexport const isArray = Array.isArray\n\n/**\n * Checks if a value is a non-null object.\n *\n * Returns `true` for plain objects, arrays, class instances, etc.\n * Returns `false` for `null`, primitives, and functions.\n *\n * @example\n * ```ts\n * isObject({}) // true\n * isObject(null) // false\n * ```\n */\nexport function isObject(value: unknown): value is object {\n  return value !== null && typeof value === 'object'\n}\n\n/**\n * Checks if a value is empty.\n *\n * - Strings: `''`\n * - Arrays: `length === 0`\n * - Maps/Sets: `size === 0`\n * - Objects: no own enumerable keys\n *\n * @example\n * ```ts\n * isEmpty('') // true\n * isEmpty([]) // true\n * isEmpty({}) // true\n * isEmpty(new Map()) // true\n * ```\n */\nexport function isEmpty(value: string | object): boolean {\n  if (typeof value === 'string' || Array.isArray(value)) {\n    return value.length === 0\n  }\n  if (value instanceof Map || value instanceof Set) {\n    return value.size === 0\n  }\n  return Object.keys(value).length === 0\n}\n\n/**\n * Checks if a value is not empty. Complement of {@link isEmpty}.\n *\n * @example\n * ```ts\n * isNotEmpty('hello') // true\n * isNotEmpty([]) // false\n * ```\n */\nexport function isNotEmpty(value: string | object): boolean {\n  return !isEmpty(value)\n}\n\n/**\n * Checks if a value is a finite number.\n *\n * @example\n * ```ts\n * isFiniteNumber(42) // true\n * isFiniteNumber(Infinity) // false\n * ```\n */\nexport const isFiniteNumber: (value: unknown) => boolean = Number.isFinite\n\n/**\n * Checks if a value is an integer.\n *\n * @example\n * ```ts\n * isInteger(42) // true\n * isInteger(4.2) // false\n * ```\n */\nexport const isInteger: (value: unknown) => boolean = Number.isInteger\n\n/**\n * Checks if a value is NaN.\n *\n * @example\n * ```ts\n * isNaN(NaN) // true\n * isNaN(42) // false\n * ```\n */\nexport const isNaN: (value: unknown) => boolean = Number.isNaN\n"],"mappings":";;AAqDA,SAAgB,QACd,YAC6B;CAC7B,QAAQ,UAAmB,WAAW,OAAO,SAAS,KAAK,MAAM,CAAC;;AAwBpE,SAAgB,QACd,YAC6B;CAC7B,QAAQ,UAAmB,WAAW,MAAM,SAAS,KAAK,MAAM,CAAC;;AAoBnE,SAAgB,KAAQ,GAA0B,GAAiD;CACjG,QAAQ,UAAa,EAAE,MAAM,IAAI,EAAE,MAAM;;AAoB3C,SAAgB,OACd,GACA,GACuB;CACvB,QAAQ,UAAa,EAAE,MAAM,IAAI,EAAE,MAAM;;;;;;;;;;;;;ACvH3C,MAAa,UAAU,MAAM;;;;;;;;;;;;;AAc7B,SAAgB,SAAS,OAAiC;CACxD,OAAO,UAAU,QAAQ,OAAO,UAAU;;;;;;;;;;;;;;;;;;AAmB5C,SAAgB,QAAQ,OAAiC;CACvD,IAAI,OAAO,UAAU,YAAY,MAAM,QAAQ,MAAM,EACnD,OAAO,MAAM,WAAW;CAE1B,IAAI,iBAAiB,OAAO,iBAAiB,KAC3C,OAAO,MAAM,SAAS;CAExB,OAAO,OAAO,KAAK,MAAM,CAAC,WAAW;;;;;;;;;;;AAYvC,SAAgB,WAAW,OAAiC;CAC1D,OAAO,CAAC,QAAQ,MAAM;;;;;;;;;;;AAYxB,MAAa,iBAA8C,OAAO;;;;;;;;;;AAWlE,MAAa,YAAyC,OAAO;;;;;;;;;;AAW7D,MAAa,QAAqC,OAAO"}

package/dist/promise/index.d.mts

@@ -0,0 +1,2 @@
+import { Mutex, Semaphore, delay, timeout, withTimeout } from "es-toolkit/promise";
+export { Mutex, Semaphore, delay, timeout, withTimeout };

package/dist/promise/index.mjs

@@ -0,0 +1,2 @@
+import { Mutex, Semaphore, delay, timeout, withTimeout } from "es-toolkit/promise";
+export { Mutex, Semaphore, delay, timeout, withTimeout };

package/dist/string/index.d.mts

@@ -0,0 +1,2 @@
+import { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words } from "es-toolkit/string";
+export { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };

package/dist/string/index.mjs

@@ -0,0 +1,2 @@
+import { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words } from "es-toolkit/string";
+export { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "massaman",
+  "version": "0.0.1-rc.0",
+  "description": "A comprehensive functional programming library and utilities for TypeScript",
+  "keywords": [
+    "es-toolkit",
+    "fp",
+    "functional",
+    "monad",
+    "pattern-matching",
+    "result",
+    "ts-pattern",
+    "typescript",
+    "utilities"
+  ],
+  "homepage": "https://github.com/zrosenbauer/fpkit#readme",
+  "bugs": {
+    "url": "https://github.com/zrosenbauer/fpkit/issues"
+  },
+  "license": "MIT",
+  "author": "Zac Rosenbauer <me@zrosenbauer.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zrosenbauer/fpkit.git"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./predicate": {
+      "types": "./dist/predicate/index.d.mts",
+      "import": "./dist/predicate/index.mjs"
+    },
+    "./array": {
+      "types": "./dist/array/index.d.mts",
+      "import": "./dist/array/index.mjs"
+    },
+    "./object": {
+      "types": "./dist/object/index.d.mts",
+      "import": "./dist/object/index.mjs"
+    },
+    "./function": {
+      "types": "./dist/function/index.d.mts",
+      "import": "./dist/function/index.mjs"
+    },
+    "./string": {
+      "types": "./dist/string/index.d.mts",
+      "import": "./dist/string/index.mjs"
+    },
+    "./control": {
+      "types": "./dist/control/index.d.mts",
+      "import": "./dist/control/index.mjs"
+    },
+    "./pattern": {
+      "types": "./dist/pattern/index.d.mts",
+      "import": "./dist/pattern/index.mjs"
+    },
+    "./math": {
+      "types": "./dist/math/index.d.mts",
+      "import": "./dist/math/index.mjs"
+    },
+    "./promise": {
+      "types": "./dist/promise/index.d.mts",
+      "import": "./dist/promise/index.mjs"
+    },
+    "./error": {
+      "types": "./dist/error/index.d.mts",
+      "import": "./dist/error/index.mjs"
+    },
+    "./conversion": {
+      "types": "./dist/conversion/index.d.mts",
+      "import": "./dist/conversion/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "es-toolkit": "1.46.1",
+    "ts-pattern": "5.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.7.0",
+    "@typescript/native-preview": "7.0.0-dev.20260512.1",
+    "@vitest/coverage-v8": "^4.1.6",
+    "tsdown": "0.22.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6",
+    "@tadka/tsconfig": "0.0.0"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsgo --noEmit"
+  }
+}