ts-data-forge 9.0.0 → 9.0.1

package/dist/guard/is-type.mjs

@@ -1,405 +1,18 @@
-/**
- * Type guard that checks if a value is `undefined`.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input type to `undefined` when `true`
- * - Useful for explicit undefined checks
- *
- * @example
- *
- * ```ts
- * const values: readonly (number | undefined)[] = [1, undefined, 2] as const;
- *
- * const undefinedValues = values.filter(isUndefined);
- *
- * assert.deepStrictEqual(undefinedValues, [undefined]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is `undefined`, `false` otherwise. When `true`,
- *   TypeScript narrows the type to `undefined`.
- */
-const isUndefined = (u) => u === undefined;
-/**
- * Type guard that checks if a value is not `undefined`.
- *
- * **Type Narrowing Behavior:**
- *
- * - Excludes `undefined` from the input type when `true`
- * - Preserves all other types in the union
- * - Commonly used to filter out undefined values
- *
- * @example
- *
- * ```ts
- * const values: readonly (number | undefined)[] = [1, undefined, 2] as const;
- *
- * const definedValues = values.filter(isNotUndefined);
- *
- * assert.deepStrictEqual(definedValues, [1, 2]);
- * ```
- *
- * @template T - The type of the input value
- * @param u - The value to check
- * @returns `true` if `u` is not `undefined`, `false` otherwise. When `true`,
- *   TypeScript excludes `undefined` from the type.
- */
-const isNotUndefined = (u) => u !== undefined;
-/**
- * Type guard that checks if a value is a boolean.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `boolean` when `true`
- * - Preserves literal boolean types (`true | false`)
- *
- * @example
- *
- * ```ts
- * const flags: readonly unknown[] = [true, 'no', false] as const;
- *
- * const booleans = flags.filter(isBoolean);
- *
- * assert.deepStrictEqual(booleans, [true, false]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a boolean, `false` otherwise. When `true`,
- *   TypeScript narrows the type to `boolean`.
- */
-const isBoolean = (u) => typeof u === 'boolean';
-/**
- * Type guard that checks if a value is not a boolean.
- *
- * **Type Narrowing Behavior:**
- *
- * - Excludes `boolean` from the input type when `true`
- * - Preserves all other types in the union
- *
- * @example
- *
- * ```ts
- * const flags: readonly unknown[] = [true, 'no', false] as const;
- *
- * const nonBooleans = flags.filter(isNotBoolean);
- *
- * assert.deepStrictEqual(nonBooleans, ['no']);
- * ```
- *
- * @template T - The type of the input value
- * @param u - The value to check
- * @returns `true` if `u` is not a boolean, `false` otherwise. When `true`,
- *   TypeScript excludes `boolean` from the type.
- */
-const isNotBoolean = (u) => typeof u !== 'boolean';
-/**
- * Type guard that checks if a value is a number.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `number` when `true`
- * - Includes `NaN`, `Infinity`, and `-Infinity` as valid numbers
- * - Preserves literal number types when possible
- *
- * @example
- *
- * ```ts
- * const mixed: readonly unknown[] = [1, '2', 3] as const;
- *
- * const numbers = mixed.filter(isNumber);
- *
- * assert.deepStrictEqual(numbers, [1, 3]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a number, `false` otherwise. When `true`,
- *   TypeScript narrows the type to `number`.
- */
-const isNumber = (u) => typeof u === 'number';
-/**
- * Type guard that checks if a value is not a number.
- *
- * **Type Narrowing Behavior:**
- *
- * - Excludes `number` from the input type when `true`
- * - Preserves all other types in the union
- *
- * @example
- *
- * ```ts
- * const mixed: readonly unknown[] = [1, '2', 3] as const;
- *
- * const nonNumbers = mixed.filter(isNotNumber);
- *
- * assert.deepStrictEqual(nonNumbers, ['2']);
- * ```
- *
- * @template T - The type of the input value
- * @param u - The value to check
- * @returns `true` if `u` is not a number, `false` otherwise. When `true`,
- *   TypeScript excludes `number` from the type.
- */
-const isNotNumber = (u) => typeof u !== 'number';
-/**
- * Type guard that checks if a value is a bigint.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `bigint` when `true`
- * - Identifies values created with `BigInt()` constructor or `n` suffix
- *
- * @example
- *
- * ```ts
- * const values: readonly unknown[] = [1n, 2, 3n] as const;
- *
- * const bigints = values.filter(isBigint);
- *
- * assert.deepStrictEqual(bigints, [1n, 3n]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a bigint, `false` otherwise. When `true`,
- *   TypeScript narrows the type to `bigint`.
- */
-const isBigint = (u) => typeof u === 'bigint';
-/**
- * Type guard that checks if a value is not a bigint.
- *
- * **Type Narrowing Behavior:**
- *
- * - Excludes `bigint` from the input type when `true`
- * - Preserves all other types in the union
- *
- * @example
- *
- * ```ts
- * const values: readonly unknown[] = [1n, 2, 3n] as const;
- *
- * const nonBigints = values.filter(isNotBigint);
- *
- * assert.deepStrictEqual(nonBigints, [2]);
- * ```
- *
- * @template T - The type of the input value
- * @param u - The value to check
- * @returns `true` if `u` is not a bigint, `false` otherwise. When `true`,
- *   TypeScript excludes `bigint` from the type.
- */
-const isNotBigint = (u) => typeof u !== 'bigint';
-/**
- * Type guard that checks if a value is a string.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `string` when `true`
- * - Preserves literal string types when possible
- * - Includes empty strings
- *
- * @example
- *
- * ```ts
- * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'] as const;
- *
- * const strings = values.filter(isString);
- *
- * assert.deepStrictEqual(strings, ['Ada', 'Lovelace']);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a string, `false` otherwise. When `true`,
- *   TypeScript narrows the type to `string`.
- */
-const isString = (u) => typeof u === 'string';
-/**
- * Type guard that checks if a value is not a string.
- *
- * **Type Narrowing Behavior:**
- *
- * - Excludes `string` from the input type when `true`
- * - Preserves all other types in the union
- *
- * @example
- *
- * ```ts
- * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'] as const;
- *
- * const nonStrings = values.filter(isNotString);
- *
- * assert.deepStrictEqual(nonStrings, [42]);
- * ```
- *
- * @template T - The type of the input value
- * @param u - The value to check
- * @returns `true` if `u` is not a string, `false` otherwise. When `true`,
- *   TypeScript excludes `string` from the type.
- */
-const isNotString = (u) => typeof u !== 'string';
-/**
- * Type guard that checks if a value is a symbol.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `symbol` when `true`
- * - Identifies values created with `Symbol()` constructor
- *
- * @example
- *
- * ```ts
- * const id = Symbol('id');
- *
- * const shared = Symbol.for('shared');
- *
- * const tokens: readonly unknown[] = [id, 'shared', shared] as const;
- *
- * const symbols = tokens.filter(isSymbol);
- *
- * assert.deepStrictEqual(symbols, [id, shared]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a symbol, `false` otherwise. When `true`,
- *   TypeScript narrows the type to `symbol`.
- */
-const isSymbol = (u) => typeof u === 'symbol';
-/**
- * Type guard that checks if a value is not a symbol.
- *
- * **Type Narrowing Behavior:**
- *
- * - Excludes `symbol` from the input type when `true`
- * - Preserves all other types in the union
- *
- * @example
- *
- * ```ts
- * const id = Symbol('id');
- *
- * const tokens: readonly unknown[] = [id, 'shared'] as const;
- *
- * const nonSymbols = tokens.filter(isNotSymbol);
- *
- * assert.deepStrictEqual(nonSymbols, ['shared']);
- * ```
- *
- * @template T - The type of the input value
- * @param u - The value to check
- * @returns `true` if `u` is not a symbol, `false` otherwise. When `true`,
- *   TypeScript excludes `symbol` from the type.
- */
-const isNotSymbol = (u) => typeof u !== 'symbol';
-/**
- * Type guard that checks if a value is `null`.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input type to `null` when `true`
- * - Useful for explicit null checks
- *
- * @example
- *
- * ```ts
- * const values: readonly (number | null)[] = [null, 5] as const;
- *
- * const nullValues = values.filter(isNull);
- *
- * assert.deepStrictEqual(nullValues, [null]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is `null`, `false` otherwise. When `true`, TypeScript
- *   narrows the type to `null`.
- */
+const isUndefined = (u) => u === void 0;
+const isNotUndefined = (u) => u !== void 0;
+const isBoolean = (u) => typeof u === "boolean";
+const isNotBoolean = (u) => typeof u !== "boolean";
+const isNumber = (u) => typeof u === "number";
+const isNotNumber = (u) => typeof u !== "number";
+const isBigint = (u) => typeof u === "bigint";
+const isNotBigint = (u) => typeof u !== "bigint";
+const isString = (u) => typeof u === "string";
+const isNotString = (u) => typeof u !== "string";
+const isSymbol = (u) => typeof u === "symbol";
+const isNotSymbol = (u) => typeof u !== "symbol";
 const isNull = (u) => u === null;
