@ac-kit/core 0.1.0

package/dist/object/defaults.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Assign default options to an object.
+ *
+ * The first argument has the highest priority, the last argument the lowest.
+ * Only properties that are `undefined` in the target object will be assigned
+ * from the source objects.
+ *
+ * This is equivalent to `_.defaults` from Lodash.
+ *
+ * @example
+ * 	```ts
+ * 	const options = defaults({ a: 1 }, { a: 2, b: 2 }, { a: 3, b: 3, c: 3 });
+ *
+ * 	console.log(options); // { a: 1, b: 2, c: 3 }
+ * 	```;
+ *
+ * @param args The objects to merge.
+ * @returns The merged object.
+ */
+export declare function defaults<R extends {}, P extends Partial<R> = Partial<R>>(...args: [...(P | null | undefined)[], R]): R;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/object/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/object/defaults.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACvE,GAAG,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC,GACvC,CAAC,CAcH"}

package/dist/object/defaults.js

@@ -0,0 +1,33 @@
+/**
+ * Assign default options to an object.
+ *
+ * The first argument has the highest priority, the last argument the lowest.
+ * Only properties that are `undefined` in the target object will be assigned
+ * from the source objects.
+ *
+ * This is equivalent to `_.defaults` from Lodash.
+ *
+ * @example
+ * 	```ts
+ * 	const options = defaults({ a: 1 }, { a: 2, b: 2 }, { a: 3, b: 3, c: 3 });
+ *
+ * 	console.log(options); // { a: 1, b: 2, c: 3 }
+ * 	```;
+ *
+ * @param args The objects to merge.
+ * @returns The merged object.
+ */
+export function defaults(...args) {
+    return args.reduce((result, arg) => {
+        if (arg) {
+            for (const key in arg) {
+                if (result[key] === undefined &&
+                    arg[key] !== undefined) {
+                    result[key] = arg[key];
+                }
+            }
+        }
+        return result;
+    }, {});
+}
+//# sourceMappingURL=defaults.js.map

package/dist/object/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../src/object/defaults.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,QAAQ,CACvB,GAAG,IAAsC;IAEzC,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,MAAa,EAAE,GAAG,EAAE,EAAE;QACzC,IAAI,GAAG,EAAE,CAAC;YACT,KAAK,MAAM,GAAG,IAAI,GAAG,EAAE,CAAC;gBACvB,IACE,MAAwB,CAAC,GAAG,CAAC,KAAK,SAAS;oBAC3C,GAAqB,CAAC,GAAG,CAAC,KAAK,SAAS,EACxC,CAAC;oBACD,MAAwB,CAAC,GAAG,CAAC,GAAI,GAAqB,CAAC,GAAG,CAAC,CAAC;gBAC9D,CAAC;YACF,CAAC;QACF,CAAC;QACD,OAAO,MAAM,CAAC;IACf,CAAC,EAAE,EAAO,CAAM,CAAC;AAClB,CAAC"}

package/dist/object/get-at-path.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A path into a nested object/array — segments are string keys or numeric
+ * indices.
+ */
+export type PropertyPath = readonly (string | number)[];
+/**
+ * Gets the value at `path` inside `root`.
+ *
+ * @param root The root object/array to traverse
+ * @param path The path to traverse
+ * @returns The value at the path, or `undefined` if the path does not exist.
+ */
+export declare function getAtPath(root: unknown, path: PropertyPath): unknown;
+//# sourceMappingURL=get-at-path.d.ts.map

package/dist/object/get-at-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-at-path.d.ts","sourceRoot":"","sources":["../../src/object/get-at-path.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;AAExD;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAkBpE"}

package/dist/object/get-at-path.js

@@ -0,0 +1,28 @@
+import { isObject } from "../guards/is-object.js";
+/**
+ * Gets the value at `path` inside `root`.
+ *
+ * @param root The root object/array to traverse
+ * @param path The path to traverse
+ * @returns The value at the path, or `undefined` if the path does not exist.
+ */
+export function getAtPath(root, path) {
+    let current = root;
+    for (const key of path) {
+        if (Array.isArray(current)) {
+            const index = +key;
+            if (Number.isNaN(index)) {
+                return;
+            }
+            current = current[index];
+        }
+        else if (isObject(current)) {
+            current = current[key];
+        }
+        else {
+            return;
+        }
+    }
+    return current;
+}
+//# sourceMappingURL=get-at-path.js.map

