ts-data-forge 3.2.0 → 3.3.1

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

@@ -1,104 +1,34 @@
 /**
  * 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.
+ * 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 to check for plain objects
- * specifically (excluding arrays), use `isRecord()` instead.
- *
- * @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`.
- *
- * @example
- * Basic usage with different value types:
- * ```typescript
- * isNonNullObject({});           // true (plain object)
- * isNonNullObject([]);           // true (arrays are objects)
- * isNonNullObject(new Date());   // true (Date instance)
- * isNonNullObject(/regex/);      // true (RegExp instance)
- * isNonNullObject(new Map());    // true (Map instance)
- * isNonNullObject(null);         // false (null is not considered object here)
- * isNonNullObject(undefined);    // false (primitive)
- * isNonNullObject("string");     // false (primitive)
- * isNonNullObject(42);           // false (primitive)
- * isNonNullObject(true);         // false (primitive)
- * isNonNullObject(() => {});     // false (functions are not objects in this context)
- * ```
- *
- * @example
- * Type guard usage with unknown values:
- * ```typescript
- * const value: unknown = parseJsonData();
- *
- * if (isNonNullObject(value)) {
- *   // value is now typed as object
- *   console.log('Value is an object');
- *
- *   // You can now safely use object-specific operations
- *   console.log(Object.keys(value));      // Safe to call Object.keys
- *   console.log(value.toString());        // Safe to call methods
- *
- *   // But you may need additional checks for specific object types
- *   if (Array.isArray(value)) {
- *     console.log('It\'s an array with length:', value.length);
- *   }
- * } else {
- *   console.log('Value is not an object');
- * }
- * ```
+ * **Note:** This function returns `true` for arrays. If you need to check for
+ * plain objects specifically (excluding arrays), use `isRecord()` instead.
  *
  * @example
- * Filtering arrays to find objects:
- * ```typescript
- * const mixedArray: unknown[] = [
- *   { name: 'John' },
- *   'string',
- *   [1, 2, 3],
- *   42,
- *   null,
- *   new Date(),
- *   () => 'function'
- * ];
  *
- * const objects = mixedArray.filter(isNonNullObject);
- * // objects contains: [{ name: 'John' }, [1, 2, 3], Date instance]
- * // Note: includes both plain objects and arrays
+ * ```ts
+ * const mixed: unknown[] = [{ id: 1 }, null, 'Ada'] as const;
  *
- * objects.forEach(obj => {
- *   // Each obj is guaranteed to be an object
- *   console.log('Object type:', obj.constructor.name);
- * });
- * ```
+ * const objects = mixed.filter(isNonNullObject);
  *
- * @example
- * Progressive type narrowing with other guards:
- * ```typescript
- * const apiResponse: unknown = await fetchData();
- *
- * if (isNonNullObject(apiResponse)) {
- *   // apiResponse is now object
- *
- *   if (isRecord(apiResponse)) {
- *     // Further narrowed to UnknownRecord (plain object, not array)
- *
- *     if (hasKey(apiResponse, 'status')) {
- *       console.log('API status:', apiResponse.status);
- *     }
- *   } else if (Array.isArray(apiResponse)) {
- *     console.log('Response is an array with length:', apiResponse.length);
- *   }
- * }
+ * 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 checking plain objects specifically (excludes arrays)
  */
 export declare const isNonNullObject: (u: unknown) => u is object;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsGG;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,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,MACb,CAAC"}

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