-/**
- * Type guard that checks if a value is not `null`.
- *
- * **Type Narrowing Behavior:**
- *
- * - Excludes `null` from the input type when `true`
- * - Preserves all other types including `undefined`
- * - Commonly used to filter out null values
- *
- * @example
- *
- * ```ts
- * const values: readonly (number | null)[] = [null, 5] as const;
- *
- * const nonNullValues = values.filter(isNotNull);
- *
- * assert.deepStrictEqual(nonNullValues, [5]);
- * ```
- *
- * @template T - The type of the input value (which could be `null`)
- * @param u - The value to check
- * @returns `true` if `u` is not `null`, `false` otherwise. When `true`,
- *   TypeScript excludes `null` from the type.
- */
 const isNotNull = (u) => u !== null;
-/**
- * Type guard that checks if a value is `null` or `undefined` (nullish).
- *
- * This function uses the loose equality operator (`==`) to check for both
- * `null` and `undefined` in a single comparison, which is the standard
- * JavaScript idiom for nullish checks.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input type to `null | undefined` when `true`
- * - Useful for checking if a value is "nullish" (either null or undefined)
- *
- * @example
- *
- * ```ts
- * const values: readonly (string | null | undefined)[] = [
- *   'Ada',
- *   null,
- *   undefined,
- * ] as const;
- *
- * const nullishValues = values.filter(isNullish);
- *
- * assert.deepStrictEqual(nullishValues, [null, undefined]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is `null` or `undefined`, `false` otherwise. When
- *   `true`, TypeScript narrows the type to `null | undefined`.
- */
 const isNullish = (u) => u == null;