package/dist/object/get-at-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-at-path.js","sourceRoot":"","sources":["../../src/object/get-at-path.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAQlD;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,IAAa,EAAE,IAAkB;IAC1D,IAAI,OAAO,GAAG,IAAI,CAAC;IAEnB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACxB,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5B,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC;YACnB,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;gBACzB,OAAO;YACR,CAAC;YACD,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAC1B,CAAC;aAAM,IAAI,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC9B,OAAO,GAAI,OAAyB,CAAC,GAAG,CAAC,CAAC;QAC3C,CAAC;aAAM,CAAC;YACP,OAAO;QACR,CAAC;IACF,CAAC;IAED,OAAO,OAAO,CAAC;AAChB,CAAC"}

package/dist/object/get-object-keys.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Represents a key of an object, including the prototype it belongs to and
+ * whether it is non-enumerable.
+ */
+export type ObjectKey = {
+    /** The property key, which can be a string or a symbol. */
+    property: string | symbol;
+    /** The prototype object that owns the property. */
+    prototype: unknown;
+    /**
+     * Indicates whether the property is non-enumerable. If `true`, the property
+     * is non-enumerable; if `false` or `undefined`, the property is enumerable.
+     */
+    nonEnumerable?: boolean;
+};
+export type GetObjectKeysOptions = {
+    /**
+     * Include symbol keys
+     *
+     * Defaults to false.
+     */
+    includeSymbolKeys?: boolean;
+    /**
+     * Include non-enumerable keys
+     *
+     * Defaults to false.
+     */
+    includeNonEnumerable?: boolean;
+    /**
+     * Include keys from the prototype chain
+     *
+     * Defaults to false.
+     */
+    includePrototypeChain?: boolean;
+};
+/**
+ * Get the keys of an object according to the specified options
+ *
+ * @param object The object to get the keys from
+ * @param options The options for getting the keys
+ * @returns The keys of the object
+ */
+export declare function getObjectKeys(object: object, options?: GetObjectKeysOptions): ObjectKey[];
+//# sourceMappingURL=get-object-keys.d.ts.map

package/dist/object/get-object-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-object-keys.d.ts","sourceRoot":"","sources":["../../src/object/get-object-keys.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACvB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAE1B,mDAAmD;IACnD,SAAS,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IAClC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,oBAAoB,GAC5B,SAAS,EAAE,CAoBb"}

package/dist/object/get-object-keys.js

@@ -0,0 +1,52 @@
+/**
+ * Get the keys of an object according to the specified options
+ *
+ * @param object The object to get the keys from
+ * @param options The options for getting the keys
+ * @returns The keys of the object
+ */
+export function getObjectKeys(object, options) {
+    const keys = [];
+    collectOwnKeys_(object, options ?? {}, keys);
+    if (options?.includePrototypeChain) {
+        // One options object for the whole walk: this runs once per node of every
+        // traversal, deep merge and deep comparison in the library.
+        const ownOnly = {
+            ...options,
+            includePrototypeChain: false,
+        };
+        let proto = Object.getPrototypeOf(object);
+        while (proto && proto !== Object.prototype) {
+            collectOwnKeys_(proto, ownOnly, keys);
+            proto = Object.getPrototypeOf(proto);
+        }
+    }
+    return keys;
+}
+/**
+ * Appends the own keys of `object` to `keys`.
+ *
+ * @param object The object to get the keys from
+ * @param options The options for getting the keys
+ * @param keys The array to append the keys to
+ */
+function collectOwnKeys_(object, options, keys) {
+    const enumerableKeys = Object.keys(object);
+    for (const key of enumerableKeys) {
+        keys.push({ property: key, prototype: object });
+    }
+    if (options.includeNonEnumerable) {
+        const enumerable = new Set(enumerableKeys);
+        for (const key of Object.getOwnPropertyNames(object)) {
+            if (!enumerable.has(key)) {
+                keys.push({ property: key, prototype: object, nonEnumerable: true });
+            }
+        }
+    }
+    if (options.includeSymbolKeys) {
+        for (const key of Object.getOwnPropertySymbols(object)) {
+            keys.push({ property: key, prototype: object });
+        }
+    }
+}
+//# sourceMappingURL=get-object-keys.js.map

