@redocly/revel-reef 0.124.0-next.30 → 0.124.0-next.32

package/dist/utils/array/ensure-array.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Ensures that the input value is always returned as an array.
+ *
+ * If the input is already an array, it is returned unchanged.
+ * If the input is a single value, it is wrapped in an array.
+ *
+ * @template T The type of the value or array elements.
+ * @param maybeArray - A single item or an array of items.
+ * @returns An array containing the input value(s).
+ *
+ * @example
+ * ```ts
+ * ensureArray(5); // [5]
+ * ensureArray([1, 2, 3]); // [1, 2, 3]
+ * ```
+ */
+export declare function ensureArray<T>(maybeArray: T | T[]): T[];
+//# sourceMappingURL=ensure-array.d.ts.map

package/dist/utils/array/ensure-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-array.d.ts","sourceRoot":"","sources":["../../../../../src/utils/array/ensure-array.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAEvD"}

package/dist/utils/array/ensure-array.js

@@ -0,0 +1 @@
+function n(r){return Array.isArray(r)?r:[r]}export{n as ensureArray};

package/dist/utils/array/ensure-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-array.js","sourceRoot":"","sources":["../../../../../src/utils/array/ensure-array.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,WAAW,CAAI,UAAmB;IAChD,OAAO,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;AAC/D,CAAC"}

package/dist/utils/array/group-by.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Groups elements of an array into an object based on a key function.
+ *
+ * Iterates over the input array and groups items by the string key returned by the key function.
+ * Each key maps to an array of items that share that key.
+ *
+ * @template T The type of elements in the input array.
+ * @param array - The array of items to group.
+ * @param keyFn - A function that takes an item and returns a string key to group by.
+ * @returns An object where each key is associated with an array of items that share that key.
+ *
+ * @example
+ * ```ts
+ * const data = [
+ *   { type: 'fruit', name: 'apple' },
+ *   { type: 'vegetable', name: 'carrot' },
+ *   { type: 'fruit', name: 'banana' }
+ * ];
+ *
+ * const grouped = groupBy(data, item => item.type);
+ * // {
+ * //   fruit: [
+ * //     { type: 'fruit', name: 'apple' },
+ * //     { type: 'fruit', name: 'banana' }
+ * //   ],
+ * //   vegetable: [
+ * //     { type: 'vegetable', name: 'carrot' }
+ * //   ]
+ * // }
+ * ```
+ */
+export declare function groupBy<T>(array: T[], keyFn: (item: T) => string): Record<string, T[]>;
+//# sourceMappingURL=group-by.d.ts.map

package/dist/utils/array/group-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by.d.ts","sourceRoot":"","sources":["../../../../../src/utils/array/group-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAUtF"}

package/dist/utils/array/group-by.js

@@ -0,0 +1 @@
+function s(r,e){const o={};for(const n of r){const t=e(n);o[t]||(o[t]=[]),o[t].push(n)}return o}export{s as groupBy};

package/dist/utils/array/group-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by.js","sourceRoot":"","sources":["../../../../../src/utils/array/group-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,MAAM,UAAU,OAAO,CAAI,KAAU,EAAE,KAA0B;IAC/D,MAAM,MAAM,GAAwB,EAAE,CAAC;IACvC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;YACjB,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;QACnB,CAAC;QACD,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/utils/array/partition.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Partitions a list into multiple groups based on a key returned by the given predicate function.
+ *
+ * For each item in the input list, the predicate is called to produce a grouping key.
+ * Items with the same key are placed in the same group (array).
+ * Items for which the predicate returns `undefined` are each placed into their own single-item group.
+ *
+ * @template T The type of items in the input list.
+ * @param list - The array of items to partition.
+ * @param predicate - A function that takes an item and returns a grouping key (string) or undefined.
+ * @returns An array of groups. Each group is an array of items that share the same key.
+ *          Items without a key are grouped individually.
+ *
+ * @example
+ * ```ts
+ * const data = ['apple', 'banana', 'apricot', 'blueberry', ''];
+ * const result = partition(data, item => item[0] || undefined);
+ * // result: [['apple', 'apricot'], ['banana', 'blueberry'], ['']]
+ * ```
+ */
+export declare function partition<T>(list: T[], predicate: (item: T) => string | undefined): T[][];
+//# sourceMappingURL=partition.d.ts.map