-/**
- * Type guard that checks if a value is not `null` or `undefined` (non-nullish).
- *
- * This function uses the loose inequality operator (`!=`) to check that a value
- * is neither `null` nor `undefined` in a single comparison. This is equivalent
- * to TypeScript's `NonNullable<T>` utility type.
- *
- * **Type Narrowing Behavior:**
- *
- * - Excludes both `null` and `undefined` from the input type when `true`
- * - Equivalent to applying TypeScript's `NonNullable<T>` utility type
- * - Commonly used to filter out nullish values from arrays
- *
- * @example
- *
- * ```ts
- * const values: readonly (string | null | undefined)[] = [
- *   'Ada',
- *   null,
- *   undefined,
- * ] as const;
- *
- * const definedValues = values.filter(isNonNullish);
- *
- * assert.deepStrictEqual(definedValues, ['Ada']);
- * ```
- *
- * @template T - The type of the input value
- * @param u - The value to check
- * @returns `true` if `u` is not `null` and not `undefined`, `false` otherwise.
- *   When `true`, TypeScript narrows the type to `NonNullable<T>`.
- */
 const isNonNullish = (u) => u != null;
 
 export { isBigint, isBoolean, isNonNullish, isNotBigint, isNotBoolean, isNotNull, isNotNumber, isNotString, isNotSymbol, isNotUndefined, isNull, isNullish, isNumber, isString, isSymbol, isUndefined };