@@ -1,104 +1,34 @@
 /**
  * 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.
+ * 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 to check for plain objects
- * specifically (excluding arrays), use `isRecord()` instead.
- *
- * @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`.
- *
- * @example
- * Basic usage with different value types:
- * ```typescript
- * isNonNullObject({});           // true (plain object)
- * isNonNullObject([]);           // true (arrays are objects)
- * isNonNullObject(new Date());   // true (Date instance)
- * isNonNullObject(/regex/);      // true (RegExp instance)
- * isNonNullObject(new Map());    // true (Map instance)
- * isNonNullObject(null);         // false (null is not considered object here)
- * isNonNullObject(undefined);    // false (primitive)
- * isNonNullObject("string");     // false (primitive)
- * isNonNullObject(42);           // false (primitive)
- * isNonNullObject(true);         // false (primitive)
- * isNonNullObject(() => {});     // false (functions are not objects in this context)
- * ```
- *
- * @example
- * Type guard usage with unknown values:
- * ```typescript
- * const value: unknown = parseJsonData();
- *
- * if (isNonNullObject(value)) {
- *   // value is now typed as object
- *   console.log('Value is an object');
- *
- *   // You can now safely use object-specific operations
- *   console.log(Object.keys(value));      // Safe to call Object.keys
- *   console.log(value.toString());        // Safe to call methods
- *
- *   // But you may need additional checks for specific object types
- *   if (Array.isArray(value)) {
- *     console.log('It\'s an array with length:', value.length);
- *   }
- * } else {
- *   console.log('Value is not an object');
- * }
- * ```
+ * **Note:** This function returns `true` for arrays. If you need to check for
+ * plain objects specifically (excluding arrays), use `isRecord()` instead.
  *
  * @example
- * Filtering arrays to find objects:
- * ```typescript
- * const mixedArray: unknown[] = [
- *   { name: 'John' },
- *   'string',
- *   [1, 2, 3],
- *   42,
- *   null,
- *   new Date(),
- *   () => 'function'
- * ];
  *
- * const objects = mixedArray.filter(isNonNullObject);
- * // objects contains: [{ name: 'John' }, [1, 2, 3], Date instance]
- * // Note: includes both plain objects and arrays
+ * ```ts
+ * const mixed: unknown[] = [{ id: 1 }, null, 'Ada'] as const;
  *
- * objects.forEach(obj => {
- *   // Each obj is guaranteed to be an object
- *   console.log('Object type:', obj.constructor.name);
- * });
- * ```
+ * const objects = mixed.filter(isNonNullObject);
  *
- * @example
- * Progressive type narrowing with other guards:
- * ```typescript
- * const apiResponse: unknown = await fetchData();
- *
- * if (isNonNullObject(apiResponse)) {
- *   // apiResponse is now object
- *
- *   if (isRecord(apiResponse)) {
- *     // Further narrowed to UnknownRecord (plain object, not array)
- *
- *     if (hasKey(apiResponse, 'status')) {
- *       console.log('API status:', apiResponse.status);
- *     }
- *   } else if (Array.isArray(apiResponse)) {
- *     console.log('Response is an array with length:', apiResponse.length);
- *   }
- * }
+ * 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 checking plain objects specifically (excludes arrays)
  */
 // eslint-disable-next-line @typescript-eslint/no-restricted-types

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsGG;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":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACH;AACO,MAAM,eAAe,GAAG,CAAC,CAAU,KACxC,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK;;;;"}

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

