@ts-fns/stdlib 0.1.0

package/dist/tuple/index.mjs

@@ -0,0 +1,122 @@
+import { t as purry } from "../purry-BOWmqwDB.mjs";
+//#region src/tuple/at.ts
+function at2Implementation(tuple, index) {
+	if (index < 0) throw new RangeError(`Tuple.at() :: ${index} must be a positive integer`);
+	if (index >= tuple.length) throw new RangeError(`Tuple.at() :: ${index} is out of bounds`);
+	return tuple[index];
+}
+function at(...args) {
+	return purry(at2Implementation, args);
+}
+//#endregion
+//#region src/tuple/fanOut.ts
+function fanOutImplementation(value, fn1, fn2) {
+	return [fn1(value), fn2(value)];
+}
+function fanOut(...args) {
+	return purry(fanOutImplementation, args);
+}
+//#endregion
+//#region src/tuple/first.ts
+/**
+* Returns the first element of a tuple with at least one element.
+*
+* @param tuple - A non-empty tuple.
+* @returns The element at index `0`.
+*
+* @example
+* ```ts
+* first([1, 2]); // 1
+* ```
+*
+* @throws {RangeError} When the tuple has fewer than one element.
+*/
+function first(tuple) {
+	if (tuple.length < 1) throw new RangeError("Tuple.first() :: received a tuple with less than 1 element");
+	return tuple[0];
+}
+//#endregion
+//#region src/tuple/insert.ts
+function updateImplementation(tuple, index, value) {
+	return tuple.with(index, value);
+}
+function insert(...args) {
+	return purry(updateImplementation, args);
+}
+//#endregion
+//#region src/tuple/mapBoth.ts
+/**
+* Maps both elements of a homogeneous pair with the same function.
+*/
+function mapBothImplementation(tuple, fn) {
+	return [fn(tuple[0]), fn(tuple[1])];
+}
+function mapBoth(...args) {
+	return purry(mapBothImplementation, args);
+}
+//#endregion
+//#region src/tuple/mapEach.ts
+function mapEachImplementation(tuple, fnA, fnB) {
+	return [fnA(tuple[0]), fnB(tuple[1])];
+}
+function mapEach(...args) {
+	return purry(mapEachImplementation, args);
+}
+//#endregion
+//#region src/tuple/mapFirst.ts
+/**
+* Maps the first element of a pair; leaves the second unchanged.
+*/
+function mapFirstImplementation(tuple, fn) {
+	return [fn(tuple[0]), tuple[1]];
+}
+function mapFirst(...args) {
+	return purry(mapFirstImplementation, args);
+}
+//#endregion
+//#region src/tuple/mapSecond.ts
+function mapSecondImplementation(tuple, fn) {
+	return [tuple[0], fn(tuple[1])];
+}
+function mapSecond(...args) {
+	return purry(mapSecondImplementation, args);
+}
+//#endregion
+//#region src/tuple/second.ts
+/**
+* Returns the second element of a tuple with at least two elements.
+*
+* @param tuple - A tuple with at least two elements.
+* @returns The element at index `1`.
+*
+* @example
+* ```ts
+* second([1, 2]); // 2
+* ```
+*
+* @throws {RangeError} When the tuple has fewer than two elements.
+*/
+function second(tuple) {
+	if (tuple.length < 2) throw new RangeError("Tuple.second() :: received a tuple with less than 2 elements");
+	return tuple[1];
+}
+//#endregion
+//#region src/tuple/swap.ts
+/**
+* Swaps the two elements of a pair.
+*
+* @param data - A two-element tuple.
+* @returns The tuple with elements reversed.
+*
+* @example
+* ```ts
+* swap([1, 'a']); // ['a', 1]
+* ```
+*/
+function swap(data) {
+	return [data[1], data[0]];
+}
+//#endregion
+export { at, fanOut, fanOutImplementation, first, insert, mapBoth, mapBothImplementation, mapEach, mapFirst, mapFirstImplementation, mapSecond, second, swap };
+
+//# sourceMappingURL=index.mjs.map

