ts-data-forge 1.0.0 → 1.0.1

package/dist/guard/is-record.mjs

@@ -0,0 +1,155 @@
+import { isNonNullObject } from './is-non-null-object.mjs';
+
+/**
+ * Type guard that checks if a value is a plain object (record) - a non-null object that is not an array.
+ *
+ * This function is useful for identifying "plain" JavaScript objects (also called records or
+ * dictionaries) - objects that are typically used as key-value collections. It excludes arrays,
+ * functions, and special object types like Date, RegExp, etc., focusing on objects that can be
+ * safely treated as property collections.
+ *
+ * **Type Narrowing Behavior:**
+ * - Narrows `unknown` to `UnknownRecord` (equivalent to `Record<PropertyKey, unknown>`)
+ * - Excludes `null`, `undefined`, primitives, arrays, and functions
+ * - Returns `true` for plain objects `{}`, object literals, and objects created with `Object.create()`
+ * - Returns `false` for arrays, even though they are technically objects
+ *
+ * **Implementation:** Uses `isNonNullObject()` to check for objects, then `Array.isArray()` to exclude arrays.
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a non-null object and not an array, `false` otherwise.
+ *          When `true`, TypeScript narrows the type to `UnknownRecord`.
+ *
+ * @example
+ * Basic usage with different value types:
+ * ```typescript
+ * isRecord({});                    // true (empty object)
+ * isRecord({ name: 'John' });      // true (object literal)
+ * isRecord(Object.create(null));   // true (object created with Object.create)
+ * isRecord(new Object());          // true (object constructor)
+ *
+ * isRecord([]);                    // false (array)
+ * isRecord([1, 2, 3]);            // false (array with elements)
+ * isRecord(null);                  // false (null)
+ * isRecord(undefined);             // false (undefined)
+ * isRecord("string");              // false (primitive)
+ * isRecord(42);                    // false (primitive)
+ * isRecord(() => {});              // false (function)
+ * isRecord(new Date());            // false (Date object - not a plain record)
+ * isRecord(/regex/);               // false (RegExp object)
+ * ```
+ *
+ * @example
+ * Type guard usage for safe property access:
+ * ```typescript
+ * const apiResponse: unknown = await fetchUserData();
+ *
+ * if (isRecord(apiResponse)) {
+ *   // apiResponse is now typed as UnknownRecord
+ *   console.log('Response keys:', Object.keys(apiResponse));
+ *
+ *   // Safe to access properties (though values are still unknown)
+ *   const userId = apiResponse.id;        // Type: unknown
+ *   const userName = apiResponse.name;    // Type: unknown
+ *
+ *   // You can combine with other type guards for further narrowing
+ *   if (hasKey(apiResponse, 'id') && isString(apiResponse.id)) {
+ *     console.log('User ID:', apiResponse.id); // Now safely typed as string
+ *   }
+ * } else {
+ *   console.log('API response is not a valid object');
+ * }
+ * ```
+ *
+ * @example
+ * Filtering mixed arrays to find plain objects:
+ * ```typescript
+ * const mixedData: unknown[] = [
+ *   { type: 'user', name: 'Alice' },
+ *   [1, 2, 3],
+ *   'string',
+ *   { type: 'admin', permissions: ['read', 'write'] },
+ *   new Date(),
+ *   null,
+ *   { id: 123 }
+ * ];
+ *
+ * const records = mixedData.filter(isRecord);
+ * // records contains only the plain objects:
+ * // [{ type: 'user', name: 'Alice' }, { type: 'admin', permissions: [...] }, { id: 123 }]
+ *
+ * records.forEach(record => {
+ *   // Each record is guaranteed to be UnknownRecord
+ *   const keys = Object.keys(record);
+ *   console.log('Object keys:', keys);
+ * });
+ * ```
+ *
+ * @example
+ * Progressive validation of nested structures:
+ * ```typescript
+ * interface User {
+ *   id: string;
+ *   profile: {
+ *     name: string;
+ *     email: string;
+ *   };
+ * }
+ *
+ * function validateUser(data: unknown): User | null {
+ *   if (!isRecord(data)) {
+ *     return null;
+ *   }
+ *
+ *   // data is now UnknownRecord
+ *   if (!hasKey(data, 'id') || !isString(data.id)) {
+ *     return null;
+ *   }
+ *
+ *   if (!hasKey(data, 'profile') || !isRecord(data.profile)) {
+ *     return null;
+ *   }
+ *
+ *   const profile = data.profile;
+ *   if (!hasKey(profile, 'name') || !isString(profile.name) ||
+ *       !hasKey(profile, 'email') || !isString(profile.email)) {
+ *     return null;
+ *   }
+ *
+ *   return {
+ *     id: data.id,
+ *     profile: {
+ *       name: profile.name,
+ *       email: profile.email
+ *     }
+ *   };
+ * }
+ * ```
+ *
+ * @example
+ * Object transformation and mapping:
+ * ```typescript
+ * function transformRecords(data: unknown[]): Record<string, unknown>[] {
+ *   return data
+ *     .filter(isRecord)  // Keep only plain objects
+ *     .map(record => {
+ *       // Transform each record
+ *       const transformed: Record<string, unknown> = {};
+ *
+ *       for (const [key, value] of Object.entries(record)) {
+ *         // Apply some transformation logic
+ *         transformed[key.toLowerCase()] = value;
+ *       }
+ *
+ *       return transformed;
+ *     });
+ * }
+ * ```
+ *
+ * @see {@link isNonNullObject} - For checking any object type (includes arrays)
+ * @see {@link hasKey} - For checking if a record has specific keys
+ */
+const isRecord = (u) => isNonNullObject(u) && !Array.isArray(u);
+
+export { isRecord };
+//# sourceMappingURL=is-record.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-record.mjs","sources":["../../src/guard/is-record.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoJG;MACU,QAAQ,GAAG,CAAC,CAAU,KACjC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;;;;"}

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

