ts-data-forge 1.0.0 → 1.0.1

package/dist/others/if-then.d.mts

@@ -0,0 +1,98 @@
+/**
+ * Implements the logical implication (if-then) operator.
+ *
+ * Returns `true` if the antecedent is `false` or the consequent is `true`.
+ * In logical terms: `antecedent → consequent` is equivalent to `¬antecedent ∨ consequent`.
+ *
+ * **Truth table:**
+ * - `true → true` = `true` (valid implication)
+ * - `true → false` = `false` (invalid implication)
+ * - `false → true` = `true` (vacuously true)
+ * - `false → false` = `true` (vacuously true)
+ *
+ * @param antecedent - The condition (if part)
+ * @param consequent - The result that should hold if the condition is true (then part)
+ * @returns `true` if the implication holds, `false` otherwise
+ *
+ * @example Basic truth table demonstration
+ * ```typescript
+ * ifThen(true, true);   // true  (if true then true = true)
+ * ifThen(true, false);  // false (if true then false = false)
+ * ifThen(false, true);  // true  (if false then true = true - vacuously true)
+ * ifThen(false, false); // true  (if false then false = true - vacuously true)
+ * ```
+ *
+ * @example Validation logic - "if required then must have value"
+ * ```typescript
+ * function validateField(value: string, isRequired: boolean): boolean {
+ *   const hasValue = value.trim().length > 0;
+ *   return ifThen(isRequired, hasValue);
+ * }
+ *
+ * validateField('hello', true);  // true (required and has value)
+ * validateField('', true);       // false (required but no value)
+ * validateField('', false);      // true (not required, so valid)
+ * validateField('hello', false); // true (not required, but has value is fine)
+ * ```
+ *
+ * @example Access control - "if admin then has all permissions"
+ * ```typescript
+ * function checkPermission(user: User, permission: string): boolean {
+ *   const isAdmin = user.role === 'admin';
+ *   const hasPermission = user.permissions.includes(permission);
+ *
+ *   // Admin must have all permissions
+ *   return ifThen(isAdmin, hasPermission);
+ * }
+ *
+ * const adminUser = { role: 'admin', permissions: ['read', 'write'] };
+ * checkPermission(adminUser, 'delete'); // false (admin without delete permission = invalid)
+ *
+ * const regularUser = { role: 'user', permissions: ['read'] };
+ * checkPermission(regularUser, 'delete'); // true (non-admin without permission is valid)
+ * ```
+ *
+ * @example Contract validation - "if premium then features enabled"
+ * ```typescript
+ * interface Subscription {
+ *   isPremium: boolean;
+ *   features: {
+ *     advancedAnalytics: boolean;
+ *     unlimitedStorage: boolean;
+ *     prioritySupport: boolean;
+ *   };
+ * }
+ *
+ * function validateSubscription(sub: Subscription): boolean {
+ *   // If premium, then all premium features must be enabled
+ *   return ifThen(sub.isPremium,
+ *     sub.features.advancedAnalytics &&
+ *     sub.features.unlimitedStorage &&
+ *     sub.features.prioritySupport
+ *   );
+ * }
+ * ```
+ *
+ * @example Chaining multiple implications
+ * ```typescript
+ * // "If A then B" AND "If B then C"
+ * function validateChain(a: boolean, b: boolean, c: boolean): boolean {
+ *   return ifThen(a, b) && ifThen(b, c);
+ * }
+ *
+ * validateChain(true, true, true);   // true (valid chain)
+ * validateChain(true, false, true);  // false (breaks at first implication)
+ * validateChain(false, false, false); // true (vacuously true chain)
+ * ```
+ *
+ * @example Negation patterns
+ * ```typescript
+ * // "If not expired then valid" is equivalent to "expired OR valid"
+ * const isExpired = Date.now() > expiryDate;
+ * const isValid = checkValidity();
+ * const result = ifThen(!isExpired, isValid);
+ * // Same as: isExpired || isValid
+ * ```
+ */
+export declare const ifThen: (antecedent: boolean, consequent: boolean) => boolean;
+//# sourceMappingURL=if-then.d.mts.map

package/dist/others/if-then.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"if-then.d.mts","sourceRoot":"","sources":["../../src/others/if-then.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,eAAO,MAAM,MAAM,GAAI,YAAY,OAAO,EAAE,YAAY,OAAO,KAAG,OACvC,CAAC"}

package/dist/others/if-then.mjs