package/dist/guard/is-type.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-type.mjs","sources":["../../src/guard/is-type.mts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,WAAW,GAAG,CAAC,CAAU,KAAqB,CAAC,KAAK;AAEjE;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,cAAc,GAAG,CAAK,CAAI,KACrC,CAAC,KAAK;AAER;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,SAAS,GAAG,CAAC,CAAU,KAAmB,OAAO,CAAC,KAAK;AAEpE;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,YAAY,GAAG,CAAK,CAAI,KACnC,OAAO,CAAC,KAAK;AAEf;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,QAAQ,GAAG,CAAC,CAAU,KAAkB,OAAO,CAAC,KAAK;AAElE;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,WAAW,GAAG,CAAK,CAAI,KAClC,OAAO,CAAC,KAAK;AAEf;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,QAAQ,GAAG,CAAC,CAAU,KAAkB,OAAO,CAAC,KAAK;AAElE;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,WAAW,GAAG,CAAK,CAAI,KAClC,OAAO,CAAC,KAAK;AAEf;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,QAAQ,GAAG,CAAC,CAAU,KAAkB,OAAO,CAAC,KAAK;AAElE;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,WAAW,GAAG,CAAK,CAAI,KAClC,OAAO,CAAC,KAAK;AAEf;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,QAAQ,GAAG,CAAC,CAAU,KAAkB,OAAO,CAAC,KAAK;AAElE;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,WAAW,GAAG,CAAK,CAAI,KAClC,OAAO,CAAC,KAAK;AAEf;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,MAAM,GAAG,CAAC,CAAU,KAAgB,CAAC,KAAK;AAEvD;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,SAAS,GAAG,CAAK,CAAW,KAAa,CAAC,KAAK;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACI,MAAM,SAAS,GAAG,CAAC,CAAU,KAA4B,CAAC,IAAI;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACI,MAAM,YAAY,GAAG,CAAK,CAAI,KAA0B,CAAC,IAAI;;;;"}
+{"version":3,"file":"is-type.mjs","sources":["../../src/guard/is-type.mts"],"sourcesContent":["import { type RelaxedExclude } from 'ts-type-forge';\n\n/**\n * Type guard that checks if a value is `undefined`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input type to `undefined` when `true`\n * - Useful for explicit undefined checks\n *\n * @example\n *\n * ```ts\n * const values: readonly (number | undefined)[] = [1, undefined, 2] as const;\n *\n * const undefinedValues = values.filter(isUndefined);\n *\n * assert.deepStrictEqual(undefinedValues, [undefined]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is `undefined`, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `undefined`.\n */\nexport const isUndefined = (u: unknown): u is undefined => u === undefined;\n\n/**\n * Type guard that checks if a value is not `undefined`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `undefined` from the input type when `true`\n * - Preserves all other types in the union\n * - Commonly used to filter out undefined values\n *\n * @example\n *\n * ```ts\n * const values: readonly (number | undefined)[] = [1, undefined, 2] as const;\n *\n * const definedValues = values.filter(isNotUndefined);\n *\n * assert.deepStrictEqual(definedValues, [1, 2]);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not `undefined`, `false` otherwise. When `true`,\n *   TypeScript excludes `undefined` from the type.\n */\nexport const isNotUndefined = <T,>(u: T): u is RelaxedExclude<T, undefined> =>\n  u !== undefined;\n\n/**\n * Type guard that checks if a value is a boolean.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `boolean` when `true`\n * - Preserves literal boolean types (`true | false`)\n *\n * @example\n *\n * ```ts\n * const flags: readonly unknown[] = [true, 'no', false] as const;\n *\n * const booleans = flags.filter(isBoolean);\n *\n * assert.deepStrictEqual(booleans, [true, false]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a boolean, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `boolean`.\n */\nexport const isBoolean = (u: unknown): u is boolean => typeof u === 'boolean';\n\n/**\n * Type guard that checks if a value is not a boolean.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `boolean` from the input type when `true`\n * - Preserves all other types in the union\n *\n * @example\n *\n * ```ts\n * const flags: readonly unknown[] = [true, 'no', false] as const;\n *\n * const nonBooleans = flags.filter(isNotBoolean);\n *\n * assert.deepStrictEqual(nonBooleans, ['no']);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not a boolean, `false` otherwise. When `true`,\n *   TypeScript excludes `boolean` from the type.\n */\nexport const isNotBoolean = <T,>(u: T): u is RelaxedExclude<T, boolean> =>\n  typeof u !== 'boolean';\n\n/**\n * Type guard that checks if a value is a number.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `number` when `true`\n * - Includes `NaN`, `Infinity`, and `-Infinity` as valid numbers\n * - Preserves literal number types when possible\n *\n * @example\n *\n * ```ts\n * const mixed: readonly unknown[] = [1, '2', 3] as const;\n *\n * const numbers = mixed.filter(isNumber);\n *\n * assert.deepStrictEqual(numbers, [1, 3]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a number, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `number`.\n */\nexport const isNumber = (u: unknown): u is number => typeof u === 'number';\n\n/**\n * Type guard that checks if a value is not a number.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `number` from the input type when `true`\n * - Preserves all other types in the union\n *\n * @example\n *\n * ```ts\n * const mixed: readonly unknown[] = [1, '2', 3] as const;\n *\n * const nonNumbers = mixed.filter(isNotNumber);\n *\n * assert.deepStrictEqual(nonNumbers, ['2']);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not a number, `false` otherwise. When `true`,\n *   TypeScript excludes `number` from the type.\n */\nexport const isNotNumber = <T,>(u: T): u is RelaxedExclude<T, number> =>\n  typeof u !== 'number';\n\n/**\n * Type guard that checks if a value is a bigint.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `bigint` when `true`\n * - Identifies values created with `BigInt()` constructor or `n` suffix\n *\n * @example\n *\n * ```ts\n * const values: readonly unknown[] = [1n, 2, 3n] as const;\n *\n * const bigints = values.filter(isBigint);\n *\n * assert.deepStrictEqual(bigints, [1n, 3n]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a bigint, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `bigint`.\n */\nexport const isBigint = (u: unknown): u is bigint => typeof u === 'bigint';\n\n/**\n * Type guard that checks if a value is not a bigint.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `bigint` from the input type when `true`\n * - Preserves all other types in the union\n *\n * @example\n *\n * ```ts\n * const values: readonly unknown[] = [1n, 2, 3n] as const;\n *\n * const nonBigints = values.filter(isNotBigint);\n *\n * assert.deepStrictEqual(nonBigints, [2]);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not a bigint, `false` otherwise. When `true`,\n *   TypeScript excludes `bigint` from the type.\n */\nexport const isNotBigint = <T,>(u: T): u is RelaxedExclude<T, bigint> =>\n  typeof u !== 'bigint';\n\n/**\n * Type guard that checks if a value is a string.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `string` when `true`\n * - Preserves literal string types when possible\n * - Includes empty strings\n *\n * @example\n *\n * ```ts\n * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'] as const;\n *\n * const strings = values.filter(isString);\n *\n * assert.deepStrictEqual(strings, ['Ada', 'Lovelace']);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a string, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `string`.\n */\nexport const isString = (u: unknown): u is string => typeof u === 'string';\n\n/**\n * Type guard that checks if a value is not a string.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `string` from the input type when `true`\n * - Preserves all other types in the union\n *\n * @example\n *\n * ```ts\n * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'] as const;\n *\n * const nonStrings = values.filter(isNotString);\n *\n * assert.deepStrictEqual(nonStrings, [42]);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not a string, `false` otherwise. When `true`,\n *   TypeScript excludes `string` from the type.\n */\nexport const isNotString = <T,>(u: T): u is RelaxedExclude<T, string> =>\n  typeof u !== 'string';\n\n/**\n * Type guard that checks if a value is a symbol.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `symbol` when `true`\n * - Identifies values created with `Symbol()` constructor\n *\n * @example\n *\n * ```ts\n * const id = Symbol('id');\n *\n * const shared = Symbol.for('shared');\n *\n * const tokens: readonly unknown[] = [id, 'shared', shared] as const;\n *\n * const symbols = tokens.filter(isSymbol);\n *\n * assert.deepStrictEqual(symbols, [id, shared]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a symbol, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `symbol`.\n */\nexport const isSymbol = (u: unknown): u is symbol => typeof u === 'symbol';\n\n/**\n * Type guard that checks if a value is not a symbol.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `symbol` from the input type when `true`\n * - Preserves all other types in the union\n *\n * @example\n *\n * ```ts\n * const id = Symbol('id');\n *\n * const tokens: readonly unknown[] = [id, 'shared'] as const;\n *\n * const nonSymbols = tokens.filter(isNotSymbol);\n *\n * assert.deepStrictEqual(nonSymbols, ['shared']);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not a symbol, `false` otherwise. When `true`,\n *   TypeScript excludes `symbol` from the type.\n */\nexport const isNotSymbol = <T,>(u: T): u is RelaxedExclude<T, symbol> =>\n  typeof u !== 'symbol';\n\n/**\n * Type guard that checks if a value is `null`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input type to `null` when `true`\n * - Useful for explicit null checks\n *\n * @example\n *\n * ```ts\n * const values: readonly (number | null)[] = [null, 5] as const;\n *\n * const nullValues = values.filter(isNull);\n *\n * assert.deepStrictEqual(nullValues, [null]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is `null`, `false` otherwise. When `true`, TypeScript\n *   narrows the type to `null`.\n */\nexport const isNull = (u: unknown): u is null => u === null;\n\n/**\n * Type guard that checks if a value is not `null`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes `null` from the input type when `true`\n * - Preserves all other types including `undefined`\n * - Commonly used to filter out null values\n *\n * @example\n *\n * ```ts\n * const values: readonly (number | null)[] = [null, 5] as const;\n *\n * const nonNullValues = values.filter(isNotNull);\n *\n * assert.deepStrictEqual(nonNullValues, [5]);\n * ```\n *\n * @template T - The type of the input value (which could be `null`)\n * @param u - The value to check\n * @returns `true` if `u` is not `null`, `false` otherwise. When `true`,\n *   TypeScript excludes `null` from the type.\n */\nexport const isNotNull = <T,>(u: T | null): u is T => u !== null;\n\n/**\n * Type guard that checks if a value is `null` or `undefined` (nullish).\n *\n * This function uses the loose equality operator (`==`) to check for both\n * `null` and `undefined` in a single comparison, which is the standard\n * JavaScript idiom for nullish checks.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input type to `null | undefined` when `true`\n * - Useful for checking if a value is \"nullish\" (either null or undefined)\n *\n * @example\n *\n * ```ts\n * const values: readonly (string | null | undefined)[] = [\n *   'Ada',\n *   null,\n *   undefined,\n * ] as const;\n *\n * const nullishValues = values.filter(isNullish);\n *\n * assert.deepStrictEqual(nullishValues, [null, undefined]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is `null` or `undefined`, `false` otherwise. When\n *   `true`, TypeScript narrows the type to `null | undefined`.\n */\nexport const isNullish = (u: unknown): u is null | undefined => u == null;\n\n/**\n * Type guard that checks if a value is not `null` or `undefined` (non-nullish).\n *\n * This function uses the loose inequality operator (`!=`) to check that a value\n * is neither `null` nor `undefined` in a single comparison. This is equivalent\n * to TypeScript's `NonNullable<T>` utility type.\n *\n * **Type Narrowing Behavior:**\n *\n * - Excludes both `null` and `undefined` from the input type when `true`\n * - Equivalent to applying TypeScript's `NonNullable<T>` utility type\n * - Commonly used to filter out nullish values from arrays\n *\n * @example\n *\n * ```ts\n * const values: readonly (string | null | undefined)[] = [\n *   'Ada',\n *   null,\n *   undefined,\n * ] as const;\n *\n * const definedValues = values.filter(isNonNullish);\n *\n * assert.deepStrictEqual(definedValues, ['Ada']);\n * ```\n *\n * @template T - The type of the input value\n * @param u - The value to check\n * @returns `true` if `u` is not `null` and not `undefined`, `false` otherwise.\n *   When `true`, TypeScript narrows the type to `NonNullable<T>`.\n */\nexport const isNonNullish = <T,>(u: T): u is NonNullable<T> => u != null;\n"],"names":[],"mappings":"AAwBO,MAAM,WAAA,GAAc,CAAC,CAAA,KAA+B,CAAA,KAAM;AA0B1D,MAAM,cAAA,GAAiB,CAAK,CAAA,KACjC,CAAA,KAAM;AAwBD,MAAM,SAAA,GAAY,CAAC,CAAA,KAA6B,OAAO,CAAA,KAAM;AAyB7D,MAAM,YAAA,GAAe,CAAK,CAAA,KAC/B,OAAO,CAAA,KAAM;AAyBR,MAAM,QAAA,GAAW,CAAC,CAAA,KAA4B,OAAO,CAAA,KAAM;AAyB3D,MAAM,WAAA,GAAc,CAAK,CAAA,KAC9B,OAAO,CAAA,KAAM;AAwBR,MAAM,QAAA,GAAW,CAAC,CAAA,KAA4B,OAAO,CAAA,KAAM;AAyB3D,MAAM,WAAA,GAAc,CAAK,CAAA,KAC9B,OAAO,CAAA,KAAM;AAyBR,MAAM,QAAA,GAAW,CAAC,CAAA,KAA4B,OAAO,CAAA,KAAM;AAyB3D,MAAM,WAAA,GAAc,CAAK,CAAA,KAC9B,OAAO,CAAA,KAAM;AA4BR,MAAM,QAAA,GAAW,CAAC,CAAA,KAA4B,OAAO,CAAA,KAAM;AA2B3D,MAAM,WAAA,GAAc,CAAK,CAAA,KAC9B,OAAO,CAAA,KAAM;AAwBR,MAAM,MAAA,GAAS,CAAC,CAAA,KAA0B,CAAA,KAAM;AA0BhD,MAAM,SAAA,GAAY,CAAK,CAAA,KAAwB,CAAA,KAAM;AAgCrD,MAAM,SAAA,GAAY,CAAC,CAAA,KAAsC,CAAA,IAAK;AAkC9D,MAAM,YAAA,GAAe,CAAK,CAAA,KAA8B,CAAA,IAAK;;;;"}

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,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;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,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,OAAO,GAClB,KAAK,CAAC,CAAC,SAAS,WAAW,EAC3B,KAAK,CAAC,CAAC,SAAS,aAAa,OAExB,CAAC,OACD,CAAC,KACL,GAAG,IAAI,CAAC,GAAG,MAAM,OAAO,GAA8B,CAAC"}

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