package/dist/object/get-object-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-object-keys.js","sourceRoot":"","sources":["../../src/object/get-object-keys.ts"],"names":[],"mappings":"AAyCA;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAC5B,MAAc,EACd,OAA8B;IAE9B,MAAM,IAAI,GAAgB,EAAE,CAAC;IAC7B,eAAe,CAAC,MAAM,EAAE,OAAO,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;IAE7C,IAAI,OAAO,EAAE,qBAAqB,EAAE,CAAC;QACpC,0EAA0E;QAC1E,4DAA4D;QAC5D,MAAM,OAAO,GAAyB;YACrC,GAAG,OAAO;YACV,qBAAqB,EAAE,KAAK;SAC5B,CAAC;QAEF,IAAI,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,MAAM,CAAkB,CAAC;QAC3D,OAAO,KAAK,IAAI,KAAK,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;YAC5C,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;YACtC,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAkB,CAAC;QACvD,CAAC;IACF,CAAC;IAED,OAAO,IAAI,CAAC;AACb,CAAC;AAED;;;;;;GAMG;AACH,SAAS,eAAe,CACvB,MAAc,EACd,OAA6B,EAC7B,IAAiB;IAEjB,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3C,KAAK,MAAM,GAAG,IAAI,cAAc,EAAE,CAAC;QAClC,IAAI,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;IACjD,CAAC;IAED,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;QAClC,MAAM,UAAU,GAAG,IAAI,GAAG,CAAS,cAAc,CAAC,CAAC;QACnD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,CAAC;YACtD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC1B,IAAI,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;YACtE,CAAC;QACF,CAAC;IACF,CAAC;IAED,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC;QAC/B,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,CAAC;YACxD,IAAI,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;QACjD,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/object/is-deep-equal.d.ts

@@ -0,0 +1,21 @@
+import { type EqualityComparisonStrategy } from "./is-equal.js";
+/**
+ * Compare two values for deep equality using the specified strategy.
+ *
+ * Supported strategies: `"strict"`, `"loose"`, `"sameValue"`,
+ * `"sameValueZero"`, or a custom predicate `(a, b) => boolean`.
+ *
+ * For structural types (plain objects, arrays, `Map`, `Set`) the structure is
+ * always compared recursively; the strategy is applied at each leaf. For `Date`
+ * and `RegExp` the strategy compares `.getTime()` / `.source` + `.flags`
+ * respectively — except when a predicate is used, in which case the predicate
+ * receives the raw `Date` / `RegExp` objects.
+ *
+ * @param a First value to compare
+ * @param b Second value to compare
+ * @param comparisonStrategy The equality comparison strategy to use (default is
+ *   `"strict"`)
+ * @returns True if the values are deeply equal, false otherwise
+ */
+export declare function isDeepEqual(a: unknown, b: unknown, comparisonStrategy?: EqualityComparisonStrategy<unknown, unknown>): boolean;
+//# sourceMappingURL=is-deep-equal.d.ts.map

package/dist/object/is-deep-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-deep-equal.d.ts","sourceRoot":"","sources":["../../src/object/is-deep-equal.ts"],"names":[],"mappings":"AAKA,OAAO,EAAW,KAAK,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAEzE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAC1B,CAAC,EAAE,OAAO,EACV,CAAC,EAAE,OAAO,EACV,kBAAkB,GAAE,0BAA0B,CAAC,OAAO,EAAE,OAAO,CAAY,GACzE,OAAO,CAET"}

package/dist/object/is-deep-equal.js

