ts-data-forge 14.6.0 → 14.6.2

package/dist/collections/stack.mjs

@@ -1,146 +1,175 @@
-import { none } from '../functional/optional/impl/optional-none.mjs';
-import { some } from '../functional/optional/impl/optional-some.mjs';
-import '@sindresorhus/is';
-import { range } from '../iterator/range.mjs';
-import '../number/branded-types/finite-number.mjs';
-import '../number/branded-types/int.mjs';
-import '../number/branded-types/int16.mjs';
-import '../number/branded-types/int32.mjs';
-import '../number/branded-types/negative-finite-number.mjs';
-import '../number/branded-types/negative-int.mjs';
-import '../number/branded-types/negative-safe-int.mjs';
-import '../number/branded-types/non-negative-finite-number.mjs';
-import '../number/branded-types/non-negative-int16.mjs';
-import '../number/branded-types/non-negative-int32.mjs';
-import '../number/branded-types/non-positive-finite-number.mjs';
-import '../number/branded-types/non-positive-int.mjs';
-import '../number/branded-types/non-positive-safe-int.mjs';
-import '../number/branded-types/non-zero-finite-number.mjs';
-import '../number/branded-types/non-zero-int.mjs';
-import '../number/branded-types/non-zero-int16.mjs';
-import '../number/branded-types/non-zero-int32.mjs';
-import '../number/branded-types/non-zero-safe-int.mjs';
-import '../number/branded-types/non-zero-uint16.mjs';
-import '../number/branded-types/non-zero-uint32.mjs';
-import '../number/branded-types/positive-finite-number.mjs';
-import '../number/branded-types/positive-int.mjs';
-import '../number/branded-types/positive-int16.mjs';
-import '../number/branded-types/positive-int32.mjs';
-import '../number/branded-types/positive-safe-int.mjs';
-import '../number/branded-types/positive-uint16.mjs';
-import '../number/branded-types/positive-uint32.mjs';
-import '../number/branded-types/safe-int.mjs';
-import '../number/branded-types/safe-uint.mjs';
-import '../number/branded-types/uint.mjs';
-import '../number/branded-types/uint16.mjs';
-import { asUint32, Uint32 } from '../number/branded-types/uint32.mjs';
-import '../number/enum/int8.mjs';
-import '../number/enum/uint8.mjs';
-import '../number/num.mjs';
-import '../number/refined-number-utils.mjs';
-
+import { Optional } from '../functional/index.mjs';
+import { range } from '../iterator/index.mjs';
+import { asUint32, Uint32 } from '../number/index.mjs';
+/**
+ * Class implementation for a stack with LIFO (Last-In, First-Out) behavior
+ * using a dynamic array. This implementation provides O(1) amortized push and
+ * O(1) pop operations by using a resizable buffer that grows as needed.
+ *
+ * The underlying array automatically resizes when it becomes full, ensuring
+ * that the stack can grow to accommodate any number of elements while
+ * maintaining efficient operations.
+ *
+ * @template T The type of elements in the stack.
+ * @implements Stack
+ */
 class StackClass {
-  /** @internal Initial capacity for new stacks. */
-  static #INITIAL_CAPACITY = 8;
-  /** @internal Dynamic array to store stack elements. */
-  #mut_buffer;
-  /** @internal Current number of elements in the stack. */
-  #mut_size;
-  /** @internal Current capacity of the buffer. */
-  #mut_capacity;
-  /**
-   * Constructs a new StackClass instance.
-   *
-   * @param initialValues Optional initial values to populate the stack.
-   */
-  constructor(initialValues = []) {
-    const initialCapacity = asUint32(
-      Math.max(StackClass.#INITIAL_CAPACITY, initialValues.length * 2)
-    );
-    this.#mut_buffer = Array.from(
-      { length: initialCapacity },
-      () => void 0
-    );
-    this.#mut_size = asUint32(0);
-    this.#mut_capacity = initialCapacity;
-    for (const value of initialValues) {
-      this.push(value);
+    /** @internal Initial capacity for new stacks. */
+    static #INITIAL_CAPACITY = 8;
+    /** @internal Dynamic array to store stack elements. */
+    #mut_buffer;
+    /** @internal Current number of elements in the stack. */
+    #mut_size;
+    /** @internal Current capacity of the buffer. */
+    #mut_capacity;
+    /**
+     * Constructs a new StackClass instance.
+     *
+     * @param initialValues Optional initial values to populate the stack.
+     */
+    constructor(initialValues = []) {
+        const initialCapacity = asUint32(Math.max(StackClass.#INITIAL_CAPACITY, initialValues.length * 2));
+        this.#mut_buffer = Array.from({ length: initialCapacity }, () => undefined);
+        this.#mut_size = asUint32(0);
+        this.#mut_capacity = initialCapacity;
+        // Add initial values
+        for (const value of initialValues) {
+            this.push(value);
+        }
     }
-  }
-  /**
-   * @internal
-   * Resizes the buffer when it becomes full.
-   * Doubles the capacity while preserving all elements.
-   */
-  #resize() {
-    const newCapacity = asUint32(this.#mut_capacity * 2);
-    const newBuffer = Array.from(
-      { length: newCapacity },
-      () => void 0
-    );
-    for (const i of range(this.#mut_size)) {
-      newBuffer[i] = this.#mut_buffer[i];
+    /**
+     * @internal
+     * Resizes the buffer when it becomes full.
+     * Doubles the capacity while preserving all elements.
+     */
+    #resize() {
+        const newCapacity = asUint32(this.#mut_capacity * 2);
+        const newBuffer = Array.from({ length: newCapacity }, () => undefined);
+        // Copy existing elements
+        for (const i of range(this.#mut_size)) {
+            newBuffer[i] = this.#mut_buffer[i];
+        }
+        this.#mut_buffer = newBuffer;
+        this.#mut_capacity = newCapacity;
     }
-    this.#mut_buffer = newBuffer;
-    this.#mut_capacity = newCapacity;
-  }
-  /** @inheritdoc */
-  get isEmpty() {
-    return this.#mut_size === 0;
-  }
-  /** @inheritdoc */
-  get size() {
-    return asUint32(this.#mut_size);
-  }
-  /**
-   * Removes and returns the element at the top of the stack (LIFO).
-   *
-   * This operation removes the element that was added most recently (last-in)
-   * and returns it. If the stack is empty, returns `Optional.none`. The
-   * operation is guaranteed to be O(1) and does not require any array resizing
-   * or memory reallocation.
-   *
-   * **Time Complexity:** O(1) - constant time operation **Space Complexity:**
-   * O(1) - no additional memory allocation
-   *
-   * @returns An Optional containing the removed element, or `Optional.none` if
-   *   the stack is empty.
-   */
-  pop() {
-    if (this.isEmpty) {
-      return none;
+    /** @inheritdoc */
+    get isEmpty() {
+        return this.#mut_size === 0;
     }
-    this.#mut_size = Uint32.sub(this.#mut_size, 1);
-    const element = this.#mut_buffer[this.#mut_size];
-    this.#mut_buffer[this.#mut_size] = void 0;
-    return some(element);
-  }
-  /**
-   * Adds an element to the top of the stack (LIFO).
-   *
-   * This operation adds the element to the top of the stack, where it will be
-   * the first to be popped (last-in, first-out ordering). The operation is
-   * amortized O(1), meaning it's O(1) for most operations with occasional O(n)
-   * when the buffer needs resizing.
-   *
-   * **Time Complexity:** O(1) amortized - O(n) only when buffer resize is
-   * needed **Space Complexity:** O(1) - constant additional memory per element
-   *
-   * **Buffer Resizing:** When the internal buffer becomes full, it
-   * automatically doubles in size and copies existing elements to maintain the
-   * stack structure.
-   *
-   * @param value The element to add to the top of the stack.
-   */
-  push(value) {
-    if (this.#mut_size === this.#mut_capacity) {
-      this.#resize();
+    /** @inheritdoc */
+    get size() {
+        return asUint32(this.#mut_size);
+    }
+    /**
+     * Removes and returns the element at the top of the stack (LIFO).
+     *
+     * This operation removes the element that was added most recently (last-in)
+     * and returns it. If the stack is empty, returns `Optional.none`. The
+     * operation is guaranteed to be O(1) and does not require any array resizing
+     * or memory reallocation.
+     *
+     * **Time Complexity:** O(1) - constant time operation **Space Complexity:**
+     * O(1) - no additional memory allocation
+     *
+     * @returns An Optional containing the removed element, or `Optional.none` if
+     *   the stack is empty.
+     */
+    pop() {
+        if (this.isEmpty) {
+            return Optional.none;
+        }
+        this.#mut_size = Uint32.sub(this.#mut_size, 1);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const element = this.#mut_buffer[this.#mut_size];
+        this.#mut_buffer[this.#mut_size] = undefined; // Clear reference for garbage collection
+        return Optional.some(element);
+    }
+    /**
+     * Adds an element to the top of the stack (LIFO).
+     *
+     * This operation adds the element to the top of the stack, where it will be
+     * the first to be popped (last-in, first-out ordering). The operation is
+     * amortized O(1), meaning it's O(1) for most operations with occasional O(n)
+     * when the buffer needs resizing.
+     *
+     * **Time Complexity:** O(1) amortized - O(n) only when buffer resize is
+     * needed **Space Complexity:** O(1) - constant additional memory per element
+     *
+     * **Buffer Resizing:** When the internal buffer becomes full, it
+     * automatically doubles in size and copies existing elements to maintain the
+     * stack structure.
+     *
+     * @param value The element to add to the top of the stack.
+     */
+    push(value) {
+        // Resize if buffer is full
+        if (this.#mut_size === this.#mut_capacity) {
+            this.#resize();
+        }
+        this.#mut_buffer[this.#mut_size] = value;
+        this.#mut_size = Uint32.add(this.#mut_size, 1);
     }
-    this.#mut_buffer[this.#mut_size] = value;
-    this.#mut_size = Uint32.add(this.#mut_size, 1);
-  }
 }
-const createStack = (initialValues) => new StackClass(initialValues);
-
-export { createStack };
-//# sourceMappingURL=stack.mjs.map
+/**
+ * Creates a new Stack instance with LIFO (Last-In, First-Out) behavior using a
+ * high-performance dynamic array.
+ *
+ * This factory function creates an optimized stack implementation that
+ * maintains excellent performance characteristics for both push and pop
+ * operations. The underlying dynamic array automatically resizes to accommodate
+ * growing workloads while providing predictable O(1) operations.
+ *
+ * **Implementation Features:**
+ *
+ * - **O(1) push operations** (amortized - occasionally O(n) when resizing)
+ * - **O(1) pop operations** (always)
+ * - **Automatic buffer resizing** - starts at 8 elements, doubles when full
+ * - **Memory efficient** - garbage collects removed elements immediately
+ * - **Dynamic array design** - eliminates need for complex memory management
+ *
+ * **Performance Benefits:**
+ *
+ * - No array shifting required for stack operations
+ * - Minimal memory allocation overhead
+ * - Predictable performance under high load
+ * - Efficient memory usage with automatic cleanup
+ *
+ * @example
+ *
+ * ```ts
+ * const stack = createStack<string>();
+ *
+ * assert.isTrue(stack.isEmpty);
+ *
+ * assert.isTrue(stack.size === 0);
+ *
+ * stack.push('first');
+ *
+ * stack.push('second');
+ *
+ * assert.isFalse(stack.isEmpty);
+ *
+ * assert.isTrue(stack.size === 2);
+ *
+ * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
+ *
+ * assert.deepStrictEqual(stack.pop(), Optional.some('first'));
+ *
+ * assert.deepStrictEqual(stack.pop(), Optional.none);
+ *
+ * const seededStack = createStack([10, 20, 30]);
+ *
+ * assert.isTrue(seededStack.size === 3);
+ *
+ * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));
+ * ```
+ *
+ * @template T The type of elements stored in the stack.
+ * @param initialValues Optional array of initial elements to populate the
+ *   stack. Elements will be popped in reverse order of how they appear in the
+ *   array (last array element will be popped first). If provided, the initial
+ *   buffer capacity will be at least twice the array length.
+ * @returns A new Stack instance optimized for high-performance LIFO operations.
+ */
+export const createStack = (initialValues) => new StackClass(initialValues);
+//# sourceMappingURL=stack.mjs.map

package/dist/collections/stack.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"stack.mjs","sources":["../../src/collections/stack.mts"],"sourcesContent":["import { Optional } from '../functional/index.mjs';\nimport { range } from '../iterator/index.mjs';\nimport { asUint32, Uint32 } from '../number/index.mjs';\nimport { type SizeType } from '../types.mjs';\n\n/**\n * Interface for a high-performance stack with LIFO (Last-In, First-Out)\n * behavior.\n *\n * This interface defines a mutable stack data structure where elements are\n * added to and removed from the top, following the Last-In, First-Out\n * principle. The implementation uses a dynamic array for optimal performance,\n * providing O(1) operations for both push and pop operations.\n *\n * **LIFO Behavior:**\n *\n * - **push**: Adds elements to the top of the stack\n * - **pop**: Removes and returns elements from the top of the stack\n * - The last element added is the first element to be removed\n *\n * **Performance Characteristics:**\n *\n * - Push: O(1) amortized (O(n) when buffer needs resizing)\n * - Pop: O(1) always\n * - Size/isEmpty: O(1) always\n * - Memory efficient with automatic garbage collection of removed elements\n *\n * **Use Cases:**\n *\n * - Function call management and recursion\n * - Undo/redo functionality\n * - Expression evaluation and parsing\n * - Depth-first search algorithms\n * - Backtracking algorithms\n * - Browser history management\n *\n * @template T The type of elements stored in the stack.\n */\nexport type Stack<T> = Readonly<{\n  /**\n   * Checks if the stack is empty.\n   *\n   * @example\n   *\n   * ```ts\n   * const stack = createStack<string>();\n   *\n   * assert.isTrue(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 0);\n   *\n   * stack.push('first');\n   *\n   * stack.push('second');\n   *\n   * assert.isFalse(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 2);\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('second'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('first'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.none);\n   *\n   * const seededStack = createStack([10, 20, 30]);\n   *\n   * assert.isTrue(seededStack.size === 3);\n   *\n   * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));\n   * ```\n   */\n  isEmpty: boolean;\n\n  /**\n   * The number of elements in the stack.\n   *\n   * @example\n   *\n   * ```ts\n   * const stack = createStack<string>();\n   *\n   * assert.isTrue(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 0);\n   *\n   * stack.push('first');\n   *\n   * stack.push('second');\n   *\n   * assert.isFalse(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 2);\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('second'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('first'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.none);\n   *\n   * const seededStack = createStack([10, 20, 30]);\n   *\n   * assert.isTrue(seededStack.size === 3);\n   *\n   * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));\n   * ```\n   */\n  size: SizeType.Arr;\n\n  /**\n   * Removes and returns the element at the top of the stack.\n   *\n   * @example\n   *\n   * ```ts\n   * const stack = createStack<string>();\n   *\n   * assert.isTrue(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 0);\n   *\n   * stack.push('first');\n   *\n   * stack.push('second');\n   *\n   * assert.isFalse(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 2);\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('second'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('first'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.none);\n   *\n   * const seededStack = createStack([10, 20, 30]);\n   *\n   * assert.isTrue(seededStack.size === 3);\n   *\n   * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));\n   * ```\n   *\n   * @returns The element at the top of the stack, or `Optional.none` if the\n   *   stack is empty.\n   */\n  pop: () => Optional<T>;\n\n  /**\n   * Adds an element to the top of the stack.\n   *\n   * @example\n   *\n   * ```ts\n   * const stack = createStack<string>();\n   *\n   * assert.isTrue(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 0);\n   *\n   * stack.push('first');\n   *\n   * stack.push('second');\n   *\n   * assert.isFalse(stack.isEmpty);\n   *\n   * assert.isTrue(stack.size === 2);\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('second'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.some('first'));\n   *\n   * assert.deepStrictEqual(stack.pop(), Optional.none);\n   *\n   * const seededStack = createStack([10, 20, 30]);\n   *\n   * assert.isTrue(seededStack.size === 3);\n   *\n   * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));\n   * ```\n   *\n   * @param value The element to add.\n   */\n  push: (value: T) => void;\n}>;\n\n/**\n * Class implementation for a stack with LIFO (Last-In, First-Out) behavior\n * using a dynamic array. This implementation provides O(1) amortized push and\n * O(1) pop operations by using a resizable buffer that grows as needed.\n *\n * The underlying array automatically resizes when it becomes full, ensuring\n * that the stack can grow to accommodate any number of elements while\n * maintaining efficient operations.\n *\n * @template T The type of elements in the stack.\n * @implements Stack\n */\nclass StackClass<T> implements Stack<T> {\n  /** @internal Initial capacity for new stacks. */\n  static readonly #INITIAL_CAPACITY = 8;\n\n  /** @internal Dynamic array to store stack elements. */\n  #mut_buffer: (T | undefined)[];\n\n  /** @internal Current number of elements in the stack. */\n  #mut_size: Uint32;\n\n  /** @internal Current capacity of the buffer. */\n  #mut_capacity: Uint32;\n\n  /**\n   * Constructs a new StackClass instance.\n   *\n   * @param initialValues Optional initial values to populate the stack.\n   */\n  constructor(initialValues: readonly T[] = []) {\n    const initialCapacity = asUint32(\n      Math.max(StackClass.#INITIAL_CAPACITY, initialValues.length * 2),\n    );\n\n    this.#mut_buffer = Array.from<unknown, T | undefined>(\n      { length: initialCapacity },\n      () => undefined,\n    );\n\n    this.#mut_size = asUint32(0);\n\n    this.#mut_capacity = initialCapacity;\n\n    // Add initial values\n    for (const value of initialValues) {\n      this.push(value);\n    }\n  }\n\n  /**\n   * @internal\n   * Resizes the buffer when it becomes full.\n   * Doubles the capacity while preserving all elements.\n   */\n  #resize(): void {\n    const newCapacity = asUint32(this.#mut_capacity * 2);\n\n    const newBuffer = Array.from<unknown, T | undefined>(\n      { length: newCapacity },\n      () => undefined,\n    );\n\n    // Copy existing elements\n    for (const i of range(this.#mut_size)) {\n      newBuffer[i] = this.#mut_buffer[i];\n    }\n\n    this.#mut_buffer = newBuffer;\n\n    this.#mut_capacity = newCapacity;\n  }\n\n  /** @inheritdoc */\n  get isEmpty(): boolean {\n    return this.#mut_size === 0;\n  }\n\n  /** @inheritdoc */\n  get size(): SizeType.Arr {\n    return asUint32(this.#mut_size);\n  }\n\n  /**\n   * Removes and returns the element at the top of the stack (LIFO).\n   *\n   * This operation removes the element that was added most recently (last-in)\n   * and returns it. If the stack is empty, returns `Optional.none`. The\n   * operation is guaranteed to be O(1) and does not require any array resizing\n   * or memory reallocation.\n   *\n   * **Time Complexity:** O(1) - constant time operation **Space Complexity:**\n   * O(1) - no additional memory allocation\n   *\n   * @returns An Optional containing the removed element, or `Optional.none` if\n   *   the stack is empty.\n   */\n  pop(): Optional<T> {\n    if (this.isEmpty) {\n      return Optional.none;\n    }\n\n    this.#mut_size = Uint32.sub(this.#mut_size, 1);\n\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const element = this.#mut_buffer[this.#mut_size]!;\n\n    this.#mut_buffer[this.#mut_size] = undefined; // Clear reference for garbage collection\n\n    return Optional.some(element);\n  }\n\n  /**\n   * Adds an element to the top of the stack (LIFO).\n   *\n   * This operation adds the element to the top of the stack, where it will be\n   * the first to be popped (last-in, first-out ordering). The operation is\n   * amortized O(1), meaning it's O(1) for most operations with occasional O(n)\n   * when the buffer needs resizing.\n   *\n   * **Time Complexity:** O(1) amortized - O(n) only when buffer resize is\n   * needed **Space Complexity:** O(1) - constant additional memory per element\n   *\n   * **Buffer Resizing:** When the internal buffer becomes full, it\n   * automatically doubles in size and copies existing elements to maintain the\n   * stack structure.\n   *\n   * @param value The element to add to the top of the stack.\n   */\n  push(value: T): void {\n    // Resize if buffer is full\n    if (this.#mut_size === this.#mut_capacity) {\n      this.#resize();\n    }\n\n    this.#mut_buffer[this.#mut_size] = value;\n\n    this.#mut_size = Uint32.add(this.#mut_size, 1);\n  }\n}\n\n/**\n * Creates a new Stack instance with LIFO (Last-In, First-Out) behavior using a\n * high-performance dynamic array.\n *\n * This factory function creates an optimized stack implementation that\n * maintains excellent performance characteristics for both push and pop\n * operations. The underlying dynamic array automatically resizes to accommodate\n * growing workloads while providing predictable O(1) operations.\n *\n * **Implementation Features:**\n *\n * - **O(1) push operations** (amortized - occasionally O(n) when resizing)\n * - **O(1) pop operations** (always)\n * - **Automatic buffer resizing** - starts at 8 elements, doubles when full\n * - **Memory efficient** - garbage collects removed elements immediately\n * - **Dynamic array design** - eliminates need for complex memory management\n *\n * **Performance Benefits:**\n *\n * - No array shifting required for stack operations\n * - Minimal memory allocation overhead\n * - Predictable performance under high load\n * - Efficient memory usage with automatic cleanup\n *\n * @example\n *\n * ```ts\n * const stack = createStack<string>();\n *\n * assert.isTrue(stack.isEmpty);\n *\n * assert.isTrue(stack.size === 0);\n *\n * stack.push('first');\n *\n * stack.push('second');\n *\n * assert.isFalse(stack.isEmpty);\n *\n * assert.isTrue(stack.size === 2);\n *\n * assert.deepStrictEqual(stack.pop(), Optional.some('second'));\n *\n * assert.deepStrictEqual(stack.pop(), Optional.some('first'));\n *\n * assert.deepStrictEqual(stack.pop(), Optional.none);\n *\n * const seededStack = createStack([10, 20, 30]);\n *\n * assert.isTrue(seededStack.size === 3);\n *\n * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));\n * ```\n *\n * @template T The type of elements stored in the stack.\n * @param initialValues Optional array of initial elements to populate the\n *   stack. Elements will be popped in reverse order of how they appear in the\n *   array (last array element will be popped first). If provided, the initial\n *   buffer capacity will be at least twice the array length.\n * @returns A new Stack instance optimized for high-performance LIFO operations.\n */\nexport const createStack = <T,>(initialValues?: readonly T[]): Stack<T> =>\n  new StackClass<T>(initialValues);\n"],"names":["Optional.none","Optional.some"],"mappings":"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"}
+{"version":3,"file":"stack.mjs","sourceRoot":"","sources":["../../src/collections/stack.mts"],"names":[],"mappings":"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"}

package/dist/entry-point.mjs

@@ -1,77 +1,4 @@
-import * as index from './array/impl/index.mjs';
-export { index as Arr };
-import * as index$1 from './functional/async-result/impl/index.mjs';
-export { index$1 as AsyncResult };
-export { match } from './functional/match.mjs';
-import * as index$2 from './functional/optional/impl/index.mjs';
-export { index$2 as Optional };
-export { pipe } from './functional/pipe.mjs';
-import * as index$3 from './functional/result/impl/index.mjs';
-export { index$3 as Result };
-import * as index$4 from './functional/ternary-result/impl/index.mjs';
-export { index$4 as TernaryResult };
-export { IMapMapped } from './collections/imap-mapped.mjs';
-export { IMap } from './collections/imap.mjs';
-export { ISetMapped } from './collections/iset-mapped.mjs';
-export { ISet } from './collections/iset.mjs';
-export { createQueue } from './collections/queue.mjs';
-export { createStack } from './collections/stack.mjs';
-export { expectType } from './expect-type.mjs';
-export { hasKey } from './guard/has-key.mjs';
-export { isNonEmptyString } from './guard/is-non-empty-string.mjs';
-export { isNonNullObject } from './guard/is-non-null-object.mjs';
-export { isPrimitive } from './guard/is-primitive.mjs';
-export { isMutableRecord, isRecord } from './guard/is-record.mjs';
-export { isBigint, isBoolean, isNonNullish, isNotBigint, isNotBoolean, isNotNull, isNotNumber, isNotString, isNotSymbol, isNotUndefined, isNull, isNullish, isNumber, isString, isSymbol, isUndefined } from './guard/is-type.mjs';
-export { keyIsIn } from './guard/key-is-in.mjs';
-export { range } from './iterator/range.mjs';
-export { Json } from './json/json.mjs';
-export { FiniteNumber, asFiniteNumber, isFiniteNumber } from './number/branded-types/finite-number.mjs';
-export { Int, asInt, isInt } from './number/branded-types/int.mjs';
-export { Int16, asInt16, isInt16 } from './number/branded-types/int16.mjs';
-export { Int32, asInt32, isInt32 } from './number/branded-types/int32.mjs';
-export { NegativeFiniteNumber, asNegativeFiniteNumber, isNegativeFiniteNumber } from './number/branded-types/negative-finite-number.mjs';
-export { NegativeInt, asNegativeInt, isNegativeInt } from './number/branded-types/negative-int.mjs';
-export { NegativeSafeInt, asNegativeSafeInt, isNegativeSafeInt } from './number/branded-types/negative-safe-int.mjs';
-export { NonNegativeFiniteNumber, asNonNegativeFiniteNumber, isNonNegativeFiniteNumber } from './number/branded-types/non-negative-finite-number.mjs';
-export { NonNegativeInt16, asNonNegativeInt16, isNonNegativeInt16 } from './number/branded-types/non-negative-int16.mjs';
-export { NonNegativeInt32, asNonNegativeInt32, isNonNegativeInt32 } from './number/branded-types/non-negative-int32.mjs';
-export { NonPositiveFiniteNumber, asNonPositiveFiniteNumber, isNonPositiveFiniteNumber } from './number/branded-types/non-positive-finite-number.mjs';
-export { NonPositiveInt, asNonPositiveInt, isNonPositiveInt } from './number/branded-types/non-positive-int.mjs';
-export { NonPositiveSafeInt, asNonPositiveSafeInt, isNonPositiveSafeInt } from './number/branded-types/non-positive-safe-int.mjs';
-export { NonZeroFiniteNumber, asNonZeroFiniteNumber, isNonZeroFiniteNumber } from './number/branded-types/non-zero-finite-number.mjs';
-export { NonZeroInt, asNonZeroInt, isNonZeroInt } from './number/branded-types/non-zero-int.mjs';
-export { NonZeroInt16, asNonZeroInt16, isNonZeroInt16 } from './number/branded-types/non-zero-int16.mjs';
-export { NonZeroInt32, asNonZeroInt32, isNonZeroInt32 } from './number/branded-types/non-zero-int32.mjs';
-export { NonZeroSafeInt, asNonZeroSafeInt, isNonZeroSafeInt } from './number/branded-types/non-zero-safe-int.mjs';
-export { NonZeroUint16, asNonZeroUint16, isNonZeroUint16 } from './number/branded-types/non-zero-uint16.mjs';
-export { NonZeroUint32, asNonZeroUint32, isNonZeroUint32 } from './number/branded-types/non-zero-uint32.mjs';
-export { PositiveFiniteNumber, asPositiveFiniteNumber, isPositiveFiniteNumber } from './number/branded-types/positive-finite-number.mjs';
-export { PositiveInt, asPositiveInt, isPositiveInt } from './number/branded-types/positive-int.mjs';
-export { PositiveInt16, asPositiveInt16, isPositiveInt16 } from './number/branded-types/positive-int16.mjs';
-export { PositiveInt32, asPositiveInt32, isPositiveInt32 } from './number/branded-types/positive-int32.mjs';
-export { PositiveSafeInt, asPositiveSafeInt, isPositiveSafeInt } from './number/branded-types/positive-safe-int.mjs';
-export { PositiveUint16, asPositiveUint16, isPositiveUint16 } from './number/branded-types/positive-uint16.mjs';
-export { PositiveUint32, asPositiveUint32, isPositiveUint32 } from './number/branded-types/positive-uint32.mjs';
-export { SafeInt, asSafeInt, isSafeInt } from './number/branded-types/safe-int.mjs';
-export { SafeUint, asSafeUint, isSafeUint } from './number/branded-types/safe-uint.mjs';
-export { Uint, asUint, isUint } from './number/branded-types/uint.mjs';
-export { Uint16, asUint16, isUint16 } from './number/branded-types/uint16.mjs';
-export { Uint32, asUint32, isUint32 } from './number/branded-types/uint32.mjs';
-export { Int8, asInt8, isInt8 } from './number/enum/int8.mjs';
-export { Uint8, asUint8, isUint8 } from './number/enum/uint8.mjs';
-export { Num } from './number/num.mjs';
-export { TsDataForgeInternals } from './number/refined-number-utils.mjs';
-export { Obj } from './object/object.mjs';
-export { castDeepMutable, castMutable } from './others/cast-mutable.mjs';
-export { castDeepReadonly, castReadonly } from './others/cast-readonly.mjs';
-export { debounce } from './others/debounce-function.mjs';
-export { fastDeepEqual } from './others/fast-deep-equal.mjs';
-export { ifThen, implies } from './others/if-then.mjs';
-export { mapNullable } from './others/map-nullable.mjs';
-export { memoizeFunction } from './others/memoize-function.mjs';
-export { tp } from './others/tuple.mjs';
-export { unknownToString } from './others/unknown-to-string.mjs';
-export { createPromise } from './promise/promise.mjs';
-export { Str } from './string/str.mjs';
-//# sourceMappingURL=entry-point.mjs.map
+export * from './array/index.mjs';
+export * from './functional/index.mjs';
+export * from './index.mjs';
+//# sourceMappingURL=entry-point.mjs.map

package/dist/entry-point.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"entry-point.mjs","sourceRoot":"","sources":["../src/entry-point.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC"}

package/dist/expect-type.mjs

@@ -1,4 +1,70 @@
-const expectType = (_relation) => void 0;
-
-export { expectType };
-//# sourceMappingURL=expect-type.mjs.map
+/**
+ * Compile-time type assertion utility for TypeScript type testing.
+ *
+ * This function performs static type relationship checking at compile-time and
+ * has no runtime effect. It is primarily used in test files to verify that
+ * TypeScript's type inference and type relationships work as expected. The
+ * function will cause TypeScript compilation errors if the specified type
+ * relationship does not hold.
+ *
+ * ## Supported Type Relations
+ *
+ * ### Equality Relations
+ *
+ * - **`"="` (strict equality)**: Asserts that types `A` and `B` are exactly the
+ *   same type. Uses TypeScript's internal type equality checking.
+ * - **`"!="` (strict inequality)**: Asserts that types `A` and `B` are not
+ *   exactly the same type.
+ *
+ * ### Assignability Relations
+ *
+ * - **`"~="` (mutual assignability)**: Asserts that `A` extends `B` AND `B`
+ *   extends `A`. Types are structurally equivalent and mutually assignable.
+ * - **`"<="` (subtype relation)**: Asserts that type `A` extends (is assignable
+ *   to) type `B`. Type `A` is a subtype of `B`.
+ * - **`">="` (supertype relation)**: Asserts that type `B` extends (is assignable
+ *   to) type `A`. Type `A` is a supertype of `B`.
+ *
+ * ### Negative Assignability Relations
+ *
+ * - **`"!<="` (not subtype)**: Asserts that type `A` does NOT extend type `B`.
+ * - **`"!>="` (not supertype)**: Asserts that type `B` does NOT extend type `A`.
+ *
+ * ## Type Parameter Constraints
+ *
+ * @since 1.0.0
+ * @template A - The first type for comparison. Can be any TypeScript type
+ *   including:
+ *
+ *   - Primitive types (string, number, boolean, etc.)
+ *   - Object types and interfaces
+ *   - Union and intersection types
+ *   - Generic types and type parameters
+ *   - Literal types and branded types
+ *   - Function types and return types
+ *
+ * @template B - The second type for comparison. Same constraints as type `A`.
+ * @param _relation - A string literal representing the expected type
+ *   relationship. TypeScript's type system automatically infers and restricts
+ *   the available operators based on the actual relationship between types `A`
+ *   and `B`. If an invalid relationship is specified, TypeScript will show a
+ *   compilation error.
+ *
+ *   Combine `expectType` with runtime assertions for comprehensive testing:
+ *
+ *   ## Important Notes
+ *
+ *   - **Compile-time only**: This function has no runtime behavior and will be
+ *       optimized away.
+ *   - **Type inference**: The available relation operators are automatically
+ *       inferred by TypeScript based on the actual type relationship between
+ *       `A` and `B`.
+ *   - **Error feedback**: Invalid type relationships will cause clear TypeScript
+ *       compilation errors.
+ *   - **Test organization**: Typically used in `.test.mts` files alongside runtime
+ *       assertions.
+ *   - **Performance**: Has zero runtime overhead as it's purely a compile-time
+ *       construct.
+ */
+export const expectType = (_relation) => undefined;
+//# sourceMappingURL=expect-type.mjs.map

package/dist/expect-type.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"expect-type.mjs","sources":["../src/expect-type.mts"],"sourcesContent":["import { type TypeEq, type TypeExtends } from 'ts-type-forge';\n\n/**\n * Compile-time type assertion utility for TypeScript type testing.\n *\n * This function performs static type relationship checking at compile-time and\n * has no runtime effect. It is primarily used in test files to verify that\n * TypeScript's type inference and type relationships work as expected. The\n * function will cause TypeScript compilation errors if the specified type\n * relationship does not hold.\n *\n * ## Supported Type Relations\n *\n * ### Equality Relations\n *\n * - **`\"=\"` (strict equality)**: Asserts that types `A` and `B` are exactly the\n *   same type. Uses TypeScript's internal type equality checking.\n * - **`\"!=\"` (strict inequality)**: Asserts that types `A` and `B` are not\n *   exactly the same type.\n *\n * ### Assignability Relations\n *\n * - **`\"~=\"` (mutual assignability)**: Asserts that `A` extends `B` AND `B`\n *   extends `A`. Types are structurally equivalent and mutually assignable.\n * - **`\"<=\"` (subtype relation)**: Asserts that type `A` extends (is assignable\n *   to) type `B`. Type `A` is a subtype of `B`.\n * - **`\">=\"` (supertype relation)**: Asserts that type `B` extends (is assignable\n *   to) type `A`. Type `A` is a supertype of `B`.\n *\n * ### Negative Assignability Relations\n *\n * - **`\"!<=\"` (not subtype)**: Asserts that type `A` does NOT extend type `B`.\n * - **`\"!>=\"` (not supertype)**: Asserts that type `B` does NOT extend type `A`.\n *\n * ## Type Parameter Constraints\n *\n * @since 1.0.0\n * @template A - The first type for comparison. Can be any TypeScript type\n *   including:\n *\n *   - Primitive types (string, number, boolean, etc.)\n *   - Object types and interfaces\n *   - Union and intersection types\n *   - Generic types and type parameters\n *   - Literal types and branded types\n *   - Function types and return types\n *\n * @template B - The second type for comparison. Same constraints as type `A`.\n * @param _relation - A string literal representing the expected type\n *   relationship. TypeScript's type system automatically infers and restricts\n *   the available operators based on the actual relationship between types `A`\n *   and `B`. If an invalid relationship is specified, TypeScript will show a\n *   compilation error.\n *\n *   Combine `expectType` with runtime assertions for comprehensive testing:\n *\n *   ## Important Notes\n *\n *   - **Compile-time only**: This function has no runtime behavior and will be\n *       optimized away.\n *   - **Type inference**: The available relation operators are automatically\n *       inferred by TypeScript based on the actual type relationship between\n *       `A` and `B`.\n *   - **Error feedback**: Invalid type relationships will cause clear TypeScript\n *       compilation errors.\n *   - **Test organization**: Typically used in `.test.mts` files alongside runtime\n *       assertions.\n *   - **Performance**: Has zero runtime overhead as it's purely a compile-time\n *       construct.\n */\nexport const expectType = <A, B>(\n  _relation: TypeEq<A, B> extends true\n    ? '<=' | '=' | '>=' | '~='\n    : | '!='\n      | (TypeExtends<A, B> extends true\n          ? '<=' | (TypeExtends<B, A> extends true ? '>=' | '~=' : '!>=')\n          : '!<=' | (TypeExtends<B, A> extends true ? '>=' : '!>=')),\n): void => undefined;\n"],"names":[],"mappings":"AAsEO,MAAM,UAAA,GAAa,CACxB,SAAA,KAMS;;;;"}
+{"version":3,"file":"expect-type.mjs","sourceRoot":"","sources":["../src/expect-type.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,SAKkE,EAC5D,EAAE,CAAC,SAAS,CAAC"}

package/dist/functional/async-result/async-result.mjs

@@ -1,3 +1,2 @@
-import * as index from './impl/index.mjs';
-export { index as AsyncResult };
-//# sourceMappingURL=async-result.mjs.map
+export * as AsyncResult from './impl/index.mjs';
+//# sourceMappingURL=async-result.mjs.map

package/dist/functional/async-result/async-result.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"async-result.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"async-result.mjs","sourceRoot":"","sources":["../../../src/functional/async-result/async-result.mts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC"}

package/dist/functional/async-result/impl/async-result-flat-map.mjs

@@ -1,25 +1,23 @@
-import { isErr } from '../../result/impl/result-is-err.mjs';
-import '@sindresorhus/is';
-
-function flatMap(...args) {
-  switch (args.length) {
-    case 2: {
-      const [asyncResult, flatMapFn] = args;
-      return flatMapImpl(asyncResult, flatMapFn);
+import { Result } from '../../result/index.mjs';
+export function flatMap(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is asyncResult
+            const [asyncResult, flatMapFn] = args;
+            return flatMapImpl(asyncResult, flatMapFn);
+        }
+        case 1: {
+            // Curried version
+            const [flatMapFn] = args;
+            return (asyncResult) => flatMapImpl(asyncResult, flatMapFn);
+        }
     }
-    case 1: {
-      const [flatMapFn] = args;
-      return (asyncResult) => flatMapImpl(asyncResult, flatMapFn);
-    }
-  }
 }
 const flatMapImpl = async (asyncResult, flatMapFn) => {
-  const result = await asyncResult;
-  return isErr(result) ? result : (
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    await flatMapFn(result.value)
-  );
+    const result = await asyncResult;
+    return Result.isErr(result)
+        ? result
+        : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            (await flatMapFn(result.value));
 };
-
-export { flatMap };
-//# sourceMappingURL=async-result-flat-map.mjs.map
+//# sourceMappingURL=async-result-flat-map.mjs.map

package/dist/functional/async-result/impl/async-result-flat-map.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"async-result-flat-map.mjs","sources":["../../../../src/functional/async-result/impl/async-result-flat-map.mts"],"sourcesContent":["import { Result, type UnknownResult } from '../../result/index.mjs';\nimport { type AsyncResult } from '../async-result.mjs';\nimport {\n  type UnknownAsyncResult,\n  type UnwrapErr,\n  type UnwrapOk,\n} from './types.mjs';\n\n/**\n * Applies a function that returns an `AsyncResult` or a `Result` to the\n * success value of an `AsyncResult`. If the input resolves to `Err`, the\n * original `Err` is passed through and the function is not called. This is\n * the monadic bind operation for `AsyncResult`.\n *\n * @example\n *\n * ```ts\n * const parseNumber = (input: string): Result<number, string> => {\n *   const num = Number.parseInt(input, 10);\n *\n *   return Number.isNaN(num) ? Result.err('not a number') : Result.ok(num);\n * };\n *\n * const input = AsyncResult.fromPromise(\n *   Promise.resolve('42'),\n *   () => 'failed',\n * );\n *\n * const parsed = await AsyncResult.flatMap(input, parseNumber);\n *\n * assert.deepStrictEqual(parsed, Result.ok(42));\n * ```\n *\n * @template S The type of the success value of the input.\n * @template E The type of the error value of the input.\n * @template R2 The `AsyncResult` or `Result` type returned by the function.\n * @param asyncResult The `AsyncResult` to flat map.\n * @param flatMapFn The function to apply that returns an `AsyncResult` or a\n *   `Result`.\n * @returns The result of applying the function, or the original `Err`.\n */\nexport function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(\n  asyncResult: AsyncResult<S, E>,\n  flatMapFn: (value: S) => R2,\n): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;\n\n// Curried version\n//\n// The function's return type is captured as a whole (`R2`) and unwrapped with\n// `UnwrapOk` / `UnwrapErr`, instead of being written as\n// `AsyncResult<S2, E2> | Result<S2, E2>` with separate `S2` / `E2` type\n// parameters. With the union form, inference for `E2` collects a candidate\n// from matching `Ok<S2>` against `Err<E2>` (both have a `value` property), so\n// `E2` ends up as the success type and the call fails to type-check even for\n// a function annotated as returning `Result<S2, E2>`.\nexport function flatMap<S, R2 extends UnknownAsyncResult | UnknownResult>(\n  flatMapFn: (value: S) => R2,\n): <E>(\n  asyncResult: AsyncResult<S, E>,\n) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;\n\nexport function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(\n  ...args:\n    | readonly [asyncResult: AsyncResult<S, E>, flatMapFn: (value: S) => R2]\n    | readonly [flatMapFn: (value: S) => R2]\n):\n  | AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>\n  | ((\n      asyncResult: AsyncResult<S, E>,\n    ) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is asyncResult\n      const [asyncResult, flatMapFn] = args;\n\n      return flatMapImpl(asyncResult, flatMapFn);\n    }\n\n    case 1: {\n      // Curried version\n      const [flatMapFn] = args;\n\n      return (asyncResult: AsyncResult<S, E>) =>\n        flatMapImpl(asyncResult, flatMapFn);\n    }\n  }\n}\n\nconst flatMapImpl = async <S, E, R2 extends UnknownAsyncResult | UnknownResult>(\n  asyncResult: AsyncResult<S, E>,\n  flatMapFn: (value: S) => R2,\n): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>> => {\n  const result = await asyncResult;\n\n  return Result.isErr(result)\n    ? result\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      ((await flatMapFn(result.value)) as Result<UnwrapOk<R2>, UnwrapErr<R2>>);\n};\n"],"names":["Result.isErr"],"mappings":";;;AA6DO,SAAS,WACX,IAAA,EAOkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,WAAA,EAAa,SAAS,CAAA,GAAI,IAAA;AAEjC,MAAA,OAAO,WAAA,CAAY,aAAa,SAAS,CAAA;AAAA,IAC3C;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,WAAA,KACN,WAAA,CAAY,WAAA,EAAa,SAAS,CAAA;AAAA,IACtC;AAAA;AAEJ;AAEA,MAAM,WAAA,GAAc,OAClB,WAAA,EACA,SAAA,KACiD;AACjD,EAAA,MAAM,SAAS,MAAM,WAAA;AAErB,EAAA,OAAOA,KAAO,CAAM,MAAM,CAAA,GACtB,MAAA;AAAA;AAAA,IAEE,MAAM,SAAA,CAAU,MAAA,CAAO,KAAK;AAAA,GAAA;AACpC,CAAA;;;;"}
+{"version":3,"file":"async-result-flat-map.mjs","sourceRoot":"","sources":["../../../../src/functional/async-result/impl/async-result-flat-map.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAsB,MAAM,wBAAwB,CAAC;AA6DpE,MAAM,UAAU,OAAO,CACrB,GAAG,IAEuC;IAM1C,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,gDAAgD;YAChD,MAAM,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC;YAEtC,OAAO,WAAW,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QAC7C,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,kBAAkB;YAClB,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;YAEzB,OAAO,CAAC,WAA8B,EAAE,EAAE,CACxC,WAAW,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,WAAW,GAAG,KAAK,EACvB,WAA8B,EAC9B,SAA2B,EACmB,EAAE;IAChD,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC;IAEjC,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC;QACzB,CAAC,CAAC,MAAM;QACR,CAAC,CAAC,oEAAoE;YACnE,CAAC,MAAM,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAyC,CAAC;AAC/E,CAAC,CAAC"}

package/dist/functional/async-result/impl/async-result-from-promise.mjs

@@ -1,11 +1,10 @@
-import { err } from '../../result/impl/result-err.mjs';
-import { ok } from '../../result/impl/result-ok.mjs';
-import '@sindresorhus/is';
-
-function fromPromise(promise, mapError) {
-  return mapError === void 0 ? fromPromiseImpl(promise, (error) => error) : fromPromiseImpl(promise, mapError);
+import { Result } from '../../result/index.mjs';
+export function fromPromise(promise, mapError) {
+    return mapError === undefined
+        ? fromPromiseImpl(promise, (error) => error)
+        : fromPromiseImpl(promise, mapError);
 }
-const fromPromiseImpl = (promise, mapError) => promise.then((value) => ok(value)).catch((error) => err(mapError(error)));
-
-export { fromPromise };
-//# sourceMappingURL=async-result-from-promise.mjs.map
+const fromPromiseImpl = (promise, mapError) => promise
+    .then((value) => Result.ok(value))
+    .catch((error) => Result.err(mapError(error)));
+//# sourceMappingURL=async-result-from-promise.mjs.map