@@ -1,43 +1,3 @@
-/**
- * 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).
- *
- * @example
- *
- * ```ts
- * const user = { id: 1, name: 'Ada' } as const;
- *
- * const maybeKey: string = 'name';
- *
- * if (keyIsIn(maybeKey, user)) {
- *   assert.isTrue(user[maybeKey] === 'Ada');
- * } else {
- *   assert.fail();
- * }
- * ```
- *
- * @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);
 
 export { keyIsIn };

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":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;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":["import { type UnknownRecord } from 'ts-type-forge';\n\n/**\n * Type guard that checks if a key exists as an own property in an object.\n *\n * This function is similar to `hasKey()` but with reversed parameter order and\n * different type narrowing behavior. While `hasKey()` narrows the object type,\n * `keyIsIn()` narrows the key type to be a valid key of the given object.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the key type to be a key that exists in the object (`K & keyof R`)\n * - Useful when you have a dynamic key and want to ensure it's valid for a\n *   specific object\n * - The object type remains unchanged\n *\n * **Implementation:** Uses `Object.hasOwn()` to check for own properties (not\n * inherited).\n *\n * @example\n *\n * ```ts\n * const user = { id: 1, name: 'Ada' } as const;\n *\n * const maybeKey: string = 'name';\n *\n * if (keyIsIn(maybeKey, user)) {\n *   assert.isTrue(user[maybeKey] === 'Ada');\n * } else {\n *   assert.fail();\n * }\n * ```\n *\n * @template K - The type of the key to check, must extend PropertyKey (string |\n *   number | symbol)\n * @template R - The type of the record (object), must extend UnknownRecord\n * @param key - The key to check for\n * @param obj - The object to check within\n * @returns `true` if `key` is an own property of `obj`, `false` otherwise. When\n *   `true`, TypeScript narrows the key type to be a valid key of the object.\n * @see {@link hasKey} - Similar function that narrows the object type instead of the key type\n */\nexport const keyIsIn = <\n  const K extends PropertyKey,\n  const R extends UnknownRecord,\n>(\n  key: K,\n  obj: R,\n): key is K & keyof typeof obj => Object.hasOwn(obj, key);\n"],"names":[],"mappings":"AA0CO,MAAM,UAAU,CAIrB,GAAA,EACA,QACgC,MAAA,CAAO,MAAA,CAAO,KAAK,GAAG;;;;"}