@@ -0,0 +1,123 @@
+import { isDate } from "../guards/is-date.js";
+import { isMap } from "../guards/is-map.js";
+import { isPojo } from "../guards/is-pojo.js";
+import { isRegExp } from "../guards/is-regexp.js";
+import { isSet } from "../guards/is-set.js";
+import { isEqual } from "./is-equal.js";
+/**
+ * Compare two values for deep equality using the specified strategy.
+ *
+ * Supported strategies: `"strict"`, `"loose"`, `"sameValue"`,
+ * `"sameValueZero"`, or a custom predicate `(a, b) => boolean`.
+ *
+ * For structural types (plain objects, arrays, `Map`, `Set`) the structure is
+ * always compared recursively; the strategy is applied at each leaf. For `Date`
+ * and `RegExp` the strategy compares `.getTime()` / `.source` + `.flags`
+ * respectively — except when a predicate is used, in which case the predicate
+ * receives the raw `Date` / `RegExp` objects.
+ *
+ * @param a First value to compare
+ * @param b Second value to compare
+ * @param comparisonStrategy The equality comparison strategy to use (default is
+ *   `"strict"`)
+ * @returns True if the values are deeply equal, false otherwise
+ */
+export function isDeepEqual(a, b, comparisonStrategy = "strict") {
+    return deepEqualInternal_(a, b, comparisonStrategy, new WeakMap());
+}
+function deepEqualInternal_(a, b, strategy, seen) {
+    // Null and primitives go straight to leaf comparison
+    if (a === null ||
+        b === null ||
+        typeof a !== "object" ||
+        typeof b !== "object") {
+        return isEqual(a, b, strategy);
+    }
+    // Same reference is always equal regardless of strategy
+    if (a === b)
+        return true;
+    // Cycle detection: seeing the same pair again means we're in a cycle
+    if (seen.get(a) === b)
+        return true;
+    seen.set(a, b);
+    if (isDate(a) || isDate(b)) {
+        if (!isDate(a) || !isDate(b)) {
+            return typeof strategy === "function" && strategy(a, b);
+        }
+        return typeof strategy === "function"
+            ? strategy(a, b)
+            : isEqual(a.getTime(), b.getTime(), strategy);
+    }
+    if (isRegExp(a) || isRegExp(b)) {
+        if (!isRegExp(a) || !isRegExp(b)) {
+            return typeof strategy === "function" && strategy(a, b);
+        }
+        return typeof strategy === "function"
+            ? strategy(a, b)
+            : isEqual(a.source, b.source, strategy) &&
+                isEqual(a.flags, b.flags, strategy);
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b)) {
+            return typeof strategy === "function" && strategy(a, b);
+        }
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqualInternal_(a[i], b[i], strategy, seen))
+                return false;
+        }
+        return true;
+    }
+    if (isMap(a) || isMap(b)) {
+        if (!isMap(a) || !isMap(b)) {
+            return typeof strategy === "function" && strategy(a, b);
+        }
+        if (a.size !== b.size)
+            return false;
+        for (const [key, value] of a) {
+            if (!b.has(key))
+                return false;
+            if (!deepEqualInternal_(value, b.get(key), strategy, seen))
+                return false;
+        }
+        return true;
+    }
+    // O(n²) matching to support unordered Set equality under any strategy
+    if (isSet(a) || isSet(b)) {
+        if (!isSet(a) || !isSet(b)) {
+            return typeof strategy === "function" && strategy(a, b);
+        }
+        if (a.size !== b.size)
+            return false;
+        const unmatched = new Set(b);
+        for (const ea of a) {
+            let found = false;
+            for (const eb of unmatched) {
+                if (deepEqualInternal_(ea, eb, strategy, seen)) {
+                    unmatched.delete(eb);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found)
+                return false;
+        }
+        return true;
+    }
+    if (isPojo(a) && isPojo(b)) {
+        const aKeys = Object.keys(a);
+        if (aKeys.length !== Object.keys(b).length)
+            return false;
+        for (const key of aKeys) {
+            if (!Object.prototype.hasOwnProperty.call(b, key))
+                return false;
+            if (!deepEqualInternal_(a[key], b[key], strategy, seen))
+                return false;
+        }
+        return true;
+    }
+    // Unhandled object types (class instances, etc.)
+    return isEqual(a, b, strategy);
+}
+//# sourceMappingURL=is-deep-equal.js.map

