ts-data-forge 9.0.0 → 10.0.0

package/dist/guard/is-length-bounded-string.mjs

@@ -1,163 +1,6 @@
-/**
- * Type guard that checks if a string has at least `minLength` characters.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `MinLengthString<MinLength>` while preserving the
- *   original string type (e.g. literal types) via intersection.
- * - The result participates in the length-constraint subtyping relation: for
- *   example, a value narrowed to `MinLengthString<3>` is assignable to
- *   `MinLengthString<1>` (= `NonEmptyString`).
- *
- * @example
- *
- * ```ts
- * const input: string = 'very-secret-password';
- *
- * assert.isTrue(isMinLengthString(input, 12));
- *
- * assert.isFalse(isMinLengthString('short', 12));
- *
- * if (isMinLengthString(input, 12)) {
- *   const password: MinLengthString<12> = input;
- *
- *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template MinLength - The minimum number of characters (inclusive).
- * @param s - The string to check.
- * @param minLength - The minimum number of characters (inclusive).
- * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,
- *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.
- */
 const isMinLengthString = (s, minLength) => s.length >= minLength;
-/**
- * Type guard that checks if a string has at most `maxLength` characters.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `MaxLengthString<MaxLength>` while preserving the
- *   original string type (e.g. literal types) via intersection.
- * - The result participates in the length-constraint subtyping relation: for
- *   example, a value narrowed to `MaxLengthString<16>` is assignable to
- *   `MaxLengthString<32>`.
- *
- * @example
- *
- * ```ts
- * const input: string = 'noshiro';
- *
- * assert.isTrue(isMaxLengthString(input, 32));
- *
- * assert.isFalse(isMaxLengthString(input, 3));
- *
- * if (isMaxLengthString(input, 32)) {
- *   const userName: MaxLengthString<32> = input;
- *
- *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template MaxLength - The maximum number of characters (inclusive).
- * @param s - The string to check.
- * @param maxLength - The maximum number of characters (inclusive).
- * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,
- *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.
- */
 const isMaxLengthString = (s, maxLength) => s.length <= maxLength;
-/**
- * Type guard that checks if a string's length is within the inclusive range
- * `[minLength, maxLength]`.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `BoundedLengthString<MinLength, MaxLength>` while
- *   preserving the original string type (e.g. literal types) via intersection.
- * - Since `BoundedLengthString` is the intersection of `MinLengthString` and
- *   `MaxLengthString`, the narrowed value is assignable to both, and both
- *   bounds can be weakened independently.
- *
- * @example
- *
- * ```ts
- * const input: string = 'user-12345678';
- *
- * assert.isTrue(isBoundedLengthString(input, 8, 16));
- *
- * assert.isFalse(isBoundedLengthString('user', 8, 16));
- *
- * if (isBoundedLengthString(input, 8, 16)) {
- *   const userId: BoundedLengthString<8, 16> = input;
- *
- *   const relaxed: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template MinLength - The minimum number of characters (inclusive).
- * @template MaxLength - The maximum number of characters (inclusive).
- * @param s - The string to check.
- * @param minLength - The minimum number of characters (inclusive).
- * @param maxLength - The maximum number of characters (inclusive).
- * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`
- *   otherwise. When `true`, TypeScript narrows `s` to
- *   `BoundedLengthString<MinLength, MaxLength> & S`.
- */
 const isBoundedLengthString = (s, minLength, maxLength) => s.length >= minLength && s.length <= maxLength;
-/**
- * Type guard that checks if a string has exactly `length` characters.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `FixedLengthString<Length>` while preserving the
- *   original string type (e.g. literal types) via intersection.
- * - Since `FixedLengthString<Length>` is defined as
- *   `BoundedLengthString<Length, Length>`, the narrowed value is assignable to
- *   any `MinLengthString<N>` with `N <= Length` and any `MaxLengthString<N>`
- *   with `N >= Length`.
- *
- * @example
- *
- * ```ts
- * const input: string = 'JP';
- *
- * assert.isTrue(isFixedLengthString(input, 2));
- *
- * assert.isFalse(isFixedLengthString(input, 3));
- *
- * if (isFixedLengthString(input, 2)) {
- *   const countryCode: FixedLengthString<2> = input;
- *
- *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template Length - The exact number of characters.
- * @param s - The string to check.
- * @param length - The exact number of characters.
- * @returns `true` if `s.length === length`, `false` otherwise. When `true`,
- *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.
- */
 const isFixedLengthString = (s, length) => s.length === length;
 
 export { isBoundedLengthString, isFixedLengthString, isMaxLengthString, isMinLengthString };