package/dist/iterator/range.mjs

@@ -36,23 +36,23 @@ import '../number/num.mjs';
 import '../number/refined-number-utils.mjs';
 
 function* range(...args) {
-    switch (args.length) {
-        case 1: {
-            const [end] = args;
-            for (const i of range(0, end, 1)) {
-                yield i;
-            }
-            break;
-        }
-        case 2:
-        // falls through
-        case 3: {
-            const [start, end, step = 1] = args;
-            for (let mut_i = asSafeInt(start); step > 0 ? mut_i < end : mut_i > end; mut_i = SafeInt.add(mut_i, asSafeInt(step))) {
-                yield mut_i;
-            }
-        }
+  switch (args.length) {
+    case 1: {
+      const [end] = args;
+      for (const i of range(0, end, 1)) {
+        yield i;
+      }
+      break;
     }
+    case 2:
+    // falls through
+    case 3: {
+      const [start, end, step = 1] = args;
+      for (let mut_i = asSafeInt(start); step > 0 ? mut_i < end : mut_i > end; mut_i = SafeInt.add(mut_i, asSafeInt(step))) {
+        yield mut_i;
+      }
+    }
+  }
 }
 
 export { range };

package/dist/iterator/range.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"range.mjs","sources":["../../src/iterator/range.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAsFiB,KAAK,CACpB,GAAG,IAME,EAAA;AAEL,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI;AAElB,YAAA,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE;AAChC,gBAAA,MAAM,CAAC;YACT;YAEA;QACF;AAEA,QAAA,KAAK,CAAC;;QAGN,KAAK,CAAC,EAAE;YACN,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI;AAEnC,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":["import {\n  type NonZeroSafeInt,\n  type PositiveSafeInt,\n  type SafeUint,\n  type WithSmallInt,\n} from 'ts-type-forge';\nimport { SafeInt, asSafeInt } from '../number/index.mjs';\n\n/**\n * Generates a sequence of numbers within a specified range using a generator\n * function.\n *\n * This function creates a generator that yields numbers from `start`\n * (inclusive) to `end` (exclusive) with the specified `step`\n * increment/decrement. The function implements the JavaScript iterator\n * protocol, making it compatible with for-of loops, spread operator,\n * Array.from(), and other iterator consumers.\n *\n * The function has two overloaded signatures:\n *\n * 1. For non-negative ranges: accepts SafeUint parameters and optional positive\n *    step\n * 2. For general ranges: accepts SafeInt parameters and optional non-zero step\n *\n * **Generator Behavior:**\n *\n * - Yields values lazily (computed on-demand)\n * - Returns `void` when iteration completes\n * - Does not accept sent values (next parameter is ignored)\n * - Automatically handles direction based on step sign and start/end relationship\n *\n * **Step Parameter Behavior:**\n *\n * - Positive step: iterates from start toward end (start < end expected)\n * - Negative step: iterates from start toward end (start > end expected)\n * - Zero step: not allowed (NonZeroSafeInt constraint)\n * - Default step: 1 (positive direction)\n *\n * **Edge Cases:**\n *\n * - When start equals end: yields no values (empty sequence)\n * - When step direction conflicts with start/end relationship: yields no values\n * - All parameters must be safe integers (within JavaScript's safe integer range)\n *\n * @example\n *\n * ```ts\n * const zeroToThree = Array.from(range(0, 3));\n *\n * const threeToZero = Array.from(range(3, 0, -1));\n *\n * const defaultEnd = Array.from(range(4));\n *\n * assert.deepStrictEqual(zeroToThree, [0, 1, 2]);\n *\n * assert.deepStrictEqual(threeToZero, [3, 2, 1]);\n *\n * assert.deepStrictEqual(defaultEnd, [0, 1, 2, 3]);\n * ```\n *\n * @template T - The specific SafeInt or SafeUint type being generated\n * @param start - The starting number of the sequence (inclusive). Must be a\n *   safe integer.\n * @param end - The end number of the sequence (exclusive). Must be a safe\n *   integer.\n * @param step - The increment or decrement value. Defaults to 1. Must be\n *   non-zero safe integer.\n * @returns A Generator object that yields safe integers in the specified range.\n */\nexport function range(\n  end: WithSmallInt<SafeUint, MaxInt>,\n): Generator<SafeUint, void, unknown>;\n\nexport function range(\n  start: WithSmallInt<SafeUint, MaxInt>,\n  end: WithSmallInt<SafeUint, MaxInt>,\n  // eslint-disable-next-line @typescript-eslint/unified-signatures\n  step?: WithSmallInt<PositiveSafeInt, MaxInt>,\n): Generator<SafeUint, void, unknown>;\n\nexport function range(\n  start: WithSmallInt<SafeInt, MaxInt>,\n  end: WithSmallInt<SafeInt, MaxInt>,\n  step?: WithSmallInt<NonZeroSafeInt, MaxInt>,\n): Generator<SafeInt, void, unknown>;\n\nexport function* range(\n  ...args:\n    | readonly [end: WithSmallInt<SafeInt, MaxInt>]\n    | readonly [\n        start: WithSmallInt<SafeInt, MaxInt>,\n        end: WithSmallInt<SafeInt, MaxInt>,\n        step?: WithSmallInt<NonZeroSafeInt, MaxInt>,\n      ]\n): Generator<SafeInt, void, unknown> {\n  switch (args.length) {\n    case 1: {\n      const [end] = args;\n\n      for (const i of range(0, end, 1)) {\n        yield i;\n      }\n\n      break;\n    }\n\n    case 2:\n\n    // falls through\n    case 3: {\n      const [start, end, step = 1] = args;\n\n      for (\n        let mut_i: SafeInt = asSafeInt(start);\n        step > 0 ? mut_i < end : mut_i > end;\n        mut_i = SafeInt.add(mut_i, asSafeInt(step))\n      ) {\n        yield mut_i;\n      }\n    }\n  }\n}\n\ntype MaxInt = 512;\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsFO,UAAU,SACZ,IAAA,EAOgC;AACnC,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,GAAG,CAAA,GAAI,IAAA;AAEd,MAAA,KAAA,MAAW,CAAA,IAAK,KAAA,CAAM,CAAA,EAAG,GAAA,EAAK,CAAC,CAAA,EAAG;AAChC,QAAA,MAAM,CAAA;AAAA,MACR;AAEA,MAAA;AAAA,IACF;AAAA,IAEA,KAAK,CAAA;AAAA;AAAA,IAGL,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,GAAA,EAAK,IAAA,GAAO,CAAC,CAAA,GAAI,IAAA;AAE/B,MAAA,KAAA,IACM,QAAiB,SAAA,CAAU,KAAK,CAAA,EACpC,IAAA,GAAO,IAAI,KAAA,GAAQ,GAAA,GAAM,KAAA,GAAQ,GAAA,EACjC,QAAQ,OAAA,CAAQ,GAAA,CAAI,OAAO,SAAA,CAAU,IAAI,CAAC,CAAA,EAC1C;AACA,QAAA,MAAM,KAAA;AAAA,MACR;AAAA,IACF;AAAA;AAEJ;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"json.d.mts","sourceRoot":"","sources":["../../src/json/json.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,aAAa,EACnB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAQ,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAIvD;;;;GAIG;AACH,yBAAiB,IAAI,CAAC;IACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACI,MAAM,KAAK,GAChB,MAAM,MAAM,EACZ,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,KAAK,OAAO,KAClE,MAAM,CAAC,SAAS,EAAE,MAAM,CAc1B,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACI,MAAM,SAAS,GACpB,OAAO,OAAO,EACd,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,OAAO,EAChE,QAAQ,kBAAkB,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,KACzC,MAAM,CAAC,MAAM,GAAG,SAAS,EAAE,MAAM,CAQnC,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgEG;IACI,MAAM,iBAAiB,GAC5B,OAAO,OAAO,EACd,yBAAyB,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACrD,QAAQ,kBAAkB,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,KACzC,MAAM,CAAC,MAAM,GAAG,SAAS,EAAE,MAAM,CAUnC,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4EG;IACI,MAAM,kBAAkB,GAC7B,OAAO,aAAa,EACpB,QAAQ,kBAAkB,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,KACzC,MAAM,CAAC,MAAM,GAAG,SAAS,EAAE,MAAM,CAMnC,CAAC;CACH"}
+{"version":3,"file":"json.d.mts","sourceRoot":"","sources":["../../src/json/json.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,aAAa,EACnB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAQ,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAIvD;;;;GAIG;AACH,yBAAiB,IAAI,CAAC;IACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACI,MAAM,KAAK,SACV,MAAM,YACF,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,KAAK,OAAO,KAClE,MAAM,CAAC,SAAS,EAAE,MAAM,CAc1B,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACI,MAAM,SAAS,UACb,OAAO,aACH,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,OAAO,UACxD,kBAAkB,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,KACzC,MAAM,CAAC,MAAM,GAAG,SAAS,EAAE,MAAM,CAQnC,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgEG;IACI,MAAM,iBAAiB,UACrB,OAAO,2BACW,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,UAC7C,kBAAkB,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,KACzC,MAAM,CAAC,MAAM,GAAG,SAAS,EAAE,MAAM,CAUnC,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4EG;IACI,MAAM,kBAAkB,UACtB,aAAa,UACZ,kBAAkB,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,KACzC,MAAM,CAAC,MAAM,GAAG,SAAS,EAAE,MAAM,CAMnC,CAAC;CACH"}