@@ -1,146 +1,33 @@
 /**
  * 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`.
+ * 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.
+ * **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
  *
- * @param u - The value to check
- * @returns `true` if `u` is a primitive type, `false` otherwise.
- *          When `true`, TypeScript narrows the type to `Primitive`.
- *
  * @example
- * Basic usage with different value types:
- * ```typescript
- * isPrimitive("hello");        // true (string)
- * isPrimitive(42);             // true (number)
- * isPrimitive(true);           // true (boolean)
- * isPrimitive(undefined);      // true (undefined)
- * isPrimitive(Symbol('test')); // true (symbol)
- * isPrimitive(123n);           // true (bigint)
- * isPrimitive(null);           // true (null is primitive despite typeof quirk)
- *
- * isPrimitive({});             // false (object)
- * isPrimitive([]);             // false (array)
- * isPrimitive(() => {});       // false (function)
- * isPrimitive(new Date());     // false (object instance)
- * isPrimitive(/regex/);        // false (RegExp object)
- * ```
  *
- * @example
- * Type guard usage for separating primitives from objects:
- * ```typescript
- * const values: unknown[] = [
- *   'string',
- *   42,
- *   true,
- *   null,
- *   undefined,
- *   {},
- *   [],
- *   new Date()
- * ];
+ * ```ts
+ * const values: readonly unknown[] = [42, 'Ada', null, { id: 1 }] as const;
  *
  * const primitives = values.filter(isPrimitive);
- * const objects = values.filter(value => !isPrimitive(value));
- *
- * primitives.forEach(primitive => {
- *   // primitive is now typed as Primitive
- *   console.log('Primitive value:', primitive);
- *   console.log('Type:', typeof primitive);
- * });
- * ```
- *
- * @example
- * Deep cloning detection - primitives don't need cloning:
- * ```typescript
- * function deepClone<T>(value: T): T {
- *   if (isPrimitive(value)) {
- *     // Primitives are immutable, return as-is
- *     return value;
- *   }
  *
- *   // Handle object cloning for non-primitives
- *   if (Array.isArray(value)) {
- *     return value.map(deepClone) as T;
- *   }
- *
- *   if (isRecord(value)) {
- *     const cloned = {} as T;
- *     for (const key in value) {
- *       if (Object.hasOwn(value, key)) {
- *         cloned[key] = deepClone(value[key]);
- *       }
- *     }
- *     return cloned;
- *   }
- *
- *   // For other object types, return as-is or implement specific cloning
- *   return value;
- * }
- * ```
- *
- * @example
- * Serialization helpers:
- * ```typescript
- * function canSerializeDirectly(value: unknown): boolean {
- *   if (isPrimitive(value)) {
- *     // Most primitives can be serialized directly
- *     return typeof value !== 'symbol' && typeof value !== 'bigint';
- *   }
- *   return false;
- * }
- *
- * function safeStringify(value: unknown): string {
- *   if (isPrimitive(value)) {
- *     if (value === null) return 'null';
- *     if (value === undefined) return 'undefined';
- *     if (typeof value === 'symbol') return value.toString();
- *     if (typeof value === 'bigint') return value.toString() + 'n';
- *     return String(value);
- *   }
- *
- *   return JSON.stringify(value);
- * }
+ * assert.deepStrictEqual(primitives, [42, 'Ada', null]);
  * ```
  *
- * @example
- * Type narrowing in conditional logic:
- * ```typescript
- * function processValue(value: unknown): string {
- *   if (isPrimitive(value)) {
- *     // value is now Primitive type
- *     switch (typeof value) {
- *       case 'string':
- *         return `String: ${value}`;
- *       case 'number':
- *         return `Number: ${value}`;
- *       case 'boolean':
- *         return `Boolean: ${value}`;
- *       case 'undefined':
- *         return 'Undefined';
- *       case 'symbol':
- *         return `Symbol: ${value.description || 'unnamed'}`;
- *       case 'bigint':
- *         return `BigInt: ${value}n`;
- *       case 'object': // This is null
- *         return 'Null';
- *       default:
- *         return 'Unknown primitive';
- *     }
- *   } else {
- *     return `Object: ${value?.constructor?.name || 'Unknown'}`;
- *   }
- * }
- * ```
+ * @param u - The value to check
+ * @returns `true` if `u` is a primitive type, `false` otherwise. When `true`,
+ *   TypeScript narrows the type to `Primitive`.
  */
 export declare const isPrimitive: (u: unknown) => u is Primitive;
 //# sourceMappingURL=is-primitive.d.mts.map

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":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+IG;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":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,WAAW,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,SAa7C,CAAC"}

package/dist/guard/is-primitive.mjs