package/dist/guard/is-length-bounded-string.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-length-bounded-string.mjs","sources":["../../src/guard/is-length-bounded-string.mts"],"sourcesContent":[null],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACI,MAAM,iBAAiB,GAAG,CAI/B,CAAI,EACJ,SAAoB,KACoB,CAAC,CAAC,MAAM,IAAI;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACI,MAAM,iBAAiB,GAAG,CAI/B,CAAI,EACJ,SAAoB,KACoB,CAAC,CAAC,MAAM,IAAI;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCG;AACI,MAAM,qBAAqB,GAAG,CAKnC,CAAI,EACJ,SAAoB,EACpB,SAAoB,KAEpB,CAAC,CAAC,MAAM,IAAI,SAAS,IAAI,CAAC,CAAC,MAAM,IAAI;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;AACI,MAAM,mBAAmB,GAAG,CAIjC,CAAI,EACJ,MAAc,KACyB,CAAC,CAAC,MAAM,KAAK;;;;"}
+{"version":3,"file":"is-length-bounded-string.mjs","sources":["../../src/guard/is-length-bounded-string.mts"],"sourcesContent":["import {\n  type BoundedLengthString,\n  type FixedLengthString,\n  type MaxLengthString,\n  type MinLengthString,\n  type SupportedLength,\n} from 'ts-type-forge';\n\n/**\n * Type guard that checks if a string has at least `minLength` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MinLengthString<MinLength>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MinLengthString<3>` is assignable to\n *   `MinLengthString<1>` (= `NonEmptyString`).\n *\n * @example\n *\n * ```ts\n * const input: string = 'very-secret-password';\n *\n * assert.isTrue(isMinLengthString(input, 12));\n *\n * assert.isFalse(isMinLengthString('short', 12));\n *\n * if (isMinLengthString(input, 12)) {\n *   const password: MinLengthString<12> = input;\n *\n *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MinLength - The minimum number of characters (inclusive).\n * @param s - The string to check.\n * @param minLength - The minimum number of characters (inclusive).\n * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.\n */\nexport const isMinLengthString = <\n  S extends string,\n  MinLength extends SupportedLength,\n>(\n  s: S,\n  minLength: MinLength,\n): s is MinLengthString<MinLength> & S => s.length >= minLength;\n\n/**\n * Type guard that checks if a string has at most `maxLength` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MaxLengthString<MaxLength>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MaxLengthString<16>` is assignable to\n *   `MaxLengthString<32>`.\n *\n * @example\n *\n * ```ts\n * const input: string = 'noshiro';\n *\n * assert.isTrue(isMaxLengthString(input, 32));\n *\n * assert.isFalse(isMaxLengthString(input, 3));\n *\n * if (isMaxLengthString(input, 32)) {\n *   const userName: MaxLengthString<32> = input;\n *\n *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MaxLength - The maximum number of characters (inclusive).\n * @param s - The string to check.\n * @param maxLength - The maximum number of characters (inclusive).\n * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.\n */\nexport const isMaxLengthString = <\n  S extends string,\n  MaxLength extends SupportedLength,\n>(\n  s: S,\n  maxLength: MaxLength,\n): s is MaxLengthString<MaxLength> & S => s.length <= maxLength;\n\n/**\n * Type guard that checks if a string's length is within the inclusive range\n * `[minLength, maxLength]`.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `BoundedLengthString<MinLength, MaxLength>` while\n *   preserving the original string type (e.g. literal types) via intersection.\n * - Since `BoundedLengthString` is the intersection of `MinLengthString` and\n *   `MaxLengthString`, the narrowed value is assignable to both, and both\n *   bounds can be weakened independently.\n *\n * @example\n *\n * ```ts\n * const input: string = 'user-12345678';\n *\n * assert.isTrue(isBoundedLengthString(input, 8, 16));\n *\n * assert.isFalse(isBoundedLengthString('user', 8, 16));\n *\n * if (isBoundedLengthString(input, 8, 16)) {\n *   const userId: BoundedLengthString<8, 16> = input;\n *\n *   const relaxed: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MinLength - The minimum number of characters (inclusive).\n * @template MaxLength - The maximum number of characters (inclusive).\n * @param s - The string to check.\n * @param minLength - The minimum number of characters (inclusive).\n * @param maxLength - The maximum number of characters (inclusive).\n * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`\n *   otherwise. When `true`, TypeScript narrows `s` to\n *   `BoundedLengthString<MinLength, MaxLength> & S`.\n */\nexport const isBoundedLengthString = <\n  S extends string,\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n>(\n  s: S,\n  minLength: MinLength,\n  maxLength: MaxLength,\n): s is BoundedLengthString<MinLength, MaxLength> & S =>\n  s.length >= minLength && s.length <= maxLength;\n\n/**\n * Type guard that checks if a string has exactly `length` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `FixedLengthString<Length>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - Since `FixedLengthString<Length>` is defined as\n *   `BoundedLengthString<Length, Length>`, the narrowed value is assignable to\n *   any `MinLengthString<N>` with `N <= Length` and any `MaxLengthString<N>`\n *   with `N >= Length`.\n *\n * @example\n *\n * ```ts\n * const input: string = 'JP';\n *\n * assert.isTrue(isFixedLengthString(input, 2));\n *\n * assert.isFalse(isFixedLengthString(input, 3));\n *\n * if (isFixedLengthString(input, 2)) {\n *   const countryCode: FixedLengthString<2> = input;\n *\n *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template Length - The exact number of characters.\n * @param s - The string to check.\n * @param length - The exact number of characters.\n * @returns `true` if `s.length === length`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.\n */\nexport const isFixedLengthString = <\n  S extends string,\n  Length extends SupportedLength,\n>(\n  s: S,\n  length: Length,\n): s is FixedLengthString<Length> & S => s.length === length;\n"],"names":[],"mappings":"AA8CO,MAAM,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU;AAwC/C,MAAM,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU;AA4C/C,MAAM,qBAAA,GAAwB,CAKnC,CAAA,EACA,SAAA,EACA,cAEA,CAAA,CAAE,MAAA,IAAU,SAAA,IAAa,CAAA,CAAE,MAAA,IAAU;AAyChC,MAAM,mBAAA,GAAsB,CAIjC,CAAA,EACA,MAAA,KACuC,EAAE,MAAA,KAAW;;;;"}