package/dist/object/is-deep-equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-deep-equal.js","sourceRoot":"","sources":["../../src/object/is-deep-equal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAmC,MAAM,eAAe,CAAC;AAEzE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,WAAW,CAC1B,CAAU,EACV,CAAU,EACV,kBAAkB,GAAiD,QAAQ;IAE3E,OAAO,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,kBAAkB,EAAE,IAAI,OAAO,EAAE,CAAC,CAAC;AACpE,CAAC;AAED,SAAS,kBAAkB,CAC1B,CAAU,EACV,CAAU,EACV,QAAsD,EACtD,IAA6B;IAE7B,qDAAqD;IACrD,IACC,CAAC,KAAK,IAAI;QACV,CAAC,KAAK,IAAI;QACV,OAAO,CAAC,KAAK,QAAQ;QACrB,OAAO,CAAC,KAAK,QAAQ,EACpB,CAAC;QACF,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;IAChC,CAAC;IAED,wDAAwD;IACxD,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEzB,qEAAqE;IACrE,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACnC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEf,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5B,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9B,OAAO,OAAO,QAAQ,KAAK,UAAU,IAAI,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACzD,CAAC;QACD,OAAO,OAAO,QAAQ,KAAK,UAAU;YACpC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;YAChB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,QAAQ,CAAC,CAAC;IAChD,CAAC;IAED,IAAI,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QAChC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;YAClC,OAAO,OAAO,QAAQ,KAAK,UAAU,IAAI,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACzD,CAAC;QACD,OAAO,OAAO,QAAQ,KAAK,UAAU;YACpC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;YAChB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,QAAQ,CAAC;gBACrC,OAAO,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACxC,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;YAC5C,OAAO,OAAO,QAAQ,KAAK,UAAU,IAAI,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACzD,CAAC;QACD,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACnC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC;gBAAE,OAAO,KAAK,CAAC;QACnE,CAAC;QACD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1B,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YAC5B,OAAO,OAAO,QAAQ,KAAK,UAAU,IAAI,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACzD,CAAC;QACD,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;YAAE,OAAO,KAAK,CAAC;QACpC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9B,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,OAAO,KAAK,CAAC;YAC9B,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC;gBAAE,OAAO,KAAK,CAAC;QAC1E,CAAC;QACD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,sEAAsE;IACtE,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1B,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YAC5B,OAAO,OAAO,QAAQ,KAAK,UAAU,IAAI,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACzD,CAAC;QACD,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;YAAE,OAAO,KAAK,CAAC;QACpC,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;QAC7B,KAAK,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC;YACpB,IAAI,KAAK,GAAG,KAAK,CAAC;YAClB,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;gBAC5B,IAAI,kBAAkB,CAAC,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,CAAC;oBAChD,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;oBACrB,KAAK,GAAG,IAAI,CAAC;oBACb,MAAM;gBACP,CAAC;YACF,CAAC;YACD,IAAI,CAAC,KAAK;gBAAE,OAAO,KAAK,CAAC;QAC1B,CAAC;QACD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5B,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QACzD,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC;gBAAE,OAAO,KAAK,CAAC;YAChE,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC;gBAAE,OAAO,KAAK,CAAC;QACvE,CAAC;QACD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,iDAAiD;IACjD,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;AAChC,CAAC"}

package/dist/object/is-equal.d.ts

