ts-data-forge 1.0.0 → 1.0.1

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

@@ -0,0 +1,160 @@
+/**
+ * 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.
+ *
+ * **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
+ * - 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
+ * ```
+ *
+ * @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];
+ *
+ *       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;
+ * }
+ * ```
+ *
+ * @see {@link hasKey} - Similar function that narrows the object type instead of the key type
+ */
+const keyIsIn = (key, obj) => Object.hasOwn(obj, key);
+
+export { keyIsIn };
+//# sourceMappingURL=key-is-in.mjs.map

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

@@ -0,0 +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;;;;"}

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+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';
+export * from './number/index.mjs';
+export * from './object/index.mjs';
+export * from './others/index.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +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"}

package/dist/index.mjs

@@ -0,0 +1,61 @@
+export { Arr } from './array/array-utils.mjs';
+export { Tpl } from './array/tuple-utils.mjs';
+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 { 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';
+export { isPrimitive } from './guard/is-primitive.mjs';
+export { 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 { 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 { 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 { TsVerifiedInternals } 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 { ifThen } 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';
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

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

package/dist/iterator/index.d.mts

@@ -0,0 +1,2 @@
+export * from './range.mjs';
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/iterator/index.mts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/iterator/index.mjs

@@ -0,0 +1,2 @@
+export { range } from './range.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/iterator/index.mjs.map

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

package/dist/iterator/range.d.mts

@@ -0,0 +1,97 @@
+/**
+ * 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.
+ *
+ * The function has two overloaded signatures:
+ * 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
+ * }
+ *
+ * // 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}`);
+ * }
+ * ```
+ */
+export declare const range: RangeFnOverload;
+type RangeFnOverload = {
+    (start: SafeUintWithSmallInt, end: SafeUintWithSmallInt, step?: PositiveSafeIntWithSmallInt): Generator<SafeUint, void, unknown>;
+    (start: SafeIntWithSmallInt, end: SafeIntWithSmallInt, step?: NonZeroSafeIntWithSmallInt): Generator<SafeInt, void, unknown>;
+};
+export {};
+//# sourceMappingURL=range.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"range.d.mts","sourceRoot":"","sources":["../../src/iterator/range.mts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AACH,eAAO,MAAM,KAAK,EAAE,eAYA,CAAC;AAErB,KAAK,eAAe,GAAG;IACrB,CACE,KAAK,EAAE,oBAAoB,EAC3B,GAAG,EAAE,oBAAoB,EACzB,IAAI,CAAC,EAAE,2BAA2B,GACjC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAEtC,CACE,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,mBAAmB,EACxB,IAAI,CAAC,EAAE,0BAA0B,GAChC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC"}

package/dist/iterator/range.mjs

@@ -0,0 +1,130 @@
+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/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-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 { asSafeInt, SafeInt } from '../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 '../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';
+
+/* eslint-disable @typescript-eslint/no-unsafe-type-assertion, func-names */
+/**
+ * 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.
+ *
+ * The function has two overloaded signatures:
+ * 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
+ * }
+ *
+ * // 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}`);
+ * }
+ * ```
+ */
+const range = function* (start, end, step = 1) {
+    for (let mut_i = asSafeInt(start); step > 0 ? mut_i < end : mut_i > end; mut_i = SafeInt.add(mut_i, step)) {
+        yield mut_i;
+    }
+};
+
+export { range };
+//# sourceMappingURL=range.mjs.map

package/dist/iterator/range.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.mjs","sources":["../../src/iterator/range.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyFG;AACI,MAAM,KAAK,GAAoB,WACpC,KAA0B,EAC1B,GAAwB,EACxB,IAAA,GAAmC,CAAC,EAAA;AAEpC,IAAA,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,IAAI,CAAC,EAChC;AACA,QAAA,MAAM,KAAK;;AAEf;;;;"}

package/dist/json/index.d.mts

@@ -0,0 +1,2 @@
+export * from './json.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/json/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/json/index.mts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/json/index.mjs

@@ -0,0 +1,2 @@
+export { Json } from './json.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/json/index.mjs.map

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