package/dist/utils/array/partition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.ts","sourceRoot":"","sources":["../../../../../src/utils/array/partition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,SAAS,GAAG,CAAC,EAAE,EAAE,CAiBzF"}

package/dist/utils/array/partition.js

@@ -0,0 +1 @@
+function i(e,s){const t={},c=[];for(const o of e){const n=s(o);if(!n){c.push([o]);continue}t[n]||(t[n]=[]),t[n].push(o)}return Object.values(t).concat(c)}export{i as partition};

package/dist/utils/array/partition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.js","sourceRoot":"","sources":["../../../../../src/utils/array/partition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,SAAS,CAAI,IAAS,EAAE,SAA0C;IAChF,MAAM,MAAM,GAAwB,EAAE,CAAC;IACvC,MAAM,KAAK,GAAG,EAAE,CAAC;IAEjB,KAAK,MAAM,IAAI,IAAI,IAAI,EAAE,CAAC;QACxB,MAAM,GAAG,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;YACnB,SAAS;QACX,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;YACjB,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;QACnB,CAAC;QACD,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC7C,CAAC"}

package/dist/utils/array/split-array-async.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Splits an array into two arrays based on an asynchronous or synchronous predicate.
+ *
+ * Iterates through the input array, applying the given predicate function to each item.
+ * If the predicate resolves to `true`, the item is placed in the first output array (positive).
+ * If the predicate resolves to `false`, the item is placed in the second output array (negative).
+ *
+ * The predicate may return a boolean directly or a Promise that resolves to a boolean.
+ *
+ * @template T The type of items in the input array.
+ * @param inputArray - The array to split.
+ * @param predicate - A function that takes an item and returns a boolean or a Promise<boolean>.
+ * @returns A Promise that resolves to a tuple: [items that matched, items that did not match].
+ *
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const [even, odd] = await splitArrayAsync(numbers, async (n) => n % 2 === 0);
+ * // even: [2, 4]
+ * // odd: [1, 3, 5]
+ * ```
+ */
+export declare function splitArrayAsync<T>(inputArray: T[], predicate: (arrayItem: T) => boolean | Promise<boolean>): Promise<[T[], T[]]>;
+//# sourceMappingURL=split-array-async.d.ts.map

package/dist/utils/array/split-array-async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-array-async.d.ts","sourceRoot":"","sources":["../../../../../src/utils/array/split-array-async.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,eAAe,CAAC,CAAC,EACrC,UAAU,EAAE,CAAC,EAAE,EACf,SAAS,EAAE,CAAC,SAAS,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GACtD,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAarB"}

package/dist/utils/array/split-array-async.js

@@ -0,0 +1 @@
+async function e(a,n){const t=[],s=[];for(const r of a)await n(r)?t.push(r):s.push(r);return[t,s]}export{e as splitArrayAsync};

package/dist/utils/array/split-array-async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-array-async.js","sourceRoot":"","sources":["../../../../../src/utils/array/split-array-async.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,UAAe,EACf,SAAuD;IAEvD,MAAM,aAAa,GAAQ,EAAE,CAAC;IAC9B,MAAM,aAAa,GAAQ,EAAE,CAAC;IAE9B,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,IAAI,MAAM,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/B,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAChC,CAAC;aAAM,CAAC;YACN,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAED,OAAO,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;AACxC,CAAC"}

package/dist/utils/array/unique.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Removes duplicate items from an array, optionally using a custom key extractor.
+ *
+ * Iterates through the input array and returns a new array containing only the first
+ * occurrence of each unique item. If a predicate function is provided, its return value
+ * is used as the unique key for comparison instead of the item itself.
+ *
+ * @template T The type of the items in the input array.
+ * @param array - The array to deduplicate.
+ * @param predicate - Optional. A function that returns the value to use for uniqueness checks.
+ * @returns A new array containing only unique items.
+ *
+ * @example
+ * ```ts
+ * unique([1, 2, 2, 3]); // [1, 2, 3]
+ *
+ * unique(
+ *   [{ id: 1, name: 'A' }, { id: 1, name: 'B' }, { id: 2, name: 'C' }],
+ *   item => item.id
+ * );
+ * // [{ id: 1, name: 'A' }, { id: 2, name: 'C' }]
+ * ```
+ */
+export declare function unique<T>(array: T[], predicate?: (item: T) => unknown): T[];
+//# sourceMappingURL=unique.d.ts.map

package/dist/utils/array/unique.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.d.ts","sourceRoot":"","sources":["../../../../../src/utils/array/unique.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,EAAE,CAa3E"}

package/dist/utils/array/unique.js

@@ -0,0 +1 @@
+function c(u,n){const o=new Set,s=[];for(const t of u){const e=n?n(t):t;o.has(e)||s.push(t),o.add(e)}return s}export{c as unique};

package/dist/utils/array/unique.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.js","sourceRoot":"","sources":["../../../../../src/utils/array/unique.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,MAAM,CAAI,KAAU,EAAE,SAAgC;IACpE,MAAM,GAAG,GAAG,IAAI,GAAG,EAAE,CAAC;IACtB,MAAM,MAAM,GAAG,EAAE,CAAC;IAElB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC/C,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAClB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC;QACD,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACf,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/utils/collection/find-in-iterable.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Finds and returns the first element in an iterable that matches the given predicate.
+ *
+ * Iterates over the provided iterable and applies the predicate function to each item.
+ * Returns the first item for which the predicate returns true. If no item matches,
+ * it returns undefined.
+ *
+ * @param iter - The iterable to search through (e.g. an array, Set, or generator).
+ * @param predicate - A function that tests each element. Should return true for the desired item.
+ * @returns The first matching item, or undefined if none match.
+ */
+export declare function findInIterable<T>(iter: Iterable<T>, predicate: (item: T) => boolean | undefined): T | undefined;
+//# sourceMappingURL=find-in-iterable.d.ts.map

package/dist/utils/collection/find-in-iterable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-in-iterable.d.ts","sourceRoot":"","sources":["../../../../../src/utils/collection/find-in-iterable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EACjB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,SAAS,GAC1C,CAAC,GAAG,SAAS,CAMf"}

package/dist/utils/collection/find-in-iterable.js

@@ -0,0 +1 @@
+function f(t,e){for(const n of t)if(e(n))return n}export{f as findInIterable};

package/dist/utils/collection/find-in-iterable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-in-iterable.js","sourceRoot":"","sources":["../../../../../src/utils/collection/find-in-iterable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,UAAU,cAAc,CAC5B,IAAiB,EACjB,SAA2C;IAE3C,KAAK,MAAM,IAAI,IAAI,IAAI,EAAE,CAAC;QACxB,IAAI,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/utils/collection/set-map-value.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Sets a value for the given key in a Map and returns the value.
+ *
+ * This is useful when you want to chain map setting with inline assignment,
+ * for example when building up a Map in a functional style.
+ *
+ * @param map - The Map to update.
+ * @param key - The key to set.
+ * @param value - The value to set for the key.
+ * @returns The same value that was set.
+ */
+export declare function setMapValue<K, T>(map: Map<K, T>, key: K, value: T): T;
+//# sourceMappingURL=set-map-value.d.ts.map

package/dist/utils/collection/set-map-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-map-value.d.ts","sourceRoot":"","sources":["../../../../../src/utils/collection/set-map-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAGrE"}

package/dist/utils/collection/set-map-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-map-value.js","sourceRoot":"","sources":["../../../../../src/utils/collection/set-map-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,UAAU,WAAW,CAAO,GAAc,EAAE,GAAM,EAAE,KAAQ;IAChE,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACpB,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/utils/env/is-browser.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks if the current environment is a browser.
+ *
+ * Returns `true` if the global `window` object exists and has the `HTMLElement` property,
+ * which is a good indication that the code is running in a browser context.
+ * Otherwise, returns `false` (e.g., Node.js or other non-browser environments).
+ *
+ * @returns `true` if running in a browser environment; otherwise `false`.
+ */
+export declare function isBrowser(): boolean;
+//# sourceMappingURL=is-browser.d.ts.map

package/dist/utils/env/is-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-browser.d.ts","sourceRoot":"","sources":["../../../../../src/utils/env/is-browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,SAAS,YAExB"}

package/dist/utils/env/is-browser.js

@@ -0,0 +1 @@
+function n(){return typeof window<"u"&&"HTMLElement"in window}export{n as isBrowser};

package/dist/utils/env/is-browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-browser.js","sourceRoot":"","sources":["../../../../../src/utils/env/is-browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS;IACvB,OAAO,OAAO,MAAM,KAAK,WAAW,IAAI,aAAa,IAAI,MAAM,CAAC;AAClE,CAAC"}

package/dist/utils/guards/is-defined.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Type guard that checks if a value is not `undefined` or `null`.
+ *
+ * Useful for filtering out nullable values while preserving type safety.
+ *
+ * @template T The value type.
+ * @param value The value to check.
+ * @returns `true` if the value is neither `undefined` nor `null`; otherwise `false`.
+ *
+ * @example
+ * const arr = [1, null, 2, undefined, 3];
+ * const filtered = arr.filter(isDefined); // [1, 2, 3]
+ */
+export declare function isDefined<T>(value: T | undefined | null): value is T;
+//# sourceMappingURL=is-defined.d.ts.map

package/dist/utils/guards/is-defined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-defined.d.ts","sourceRoot":"","sources":["../../../../../src/utils/guards/is-defined.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,GAAG,IAAI,GAAG,KAAK,IAAI,CAAC,CAEpE"}

package/dist/utils/guards/is-defined.js

@@ -0,0 +1 @@
+function e(n){return n!=null}export{e as isDefined};

package/dist/utils/guards/is-defined.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-defined.js","sourceRoot":"","sources":["../../../../../src/utils/guards/is-defined.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,SAAS,CAAI,KAA2B;IACtD,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,CAAC;AAC/C,CAAC"}

package/dist/utils/guards/is-function.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Type guard that checks if a value is a function.
+ *
+ * Useful for safely calling or handling values that may or may not be functions.
+ *§
+ * @template T The return type of the function.
+ * @param value The value to check.
+ * @returns `true` if the value is a function; otherwise `false`.
+ *
+ * @example
+ * const maybeFn: unknown = () => 42;
+ * if (isFunction(maybeFn)) {
+ *   const result = maybeFn(); // Safe to call
+ * }
+ */
+export declare function isFunction<T>(value: any): value is (...args: any[]) => T;
+//# sourceMappingURL=is-function.d.ts.map

package/dist/utils/guards/is-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-function.d.ts","sourceRoot":"","sources":["../../../../../src/utils/guards/is-function.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAExE"}

package/dist/utils/guards/is-function.js

@@ -0,0 +1 @@
+function t(n){return typeof n=="function"}export{t as isFunction};

package/dist/utils/guards/is-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-function.js","sourceRoot":"","sources":["../../../../../src/utils/guards/is-function.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,UAAU,CAAI,KAAU;IACtC,OAAO,OAAO,KAAK,KAAK,UAAU,CAAC;AACrC,CAAC"}

package/dist/utils/guards/is-object.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Determines whether a given value is a plain object.
+ *
+ * Checks that the value is of type 'object', not null,
+ * and has either Object.prototype or null as its prototype.
+ * This excludes arrays, functions, and other built-in objects.
+ *
+ * @param obj - The value to check.
+ * @returns True if the value is a plain object, otherwise false.
+ *
+ * Example:
+ * ```ts
+ * isObject({}); // true
+ * isObject(Object.create(null)); // true
+ * isObject([]); // false
+ * isObject(null); // false
+ * isObject(() => {}); // false
+ * ```
+ */
+export declare function isObject(obj: unknown): obj is object;
+//# sourceMappingURL=is-object.d.ts.map

package/dist/utils/guards/is-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-object.d.ts","sourceRoot":"","sources":["../../../../../src/utils/guards/is-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAWpD"}

package/dist/utils/guards/is-object.js

@@ -0,0 +1 @@
+function o(t){if(typeof t=="object"&&t!==null){if(typeof Object.getPrototypeOf=="function"){const e=Object.getPrototypeOf(t);return e===Object.prototype||e===null}return Object.prototype.toString.call(t)==="[object Object]"}return!1}export{o as isObject};

package/dist/utils/guards/is-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-object.js","sourceRoot":"","sources":["../../../../../src/utils/guards/is-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,UAAU,QAAQ,CAAC,GAAY;IACnC,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;QAC5C,IAAI,OAAO,MAAM,CAAC,cAAc,KAAK,UAAU,EAAE,CAAC;YAChD,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YAC7C,OAAO,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,CAAC;QAC9D,CAAC;QAED,0BAA0B;QAC1B,OAAO,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,iBAAiB,CAAC;IACnE,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/utils/guards/is-truthy.d.ts

@@ -0,0 +1,18 @@
+type Falsy = undefined | null | false | '' | 0;
+/**
+ * Type guard that checks if a value is *truthy*.
+ *
+ * This narrows out common falsy values: `undefined`, `null`, `false`, `''` (empty string), and `0`.
+ * It’s especially useful for filtering arrays to remove falsy values with proper TypeScript narrowing.
+ *
+ * @template Truthy The inferred type of a truthy value.
+ * @param value The value to check.
+ * @returns `true` if the value is truthy; otherwise `false`.
+ *
+ * @example
+ * const arr = [0, 1, '', 'hello', false, true];
+ * const truthyValues = arr.filter(isTruthy); // [1, 'hello', true]
+ */
+export declare function isTruthy<Truthy>(value: Truthy | Falsy): value is Truthy;
+export {};
+//# sourceMappingURL=is-truthy.d.ts.map

package/dist/utils/guards/is-truthy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-truthy.d.ts","sourceRoot":"","sources":["../../../../../src/utils/guards/is-truthy.ts"],"names":[],"mappings":"AAAA,KAAK,KAAK,GAAG,SAAS,GAAG,IAAI,GAAG,KAAK,GAAG,EAAE,GAAG,CAAC,CAAC;AAE/C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,IAAI,MAAM,CAEvE"}

package/dist/utils/guards/is-truthy.js

@@ -0,0 +1 @@
+function t(r){return!!r}export{t as isTruthy};

package/dist/utils/guards/is-truthy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-truthy.js","sourceRoot":"","sources":["../../../../../src/utils/guards/is-truthy.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,QAAQ,CAAS,KAAqB;IACpD,OAAO,CAAC,CAAC,KAAK,CAAC;AACjB,CAAC"}

package/dist/utils/object/deep-merge.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Converts a union type to an intersection type.
+ *
+ * This utility type is used internally to represent the result of merging multiple
+ * object types into a single type containing all their properties.
+ *
+ * Example:
+ * ```ts
+ * type A = { a: number };
+ * type B = { b: string };
+ * type C = TUnionToIntersection<A | B>; // { a: number } & { b: string }
+ * ```
+ */
+type TUnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Deeply merges multiple plain objects into a single object.
+ *
+ * For each property:
+ * - If both source and target properties are plain objects, they are merged recursively.
+ * - If both are arrays, the source array overwrites the target array.
+ * - Otherwise, the source property overwrites the target property.
+ *
+ * This function skips dangerous keys like `__proto__`, `constructor`, and `prototype`
+ * to prevent prototype pollution.
+ *
+ * @param objects - Two or more plain objects to merge.
+ * @returns A new object that is the deep merge of all input objects.
+ *
+ * Example:
+ * ```ts
+ * const a = { x: 1, nested: { y: 2 } };
+ * const b = { nested: { z: 3 }, arr: [1, 2] };
+ * const merged = deepMerge(a, b); // { x: 1, nested: { y: 2, z: 3 }, arr: [1, 2] }
+ * ```
+ */
+export declare function deepMerge<T extends object[]>(...objects: T): TUnionToIntersection<T[number]>;
+export {};
+//# sourceMappingURL=deep-merge.d.ts.map

package/dist/utils/object/deep-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-merge.d.ts","sourceRoot":"","sources":["../../../../../src/utils/object/deep-merge.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,KAAK,oBAAoB,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,IAAI,GAChG,CAAC,GACD,KAAK,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,GAAG,OAAO,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAqB5F"}

package/dist/utils/object/deep-merge.js

@@ -0,0 +1 @@
+import{isObject as f}from"../guards/is-object.js";function p(...y){return y.reduce((i,e={})=>{for(const o of Object.keys(e))["__proto__","constructor","prototype"].includes(o)||(Array.isArray(i[o])&&Array.isArray(e[o])?i[o]=e[o]:f(i[o])&&f(e[o])?i[o]=p(i[o],e[o]):i[o]=e[o]);return i},{})}export{p as deepMerge};

package/dist/utils/object/deep-merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-merge.js","sourceRoot":"","sources":["../../../../../src/utils/object/deep-merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAmBlD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,UAAU,SAAS,CAAqB,GAAG,OAAU;IACzD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,UAAe,EAAE,EAAE,EAAE;QAClD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YACvC,IAAI,CAAC,WAAW,EAAE,aAAa,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC5D,SAAS;YACX,CAAC;YAED,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBAC9D,MAAM,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;YAC7B,CAAC;iBAAM,IAAI,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBAC3D,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CACrB,MAAM,CAAC,GAAG,CAA4B,EACtC,OAAO,CAAC,GAAG,CAA4B,CACxC,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC,EAAE,EAAS,CAAQ,CAAC;AACvB,CAAC"}

package/dist/utils/object/get-value-deep.d.ts

@@ -0,0 +1,22 @@
+type GetValueDeep<T> = {
+    error: null;
+    value: T;
+} | {
+    error: Error;
+    value: null;
+};
+/**
+ * Retrieves a value from a nested object structure using an array of property names as a path.
+ * Returns an object containing either the result or any error encountered during traversal.
+ *
+ * @param {any} obj - The object to traverse
+ * @param {string[]} path - Array of property names defining the path to the desired value
+ * @returns {GetValueDeep} - Object containing the result or error
+ *
+ * @example
+ * const obj = { user: { address: { city: 'New York' } } };
+ * getValueDeep(obj, ['user', 'address', 'city']); // { error: null, value: 'New York' }
+ */
+export declare function getValueDeep<T>(obj: any, path: string[]): GetValueDeep<T>;
+export {};
+//# sourceMappingURL=get-value-deep.d.ts.map

package/dist/utils/object/get-value-deep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-value-deep.d.ts","sourceRoot":"","sources":["../../../../../src/utils/object/get-value-deep.ts"],"names":[],"mappings":"AAAA,KAAK,YAAY,CAAC,CAAC,IAAI;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC;AAEjF;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC,CAAC,CAAC,CAWzE"}

package/dist/utils/object/get-value-deep.js

@@ -0,0 +1 @@
+function u(t,l){let r=t;try{for(let e=0;e<l.length;e++)r=r[l[e]]}catch(e){return{error:e,value:null}}return{error:null,value:r}}export{u as getValueDeep};

package/dist/utils/object/get-value-deep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-value-deep.js","sourceRoot":"","sources":["../../../../../src/utils/object/get-value-deep.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAAI,GAAQ,EAAE,IAAc;IACtD,IAAI,GAAG,GAAG,GAAG,CAAC;IACd,IAAI,CAAC;QACH,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAChC,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,GAAQ,EAAE,CAAC;AAC1C,CAAC"}

package/dist/utils/object/map-object-async.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Asynchronously maps the values of an object using an async mapping function.
+ *
+ * Iterates over the object's own enumerable string keys,
+ * calls the given async function for each `[key, value]` pair,
+ * and returns a Promise that resolves to a new object with the same keys
+ * and the resolved mapped values.
+ *
+ * All mapping operations run in parallel using `Promise.all`.
+ *
+ * @typeParam T - The type of the input object’s values.
+ * @typeParam P - The type of the resolved output object’s values.
+ * @param obj - The object whose values should be mapped.
+ * @param fn - An async function that receives the value and key, and resolves to a new value.
+ * @returns A Promise that resolves to a new object with the same keys and transformed values.
+ *
+ * Example:
+ * ```ts
+ * const input = { a: 1, b: 2 };
+ * const result = await mapObjectAsync(input, async (v) => v * 2);
+ * console.log(result); // { a: 2, b: 4 }
+ * ```
+ */
+export declare function mapObjectAsync<T, P>(obj: Record<string, T>, fn: (v: T, k: string) => Promise<P>): Promise<Record<string, P>>;
+//# sourceMappingURL=map-object-async.d.ts.map

package/dist/utils/object/map-object-async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-object-async.d.ts","sourceRoot":"","sources":["../../../../../src/utils/object/map-object-async.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,cAAc,CAAC,CAAC,EAAE,CAAC,EACvC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EACtB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAClC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAQ5B"}

package/dist/utils/object/map-object-async.js

@@ -0,0 +1 @@
+async function r(a,e){return Object.fromEntries(await Promise.all(Object.entries(a).map(async([t,n])=>[t,await e(n,t)])))}export{r as mapObjectAsync};

package/dist/utils/object/map-object-async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-object-async.js","sourceRoot":"","sources":["../../../../../src/utils/object/map-object-async.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,GAAsB,EACtB,EAAmC;IAEnC,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,OAAO,CAAC,GAAG,CACf,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;QAC3C,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACnC,CAAC,CAAC,CACH,CACF,CAAC;AACJ,CAAC"}

package/dist/utils/object/map-object.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Creates a new object by applying a mapping function to each value of the input object.
+ *
+ * Iterates over the object's own enumerable string keys,
+ * applies the given callback to each `[key, value]` pair,
+ * and returns a new object with the same keys and transformed values.
+ *
+ * @typeParam T - The type of the input object’s values.
+ * @typeParam P - The type of the output object’s values.
+ * @param obj - The object to map over.
+ * @param fn - A function that receives the value and key, and returns a new value.
+ * @returns A new object with the same keys and transformed values.
+ *
+ * Example:
+ * ```ts
+ * const input = { a: 1, b: 2 };
+ * const result = mapObject(input, (v) => v * 2);
+ * console.log(result); // { a: 2, b: 4 }
+ * ```
+ */
+export declare function mapObject<T, P>(obj: Record<string, T>, fn: (v: T, k: string) => P): Record<string, P>;
+//# sourceMappingURL=map-object.d.ts.map

package/dist/utils/object/map-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-object.d.ts","sourceRoot":"","sources":["../../../../../src/utils/object/map-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EACtB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC,GACzB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAMnB"}

package/dist/utils/object/map-object.js

@@ -0,0 +1 @@
+function c(e,r){return Object.fromEntries(Object.entries(e).map(([t,n])=>[t,r(n,t)]))}export{c as mapObject};

package/dist/utils/object/map-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-object.js","sourceRoot":"","sources":["../../../../../src/utils/object/map-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,SAAS,CACvB,GAAsB,EACtB,EAA0B;IAE1B,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;QACrC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IAC7B,CAAC,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/utils/object/map-to-object.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Converts a Map to a plain object with string keys and values of type T.
+ *
+ * @param map - A Map or an object with an `entries` method that returns key-value pairs.
+ * @returns A plain object containing the same entries as the Map.
+ *
+ * Example:
+ * ```ts
+ * const map = new Map([['a', 1], ['b', 2]]);
+ * const obj = mapToObject(map); // { a: 1, b: 2 }
+ * ```
+ */
+export declare function mapToObject<T>(map: Pick<Map<string, T>, 'entries'>): Record<string, T>;
+//# sourceMappingURL=map-to-object.d.ts.map

package/dist/utils/object/map-to-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-to-object.d.ts","sourceRoot":"","sources":["../../../../../src/utils/object/map-to-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAEtF"}

package/dist/utils/object/map-to-object.js

@@ -0,0 +1 @@
+function t(e){return Object.fromEntries(e.entries())}export{t as mapToObject};

package/dist/utils/object/map-to-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-to-object.js","sourceRoot":"","sources":["../../../../../src/utils/object/map-to-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,UAAU,WAAW,CAAI,GAAoC;IACjE,OAAO,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;AAC3C,CAAC"}

package/dist/utils/object/remove-deep-property.d.ts

@@ -0,0 +1,21 @@
+type ObjectOrArray = Record<string, unknown> | unknown[];
+/**
+ * Recursively removes a deeply nested property from an object or array.
+ *
+ * Given a path (as an array of keys), it traverses the object and deletes
+ * the target property when the path is fully resolved.
+ * If any part of the path does not exist, the function does nothing.
+ *
+ * @param obj - The object or array to modify.
+ * @param path - An array of keys representing the path to the property to remove.
+ *
+ * Example:
+ * ```ts
+ * const data = { a: { b: { c: 1 } } };
+ * removeDeepProperty(data, ['a', 'b', 'c']);
+ * console.log(data); // { a: { b: {} } }
+ * ```
+ */
+export declare function removeDeepProperty(obj: ObjectOrArray | unknown, [field, ...path]: string[]): void;
+export {};
+//# sourceMappingURL=remove-deep-property.d.ts.map

package/dist/utils/object/remove-deep-property.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-deep-property.d.ts","sourceRoot":"","sources":["../../../../../src/utils/object/remove-deep-property.ts"],"names":[],"mappings":"AAAA,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,EAAE,CAAC;AACzD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,EAAE,MAAM,EAAE,QAU1F"}

package/dist/utils/object/remove-deep-property.js

@@ -0,0 +1 @@
+function r(e,[t,...n]){typeof e!="object"||!e||e?.[t]===void 0||(n.length===0?delete e?.[t]:e?.[t]&&r(e?.[t],n))}export{r as removeDeepProperty};

package/dist/utils/object/remove-deep-property.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-deep-property.js","sourceRoot":"","sources":["../../../../../src/utils/object/remove-deep-property.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAA4B,EAAE,CAAC,KAAK,EAAE,GAAG,IAAI,CAAW;IACzF,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,GAAG,IAAK,GAA+B,EAAE,CAAC,KAAK,CAAC,KAAK,SAAS,EAAE,CAAC;QAC/F,OAAO;IACT,CAAC;IAED,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,OAAQ,GAA+B,EAAE,CAAC,KAAK,CAAC,CAAC;IACnD,CAAC;SAAM,IAAK,GAA+B,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;QACrD,kBAAkB,CAAE,GAA+B,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;IACtE,CAAC;AACH,CAAC"}