@@ -0,0 +1,110 @@
+import type { Predicate } from "../types/callable.js";
+/**
+ * A type representing well-known equality comparison strategies for item
+ * comparison.
+ *
+ * It can be one of the following string literals:
+ *
+ * - `"loose"`: Uses loose equality (`==`) for comparison. Double equals (==) will
+ *   perform a type conversion when comparing two things, and will handle NaN,
+ *   -0, and +0 specially to conform to IEEE 754 (so NaN != NaN, and -0 == +0)
+ * - `"strict"`: Uses strict equality (`===`) for comparison. Triple equals (===)
+ *   will do the same comparison as double equals (including the special
+ *   handling for NaN, -0, and +0) but without type conversion; if the types
+ *   differ, false is returned.
+ * - `"sameValue"`: Uses `Object.is()` for comparison. Object.is() does no type
+ *   conversion and no special handling for NaN, -0, and +0 (giving it the same
+ *   behavior as === except on those special numeric values).
+ * - `"sameValueZero"`: Uses `Object.is()` but +0 and -0 are considered equal.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Equality_comparisons_and_sameness
+ */
+export type WellKnownEqualityComparisonStrategy = "loose" | "strict" | "sameValue" | "sameValueZero";
+/**
+ * A type representing a function that compares two values for equality.
+ *
+ * The function should return `true` if the values are considered equal, and
+ * `false` otherwise.
+ */
+export type EqualityComparator<A, B> = Predicate<[A, B]>;
+/**
+ * A type representing an equality comparison strategy, which can be either a
+ * well-known strategy or a custom predicate function.
+ */
+export type EqualityComparisonStrategy<A = unknown, B = unknown> = WellKnownEqualityComparisonStrategy | EqualityComparator<A, B>;
+/**
+ * Compare two values for equality using the specified strategy or a custom
+ * predicate.
+ *
+ * @param a The first value to compare
+ * @param b The second value to compare
+ * @param comparisonStrategy The strategy to use for comparison, which can be a
+ *   well-known strategy or a custom predicate function. Defaults to
+ *   `"strict"`.
+ * @returns True if the values are equal, false otherwise
+ */
+export declare function isEqual<A, B>(a: A, b: B, comparisonStrategy?: EqualityComparisonStrategy<A, B>): boolean;
+/**
+ * This is the same as `==`.
+ *
+ * Double equals (==) will perform a type conversion when comparing two things,
+ * and will handle NaN, -0, and +0 specially to conform to IEEE 754 (so NaN !=
+ * NaN, and -0 == +0).
+ */
+export declare function isLooseEqual(a: unknown, b: unknown): boolean;
+/**
+ * This is the same as `===`.
+ *
+ * Triple equals (===) will do the same comparison as double equals (==) but
+ * without type conversion; if the types differ, false is returned. It also
+ * handles NaN, -0, and +0 specially to conform to IEEE 754 (so NaN != NaN, and
+ * -0 == +0).
+ */
+export declare function isStrictEqual(a: unknown, b: unknown): boolean;
+/**
+ * This is the same as `Object.is()`.
+ *
+ * Object.is() determines whether two values are the same value. Two values are
+ * the same if one of the following holds:
+ *
+ * - Both values are undefined.
+ * - Both values are null.
+ * - Both values are true or both values are false.
+ * - Both values are strings of the same length with the same characters in the
+ *   same order.
+ * - Both values are the same object (meaning both values reference the same
+ *   object in memory).
+ * - Both values are numbers and either both are +0, both are -0, both are NaN, or
+ *   both are non-zero and have the same value.
+ */
+export declare function isSameValueEqual(a: unknown, b: unknown): boolean;
+/**
+ * This is the same as `Object.is()` except that +0 and -0 are considered equal.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Equality_comparisons_and_sameness#same-value-zero_equality
+ */
+export declare function isSameValueZeroEqual(a: unknown, b: unknown): boolean;
+/**
+ * Resolves an {@link EqualityComparisonStrategy} to the comparator it names,
+ * once, so a per-element caller does not re-dispatch the string on every
+ * comparison.
+ *
+ * {@link isEqual} re-reads `comparisonStrategy` and re-enters its `switch` per
+ * call, which is fine for a one-shot comparison and wrong inside a loop that
+ * runs once per element. Resolve at construction (or at the top of the
+ * operation) and call the result.
+ *
+ * @example
+ * 	```ts
+ *      const equals = resolveEqualityComparator(options.comparisonStrategy);
+ *      for (let i = 0; i < items.length; i++) {
+ *              if (equals(items[i]!, needle)) return i;
+ *      }
+ *      ```;
+ *
+ * @param comparisonStrategy The strategy to resolve. Defaults to `"strict"`.
+ * @returns The comparator. A custom predicate is returned as-is; a well-known
+ *   strategy resolves to a shared function, never a fresh closure.
+ */
+export declare function resolveEqualityComparator<A, B>(comparisonStrategy?: EqualityComparisonStrategy<A, B>): EqualityComparator<A, B>;
+//# sourceMappingURL=is-equal.d.ts.map

package/dist/object/is-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-equal.d.ts","sourceRoot":"","sources":["../../src/object/is-equal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,mCAAmC,GAC5C,OAAO,GACP,QAAQ,GACR,WAAW,GACX,eAAe,CAAC;AAEnB;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEzD;;;GAGG;AACH,MAAM,MAAM,0BAA0B,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,IAC5D,mCAAmC,GACnC,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE5B;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC3B,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,CAAC,EACJ,kBAAkB,GAAE,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAY,GAC7D,OAAO,CAMT;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAE5D;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAMpE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,CAAC,EAC7C,kBAAkB,GAAE,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAY,GAC7D,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAe1B"}