package/dist/tuple/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/tuple/at.ts","../../src/tuple/fanOut.ts","../../src/tuple/first.ts","../../src/tuple/insert.ts","../../src/tuple/mapBoth.ts","../../src/tuple/mapEach.ts","../../src/tuple/mapFirst.ts","../../src/tuple/mapSecond.ts","../../src/tuple/second.ts","../../src/tuple/swap.ts"],"sourcesContent":["import { purry } from '../function/purry';\n\nfunction at2Implementation<T>(tuple: T[], index: number): T {\n  if (index < 0) {\n    throw new RangeError(`Tuple.at() :: ${index} must be a positive integer`);\n  }\n  if (index >= tuple.length) {\n    throw new RangeError(`Tuple.at() :: ${index} is out of bounds`);\n  }\n\n  return tuple[index]!;\n}\n\n/**\n * Get an element from a tuple by index.\n *\n * @param tuple - The tuple to get the element from.\n * @param index - The index of the element to get.\n *\n * @example\n * ```ts\n * at(0, [1, 2, 3]) // 1\n * at(1, [1, 2, 3]) // 2\n * at([1, 2, 3], 0) // 1\n * at([1, 2, 3], 1) // 2\n * ```\n *\n * @throws {RangeError}\n */\nexport function at<T>(index: 0): (tuple: [T, ...unknown[]]) => T;\nexport function at<T>(index: 1): (tuple: [unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 2): (tuple: [unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 3): (tuple: [unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 4): (tuple: [unknown, unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 5): (tuple: [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(index: 6): (tuple: [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]) => T;\nexport function at<T>(tuple: [T, ...unknown[]], index: 0): T;\nexport function at<T>(tuple: [unknown, T, ...unknown[]], index: 1): T;\nexport function at<T>(tuple: [unknown, unknown, T, ...unknown[]], index: 2): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, T, ...unknown[]], index: 3): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, unknown, T, ...unknown[]], index: 4): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]], index: 5): T;\nexport function at<T>(tuple: [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]], index: 6): T;\nexport function at(...args: readonly unknown[]): unknown {\n  return purry(at2Implementation, args);\n}\n","import { purry } from '../function/purry';\n\nexport function fanOutImplementation<A, C, D>(value: A, fn1: (value: A) => C, fn2: (value: A) => D): [C, D] {\n  return [fn1(value), fn2(value)];\n}\n\n/**\n * Takes a value and two functions and returns a tuple of the results of the functions.\n *\n * @public\n * @category Tuple\n * @param value - The value to apply the functions to.\n * @param fn1 - The first function to apply to the value.\n * @param fn2 - The second function to apply to the value.\n *\n * @example\n * ```ts\n * fanOut((x) => x * 2, (x) => x + 1, 2); // [4, 3]\n * ```\n */\nexport function fanOut<A, C, D>(fn1: (value: A) => C, fn2: (value: A) => D): (value: A) => [C, D];\nexport function fanOut<A, C, D>(value: A, fn1: (value: A) => C, fn2: (value: A) => D): [C, D];\nexport function fanOut(...args: readonly unknown[]): unknown {\n  return purry(fanOutImplementation, args);\n}\n","/**\n * Returns the first element of a tuple with at least one element.\n *\n * @param tuple - A non-empty tuple.\n * @returns The element at index `0`.\n *\n * @example\n * ```ts\n * first([1, 2]); // 1\n * ```\n *\n * @throws {RangeError} When the tuple has fewer than one element.\n */\nexport function first<T>(tuple: [T, ...unknown[]]): T {\n  if (tuple.length < 1) {\n    throw new RangeError('Tuple.first() :: received a tuple with less than 1 element');\n  }\n  return tuple[0];\n}\n","/* eslint-disable @typescript-eslint/unified-signatures */\nimport { purry } from '../function/purry';\n\nfunction updateImplementation<T>(tuple: T[], index: number, value: T): T[] {\n  return tuple.with(index, value);\n}\n\n/**\n * Returns a new tuple with the element at `index` replaced by `value`.\n *\n * @param index - Zero-based index of the element to replace.\n * @param value - Replacement value.\n * @param tuple - The source tuple.\n *\n * @example\n * ```ts\n * insert([1, 2, 3], 1, 99); // [1, 99, 3]\n * insert(1, 99)([1, 2, 3]); // [1, 99, 3]\n * ```\n *\n * @throws {RangeError} When `index` is negative or out of bounds (from the underlying `with` call).\n */\nexport function insert<T>(index: 0, value: T): <U extends readonly [T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(index: 1, value: T): <U extends readonly [unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(index: 2, value: T): <U extends readonly [unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 3,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 4,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 5,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 6,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 7,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(tuple: U) => U;\nexport function insert<T>(\n  index: 8,\n  value: T,\n): <U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n) => U;\nexport function insert<T, U extends readonly [T, ...unknown[]]>(tuple: U, index: 0, value: T): U;\nexport function insert<T, U extends readonly [unknown, T, ...unknown[]]>(tuple: U, index: 1, value: T): U;\nexport function insert<T, U extends readonly [unknown, unknown, T, ...unknown[]]>(tuple: U, index: 2, value: T): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 3,\n  value: T,\n): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 4,\n  value: T,\n): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 5,\n  value: T,\n): U;\nexport function insert<T, U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]]>(\n  tuple: U,\n  index: 6,\n  value: T,\n): U;\nexport function insert<\n  T,\n  U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]],\n>(tuple: U, index: 7, value: T): U;\nexport function insert<\n  T,\n  U extends readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, T, ...unknown[]],\n>(tuple: U, index: 8, value: T): U;\nexport function insert(...args: readonly unknown[]): unknown {\n  return purry(updateImplementation, args);\n}\n","import { purry } from '../function/purry';\n\n/**\n * Maps both elements of a homogeneous pair with the same function.\n */\nexport function mapBothImplementation<T, U>(tuple: [T, T], fn: (value: T) => U): [U, U] {\n  return [fn(tuple[0]), fn(tuple[1])];\n}\n\n/**\n * Maps both elements of a homogeneous pair with the same function.\n *\n * @param fn - Function applied to each element\n * @param tuple - A two-element tuple of the same type\n *\n * @example\n * ```ts\n * mapBoth([1, 2], (n) => n * 2); // [2, 4]\n * mapBoth((n) => n * 2)([1, 2]); // [2, 4]\n * ```\n */\nexport function mapBoth<T, U>(fn: (value: T) => U): (tuple: [T, T]) => [U, U];\nexport function mapBoth<T, U>(tuple: [T, T], fn: (value: T) => U): [U, U];\nexport function mapBoth(...args: readonly unknown[]): unknown {\n  return purry(mapBothImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction mapEachImplementation<A, B, X, Y>(tuple: [A, B], fnA: (value: A) => X, fnB: (value: B) => Y): [X, Y] {\n  return [fnA(tuple[0]), fnB(tuple[1])];\n}\n\n/**\n * Maps the first and second elements of a pair with two functions.\n *\n * @param fnA - Function applied to the first element\n * @param fnB - Function applied to the second element\n * @param tuple - A two-element tuple\n *\n * @example\n * ```ts\n * mapEach([1, 'a'], String, (s) => s.toUpperCase()); // ['1', 'A']\n * mapEach(String, (s) => s.toUpperCase())([1, 'a']); // ['1', 'A']\n * ```\n */\nexport function mapEach<A, B, X, Y>(fnA: (value: A) => X, fnB: (value: B) => Y): (tuple: [A, B]) => [X, Y];\nexport function mapEach<A, B, X, Y>(tuple: [A, B], fnA: (value: A) => X, fnB: (value: B) => Y): [X, Y];\nexport function mapEach(...args: readonly unknown[]): unknown {\n  return purry(mapEachImplementation, args);\n}\n","import { purry } from '../function/purry';\n\n/**\n * Maps the first element of a pair; leaves the second unchanged.\n */\nexport function mapFirstImplementation<A, B, X>(tuple: [A, B], fn: (value: A) => X): [X, B] {\n  return [fn(tuple[0]), tuple[1]];\n}\n\n/**\n * Maps the first element of a pair; leaves the second unchanged.\n *\n * @param fn - Function applied to the first element\n * @param tuple - A two-element tuple\n *\n * @example\n * ```ts\n * mapFirst([1, 'a'], (n) => n + 1); // [2, 'a']\n * mapFirst((n) => n + 1)([1, 'a']); // [2, 'a']\n * ```\n */\nexport function mapFirst<A, B, X>(fn: (value: A) => X): (tuple: [A, B]) => [X, B];\nexport function mapFirst<A, B, X>(tuple: [A, B], fn: (value: A) => X): [X, B];\nexport function mapFirst(...args: readonly unknown[]): unknown {\n  return purry(mapFirstImplementation, args);\n}\n","import { purry } from '../function/purry';\n\nfunction mapSecondImplementation<A, B, Y>(tuple: [A, B], fn: (value: B) => Y): [A, Y] {\n  return [tuple[0], fn(tuple[1])];\n}\n\n/**\n * Maps the second element of a pair; leaves the first unchanged.\n *\n * @param fn - Function applied to the second element\n * @param tuple - A two-element tuple (data-first overload).\n *\n * @example\n * ```ts\n * mapSecond([1, 'a'], (s) => s.toUpperCase()); // [1, 'A']\n * mapSecond((s) => s.toUpperCase())([1, 'a']); // [1, 'A']\n * ```\n */\nexport function mapSecond<A, B, Y>(fn: (value: B) => Y): (tuple: [A, B]) => [A, Y];\nexport function mapSecond<A, B, Y>(tuple: [A, B], fn: (value: B) => Y): [A, Y];\nexport function mapSecond(...args: readonly unknown[]): unknown {\n  return purry(mapSecondImplementation, args);\n}\n","/**\n * Returns the second element of a tuple with at least two elements.\n *\n * @param tuple - A tuple with at least two elements.\n * @returns The element at index `1`.\n *\n * @example\n * ```ts\n * second([1, 2]); // 2\n * ```\n *\n * @throws {RangeError} When the tuple has fewer than two elements.\n */\nexport function second<T>(tuple: [unknown, T, ...unknown[]]): T {\n  if (tuple.length < 2) {\n    throw new RangeError('Tuple.second() :: received a tuple with less than 2 elements');\n  }\n  return tuple[1];\n}\n","/**\n * Swaps the two elements of a pair.\n *\n * @param data - A two-element tuple.\n * @returns The tuple with elements reversed.\n *\n * @example\n * ```ts\n * swap([1, 'a']); // ['a', 1]\n * ```\n */\nexport function swap<A, B>(data: [A, B]): [B, A] {\n  return [data[1], data[0]];\n}\n"],"mappings":";;AAEA,SAAS,kBAAqB,OAAY,OAAkB;CAC1D,IAAI,QAAQ,GACV,MAAM,IAAI,WAAW,iBAAiB,MAAM,4BAA4B;CAE1E,IAAI,SAAS,MAAM,QACjB,MAAM,IAAI,WAAW,iBAAiB,MAAM,kBAAkB;CAGhE,OAAO,MAAM;AACf;AAgCA,SAAgB,GAAG,GAAG,MAAmC;CACvD,OAAO,MAAM,mBAAmB,IAAI;AACtC;;;AC3CA,SAAgB,qBAA8B,OAAU,KAAsB,KAA8B;CAC1G,OAAO,CAAC,IAAI,KAAK,GAAG,IAAI,KAAK,CAAC;AAChC;AAkBA,SAAgB,OAAO,GAAG,MAAmC;CAC3D,OAAO,MAAM,sBAAsB,IAAI;AACzC;;;;;;;;;;;;;;;;ACXA,SAAgB,MAAS,OAA6B;CACpD,IAAI,MAAM,SAAS,GACjB,MAAM,IAAI,WAAW,4DAA4D;CAEnF,OAAO,MAAM;AACf;;;ACfA,SAAS,qBAAwB,OAAY,OAAe,OAAe;CACzE,OAAO,MAAM,KAAK,OAAO,KAAK;AAChC;AA6EA,SAAgB,OAAO,GAAG,MAAmC;CAC3D,OAAO,MAAM,sBAAsB,IAAI;AACzC;;;;;;AC/EA,SAAgB,sBAA4B,OAAe,IAA6B;CACtF,OAAO,CAAC,GAAG,MAAM,EAAE,GAAG,GAAG,MAAM,EAAE,CAAC;AACpC;AAgBA,SAAgB,QAAQ,GAAG,MAAmC;CAC5D,OAAO,MAAM,uBAAuB,IAAI;AAC1C;;;ACvBA,SAAS,sBAAkC,OAAe,KAAsB,KAA8B;CAC5G,OAAO,CAAC,IAAI,MAAM,EAAE,GAAG,IAAI,MAAM,EAAE,CAAC;AACtC;AAiBA,SAAgB,QAAQ,GAAG,MAAmC;CAC5D,OAAO,MAAM,uBAAuB,IAAI;AAC1C;;;;;;AClBA,SAAgB,uBAAgC,OAAe,IAA6B;CAC1F,OAAO,CAAC,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;AAChC;AAgBA,SAAgB,SAAS,GAAG,MAAmC;CAC7D,OAAO,MAAM,wBAAwB,IAAI;AAC3C;;;ACvBA,SAAS,wBAAiC,OAAe,IAA6B;CACpF,OAAO,CAAC,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC;AAChC;AAgBA,SAAgB,UAAU,GAAG,MAAmC;CAC9D,OAAO,MAAM,yBAAyB,IAAI;AAC5C;;;;;;;;;;;;;;;;ACTA,SAAgB,OAAU,OAAsC;CAC9D,IAAI,MAAM,SAAS,GACjB,MAAM,IAAI,WAAW,8DAA8D;CAErF,OAAO,MAAM;AACf;;;;;;;;;;;;;;ACPA,SAAgB,KAAW,MAAsB;CAC/C,OAAO,CAAC,KAAK,IAAI,KAAK,EAAE;AAC1B"}

package/dist/types-D8f67ZCe.d.cts

@@ -0,0 +1,54 @@
+//#region src/types.d.ts
+/**
+ * Global configuration types.
+ */
+interface Config {
+  noUncheckedIndexedAccess: true;
+}
+/**
+ * Extracts the `noUncheckedIndexedAccess` value from the provided configuration type.
+ * Defaults to `false` if not specified.
+ */
+type NoUncheckedIndexedAccess<TConfig = Config> = TConfig extends {
+  noUncheckedIndexedAccess: infer TValue;
+} ? TValue : false;
+/**
+ * Returns `T | undefined` if `noUncheckedIndexedAccess` is enabled, otherwise returns `T`.
+ * Simulates TypeScript's `noUncheckedIndexedAccess` compiler option.
+ */
+type Accessed<T> = NoUncheckedIndexedAccess extends true ? T | undefined : T;
+/**
+ * Represents an array containing at least one element.
+ */
+type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * Represents a readonly array containing at least one element.
+ */
+type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];
+/**
+ * Helper type to prevent type inference on `T`.
+ */
+type NoInfer<T> = T extends infer U ? U : never;
+/**
+ * Evaluates to `true` if type `T` is `any`, otherwise `false`.
+ */
+type IsAny<T> = 0 extends NoInfer<T> & 1 ? true : false;
+/**
+ * Narrows type `T` to base type `Base`. Reverts to `Base` if `T` is `any` or incompatible.
+ */
+type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
+/**
+ * Extracts the success type from a union type containing `Error`.
+ */
+type Ok<T> = Exclude<T, Error>;
+/**
+ * Extracts the `Error` type from a union type.
+ */
+type Err<T> = Extract<T, Error>;
+/**
+ * Represents a function taking a single input of type `I` and returning type `O`.
+ */
+type Fn<I, O> = (input: I) => O;
+//#endregion
+export { NonEmptyArray as a, NarrowedTo as i, Err as n, Ok as o, Fn as r, ReadonlyNonEmptyArray as s, Accessed as t };
+//# sourceMappingURL=types-D8f67ZCe.d.cts.map

package/dist/types-D8f67ZCe.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-D8f67ZCe.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;AAGA;;UAAiB,MAAA;EACf,wBAAwB;AAAA;AAO1B;;;;AAAA,KAAY,wBAAA,WAAmC,MAAA,IAAU,OAAO;EAC9D,wBAAA;AAAA,IAEE,MAAA;;;;;KAOQ,QAAA,MAAc,wBAAA,gBAAwC,CAAA,eAAgB,CAAA;;;;KAqBtE,aAAA,OAAoB,CAAA,KAAM,CAAC;AAAvC;;;AAAA,KAKY,qBAAA,gBAAqC,CAAA,KAAM,CAAC;;;;KAKnD,OAAA,MAAa,CAAC,mBAAmB,CAAA;AAVC;AAKvC;;AALuC,KAe3B,KAAA,gBAAqB,OAAO,CAAC,CAAA;;;;KAK7B,UAAA,YACV,OAAA,CAAQ,CAAA,EAAG,IAAA,kBAAsB,IAAA,GAAO,KAAA,CAAM,CAAA,iBAAkB,IAAA,GAAO,OAAA,CAAQ,CAAA,EAAG,IAAA;;AAX7C;AAKvC;KA+BY,EAAA,MAAQ,OAAA,CAAQ,CAAA,EAAG,KAAA;;;;KAKnB,GAAA,MAAS,OAAA,CAAQ,CAAA,EAAG,KAAA;;;AApCU;KAyC9B,EAAA,UAAY,KAAA,EAAO,CAAA,KAAM,CAAC"}

package/dist/types-D8f67ZCe.d.mts

@@ -0,0 +1,54 @@
+//#region src/types.d.ts
+/**
+ * Global configuration types.
+ */
+interface Config {
+  noUncheckedIndexedAccess: true;
+}
+/**
+ * Extracts the `noUncheckedIndexedAccess` value from the provided configuration type.
+ * Defaults to `false` if not specified.
+ */
+type NoUncheckedIndexedAccess<TConfig = Config> = TConfig extends {
+  noUncheckedIndexedAccess: infer TValue;
+} ? TValue : false;
+/**
+ * Returns `T | undefined` if `noUncheckedIndexedAccess` is enabled, otherwise returns `T`.
+ * Simulates TypeScript's `noUncheckedIndexedAccess` compiler option.
+ */
+type Accessed<T> = NoUncheckedIndexedAccess extends true ? T | undefined : T;
+/**
+ * Represents an array containing at least one element.
+ */
+type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * Represents a readonly array containing at least one element.
+ */
+type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];
+/**
+ * Helper type to prevent type inference on `T`.
+ */
+type NoInfer<T> = T extends infer U ? U : never;
+/**
+ * Evaluates to `true` if type `T` is `any`, otherwise `false`.
+ */
+type IsAny<T> = 0 extends NoInfer<T> & 1 ? true : false;
+/**
+ * Narrows type `T` to base type `Base`. Reverts to `Base` if `T` is `any` or incompatible.
+ */
+type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
+/**
+ * Extracts the success type from a union type containing `Error`.
+ */
+type Ok<T> = Exclude<T, Error>;
+/**
+ * Extracts the `Error` type from a union type.
+ */
+type Err<T> = Extract<T, Error>;
+/**
+ * Represents a function taking a single input of type `I` and returning type `O`.
+ */
+type Fn<I, O> = (input: I) => O;
+//#endregion
+export { NonEmptyArray as a, NarrowedTo as i, Err as n, Ok as o, Fn as r, ReadonlyNonEmptyArray as s, Accessed as t };
+//# sourceMappingURL=types-D8f67ZCe.d.mts.map