@@ -0,0 +1,100 @@
+/**
+ * Implements the logical implication (if-then) operator.
+ *
+ * Returns `true` if the antecedent is `false` or the consequent is `true`.
+ * In logical terms: `antecedent → consequent` is equivalent to `¬antecedent ∨ consequent`.
+ *
+ * **Truth table:**
+ * - `true → true` = `true` (valid implication)
+ * - `true → false` = `false` (invalid implication)
+ * - `false → true` = `true` (vacuously true)
+ * - `false → false` = `true` (vacuously true)
+ *
+ * @param antecedent - The condition (if part)
+ * @param consequent - The result that should hold if the condition is true (then part)
+ * @returns `true` if the implication holds, `false` otherwise
+ *
+ * @example Basic truth table demonstration
+ * ```typescript
+ * ifThen(true, true);   // true  (if true then true = true)
+ * ifThen(true, false);  // false (if true then false = false)
+ * ifThen(false, true);  // true  (if false then true = true - vacuously true)
+ * ifThen(false, false); // true  (if false then false = true - vacuously true)
+ * ```
+ *
+ * @example Validation logic - "if required then must have value"
+ * ```typescript
+ * function validateField(value: string, isRequired: boolean): boolean {
+ *   const hasValue = value.trim().length > 0;
+ *   return ifThen(isRequired, hasValue);
+ * }
+ *
+ * validateField('hello', true);  // true (required and has value)
+ * validateField('', true);       // false (required but no value)
+ * validateField('', false);      // true (not required, so valid)
+ * validateField('hello', false); // true (not required, but has value is fine)
+ * ```
+ *
+ * @example Access control - "if admin then has all permissions"
+ * ```typescript
+ * function checkPermission(user: User, permission: string): boolean {
+ *   const isAdmin = user.role === 'admin';
+ *   const hasPermission = user.permissions.includes(permission);
+ *
+ *   // Admin must have all permissions
+ *   return ifThen(isAdmin, hasPermission);
+ * }
+ *
+ * const adminUser = { role: 'admin', permissions: ['read', 'write'] };
+ * checkPermission(adminUser, 'delete'); // false (admin without delete permission = invalid)
+ *
+ * const regularUser = { role: 'user', permissions: ['read'] };
+ * checkPermission(regularUser, 'delete'); // true (non-admin without permission is valid)
+ * ```
+ *
+ * @example Contract validation - "if premium then features enabled"
+ * ```typescript
+ * interface Subscription {
+ *   isPremium: boolean;
+ *   features: {
+ *     advancedAnalytics: boolean;
+ *     unlimitedStorage: boolean;
+ *     prioritySupport: boolean;
+ *   };
+ * }
+ *
+ * function validateSubscription(sub: Subscription): boolean {
+ *   // If premium, then all premium features must be enabled
+ *   return ifThen(sub.isPremium,
+ *     sub.features.advancedAnalytics &&
+ *     sub.features.unlimitedStorage &&
+ *     sub.features.prioritySupport
+ *   );
+ * }
+ * ```
+ *
+ * @example Chaining multiple implications
+ * ```typescript
+ * // "If A then B" AND "If B then C"
+ * function validateChain(a: boolean, b: boolean, c: boolean): boolean {
+ *   return ifThen(a, b) && ifThen(b, c);
+ * }
+ *
+ * validateChain(true, true, true);   // true (valid chain)
+ * validateChain(true, false, true);  // false (breaks at first implication)
+ * validateChain(false, false, false); // true (vacuously true chain)
+ * ```
+ *
+ * @example Negation patterns
+ * ```typescript
+ * // "If not expired then valid" is equivalent to "expired OR valid"
+ * const isExpired = Date.now() > expiryDate;
+ * const isValid = checkValidity();
+ * const result = ifThen(!isExpired, isValid);
+ * // Same as: isExpired || isValid
+ * ```
+ */
+const ifThen = (antecedent, consequent) => !antecedent || consequent;
+
+export { ifThen };
+//# sourceMappingURL=if-then.mjs.map

package/dist/others/if-then.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"if-then.mjs","sources":["../../src/others/if-then.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FG;AACI,MAAM,MAAM,GAAG,CAAC,UAAmB,EAAE,UAAmB,KAC7D,CAAC,UAAU,IAAI;;;;"}

package/dist/others/index.d.mts

@@ -0,0 +1,8 @@
+export * from './cast-mutable.mjs';
+export * from './cast-readonly.mjs';
+export * from './if-then.mjs';
+export * from './map-nullable.mjs';
+export * from './memoize-function.mjs';
+export * from './tuple.mjs';
+export * from './unknown-to-string.mjs';
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/others/index.mts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC"}