package/dist/object/is-equal.js

@@ -0,0 +1,107 @@
+/**
+ * Compare two values for equality using the specified strategy or a custom
+ * predicate.
+ *
+ * @param a The first value to compare
+ * @param b The second value to compare
+ * @param comparisonStrategy The strategy to use for comparison, which can be a
+ *   well-known strategy or a custom predicate function. Defaults to
+ *   `"strict"`.
+ * @returns True if the values are equal, false otherwise
+ */
+export function isEqual(a, b, comparisonStrategy = "strict") {
+    if (typeof comparisonStrategy === "function") {
+        return comparisonStrategy(a, b);
+    }
+    return resolveEqualityComparator(comparisonStrategy)(a, b);
+}
+/**
+ * This is the same as `==`.
+ *
+ * Double equals (==) will perform a type conversion when comparing two things,
+ * and will handle NaN, -0, and +0 specially to conform to IEEE 754 (so NaN !=
+ * NaN, and -0 == +0).
+ */
+export function isLooseEqual(a, b) {
+    return a == b;
+}
+/**
+ * This is the same as `===`.
+ *
+ * Triple equals (===) will do the same comparison as double equals (==) but
+ * without type conversion; if the types differ, false is returned. It also
+ * handles NaN, -0, and +0 specially to conform to IEEE 754 (so NaN != NaN, and
+ * -0 == +0).
+ */
+export function isStrictEqual(a, b) {
+    return a === b;
+}
+/**
+ * This is the same as `Object.is()`.
+ *
+ * Object.is() determines whether two values are the same value. Two values are
+ * the same if one of the following holds:
+ *
+ * - Both values are undefined.
+ * - Both values are null.
+ * - Both values are true or both values are false.
+ * - Both values are strings of the same length with the same characters in the
+ *   same order.
+ * - Both values are the same object (meaning both values reference the same
+ *   object in memory).
+ * - Both values are numbers and either both are +0, both are -0, both are NaN, or
+ *   both are non-zero and have the same value.
+ */
+export function isSameValueEqual(a, b) {
+    return Object.is(a, b);
+}
+/**
+ * This is the same as `Object.is()` except that +0 and -0 are considered equal.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Equality_comparisons_and_sameness#same-value-zero_equality
+ */
+export function isSameValueZeroEqual(a, b) {
+    if (typeof a === "number" && typeof b === "number") {
+        // a and b are equal (may be -0 and 0) or they are both NaN
+        return a === b || (a !== a && b !== b);
+    }
+    return a === b;
+}
+/**
+ * Resolves an {@link EqualityComparisonStrategy} to the comparator it names,
+ * once, so a per-element caller does not re-dispatch the string on every
+ * comparison.
+ *
+ * {@link isEqual} re-reads `comparisonStrategy` and re-enters its `switch` per
+ * call, which is fine for a one-shot comparison and wrong inside a loop that
+ * runs once per element. Resolve at construction (or at the top of the
+ * operation) and call the result.
+ *
+ * @example
+ * 	```ts
+ *      const equals = resolveEqualityComparator(options.comparisonStrategy);
+ *      for (let i = 0; i < items.length; i++) {
+ *              if (equals(items[i]!, needle)) return i;
+ *      }
+ *      ```;
+ *
+ * @param comparisonStrategy The strategy to resolve. Defaults to `"strict"`.
+ * @returns The comparator. A custom predicate is returned as-is; a well-known
+ *   strategy resolves to a shared function, never a fresh closure.
+ */
+export function resolveEqualityComparator(comparisonStrategy = "strict") {
+    if (typeof comparisonStrategy === "function") {
+        return comparisonStrategy;
+    }
+    switch (comparisonStrategy) {
+        case "loose":
+            return isLooseEqual;
+        case "strict":
+            return isStrictEqual;
+        case "sameValue":
+            return isSameValueEqual;
+        case "sameValueZero":
+            return isSameValueZeroEqual;
+    }
+}
+//# sourceMappingURL=is-equal.js.map