package/dist/types-D8f67ZCe.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-D8f67ZCe.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;AAGA;;UAAiB,MAAA;EACf,wBAAwB;AAAA;AAO1B;;;;AAAA,KAAY,wBAAA,WAAmC,MAAA,IAAU,OAAO;EAC9D,wBAAA;AAAA,IAEE,MAAA;;;;;KAOQ,QAAA,MAAc,wBAAA,gBAAwC,CAAA,eAAgB,CAAA;;;;KAqBtE,aAAA,OAAoB,CAAA,KAAM,CAAC;AAAvC;;;AAAA,KAKY,qBAAA,gBAAqC,CAAA,KAAM,CAAC;;;;KAKnD,OAAA,MAAa,CAAC,mBAAmB,CAAA;AAVC;AAKvC;;AALuC,KAe3B,KAAA,gBAAqB,OAAO,CAAC,CAAA;;;;KAK7B,UAAA,YACV,OAAA,CAAQ,CAAA,EAAG,IAAA,kBAAsB,IAAA,GAAO,KAAA,CAAM,CAAA,iBAAkB,IAAA,GAAO,OAAA,CAAQ,CAAA,EAAG,IAAA;;AAX7C;AAKvC;KA+BY,EAAA,MAAQ,OAAA,CAAQ,CAAA,EAAG,KAAA;;;;KAKnB,GAAA,MAAS,OAAA,CAAQ,CAAA,EAAG,KAAA;;;AApCU;KAyC9B,EAAA,UAAY,KAAA,EAAO,CAAA,KAAM,CAAC"}