package/dist/others/index.mjs

@@ -0,0 +1,8 @@
+export { castDeepMutable, castMutable } from './cast-mutable.mjs';
+export { castDeepReadonly, castReadonly } from './cast-readonly.mjs';
+export { ifThen } from './if-then.mjs';
+export { mapNullable } from './map-nullable.mjs';
+export { memoizeFunction } from './memoize-function.mjs';
+export { tp } from './tuple.mjs';
+export { unknownToString } from './unknown-to-string.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/others/index.mjs.map

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

package/dist/others/map-nullable.d.mts

@@ -0,0 +1,151 @@
+/**
+ * Applies a function to a value if the value is not `null` or `undefined`.
+ * If the value is `null` or `undefined`, it returns `undefined`.
+ *
+ * This function provides a safe way to transform nullable values without explicit null checks.
+ * It's similar to Optional.map() but works directly with TypeScript's nullable types.
+ * Supports both regular and curried usage for functional composition.
+ *
+ * @template A - The type of the input value (excluding null/undefined)
+ * @template B - The type of the value returned by the mapping function
+ * @param value - The value to potentially transform (can be `A`, `null`, or `undefined`)
+ * @param mapFn - A function that transforms a non-nullable value of type `A` to type `B`
+ * @returns The result of applying `mapFn` to `value` if value is not null/undefined; otherwise `undefined`
+ *
+ * @example Basic usage with nullable values
+ * ```typescript
+ * // Safe string transformation
+ * mapNullable("hello", s => s.toUpperCase()); // "HELLO"
+ * mapNullable(null, s => s.toUpperCase()); // undefined
+ * mapNullable(undefined, s => s.toUpperCase()); // undefined
+ *
+ * // Number operations
+ * mapNullable(5, n => n * 2); // 10
+ * mapNullable(0, n => n * 2); // 0 (note: 0 is not null/undefined)
+ * mapNullable(null as number | null, n => n * 2); // undefined
+ * ```
+ *
+ * @example Working with optional object properties
+ * ```typescript
+ * interface User {
+ *   id: number;
+ *   name?: string;
+ *   email?: string;
+ * }
+ *
+ * function formatUserDisplay(user: User): string {
+ *   const displayName = mapNullable(user.name, name => name.toUpperCase()) ?? 'Anonymous';
+ *   const emailDomain = mapNullable(user.email, email => email.split('@')[1]);
+ *
+ *   return `${displayName} ${emailDomain ? `(${emailDomain})` : ''}`;
+ * }
+ *
+ * formatUserDisplay({ id: 1, name: 'John', email: 'john@example.com' }); // "JOHN (example.com)"
+ * formatUserDisplay({ id: 2 }); // "Anonymous "
+ * ```
+ *
+ * @example Curried usage for functional composition
+ * ```typescript
+ * // Create reusable transformers
+ * const toUpperCase = mapNullable((s: string) => s.toUpperCase());
+ * const addPrefix = mapNullable((s: string) => `PREFIX_${s}`);
+ * const parseNumber = mapNullable((s: string) => parseInt(s, 10));
+ *
+ * // Use in different contexts
+ * toUpperCase("hello"); // "HELLO"
+ * toUpperCase(null); // undefined
+ *
+ * // Compose transformations
+ * const processString = (s: string | null) => {
+ *   const upper = toUpperCase(s);
+ *   return addPrefix(upper);
+ * };
+ *
+ * processString("test"); // "PREFIX_TEST"
+ * processString(null); // undefined
+ * ```
+ *
+ * @example Chaining nullable operations
+ * ```typescript
+ * // API response handling
+ * interface ApiResponse {
+ *   data?: {
+ *     user?: {
+ *       profile?: {
+ *         displayName?: string;
+ *       };
+ *     };
+ *   };
+ * }
+ *
+ * function getDisplayName(response: ApiResponse): string | undefined {
+ *   return mapNullable(
+ *     response.data?.user?.profile?.displayName,
+ *     name => name.trim().toUpperCase()
+ *   );
+ * }
+ *
+ * // Chain multiple transformations
+ * function processNullableChain(value: string | null): string | undefined {
+ *   const step1 = mapNullable(value, v => v.trim());
+ *   const step2 = mapNullable(step1, v => v.length > 0 ? v : null);
+ *   const step3 = mapNullable(step2, v => v.toUpperCase());
+ *   return step3;
+ * }
+ * ```
+ *
+ * @example Integration with array methods
+ * ```typescript
+ * const nullableNumbers: (number | null | undefined)[] = [1, null, 3, undefined, 5];
+ *
+ * // Transform and filter in one step
+ * const doubled = nullableNumbers
+ *   .map(n => mapNullable(n, x => x * 2))
+ *   .filter((n): n is number => n !== undefined);
+ * // Result: [2, 6, 10]
+ *
+ * // Process optional array elements
+ * const users: Array<{ name?: string }> = [
+ *   { name: 'Alice' },
+ *   { name: undefined },
+ *   { name: 'Bob' }
+ * ];
+ *
+ * const upperNames = users
+ *   .map(u => mapNullable(u.name, n => n.toUpperCase()))
+ *   .filter((n): n is string => n !== undefined);
+ * // Result: ['ALICE', 'BOB']
+ * ```
+ *
+ * @example Error handling patterns
+ * ```typescript
+ * // Safe JSON parsing
+ * function parseJsonSafe<T>(json: string | null): T | undefined {
+ *   return mapNullable(json, j => {
+ *     try {
+ *       return JSON.parse(j) as T;
+ *     } catch {
+ *       return null;
+ *     }
+ *   }) ?? undefined;
+ * }
+ *
+ * // Safe property access with computation
+ * function calculateAge(birthYear: number | null): string | undefined {
+ *   return mapNullable(birthYear, year => {
+ *     const age = new Date().getFullYear() - year;
+ *     return age >= 0 ? `${age} years old` : null;
+ *   }) ?? undefined;
+ * }
+ * ```
+ *
+ * @see Optional - For more complex optional value handling
+ * @see Result - For error handling with detailed error information
+ */
+export declare const mapNullable: MapNullableFnOverload;
+type MapNullableFnOverload = {
+    <const A, const B>(value: A | null | undefined, mapFn: (v: A) => B): B | undefined;
+    <const A, const B>(mapFn: (v: A) => B): (value: A | null | undefined) => B | undefined;
+};
+export {};
+//# sourceMappingURL=map-nullable.d.mts.map

