ts-data-forge 3.3.0 → 4.0.0

package/dist/guard/key-is-in.d.mts

@@ -1,157 +1,40 @@
 /**
  * Type guard that checks if a key exists as an own property in an object.
  *
- * This function is similar to `hasKey()` but with reversed parameter order and different
- * type narrowing behavior. While `hasKey()` narrows the object type, `keyIsIn()` narrows
- * the key type to be a valid key of the given object.
+ * This function is similar to `hasKey()` but with reversed parameter order and
+ * different type narrowing behavior. While `hasKey()` narrows the object type,
+ * `keyIsIn()` narrows the key type to be a valid key of the given object.
  *
  * **Type Narrowing Behavior:**
+ *
  * - Narrows the key type to be a key that exists in the object (`K & keyof R`)
- * - Useful when you have a dynamic key and want to ensure it's valid for a specific object
+ * - Useful when you have a dynamic key and want to ensure it's valid for a
+ *   specific object
  * - The object type remains unchanged
  *
- * **Implementation:** Uses `Object.hasOwn()` to check for own properties (not inherited).
- *
- * @template K - The type of the key to check, must extend PropertyKey (string | number | symbol)
- * @template R - The type of the record (object), must extend UnknownRecord
- * @param key - The key to check for
- * @param obj - The object to check within
- * @returns `true` if `key` is an own property of `obj`, `false` otherwise.
- *          When `true`, TypeScript narrows the key type to be a valid key of the object.
- *
- * @example
- * Basic usage with known object structure:
- * ```typescript
- * const obj = { a: 1, b: 2, c: 3 };
- * const userInput: string = getUserInput(); // Could be any string
- *
- * if (keyIsIn(userInput, obj)) {
- *   // userInput is now narrowed to 'a' | 'b' | 'c'
- *   const value = obj[userInput]; // Type-safe access, value is number
- *   console.log(`Value for ${userInput}:`, value);
- * } else {
- *   console.log(`Key '${userInput}' not found in object`);
- * }
- * ```
- *
- * @example
- * Dynamic key validation for safe property access:
- * ```typescript
- * const config = {
- *   apiUrl: 'https://api.example.com',
- *   timeout: 5000,
- *   retries: 3
- * } as const;
- *
- * function getConfigValue(key: string): unknown {
- *   if (keyIsIn(key, config)) {
- *     // key is now narrowed to 'apiUrl' | 'timeout' | 'retries'
- *     return config[key]; // Safe access with proper typing
- *   }
- *
- *   throw new Error(`Invalid config key: ${key}`);
- * }
- *
- * // Usage
- * const apiUrl = getConfigValue('apiUrl');    // Returns string
- * const timeout = getConfigValue('timeout');  // Returns number
- * // getConfigValue('invalid') would throw an error
- * ```
+ * **Implementation:** Uses `Object.hasOwn()` to check for own properties (not
+ * inherited).
  *
  * @example
- * Form field validation:
- * ```typescript
- * interface FormData {
- *   name: string;
- *   email: string;
- *   age: number;
- * }
- *
- * const formData: FormData = getFormData();
- * const requiredFields: readonly string[] = ['name', 'email'] as const;
- *
- * function validateRequiredFields(data: FormData): string[] {
- *   const errors: string[] = [];
  *
- *   for (const field of requiredFields) {
- *     if (keyIsIn(field, data)) {
- *       // field is now narrowed to keyof FormData
- *       const value = data[field];
+ * ```ts
+ * const user = { id: 1, name: 'Ada' } as const;
+ * const maybeKey: string = 'name';
  *
- *       if (typeof value === 'string' && value.trim() === '') {
- *         errors.push(`${field} is required`);
- *       }
- *     }
- *   }
- *
- *   return errors;
- * }
- * ```
- *
- * @example
- * Safe object property iteration:
- * ```typescript
- * const userPreferences = {
- *   theme: 'dark',
- *   language: 'en',
- *   notifications: true
- * };
- *
- * const settingsToUpdate: string[] = getSettingsFromUser();
- *
- * function updatePreferences(updates: Record<string, unknown>) {
- *   const validUpdates: Partial<typeof userPreferences> = {};
- *
- *   for (const [key, value] of Object.entries(updates)) {
- *     if (keyIsIn(key, userPreferences)) {
- *       // key is now narrowed to valid preference keys
- *       validUpdates[key] = value as typeof userPreferences[typeof key];
- *     } else {
- *       console.warn(`Unknown preference key: ${key}`);
- *     }
- *   }
- *
- *   return { ...userPreferences, ...validUpdates };
- * }
- * ```
- *
- * @example
- * Comparison with hasKey() - different narrowing behavior:
- * ```typescript
- * const obj = { x: 10, y: 20 };
- * const key: string = 'x';
- *
- * // Using keyIsIn - narrows the key type
- * if (keyIsIn(key, obj)) {
- *   // key is now 'x' | 'y'
- *   const value = obj[key]; // Safe access
- * }
- *
- * // Using hasKey - narrows the object type
- * if (hasKey(obj, key)) {
- *   // obj type is narrowed to guarantee the key exists
- *   const value = obj.x; // Direct access
- * }
- * ```
- *
- * @example
- * Working with union types:
- * ```typescript
- * type Config =
- *   | { type: 'database'; host: string; port: number }
- *   | { type: 'file'; path: string }
- *   | { type: 'memory'; maxSize: number };
- *
- * function getConfigProperty(config: Config, propName: string): unknown {
- *   if (keyIsIn(propName, config)) {
- *     // propName is narrowed to valid keys for the specific config type
- *     return config[propName];
- *   }
- *
- *   return undefined;
+ * if (keyIsIn(maybeKey, user)) {
+ *   assert(user[maybeKey] === 'Ada');
+ * } else {
+ *   assert.fail('Expected a known key.');
  * }
  * ```
  *
+ * @template K - The type of the key to check, must extend PropertyKey (string |
+ *   number | symbol)
+ * @template R - The type of the record (object), must extend UnknownRecord
+ * @param key - The key to check for
+ * @param obj - The object to check within
+ * @returns `true` if `key` is an own property of `obj`, `false` otherwise. When
+ *   `true`, TypeScript narrows the key type to be a valid key of the object.
  * @see {@link hasKey} - Similar function that narrows the object type instead of the key type
  */
 export declare const keyIsIn: <const K extends PropertyKey, const R extends UnknownRecord>(key: K, obj: R) => key is K & keyof typeof obj;