package/dist/guard/is-non-empty-string.d.mts

@@ -36,5 +36,5 @@ import { type NonEmptyString, type RelaxedExclude } from 'ts-type-forge';
  *   `true`, TypeScript narrows the type to exclude empty strings and nullish
  *   values.
  */
-export declare const isNonEmptyString: <S extends string | null | undefined>(s: S) => s is NonEmptyString & RelaxedExclude<NonNullable<S>, "">;
+export declare const isNonEmptyString: <S extends string | null | undefined>(s: S) => s is NonEmptyString & RelaxedExclude<NonNullable<S>, ''>;
 //# sourceMappingURL=is-non-empty-string.d.mts.map

package/dist/guard/is-non-empty-string.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-empty-string.d.mts","sourceRoot":"","sources":["../../src/guard/is-non-empty-string.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,MAAM,GAAG,IAAI,GAAG,SAAS,EAClE,GAAG,CAAC,KACH,CAAC,IAAI,cAAc,GAAG,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,CACnB,CAAC"}
+{"version":3,"file":"is-non-empty-string.d.mts","sourceRoot":"","sources":["../../src/guard/is-non-empty-string.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,MAAM,GAAG,IAAI,GAAG,SAAS,KAC/D,CAAC,KACH,CAAC,IAAI,cAAc,GAAG,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,CACnB,CAAC"}

package/dist/guard/is-non-empty-string.mjs

@@ -1,41 +1,4 @@
-/**
- * Type guard that checks if a value is a non-empty string.
- *
- * This function performs both a type check (ensuring the value is a string) and
- * a length check (ensuring the string is not empty). It acts as a type guard
- * that narrows the input type to exclude `null`, `undefined`, and empty
- * strings.
- *
- * **Type Narrowing Behavior:**
- *
- * - Eliminates `null` and `undefined` from the type
- * - Excludes empty string (`""`) from the type
- * - Preserves literal string types when possible
- * - Whitespace-only strings are considered non-empty
- *
- * @example
- *
- * ```ts
- * const words: readonly (string | undefined)[] = [
- *   'Ada',
- *   undefined,
- *   '',
- *   'Lovelace',
- * ] as const;
- *
- * const nonEmpty = words.filter(isNonEmptyString);
- *
- * assert.deepStrictEqual(nonEmpty, ['Ada', 'Lovelace']);
- * ```
- *
- * @template S - The input type, which can include `string`, `null`, or
- *   `undefined`
- * @param s - The value to check
- * @returns `true` if `s` is a string with length > 0, `false` otherwise. When
- *   `true`, TypeScript narrows the type to exclude empty strings and nullish
- *   values.
- */
-const isNonEmptyString = (s) => typeof s === 'string' && s.length > 0;
+const isNonEmptyString = (s) => typeof s === "string" && s.length > 0;
 
 export { isNonEmptyString };
 //# sourceMappingURL=is-non-empty-string.mjs.map

package/dist/guard/is-non-empty-string.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-empty-string.mjs","sources":["../../src/guard/is-non-empty-string.mts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCG;AACI,MAAM,gBAAgB,GAAG,CAC9B,CAAI,KAEJ,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,GAAG;;;;"}
+{"version":3,"file":"is-non-empty-string.mjs","sources":["../../src/guard/is-non-empty-string.mts"],"sourcesContent":["import { type NonEmptyString, type RelaxedExclude } from 'ts-type-forge';\n\n/**\n * Type guard that checks if a value is a non-empty string.\n *\n * This function performs both a type check (ensuring the value is a string) and\n * a length check (ensuring the string is not empty). It acts as a type guard\n * that narrows the input type to exclude `null`, `undefined`, and empty\n * strings.\n *\n * **Type Narrowing Behavior:**\n *\n * - Eliminates `null` and `undefined` from the type\n * - Excludes empty string (`\"\"`) from the type\n * - Preserves literal string types when possible\n * - Whitespace-only strings are considered non-empty\n *\n * @example\n *\n * ```ts\n * const words: readonly (string | undefined)[] = [\n *   'Ada',\n *   undefined,\n *   '',\n *   'Lovelace',\n * ] as const;\n *\n * const nonEmpty = words.filter(isNonEmptyString);\n *\n * assert.deepStrictEqual(nonEmpty, ['Ada', 'Lovelace']);\n * ```\n *\n * @template S - The input type, which can include `string`, `null`, or\n *   `undefined`\n * @param s - The value to check\n * @returns `true` if `s` is a string with length > 0, `false` otherwise. When\n *   `true`, TypeScript narrows the type to exclude empty strings and nullish\n *   values.\n */\nexport const isNonEmptyString = <S extends string | null | undefined>(\n  s: S,\n): s is NonEmptyString & RelaxedExclude<NonNullable<S>, ''> =>\n  typeof s === 'string' && s.length > 0;\n"],"names":[],"mappings":"AAuCO,MAAM,mBAAmB,CAC9B,CAAA,KAEA,OAAO,CAAA,KAAM,QAAA,IAAY,EAAE,MAAA,GAAS;;;;"}

package/dist/guard/is-non-null-object.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-null-object.d.mts","sourceRoot":"","sources":["../../src/guard/is-non-null-object.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,eAAO,MAAM,eAAe,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,MACb,CAAC"}
+{"version":3,"file":"is-non-null-object.d.mts","sourceRoot":"","sources":["../../src/guard/is-non-null-object.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,eAAO,MAAM,eAAe,MAAO,OAAO,KAAG,CAAC,IAAI,MACb,CAAC"}

package/dist/guard/is-non-null-object.mjs

@@ -1,38 +1,4 @@
-/**
- * Type guard that checks if a value is a non-null object.
- *
- * This function checks if a value has type `"object"` according to the `typeof`
- * operator and is not `null`. This includes all object types such as plain
- * objects, arrays, dates, regular expressions, and other object instances, but
- * excludes functions.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `object`
- * - Excludes `null`, `undefined`, and all primitive types
- * - Excludes functions (they have `typeof` === `"function"`, not `"object"`)
- * - Includes arrays, dates, regex, and other object instances
- *
- * **Note:** This function returns `true` for arrays. If you need
- * record-oriented narrowing that excludes arrays, use `isRecord()` instead.
- *
- * @example
- *
- * ```ts
- * const mixed: readonly unknown[] = [{ id: 1 }, null, 'Ada'] as const;
- *
- * const objects = mixed.filter(isNonNullObject);
- *
- * assert.deepStrictEqual(objects, [{ id: 1 }]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is an object and not `null`, `false` otherwise. When
- *   `true`, TypeScript narrows the type to `object`.
- * @see {@link isRecord} - For record-oriented type narrowing (excludes arrays)
- */
-// eslint-disable-next-line @typescript-eslint/no-restricted-types
-const isNonNullObject = (u) => typeof u === 'object' && u !== null;
+const isNonNullObject = (u) => typeof u === "object" && u !== null;
 
 export { isNonNullObject };
 //# sourceMappingURL=is-non-null-object.mjs.map

package/dist/guard/is-non-null-object.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-null-object.mjs","sources":["../../src/guard/is-non-null-object.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACH;AACO,MAAM,eAAe,GAAG,CAAC,CAAU,KACxC,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK;;;;"}
+{"version":3,"file":"is-non-null-object.mjs","sources":["../../src/guard/is-non-null-object.mts"],"sourcesContent":["/**\n * Type guard that checks if a value is a non-null object.\n *\n * This function checks if a value has type `\"object\"` according to the `typeof`\n * operator and is not `null`. This includes all object types such as plain\n * objects, arrays, dates, regular expressions, and other object instances, but\n * excludes functions.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `object`\n * - Excludes `null`, `undefined`, and all primitive types\n * - Excludes functions (they have `typeof` === `\"function\"`, not `\"object\"`)\n * - Includes arrays, dates, regex, and other object instances\n *\n * **Note:** This function returns `true` for arrays. If you need\n * record-oriented narrowing that excludes arrays, use `isRecord()` instead.\n *\n * @example\n *\n * ```ts\n * const mixed: readonly unknown[] = [{ id: 1 }, null, 'Ada'] as const;\n *\n * const objects = mixed.filter(isNonNullObject);\n *\n * assert.deepStrictEqual(objects, [{ id: 1 }]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is an object and not `null`, `false` otherwise. When\n *   `true`, TypeScript narrows the type to `object`.\n * @see {@link isRecord} - For record-oriented type narrowing (excludes arrays)\n */\n// eslint-disable-next-line @typescript-eslint/no-restricted-types\nexport const isNonNullObject = (u: unknown): u is object =>\n  typeof u === 'object' && u !== null;\n"],"names":[],"mappings":"AAkCO,MAAM,kBAAkB,CAAC,CAAA,KAC9B,OAAO,CAAA,KAAM,YAAY,CAAA,KAAM;;;;"}

package/dist/guard/is-primitive.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-primitive.d.mts","sourceRoot":"","sources":["../../src/guard/is-primitive.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,WAAW,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,SAa7C,CAAC"}
+{"version":3,"file":"is-primitive.d.mts","sourceRoot":"","sources":["../../src/guard/is-primitive.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,WAAW,MAAO,OAAO,KAAG,CAAC,IAAI,SAa7C,CAAC"}

package/dist/guard/is-primitive.mjs

@@ -1,47 +1,16 @@
-/**
- * Type guard that checks if a value is a primitive type.
- *
- * This function identifies JavaScript primitive types, which are immutable data
- * types that are not objects. The primitive types are: `string`, `number`,
- * `boolean`, `undefined`, `symbol`, `bigint`, and `null`.
- *
- * **Important Note:** Although `null` has `typeof null === "object"` due to a
- * historical JavaScript quirk, this function correctly identifies `null` as a
- * primitive value.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input type to `Primitive` (union of all primitive types)
- * - Excludes object types, arrays, functions, and other non-primitive values
- * - Includes `null` despite its misleading `typeof` result
- *
- * @example
- *
- * ```ts
- * const values: readonly unknown[] = [42, 'Ada', null, { id: 1 }] as const;
- *
- * const primitives = values.filter(isPrimitive);
- *
- * assert.deepStrictEqual(primitives, [42, 'Ada', null]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a primitive type, `false` otherwise. When `true`,
- *   TypeScript narrows the type to `Primitive`.
- */
 const isPrimitive = (u) => {
-    switch (typeof u) {
-        case 'string':
-        case 'number':
-        case 'boolean':
-        case 'undefined':
-        case 'symbol':
-        case 'bigint':
-            return true;
-        case 'function':
-        case 'object':
-            return u === null;
-    }
+  switch (typeof u) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "undefined":
+    case "symbol":
+    case "bigint":
+      return true;
+    case "function":
+    case "object":
+      return u === null;
+  }
 };
 
 export { isPrimitive };

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

@@ -1 +1 @@
-{"version":3,"file":"is-primitive.mjs","sources":["../../src/guard/is-primitive.mts"],"sourcesContent":[null],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACI,MAAM,WAAW,GAAG,CAAC,CAAU,KAAoB;IACxD,QAAQ,OAAO,CAAC;AACd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,SAAS;AACd,QAAA,KAAK,WAAW;AAChB,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,IAAI;AACb,QAAA,KAAK,UAAU;AACf,QAAA,KAAK,QAAQ;YACX,OAAO,CAAC,KAAK,IAAI;;AAEvB;;;;"}
+{"version":3,"file":"is-primitive.mjs","sources":["../../src/guard/is-primitive.mts"],"sourcesContent":["import { type Primitive } from 'ts-type-forge';\nimport { expectType } from '../expect-type.mjs';\n\n/**\n * Type guard that checks if a value is a primitive type.\n *\n * This function identifies JavaScript primitive types, which are immutable data\n * types that are not objects. The primitive types are: `string`, `number`,\n * `boolean`, `undefined`, `symbol`, `bigint`, and `null`.\n *\n * **Important Note:** Although `null` has `typeof null === \"object\"` due to a\n * historical JavaScript quirk, this function correctly identifies `null` as a\n * primitive value.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input type to `Primitive` (union of all primitive types)\n * - Excludes object types, arrays, functions, and other non-primitive values\n * - Includes `null` despite its misleading `typeof` result\n *\n * @example\n *\n * ```ts\n * const values: readonly unknown[] = [42, 'Ada', null, { id: 1 }] as const;\n *\n * const primitives = values.filter(isPrimitive);\n *\n * assert.deepStrictEqual(primitives, [42, 'Ada', null]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a primitive type, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `Primitive`.\n */\nexport const isPrimitive = (u: unknown): u is Primitive => {\n  switch (typeof u) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n    case 'undefined':\n    case 'symbol':\n    case 'bigint':\n      return true;\n    case 'function':\n    case 'object':\n      return u === null;\n  }\n};\n\nexpectType<\n  bigint | boolean | number | string | symbol | undefined | null,\n  Primitive\n>('=');\n"],"names":[],"mappings":"AAkCO,MAAM,WAAA,GAAc,CAAC,CAAA,KAA+B;AACzD,EAAA,QAAQ,OAAO,CAAA;AAAG,IAChB,KAAK,QAAA;AAAA,IACL,KAAK,QAAA;AAAA,IACL,KAAK,SAAA;AAAA,IACL,KAAK,WAAA;AAAA,IACL,KAAK,QAAA;AAAA,IACL,KAAK,QAAA;AACH,MAAA,OAAO,IAAA;AAAA,IACT,KAAK,UAAA;AAAA,IACL,KAAK,QAAA;AACH,MAAA,OAAO,CAAA,KAAM,IAAA;AAAA;AAEnB;;;;"}

package/dist/guard/is-record.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-record.d.mts","sourceRoot":"","sources":["../../src/guard/is-record.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,aACF,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,eAAe,EAAE,CAC5B,CAAC,EAAE,OAAO,KACP,CAAC,IAAI,aAAa,CAAC,MAAM,EAAE,OAAO,CAAY,CAAC"}
+{"version":3,"file":"is-record.d.mts","sourceRoot":"","sources":["../../src/guard/is-record.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,QAAQ,MAAO,OAAO,KAAG,CAAC,IAAI,aACF,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,eAAe,EAAE,CAC5B,CAAC,EAAE,OAAO,KACP,CAAC,IAAI,aAAa,CAAC,MAAM,EAAE,OAAO,CAAY,CAAC"}

package/dist/guard/is-record.mjs

@@ -1,92 +1,6 @@
 import { isNonNullObject } from './is-non-null-object.mjs';
 
-/**
- * Type guard that checks if a value is a record — a non-null, non-array
- * object — and narrows it to `UnknownRecord` (= `ReadonlyRecord<string,
- * unknown>`).
- *
- * This function is designed to be combined with {@link hasKey} to probe
- * values of type `unknown` (e.g. parsed JSON, caught errors, external data)
- * in a type-safe way: `if (isRecord(u) && hasKey(u, 'some-key')) { ... }`.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `UnknownRecord` (= `ReadonlyRecord<string, unknown>`)
- * - Excludes `null`, `undefined`, primitives, and functions
- * - Excludes arrays: arrays have no string index signature, so they are not
- *   assignable to `UnknownRecord`; admitting them at runtime would be
- *   inconsistent with the narrowed type
- * - Returns `true` for every other non-null object, including dictionary
- *   objects created with `Object.create(null)` and instances such as `Date`,
- *   `RegExp`, `Map`, `Set`, `Error`, and user-defined classes
- *
- * **Why non-plain objects are included:** since every property of
- * `UnknownRecord` is typed `unknown`, reading properties from any object
- * through this narrowing is type-safe, and `hasKey` (backed by
- * `Object.hasOwn`) answers own-property questions correctly on any object
- * (e.g. `Map` entries are not own properties, so `hasKey` correctly returns
- * `false` for them). Restricting the guard to plain objects would require
- * prototype checks that misjudge cross-realm objects and would prevent
- * probing useful instances such as `Error` subclasses.
- *
- * **Implementation:** `isNonNullObject(u) && !Array.isArray(u)`.
- *
- * @example
- *
- * ```ts
- * const entries: readonly unknown[] = [
- *   { id: 1 },
- *   [1, 2],
- *   'str',
- *   0,
- *   null,
- * ] as const;
- *
- * const records = entries.filter(isRecord);
- *
- * assert.deepStrictEqual(records, [{ id: 1 }]);
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.
- *   When `true`, TypeScript narrows the type to `UnknownRecord`.
- * @see {@link isNonNullObject} - For checking any non-null object (includes arrays)
- * @see {@link hasKey} - For checking if a record has specific keys
- */
 const isRecord = (u) => isNonNullObject(u) && !Array.isArray(u);
-/**
- * Type guard that checks if a value is a mutable record.
- *
- * This function has the same runtime behavior as {@link isRecord} (non-null,
- * non-array object check), but narrows the type to `MutableRecord<string,
- * unknown>`, which is useful when you need to add or overwrite properties on
- * the narrowed object.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows `unknown` to `MutableRecord<string, unknown>`
- * - Excludes `null`, `undefined`, primitives, functions, and arrays
- * - Returns `true` for every other non-null object (see {@link isRecord} for
- *   details on non-plain objects such as `Date`, `Map`, and `Set`)
- *
- * **Implementation:** This is a type alias for {@link isRecord}.
- *
- * @example
- *
- * ```ts
- * const obj: unknown = { foo: 1 } as const;
- *
- * if (isMutableRecord(obj)) {
- *   obj['bar'] = 2; // Safe: obj is now known to be a mutable record
- * }
- * ```
- *
- * @param u - The value to check
- * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.
- *   When `true`, TypeScript narrows the type to `MutableRecord<string,
- *   unknown>`.
- * @see {@link isRecord} - For the underlying implementation and more details
- */
 const isMutableRecord = isRecord;
 
 export { isMutableRecord, isRecord };

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

@@ -1 +1 @@
-{"version":3,"file":"is-record.mjs","sources":["../../src/guard/is-record.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;MACU,QAAQ,GAAG,CAAC,CAAU,KACjC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACI,MAAM,eAAe,GAEe;;;;"}
+{"version":3,"file":"is-record.mjs","sources":["../../src/guard/is-record.mts"],"sourcesContent":["import { type MutableRecord, type UnknownRecord } from 'ts-type-forge';\nimport { isNonNullObject } from './is-non-null-object.mjs';\n\n/**\n * Type guard that checks if a value is a record — a non-null, non-array\n * object — and narrows it to `UnknownRecord` (= `ReadonlyRecord<string,\n * unknown>`).\n *\n * This function is designed to be combined with {@link hasKey} to probe\n * values of type `unknown` (e.g. parsed JSON, caught errors, external data)\n * in a type-safe way: `if (isRecord(u) && hasKey(u, 'some-key')) { ... }`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `UnknownRecord` (= `ReadonlyRecord<string, unknown>`)\n * - Excludes `null`, `undefined`, primitives, and functions\n * - Excludes arrays: arrays have no string index signature, so they are not\n *   assignable to `UnknownRecord`; admitting them at runtime would be\n *   inconsistent with the narrowed type\n * - Returns `true` for every other non-null object, including dictionary\n *   objects created with `Object.create(null)` and instances such as `Date`,\n *   `RegExp`, `Map`, `Set`, `Error`, and user-defined classes\n *\n * **Why non-plain objects are included:** since every property of\n * `UnknownRecord` is typed `unknown`, reading properties from any object\n * through this narrowing is type-safe, and `hasKey` (backed by\n * `Object.hasOwn`) answers own-property questions correctly on any object\n * (e.g. `Map` entries are not own properties, so `hasKey` correctly returns\n * `false` for them). Restricting the guard to plain objects would require\n * prototype checks that misjudge cross-realm objects and would prevent\n * probing useful instances such as `Error` subclasses.\n *\n * **Implementation:** `isNonNullObject(u) && !Array.isArray(u)`.\n *\n * @example\n *\n * ```ts\n * const entries: readonly unknown[] = [\n *   { id: 1 },\n *   [1, 2],\n *   'str',\n *   0,\n *   null,\n * ] as const;\n *\n * const records = entries.filter(isRecord);\n *\n * assert.deepStrictEqual(records, [{ id: 1 }]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.\n *   When `true`, TypeScript narrows the type to `UnknownRecord`.\n * @see {@link isNonNullObject} - For checking any non-null object (includes arrays)\n * @see {@link hasKey} - For checking if a record has specific keys\n */\nexport const isRecord = (u: unknown): u is UnknownRecord =>\n  isNonNullObject(u) && !Array.isArray(u);\n\n/**\n * Type guard that checks if a value is a mutable record.\n *\n * This function has the same runtime behavior as {@link isRecord} (non-null,\n * non-array object check), but narrows the type to `MutableRecord<string,\n * unknown>`, which is useful when you need to add or overwrite properties on\n * the narrowed object.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `MutableRecord<string, unknown>`\n * - Excludes `null`, `undefined`, primitives, functions, and arrays\n * - Returns `true` for every other non-null object (see {@link isRecord} for\n *   details on non-plain objects such as `Date`, `Map`, and `Set`)\n *\n * **Implementation:** This is a type alias for {@link isRecord}.\n *\n * @example\n *\n * ```ts\n * const obj: unknown = { foo: 1 } as const;\n *\n * if (isMutableRecord(obj)) {\n *   obj['bar'] = 2; // Safe: obj is now known to be a mutable record\n * }\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a non-null, non-array object, `false` otherwise.\n *   When `true`, TypeScript narrows the type to `MutableRecord<string,\n *   unknown>`.\n * @see {@link isRecord} - For the underlying implementation and more details\n */\nexport const isMutableRecord: (\n  u: unknown,\n) => u is MutableRecord<string, unknown> = isRecord;\n"],"names":[],"mappings":";;AAwDO,MAAM,QAAA,GAAW,CAAC,CAAA,KACvB,eAAA,CAAgB,CAAC,CAAA,IAAK,CAAC,KAAA,CAAM,OAAA,CAAQ,CAAC;AAmCjC,MAAM,eAAA,GAE8B;;;;"}

package/dist/guard/is-type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-type.d.mts","sourceRoot":"","sources":["../../src/guard/is-type.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,WAAW,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,SAA4B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAG,GAAG,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,SAAS,CACzD,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,SAAS,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,OAAiC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAG,GAAG,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,OAAO,CAC9C,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,MAA+B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAG,GAAG,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,MAAM,CAC7C,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,MAA+B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAG,GAAG,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,MAAM,CAC7C,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,MAA+B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAG,GAAG,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,MAAM,CAC7C,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,MAA+B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAG,GAAG,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,MAAM,CAC7C,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,MAAM,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,IAAkB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAG,GAAG,CAAC,GAAG,IAAI,KAAG,CAAC,IAAI,CAAe,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,SAAS,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,IAAI,GAAG,SAAsB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAG,GAAG,CAAC,KAAG,CAAC,IAAI,WAAW,CAAC,CAAC,CAAc,CAAC"}
+{"version":3,"file":"is-type.d.mts","sourceRoot":"","sources":["../../src/guard/is-type.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,WAAW,MAAO,OAAO,KAAG,CAAC,IAAI,SAA4B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,KAAM,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,SAAS,CACzD,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,SAAS,MAAO,OAAO,KAAG,CAAC,IAAI,OAAiC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,KAAM,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,OAAO,CAC9C,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,QAAQ,MAAO,OAAO,KAAG,CAAC,IAAI,MAA+B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,KAAM,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,MAAM,CAC7C,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,QAAQ,MAAO,OAAO,KAAG,CAAC,IAAI,MAA+B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,KAAM,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,MAAM,CAC7C,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,QAAQ,MAAO,OAAO,KAAG,CAAC,IAAI,MAA+B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,KAAM,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,MAAM,CAC7C,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,QAAQ,MAAO,OAAO,KAAG,CAAC,IAAI,MAA+B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,KAAM,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,MAAM,CAC7C,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,MAAM,MAAO,OAAO,KAAG,CAAC,IAAI,IAAkB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,KAAM,CAAC,GAAG,IAAI,KAAG,CAAC,IAAI,CAAe,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,SAAS,MAAO,OAAO,KAAG,CAAC,IAAI,IAAI,GAAG,SAAsB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,KAAM,CAAC,KAAG,CAAC,IAAI,WAAW,CAAC,CAAC,CAAc,CAAC"}