package/dist/object/is-equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-equal.js","sourceRoot":"","sources":["../../src/object/is-equal.ts"],"names":[],"mappings":"AA4CA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,OAAO,CACtB,CAAI,EACJ,CAAI,EACJ,kBAAkB,GAAqC,QAAQ;IAE/D,IAAI,OAAO,kBAAkB,KAAK,UAAU,EAAE,CAAC;QAC9C,OAAO,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACjC,CAAC;IAED,OAAO,yBAAyB,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,CAAU,EAAE,CAAU;IAClD,OAAO,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,CAAU,EAAE,CAAU;IACnD,OAAO,CAAC,KAAK,CAAC,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,gBAAgB,CAAC,CAAU,EAAE,CAAU;IACtD,OAAO,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACxB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,CAAU,EAAE,CAAU;IAC1D,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QACpD,2DAA2D;QAC3D,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,CAAC,KAAK,CAAC,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,yBAAyB,CACxC,kBAAkB,GAAqC,QAAQ;IAE/D,IAAI,OAAO,kBAAkB,KAAK,UAAU,EAAE,CAAC;QAC9C,OAAO,kBAAkB,CAAC;IAC3B,CAAC;IAED,QAAQ,kBAAkB,EAAE,CAAC;QAC5B,KAAK,OAAO;YACX,OAAO,YAAY,CAAC;QACrB,KAAK,QAAQ;YACZ,OAAO,aAAa,CAAC;QACtB,KAAK,WAAW;YACf,OAAO,gBAAgB,CAAC;QACzB,KAAK,eAAe;YACnB,OAAO,oBAAoB,CAAC;IAC9B,CAAC;AACF,CAAC"}

package/dist/object/merge-inplace.d.ts

@@ -0,0 +1,34 @@
+import type { Merge, MergeDeep } from "type-fest";
+import { type MergedSources, type MergeOptions } from "./merge-options.js";
+/**
+ * Merge `source` into `target`, modifying it.
+ *
+ * Shallow by default: a key present in both takes the source's value whole.
+ * With `recursive`, two mergeable values are merged instead — see
+ * {@link MergeOptions.recursive} for what that costs.
+ *
+ * @param target Value to merge into; modified when it is mergeable
+ * @param source Value to merge from
+ * @param options Merge options
+ * @returns `target` where it could be merged into, otherwise the source value
+ */
+export declare function mergeInplace<T, U, R extends Merge<T, U>>(target: T, source: U, options?: MergeOptions & {
+    recursive?: false;
+}): R;
+export declare function mergeInplace<T, U, R extends MergeDeep<T, U>>(target: T, source: U, options: MergeOptions & {
+    recursive: true;
+}): R;
+/**
+ * Fold several sources into `target`, each merged over the one before it.
+ *
+ * Options are resolved once for the whole fold, where a chain of binary
+ * {@link mergeInplace} calls resolves them per step.
+ *
+ * @param target Value to merge into; modified when it is mergeable
+ * @param sources Values to merge, lowest priority first
+ * @param options Merge options
+ * @returns `target` where it could be merged into, otherwise the last value
+ *   that replaced it
+ */
+export declare function mergeAllInplace<TTarget, TSources extends readonly unknown[]>(target: TTarget, sources: TSources, options?: MergeOptions): TTarget & MergedSources<TSources>;
+//# sourceMappingURL=merge-inplace.d.ts.map

package/dist/object/merge-inplace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-inplace.d.ts","sourceRoot":"","sources":["../../src/object/merge-inplace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAOlD,OAAO,EAEN,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,MAAM,oBAAoB,CAAC;AA4B5B;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EACvD,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,CAAC,EACT,OAAO,CAAC,EAAE,YAAY,GAAG;IAAE,SAAS,CAAC,EAAE,KAAK,CAAA;CAAE,GAC5C,CAAC,CAAC;AACL,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAC3D,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,YAAY,GAAG;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,GACzC,CAAC,CAAC;AASL;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,QAAQ,SAAS,SAAS,OAAO,EAAE,EAC3E,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,YAAY,GACpB,OAAO,GAAG,aAAa,CAAC,QAAQ,CAAC,CASnC"}