package/dist/guard/key-is-in.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"key-is-in.d.mts","sourceRoot":"","sources":["../../src/guard/key-is-in.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2JG;AACH,eAAO,MAAM,OAAO,GAClB,KAAK,CAAC,CAAC,SAAS,WAAW,EAC3B,KAAK,CAAC,CAAC,SAAS,aAAa,EAE7B,KAAK,CAAC,EACN,KAAK,CAAC,KACL,GAAG,IAAI,CAAC,GAAG,MAAM,OAAO,GAA8B,CAAC"}
+{"version":3,"file":"key-is-in.d.mts","sourceRoot":"","sources":["../../src/guard/key-is-in.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,OAAO,GAClB,KAAK,CAAC,CAAC,SAAS,WAAW,EAC3B,KAAK,CAAC,CAAC,SAAS,aAAa,EAE7B,KAAK,CAAC,EACN,KAAK,CAAC,KACL,GAAG,IAAI,CAAC,GAAG,MAAM,OAAO,GAA8B,CAAC"}

package/dist/guard/key-is-in.mjs

@@ -1,157 +1,40 @@
 /**
  * Type guard that checks if a key exists as an own property in an object.
  *
- * This function is similar to `hasKey()` but with reversed parameter order and different
- * type narrowing behavior. While `hasKey()` narrows the object type, `keyIsIn()` narrows
- * the key type to be a valid key of the given object.
+ * This function is similar to `hasKey()` but with reversed parameter order and
+ * different type narrowing behavior. While `hasKey()` narrows the object type,
+ * `keyIsIn()` narrows the key type to be a valid key of the given object.
  *
  * **Type Narrowing Behavior:**
+ *
  * - Narrows the key type to be a key that exists in the object (`K & keyof R`)
- * - Useful when you have a dynamic key and want to ensure it's valid for a specific object
+ * - Useful when you have a dynamic key and want to ensure it's valid for a
+ *   specific object
  * - The object type remains unchanged
  *
- * **Implementation:** Uses `Object.hasOwn()` to check for own properties (not inherited).
- *
- * @template K - The type of the key to check, must extend PropertyKey (string | number | symbol)
- * @template R - The type of the record (object), must extend UnknownRecord
- * @param key - The key to check for
- * @param obj - The object to check within
- * @returns `true` if `key` is an own property of `obj`, `false` otherwise.
- *          When `true`, TypeScript narrows the key type to be a valid key of the object.
- *
- * @example
- * Basic usage with known object structure:
- * ```typescript
- * const obj = { a: 1, b: 2, c: 3 };
- * const userInput: string = getUserInput(); // Could be any string
- *
- * if (keyIsIn(userInput, obj)) {
- *   // userInput is now narrowed to 'a' | 'b' | 'c'
- *   const value = obj[userInput]; // Type-safe access, value is number
- *   console.log(`Value for ${userInput}:`, value);
- * } else {
- *   console.log(`Key '${userInput}' not found in object`);
- * }
- * ```
- *
- * @example
- * Dynamic key validation for safe property access:
- * ```typescript
- * const config = {
- *   apiUrl: 'https://api.example.com',
- *   timeout: 5000,
- *   retries: 3
- * } as const;
- *
- * function getConfigValue(key: string): unknown {
- *   if (keyIsIn(key, config)) {
- *     // key is now narrowed to 'apiUrl' | 'timeout' | 'retries'
- *     return config[key]; // Safe access with proper typing
- *   }
- *
- *   throw new Error(`Invalid config key: ${key}`);
- * }
- *
- * // Usage
- * const apiUrl = getConfigValue('apiUrl');    // Returns string
- * const timeout = getConfigValue('timeout');  // Returns number
- * // getConfigValue('invalid') would throw an error
- * ```
+ * **Implementation:** Uses `Object.hasOwn()` to check for own properties (not
+ * inherited).
  *
  * @example
- * Form field validation:
- * ```typescript
- * interface FormData {
- *   name: string;
- *   email: string;
- *   age: number;
- * }
- *
- * const formData: FormData = getFormData();
- * const requiredFields: readonly string[] = ['name', 'email'] as const;
- *
- * function validateRequiredFields(data: FormData): string[] {
- *   const errors: string[] = [];
  *
- *   for (const field of requiredFields) {
- *     if (keyIsIn(field, data)) {
- *       // field is now narrowed to keyof FormData
- *       const value = data[field];
+ * ```ts
+ * const user = { id: 1, name: 'Ada' } as const;
+ * const maybeKey: string = 'name';
  *
- *       if (typeof value === 'string' && value.trim() === '') {
- *         errors.push(`${field} is required`);
- *       }
- *     }
- *   }
- *
- *   return errors;
- * }
- * ```
- *
- * @example
- * Safe object property iteration:
- * ```typescript
- * const userPreferences = {
- *   theme: 'dark',
- *   language: 'en',
- *   notifications: true
- * };
- *
- * const settingsToUpdate: string[] = getSettingsFromUser();
- *
- * function updatePreferences(updates: Record<string, unknown>) {
- *   const validUpdates: Partial<typeof userPreferences> = {};
- *
- *   for (const [key, value] of Object.entries(updates)) {
- *     if (keyIsIn(key, userPreferences)) {
- *       // key is now narrowed to valid preference keys
- *       validUpdates[key] = value as typeof userPreferences[typeof key];
- *     } else {
- *       console.warn(`Unknown preference key: ${key}`);
- *     }
- *   }
- *
- *   return { ...userPreferences, ...validUpdates };
- * }
- * ```
- *
- * @example
- * Comparison with hasKey() - different narrowing behavior:
- * ```typescript
- * const obj = { x: 10, y: 20 };
- * const key: string = 'x';
- *
- * // Using keyIsIn - narrows the key type
- * if (keyIsIn(key, obj)) {
- *   // key is now 'x' | 'y'
- *   const value = obj[key]; // Safe access
- * }
- *
- * // Using hasKey - narrows the object type
- * if (hasKey(obj, key)) {
- *   // obj type is narrowed to guarantee the key exists
- *   const value = obj.x; // Direct access
- * }
- * ```
- *
- * @example
- * Working with union types:
- * ```typescript
- * type Config =
- *   | { type: 'database'; host: string; port: number }
- *   | { type: 'file'; path: string }
- *   | { type: 'memory'; maxSize: number };
- *
- * function getConfigProperty(config: Config, propName: string): unknown {
- *   if (keyIsIn(propName, config)) {
- *     // propName is narrowed to valid keys for the specific config type
- *     return config[propName];
- *   }
- *
- *   return undefined;
+ * if (keyIsIn(maybeKey, user)) {
+ *   assert(user[maybeKey] === 'Ada');
+ * } else {
+ *   assert.fail('Expected a known key.');
  * }
  * ```
  *
+ * @template K - The type of the key to check, must extend PropertyKey (string |
+ *   number | symbol)
+ * @template R - The type of the record (object), must extend UnknownRecord
+ * @param key - The key to check for
+ * @param obj - The object to check within
+ * @returns `true` if `key` is an own property of `obj`, `false` otherwise. When
+ *   `true`, TypeScript narrows the key type to be a valid key of the object.
  * @see {@link hasKey} - Similar function that narrows the object type instead of the key type
  */
 const keyIsIn = (key, obj) => Object.hasOwn(obj, key);

package/dist/guard/key-is-in.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"key-is-in.mjs","sources":["../../src/guard/key-is-in.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2JG;AACI,MAAM,OAAO,GAAG,CAIrB,GAAM,EACN,GAAM,KAC0B,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG;;;;"}
+{"version":3,"file":"key-is-in.mjs","sources":["../../src/guard/key-is-in.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;AACI,MAAM,OAAO,GAAG,CAIrB,GAAM,EACN,GAAM,KAC0B,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG;;;;"}

package/dist/index.d.mts

@@ -1,7 +1,5 @@
-export * from './array/index.mjs';
 export * from './collections/index.mjs';
 export * from './expect-type.mjs';
-export * from './functional/index.mjs';
 export * from './guard/index.mjs';
 export * from './iterator/index.mjs';
 export * from './json/index.mjs';

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/index.mjs

@@ -1,4 +1,3 @@
-export { Arr } from './array/array-utils.mjs';
 export { IMapMapped } from './collections/imap-mapped.mjs';
 export { IMap } from './collections/imap.mjs';
 export { ISetMapped } from './collections/iset-mapped.mjs';
@@ -6,10 +5,6 @@ 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 { match } from './functional/match.mjs';
-export { Optional } from './functional/optional.mjs';
-export { pipe } from './functional/pipe.mjs';
-export { Result } from './functional/result.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';

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/iterator/range.d.mts

@@ -1,92 +1,59 @@
 /**
- * Generates a sequence of numbers within a specified range using a generator function.
+ * Generates a sequence of numbers within a specified range using a generator
+ * function.
  *
- * This function creates a generator that yields numbers from `start` (inclusive) to `end` (exclusive)
- * with the specified `step` increment/decrement. The function implements the JavaScript iterator protocol,
- * making it compatible with for-of loops, spread operator, Array.from(), and other iterator consumers.
+ * This function creates a generator that yields numbers from `start`
+ * (inclusive) to `end` (exclusive) with the specified `step`
+ * increment/decrement. The function implements the JavaScript iterator
+ * protocol, making it compatible with for-of loops, spread operator,
+ * Array.from(), and other iterator consumers.
  *
  * The function has two overloaded signatures:
- * 1. For non-negative ranges: accepts SafeUint parameters and optional positive step
+ *
+ * 1. For non-negative ranges: accepts SafeUint parameters and optional positive
+ *    step
  * 2. For general ranges: accepts SafeInt parameters and optional non-zero step
  *
  * **Generator Behavior:**
+ *
  * - Yields values lazily (computed on-demand)
  * - Returns `void` when iteration completes
  * - Does not accept sent values (next parameter is ignored)
  * - Automatically handles direction based on step sign and start/end relationship
  *
  * **Step Parameter Behavior:**
+ *
  * - Positive step: iterates from start toward end (start < end expected)
  * - Negative step: iterates from start toward end (start > end expected)
  * - Zero step: not allowed (NonZeroSafeInt constraint)
  * - Default step: 1 (positive direction)
  *
  * **Edge Cases:**
+ *
  * - When start equals end: yields no values (empty sequence)
  * - When step direction conflicts with start/end relationship: yields no values
  * - All parameters must be safe integers (within JavaScript's safe integer range)
  *
- * @template T - The specific SafeInt or SafeUint type being generated
- * @param start - The starting number of the sequence (inclusive). Must be a safe integer.
- * @param end - The end number of the sequence (exclusive). Must be a safe integer.
- * @param step - The increment or decrement value. Defaults to 1. Must be non-zero safe integer.
- * @returns A Generator object that yields safe integers in the specified range.
- *
  * @example
- * ```typescript
- * // Basic ascending range
- * for (const n of range(0, 5)) {
- *   console.log(n); // Outputs: 0, 1, 2, 3, 4
- * }
- *
- * // Range with custom step
- * for (const n of range(0, 10, 2)) {
- *   console.log(n); // Outputs: 0, 2, 4, 6, 8
- * }
- *
- * // Descending range with negative step
- * for (const n of range(10, 0, -1)) {
- *   console.log(n); // Outputs: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
- * }
  *
- * // Negative numbers with negative step
- * for (const n of range(0, -10, -1)) {
- *   console.log(n); // Outputs: 0, -1, -2, -3, -4, -5, -6, -7, -8, -9
- * }
+ * ```ts
+ * const zeroToThree = Array.from(range(0, 3));
+ * const threeToZero = Array.from(range(3, 0, -1));
+ * const defaultEnd = Array.from(range(4));
  *
- * // Convert generator to array
- * const numbers = Array.from(range(1, 4)); // [1, 2, 3]
- * const evens = [...range(0, 11, 2)]; // [0, 2, 4, 6, 8, 10]
- *
- * // Empty ranges
- * Array.from(range(5, 5)); // [] (start equals end)
- * Array.from(range(5, 3)); // [] (positive step, start > end)
- * Array.from(range(3, 5, -1)); // [] (negative step, start < end)
- *
- * // Using with iterator protocol manually
- * const gen = range(1, 4);
- * console.log(gen.next()); // { value: 1, done: false }
- * console.log(gen.next()); // { value: 2, done: false }
- * console.log(gen.next()); // { value: 3, done: false }
- * console.log(gen.next()); // { value: undefined, done: true }
- *
- * // Practical usage patterns
- * // Create index sequences
- * const indices = Array.from(range(0, items.length));
- *
- * // Generate test data
- * const testIds = [...range(1, 101)]; // [1, 2, ..., 100]
- *
- * // Iterate with step intervals
- * for (const minute of range(0, 60, 5)) {
- *   scheduleTask(minute); // Every 5 minutes
- * }
- *
- * // Countdown sequences
- * for (const count of range(10, 0, -1)) {
- *   console.log(`T-minus ${count}`);
- * }
+ * assert.deepStrictEqual(zeroToThree, [0, 1, 2]);
+ * assert.deepStrictEqual(threeToZero, [3, 2, 1]);
+ * assert.deepStrictEqual(defaultEnd, [0, 1, 2, 3]);
  * ```
+ *
+ * @template T - The specific SafeInt or SafeUint type being generated
+ * @param start - The starting number of the sequence (inclusive). Must be a
+ *   safe integer.
+ * @param end - The end number of the sequence (exclusive). Must be a safe
+ *   integer.
+ * @param step - The increment or decrement value. Defaults to 1. Must be
+ *   non-zero safe integer.
+ * @returns A Generator object that yields safe integers in the specified range.
  */
 export declare function range(end: WithSmallInt<SafeUint, MaxInt>): Generator<SafeUint, void, unknown>;
 export declare function range(start: WithSmallInt<SafeUint, MaxInt>, end: WithSmallInt<SafeUint, MaxInt>, step?: WithSmallInt<PositiveSafeInt, MaxInt>): Generator<SafeUint, void, unknown>;

package/dist/iterator/range.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"range.d.mts","sourceRoot":"","sources":["../../src/iterator/range.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AACH,wBAAgB,KAAK,CACnB,GAAG,EAAE,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,GAClC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAEtC,wBAAgB,KAAK,CACnB,KAAK,EAAE,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,EACrC,GAAG,EAAE,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,EAEnC,IAAI,CAAC,EAAE,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,GAC3C,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAEtC,wBAAgB,KAAK,CACnB,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,EACpC,GAAG,EAAE,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,EAClC,IAAI,CAAC,EAAE,YAAY,CAAC,cAAc,EAAE,MAAM,CAAC,GAC1C,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAkCrC,KAAK,MAAM,GAAG,GAAG,CAAC"}
+{"version":3,"file":"range.d.mts","sourceRoot":"","sources":["../../src/iterator/range.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,KAAK,CACnB,GAAG,EAAE,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,GAClC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAEtC,wBAAgB,KAAK,CACnB,KAAK,EAAE,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,EACrC,GAAG,EAAE,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,EAEnC,IAAI,CAAC,EAAE,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,GAC3C,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAEtC,wBAAgB,KAAK,CACnB,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,EACpC,GAAG,EAAE,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,EAClC,IAAI,CAAC,EAAE,YAAY,CAAC,cAAc,EAAE,MAAM,CAAC,GAC1C,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAkCrC,KAAK,MAAM,GAAG,GAAG,CAAC"}

package/dist/iterator/range.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"range.mjs","sources":["../../src/iterator/range.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA6GiB,KAAK,CACpB,GAAG,IAME,EAAA;AAEL,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI;AAClB,YAAA,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE;AAChC,gBAAA,MAAM,CAAC;YACT;YACA;QACF;AAEA,QAAA,KAAK,CAAC;QACN,KAAK,CAAC,EAAE;YACN,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI;AACnC,YAAA,KACE,IAAI,KAAK,GAAY,SAAS,CAAC,KAAK,CAAC,EACrC,IAAI,GAAG,CAAC,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,EACpC,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAC3C;AACA,gBAAA,MAAM,KAAK;YACb;QACF;;AAEJ;;;;"}
+{"version":3,"file":"range.mjs","sources":["../../src/iterator/range.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4EiB,KAAK,CACpB,GAAG,IAME,EAAA;AAEL,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI;AAClB,YAAA,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE;AAChC,gBAAA,MAAM,CAAC;YACT;YACA;QACF;AAEA,QAAA,KAAK,CAAC;QACN,KAAK,CAAC,EAAE;YACN,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI;AACnC,YAAA,KACE,IAAI,KAAK,GAAY,SAAS,CAAC,KAAK,CAAC,EACrC,IAAI,GAAG,CAAC,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,EACpC,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAC3C;AACA,gBAAA,MAAM,KAAK;YACb;QACF;;AAEJ;;;;"}