package/dist/others/map-nullable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-nullable.d.mts","sourceRoot":"","sources":["../../src/others/map-nullable.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+IG;AACH,eAAO,MAAM,WAAW,EAAE,qBAeC,CAAC;AAE5B,KAAK,qBAAqB,GAAG;IAC3B,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EACf,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAC3B,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACjB,CAAC,GAAG,SAAS,CAAC;IAGjB,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EACf,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACjB,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,KAAK,CAAC,GAAG,SAAS,CAAC;CACnD,CAAC"}

package/dist/others/map-nullable.mjs

@@ -0,0 +1,159 @@
+/**
+ * Applies a function to a value if the value is not `null` or `undefined`.
+ * If the value is `null` or `undefined`, it returns `undefined`.
+ *
+ * This function provides a safe way to transform nullable values without explicit null checks.
+ * It's similar to Optional.map() but works directly with TypeScript's nullable types.
+ * Supports both regular and curried usage for functional composition.
+ *
+ * @template A - The type of the input value (excluding null/undefined)
+ * @template B - The type of the value returned by the mapping function
+ * @param value - The value to potentially transform (can be `A`, `null`, or `undefined`)
+ * @param mapFn - A function that transforms a non-nullable value of type `A` to type `B`
+ * @returns The result of applying `mapFn` to `value` if value is not null/undefined; otherwise `undefined`
+ *
+ * @example Basic usage with nullable values
+ * ```typescript
+ * // Safe string transformation
+ * mapNullable("hello", s => s.toUpperCase()); // "HELLO"
+ * mapNullable(null, s => s.toUpperCase()); // undefined
+ * mapNullable(undefined, s => s.toUpperCase()); // undefined
+ *
+ * // Number operations
+ * mapNullable(5, n => n * 2); // 10
+ * mapNullable(0, n => n * 2); // 0 (note: 0 is not null/undefined)
+ * mapNullable(null as number | null, n => n * 2); // undefined
+ * ```
+ *
+ * @example Working with optional object properties
+ * ```typescript
+ * interface User {
+ *   id: number;
+ *   name?: string;
+ *   email?: string;
+ * }
+ *
+ * function formatUserDisplay(user: User): string {
+ *   const displayName = mapNullable(user.name, name => name.toUpperCase()) ?? 'Anonymous';
+ *   const emailDomain = mapNullable(user.email, email => email.split('@')[1]);
+ *
+ *   return `${displayName} ${emailDomain ? `(${emailDomain})` : ''}`;
+ * }
+ *
+ * formatUserDisplay({ id: 1, name: 'John', email: 'john@example.com' }); // "JOHN (example.com)"
+ * formatUserDisplay({ id: 2 }); // "Anonymous "
+ * ```
+ *
+ * @example Curried usage for functional composition
+ * ```typescript
+ * // Create reusable transformers
+ * const toUpperCase = mapNullable((s: string) => s.toUpperCase());
+ * const addPrefix = mapNullable((s: string) => `PREFIX_${s}`);
+ * const parseNumber = mapNullable((s: string) => parseInt(s, 10));
+ *
+ * // Use in different contexts
+ * toUpperCase("hello"); // "HELLO"
+ * toUpperCase(null); // undefined
+ *
+ * // Compose transformations
+ * const processString = (s: string | null) => {
+ *   const upper = toUpperCase(s);
+ *   return addPrefix(upper);
+ * };
+ *
+ * processString("test"); // "PREFIX_TEST"
+ * processString(null); // undefined
+ * ```
+ *
+ * @example Chaining nullable operations
+ * ```typescript
+ * // API response handling
+ * interface ApiResponse {
+ *   data?: {
+ *     user?: {
+ *       profile?: {
+ *         displayName?: string;
+ *       };
+ *     };
+ *   };
+ * }
+ *
+ * function getDisplayName(response: ApiResponse): string | undefined {
+ *   return mapNullable(
+ *     response.data?.user?.profile?.displayName,
+ *     name => name.trim().toUpperCase()
+ *   );
+ * }
+ *
+ * // Chain multiple transformations
+ * function processNullableChain(value: string | null): string | undefined {
+ *   const step1 = mapNullable(value, v => v.trim());
+ *   const step2 = mapNullable(step1, v => v.length > 0 ? v : null);
+ *   const step3 = mapNullable(step2, v => v.toUpperCase());
+ *   return step3;
+ * }
+ * ```
+ *
+ * @example Integration with array methods
+ * ```typescript
+ * const nullableNumbers: (number | null | undefined)[] = [1, null, 3, undefined, 5];
+ *
+ * // Transform and filter in one step
+ * const doubled = nullableNumbers
+ *   .map(n => mapNullable(n, x => x * 2))
+ *   .filter((n): n is number => n !== undefined);
+ * // Result: [2, 6, 10]
+ *
+ * // Process optional array elements
+ * const users: Array<{ name?: string }> = [
+ *   { name: 'Alice' },
+ *   { name: undefined },
+ *   { name: 'Bob' }
+ * ];
+ *
+ * const upperNames = users
+ *   .map(u => mapNullable(u.name, n => n.toUpperCase()))
+ *   .filter((n): n is string => n !== undefined);
+ * // Result: ['ALICE', 'BOB']
+ * ```
+ *
+ * @example Error handling patterns
+ * ```typescript
+ * // Safe JSON parsing
+ * function parseJsonSafe<T>(json: string | null): T | undefined {
+ *   return mapNullable(json, j => {
+ *     try {
+ *       return JSON.parse(j) as T;
+ *     } catch {
+ *       return null;
+ *     }
+ *   }) ?? undefined;
+ * }
+ *
+ * // Safe property access with computation
+ * function calculateAge(birthYear: number | null): string | undefined {
+ *   return mapNullable(birthYear, year => {
+ *     const age = new Date().getFullYear() - year;
+ *     return age >= 0 ? `${age} years old` : null;
+ *   }) ?? undefined;
+ * }
+ * ```
+ *
+ * @see Optional - For more complex optional value handling
+ * @see Result - For error handling with detailed error information
+ */
+const mapNullable = ((...args) => {
+    switch (args.length) {
+        case 2: {
+            const [value, mapFn] = args;
+            return value == null ? undefined : mapFn(value);
+        }
+        case 1: {
+            const [mapFn] = args;
+            return (value) => mapNullable(value, mapFn);
+        }
+    }
+});
+
+export { mapNullable };
+//# sourceMappingURL=map-nullable.mjs.map

package/dist/others/map-nullable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-nullable.mjs","sources":["../../src/others/map-nullable.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+IG;MACU,WAAW,IAA2B,CACjD,GAAG,IAE8B,KACqC;AACtE,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,IAAI;AAC3B,YAAA,OAAO,KAAK,IAAI,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC;;QAEjD,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;YACpB,OAAO,CAAC,KAA2B,KAAK,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC;;;AAGvE,CAAC;;;;"}