package/package.json

@@ -0,0 +1,177 @@
+{
+  "name": "@ts-fns/stdlib",
+  "version": "0.1.0",
+  "type": "module",
+  "author": "Harris Miller <harrismillerconsulting@gmail.com>",
+  "packageManager": "pnpm@10.29.3",
+  "description": "A Functional Programming Standard Library for Typescript",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Harris-Miller/fp-utils.git"
+  },
+  "keywords": [
+    "fp",
+    "stdlib",
+    "typescript",
+    "functional",
+    "result",
+    "adt",
+    "lens",
+    "lenses"
+  ],
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rimraf dist public",
+    "docs": "typedoc",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "lint": "eslint .",
+    "local-ci": "run-s typecheck lint test test-d",
+    "test": "vitest --passWithNoTests",
+    "test-d": "vitest --typecheck.only --typecheck.ignoreSourceErrors",
+    "typecheck": "tsgo --noEmit"
+  },
+  "exports": {
+    "array": {
+      "import": {
+        "types": "./dist/array/index.d.mts",
+        "default": "./dist/array/index.mjs"
+      },
+      "require": {
+        "types": "./dist/array/index.d.cts",
+        "default": "./dist/array/index.cjs"
+      }
+    },
+    "function": {
+      "import": {
+        "types": "./dist/function/index.d.mts",
+        "default": "./dist/function/index.mjs"
+      },
+      "require": {
+        "types": "./dist/function/index.d.cts",
+        "default": "./dist/function/index.cjs"
+      }
+    },
+    "guard": {
+      "import": {
+        "types": "./dist/guard/index.d.mts",
+        "default": "./dist/guard/index.mjs"
+      },
+      "require": {
+        "types": "./dist/guard/index.d.cts",
+        "default": "./dist/guard/index.cjs"
+      }
+    },
+    "iterator": {
+      "import": {
+        "types": "./dist/iterator/index.d.mts",
+        "default": "./dist/iterator/index.mjs"
+      },
+      "require": {
+        "types": "./dist/iterator/index.d.cts",
+        "default": "./dist/iterator/index.cjs"
+      }
+    },
+    "lens": {
+      "import": {
+        "types": "./dist/lens/index.d.mts",
+        "default": "./dist/lens/index.mjs"
+      },
+      "require": {
+        "types": "./dist/lens/index.d.cts",
+        "default": "./dist/lens/index.cjs"
+      }
+    },
+    "map": {
+      "import": {
+        "types": "./dist/map/index.d.mts",
+        "default": "./dist/map/index.mjs"
+      },
+      "require": {
+        "types": "./dist/map/index.d.cts",
+        "default": "./dist/map/index.cjs"
+      }
+    },
+    "number": {
+      "import": {
+        "types": "./dist/number/index.d.mts",
+        "default": "./dist/number/index.mjs"
+      },
+      "require": {
+        "types": "./dist/number/index.d.cts",
+        "default": "./dist/number/index.cjs"
+      }
+    },
+    "object": {
+      "import": {
+        "types": "./dist/object/index.d.mts",
+        "default": "./dist/object/index.mjs"
+      },
+      "require": {
+        "types": "./dist/object/index.d.cts",
+        "default": "./dist/object/index.cjs"
+      }
+    },
+    "order": {
+      "import": {
+        "types": "./dist/order/index.d.mts",
+        "default": "./dist/order/index.mjs"
+      },
+      "require": {
+        "types": "./dist/order/index.d.cts",
+        "default": "./dist/order/index.cjs"
+      }
+    },
+    "set": {
+      "import": {
+        "types": "./dist/set/index.d.mts",
+        "default": "./dist/set/index.mjs"
+      },
+      "require": {
+        "types": "./dist/set/index.d.cts",
+        "default": "./dist/set/index.cjs"
+      }
+    },
+    "string": {
+      "import": {
+        "types": "./dist/string/index.d.mts",
+        "default": "./dist/string/index.mjs"
+      },
+      "require": {
+        "types": "./dist/string/index.d.cts",
+        "default": "./dist/string/index.cjs"
+      }
+    },
+    "tuple": {
+      "import": {
+        "types": "./dist/tuple/index.d.mts",
+        "default": "./dist/tuple/index.mjs"
+      },
+      "require": {
+        "types": "./dist/tuple/index.d.cts",
+        "default": "./dist/tuple/index.cjs"
+      }
+    }
+  },
+  "dependencies": {
+    "type-fest": "^5.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.19",
+    "@typescript/native-preview": "7.0.0-dev.20260527.2",
+    "eslint": "^9.39.4",
+    "eslint-config-harris": "5.1.2",
+    "npm-run-all2": "^9.0.1",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.22.1",
+    "typedoc": "^0.28.19",
+    "typescript": "^6.0.3",
+    "vitepress": "2.0.0-alpha.17",
+    "vitest": "^4.1.7"
+  }
+}