@@ -0,0 +1,430 @@
+/**
+ * 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
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is `undefined`, `false` otherwise.
+ *          When `true`, TypeScript narrows the type to `undefined`.
+ *
+ * @example
+ * ```typescript
+ * const value: string | undefined = getValue();
+ *
+ * if (isUndefined(value)) {
+ *   // value is now typed as undefined
+ *   console.log('Value is undefined');
+ * } else {
+ *   // value is now typed as string
+ *   console.log('Value length:', value.length);
+ * }
+ * ```
+ */
+export declare const isUndefined: (u: unknown) => u is 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
+ *
+ * @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.
+ *
+ * @example
+ * ```typescript
+ * const items: (string | undefined)[] = ['a', undefined, 'b', undefined, 'c'];
+ *
+ * const definedItems = items.filter(isNotUndefined);
+ * // definedItems is now string[] - undefined values are filtered out
+ *
+ * definedItems.forEach(item => {
+ *   // item is guaranteed to be string, not undefined
+ *   console.log(item.toUpperCase());
+ * });
+ * ```
+ */
+export declare const isNotUndefined: <T>(u: T) => u is RelaxedExclude<T, 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`)
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a boolean, `false` otherwise.
+ *          When `true`, TypeScript narrows the type to `boolean`.
+ *
+ * @example
+ * ```typescript
+ * const userInput: unknown = parseInput();
+ *
+ * if (isBoolean(userInput)) {
+ *   // userInput is now typed as boolean
+ *   console.log('Boolean value:', userInput ? 'true' : 'false');
+ * }
+ * ```
+ */
+export declare const isBoolean: (u: unknown) => u is 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
+ *
+ * @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.
+ *
+ * @example
+ * ```typescript
+ * type MixedValue = string | number | boolean;
+ * const value: MixedValue = getValue();
+ *
+ * if (isNotBoolean(value)) {
+ *   // value is now string | number
+ *   console.log('Non-boolean value:', value);
+ * }
+ * ```
+ */
+export declare const isNotBoolean: <T>(u: T) => u is RelaxedExclude<T, 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
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a number, `false` otherwise.
+ *          When `true`, TypeScript narrows the type to `number`.
+ *
+ * @example
+ * ```typescript
+ * const userInput: unknown = parseInput();
+ *
+ * if (isNumber(userInput)) {
+ *   // userInput is now typed as number
+ *   console.log('Number value:', userInput.toFixed(2));
+ *
+ *   // Note: this includes NaN and Infinity
+ *   if (Number.isFinite(userInput)) {
+ *     console.log('Finite number:', userInput);
+ *   }
+ * }
+ * ```
+ */
+export declare const isNumber: (u: unknown) => u is 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
+ *
+ * @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.
+ *
+ * @example
+ * ```typescript
+ * type Value = string | number | boolean;
+ * const values: Value[] = ['hello', 42, true, 3.14, false];
+ *
+ * const nonNumbers = values.filter(isNotNumber);
+ * // nonNumbers is now (string | boolean)[] - numbers are filtered out
+ * ```
+ */
+export declare const isNotNumber: <T>(u: T) => u is RelaxedExclude<T, 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
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a bigint, `false` otherwise.
+ *          When `true`, TypeScript narrows the type to `bigint`.
+ *
+ * @example
+ * ```typescript
+ * const userInput: unknown = parseInput();
+ *
+ * if (isBigint(userInput)) {
+ *   // userInput is now typed as bigint
+ *   console.log('BigInt value:', userInput.toString());
+ *   const doubled = userInput * 2n; // Safe bigint operations
+ * }
+ * ```
+ */
+export declare const isBigint: (u: unknown) => u is 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
+ *
+ * @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.
+ *
+ * @example
+ * ```typescript
+ * type NumericValue = number | bigint;
+ * const value: NumericValue = getValue();
+ *
+ * if (isNotBigint(value)) {
+ *   // value is now number
+ *   console.log('Regular number:', value.toFixed(2));
+ * }
+ * ```
+ */
+export declare const isNotBigint: <T>(u: T) => u is RelaxedExclude<T, 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
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a string, `false` otherwise.
+ *          When `true`, TypeScript narrows the type to `string`.
+ *
+ * @example
+ * ```typescript
+ * const userInput: unknown = parseInput();
+ *
+ * if (isString(userInput)) {
+ *   // userInput is now typed as string
+ *   console.log('String length:', userInput.length);
+ *   console.log('Uppercase:', userInput.toUpperCase());
+ *
+ *   // You can further check for non-empty strings
+ *   if (userInput.length > 0) {
+ *     console.log('Non-empty string:', userInput);
+ *   }
+ * }
+ * ```
+ */
+export declare const isString: (u: unknown) => u is 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
+ *
+ * @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.
+ *
+ * @example
+ * ```typescript
+ * type Value = string | number | boolean;
+ * const mixedValues: Value[] = ['hello', 42, true, 'world', 3.14];
+ *
+ * const nonStrings = mixedValues.filter(isNotString);
+ * // nonStrings is now (number | boolean)[] - strings are filtered out
+ * ```
+ */
+export declare const isNotString: <T>(u: T) => u is RelaxedExclude<T, 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
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a symbol, `false` otherwise.
+ *          When `true`, TypeScript narrows the type to `symbol`.
+ *
+ * @example
+ * ```typescript
+ * const userInput: unknown = parseInput();
+ *
+ * if (isSymbol(userInput)) {
+ *   // userInput is now typed as symbol
+ *   console.log('Symbol description:', userInput.description);
+ *   console.log('Symbol string:', userInput.toString());
+ * }
+ * ```
+ */
+export declare const isSymbol: (u: unknown) => u is 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
+ *
+ * @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.
+ *
+ * @example
+ * ```typescript
+ * type PropertyKey = string | number | symbol;
+ * const key: PropertyKey = getPropertyKey();
+ *
+ * if (isNotSymbol(key)) {
+ *   // key is now string | number
+ *   console.log('Non-symbol key:', key);
+ * }
+ * ```
+ */
+export declare const isNotSymbol: <T>(u: T) => u is RelaxedExclude<T, 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
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is `null`, `false` otherwise.
+ *          When `true`, TypeScript narrows the type to `null`.
+ *
+ * @example
+ * ```typescript
+ * const value: string | null = getValue();
+ *
+ * if (isNull(value)) {
+ *   // value is now typed as null
+ *   console.log('Value is null');
+ * } else {
+ *   // value is now typed as string
+ *   console.log('Value length:', value.length);
+ * }
+ * ```
+ */
+export declare const isNull: (u: unknown) => u is 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
+ *
+ * @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.
+ *
+ * @example
+ * ```typescript
+ * const items: (string | null)[] = ['a', null, 'b', null, 'c'];
+ *
+ * const nonNullItems = items.filter(isNotNull);
+ * // nonNullItems is now string[] - null values are filtered out
+ *
+ * nonNullItems.forEach(item => {
+ *   // item is guaranteed to be string, not null
+ *   console.log(item.toUpperCase());
+ * });
+ * ```
+ */
+export declare const isNotNull: <T>(u: T | null) => u is T;
+/**
+ * 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)
+ *
+ * @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`.
+ *
+ * @example
+ * ```typescript
+ * const value: string | null | undefined = getValue();
+ *
+ * if (isNullish(value)) {
+ *   // value is now typed as null | undefined
+ *   console.log('Value is nullish');
+ * } else {
+ *   // value is now typed as string
+ *   console.log('Value length:', value.length);
+ * }
+ * ```
+ */
+export declare const isNullish: (u: unknown) => u is null | undefined;
+/**
+ * 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
+ *
+ * @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>`.
+ *
+ * @example
+ * ```typescript
+ * const items: (string | null | undefined)[] = [
+ *   'hello',
+ *   null,
+ *   'world',
+ *   undefined,
+ *   'test'
+ * ];
+ *
+ * const definedItems = items.filter(isNonNullish);
+ * // definedItems is now string[] - both null and undefined values are filtered out
+ *
+ * definedItems.forEach(item => {
+ *   // item is guaranteed to be string, never null or undefined
+ *   console.log(item.toUpperCase());
+ * });
+ * ```
+ *
+ * @example
+ * Progressive validation with optional chaining alternative:
+ * ```typescript
+ * interface User {
+ *   profile?: {
+ *     name?: string;
+ *     email?: string;
+ *   };
+ * }
+ *
+ * const user: User = getUser();
+ *
+ * // Instead of optional chaining: user.profile?.name
+ * if (isNonNullish(user.profile) && isNonNullish(user.profile.name)) {
+ *   // user.profile.name is now guaranteed to be string
+ *   console.log('User name:', user.profile.name.toUpperCase());
+ * }
+ * ```
+ */
+export declare const isNonNullish: <T>(u: T) => u is NonNullable<T>;
+//# sourceMappingURL=is-type.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-type.d.mts","sourceRoot":"","sources":["../../src/guard/is-type.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,WAAW,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,SAA4B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAG,GAAG,CAAC,KAAG,CAAC,IAAI,cAAc,CAAC,CAAC,EAAE,SAAS,CACzD,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;GAoBG;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;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,MAA+B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;GAoBG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,MAA+B,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;GAoBG;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;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,MAAM,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,IAAkB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAG,GAAG,CAAC,GAAG,IAAI,KAAG,CAAC,IAAI,CAAe,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,SAAS,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,IAAI,GAAG,SAAsB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAG,GAAG,CAAC,KAAG,CAAC,IAAI,WAAW,CAAC,CAAC,CAAc,CAAC"}