@@ -1,146 +1,33 @@
 /**
  * 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`.
+ * 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.
+ * **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
  *
- * @param u - The value to check
- * @returns `true` if `u` is a primitive type, `false` otherwise.
- *          When `true`, TypeScript narrows the type to `Primitive`.
- *
  * @example
- * Basic usage with different value types:
- * ```typescript
- * isPrimitive("hello");        // true (string)
- * isPrimitive(42);             // true (number)
- * isPrimitive(true);           // true (boolean)
- * isPrimitive(undefined);      // true (undefined)
- * isPrimitive(Symbol('test')); // true (symbol)
- * isPrimitive(123n);           // true (bigint)
- * isPrimitive(null);           // true (null is primitive despite typeof quirk)
- *
- * isPrimitive({});             // false (object)
- * isPrimitive([]);             // false (array)
- * isPrimitive(() => {});       // false (function)
- * isPrimitive(new Date());     // false (object instance)
- * isPrimitive(/regex/);        // false (RegExp object)
- * ```
  *
- * @example
- * Type guard usage for separating primitives from objects:
- * ```typescript
- * const values: unknown[] = [
- *   'string',
- *   42,
- *   true,
- *   null,
- *   undefined,
- *   {},
- *   [],
- *   new Date()
- * ];
+ * ```ts
+ * const values: readonly unknown[] = [42, 'Ada', null, { id: 1 }] as const;
  *
  * const primitives = values.filter(isPrimitive);
- * const objects = values.filter(value => !isPrimitive(value));
- *
- * primitives.forEach(primitive => {
- *   // primitive is now typed as Primitive
- *   console.log('Primitive value:', primitive);
- *   console.log('Type:', typeof primitive);
- * });
- * ```
- *
- * @example
- * Deep cloning detection - primitives don't need cloning:
- * ```typescript
- * function deepClone<T>(value: T): T {
- *   if (isPrimitive(value)) {
- *     // Primitives are immutable, return as-is
- *     return value;
- *   }
  *
- *   // Handle object cloning for non-primitives
- *   if (Array.isArray(value)) {
- *     return value.map(deepClone) as T;
- *   }
- *
- *   if (isRecord(value)) {
- *     const cloned = {} as T;
- *     for (const key in value) {
- *       if (Object.hasOwn(value, key)) {
- *         cloned[key] = deepClone(value[key]);
- *       }
- *     }
- *     return cloned;
- *   }
- *
- *   // For other object types, return as-is or implement specific cloning
- *   return value;
- * }
- * ```
- *
- * @example
- * Serialization helpers:
- * ```typescript
- * function canSerializeDirectly(value: unknown): boolean {
- *   if (isPrimitive(value)) {
- *     // Most primitives can be serialized directly
- *     return typeof value !== 'symbol' && typeof value !== 'bigint';
- *   }
- *   return false;
- * }
- *
- * function safeStringify(value: unknown): string {
- *   if (isPrimitive(value)) {
- *     if (value === null) return 'null';
- *     if (value === undefined) return 'undefined';
- *     if (typeof value === 'symbol') return value.toString();
- *     if (typeof value === 'bigint') return value.toString() + 'n';
- *     return String(value);
- *   }
- *
- *   return JSON.stringify(value);
- * }
+ * assert.deepStrictEqual(primitives, [42, 'Ada', null]);
  * ```
  *
- * @example
- * Type narrowing in conditional logic:
- * ```typescript
- * function processValue(value: unknown): string {
- *   if (isPrimitive(value)) {
- *     // value is now Primitive type
- *     switch (typeof value) {
- *       case 'string':
- *         return `String: ${value}`;
- *       case 'number':
- *         return `Number: ${value}`;
- *       case 'boolean':
- *         return `Boolean: ${value}`;
- *       case 'undefined':
- *         return 'Undefined';
- *       case 'symbol':
- *         return `Symbol: ${value.description || 'unnamed'}`;
- *       case 'bigint':
- *         return `BigInt: ${value}n`;
- *       case 'object': // This is null
- *         return 'Null';
- *       default:
- *         return 'Unknown primitive';
- *     }
- *   } else {
- *     return `Object: ${value?.constructor?.name || 'Unknown'}`;
- *   }
- * }
- * ```
+ * @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) {

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":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+IG;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":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;"}