@vinicunca/perkakas 1.7.1 → 1.9.0

package/dist/is-plain-object-CDsM3KdY.d.ts

@@ -0,0 +1,33 @@
+import { NarrowedTo } from "./narrowed-to-BLLrlAhb.js";
+
+//#region src/is-plain-object.d.ts
+
+/**
+ * Checks if `data` is a "plain" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.
+ *
+ * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `"object"` by JavaScript's `typeof`.
+ *
+ * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.
+ *
+ * @param data - The variable to check.
+ * @returns The input type, narrowed to only plain objects.
+ * @signature
+ *    P.isPlainObject(data)
+ * @example
+ *    // true
+ *    P.isPlainObject({}) //=> true
+ *    P.isPlainObject({ a: 123 }) //=> true
+ *
+ *    // false
+ *    P.isPlainObject([]) //=> false
+ *    P.isPlainObject(Promise.resolve("something")) //=> false
+ *    P.isPlainObject(new Date()) //=> false
+ *    P.isPlainObject(new Error("error")) //=> false
+ *    P.isPlainObject('somethingElse') //=> false
+ *    P.isPlainObject(null) //=> false
+ * @category Guard
+ */
+declare function isPlainObject<T>(data: Readonly<Record<PropertyKey, unknown>> | T): data is NarrowedTo<T, Record<PropertyKey, unknown>>;
+//#endregion
+export { isPlainObject };
+//# sourceMappingURL=is-plain-object-CDsM3KdY.d.ts.map

package/dist/is-plain-object-CDsM3KdY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object-CDsM3KdY.d.ts","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,uBACR,SAAS,OAAO,yBAAyB,YACtC,WAAW,GAAG,OAAO"}

package/dist/is-plain-object-D0HZzwPq.cjs

@@ -0,0 +1 @@
+function e(e){if(typeof e!=`object`||!e)return!1;let t=Object.getPrototypeOf(e);return t===null||t===Object.prototype}Object.defineProperty(exports,`isPlainObject`,{enumerable:!0,get:function(){return e}});

package/dist/is-plain-object-DOXTHODS.js

@@ -0,0 +1,2 @@
+function e(e){if(typeof e!=`object`||!e)return!1;let t=Object.getPrototypeOf(e);return t===null||t===Object.prototype}export{e as isPlainObject};
+//# sourceMappingURL=is-plain-object-DOXTHODS.js.map

package/dist/is-plain-object-DOXTHODS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object-DOXTHODS.js","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if `data` is a \"plain\" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.\n *\n * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `\"object\"` by JavaScript's `typeof`.\n *\n * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.\n *\n * @param data - The variable to check.\n * @returns The input type, narrowed to only plain objects.\n * @signature\n *    P.isPlainObject(data)\n * @example\n *    // true\n *    P.isPlainObject({}) //=> true\n *    P.isPlainObject({ a: 123 }) //=> true\n *\n *    // false\n *    P.isPlainObject([]) //=> false\n *    P.isPlainObject(Promise.resolve(\"something\")) //=> false\n *    P.isPlainObject(new Date()) //=> false\n *    P.isPlainObject(new Error(\"error\")) //=> false\n *    P.isPlainObject('somethingElse') //=> false\n *    P.isPlainObject(null) //=> false\n * @category Guard\n */\nexport function isPlainObject<T>(\n  data: Readonly<Record<PropertyKey, unknown>> | T,\n): data is NarrowedTo<T, Record<PropertyKey, unknown>> {\n  if (typeof data !== 'object' || data === null) {\n    return false;\n  }\n\n  const proto = Object.getPrototypeOf(data);\n  return proto === null || proto === Object.prototype;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EACqD,CACrD,GAAI,OAAO,GAAS,WAAY,EAC9B,MAAO,GAGT,IAAM,EAAQ,OAAO,eAAe,EAAK,CACzC,OAAO,IAAU,MAAQ,IAAU,OAAO"}

package/dist/is-plain-object-DecAYLun.d.cts

@@ -0,0 +1,33 @@
+import { NarrowedTo } from "./narrowed-to-BTrqm7Xt.cjs";
+
+//#region src/is-plain-object.d.ts
+
+/**
+ * Checks if `data` is a "plain" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.
+ *
+ * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `"object"` by JavaScript's `typeof`.
+ *
+ * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.
+ *
+ * @param data - The variable to check.
+ * @returns The input type, narrowed to only plain objects.
+ * @signature
+ *    P.isPlainObject(data)
+ * @example
+ *    // true
+ *    P.isPlainObject({}) //=> true
+ *    P.isPlainObject({ a: 123 }) //=> true
+ *
+ *    // false
+ *    P.isPlainObject([]) //=> false
+ *    P.isPlainObject(Promise.resolve("something")) //=> false
+ *    P.isPlainObject(new Date()) //=> false
+ *    P.isPlainObject(new Error("error")) //=> false
+ *    P.isPlainObject('somethingElse') //=> false
+ *    P.isPlainObject(null) //=> false
+ * @category Guard
+ */
+declare function isPlainObject<T>(data: Readonly<Record<PropertyKey, unknown>> | T): data is NarrowedTo<T, Record<PropertyKey, unknown>>;
+//#endregion
+export { isPlainObject };
+//# sourceMappingURL=is-plain-object-DecAYLun.d.cts.map

package/dist/is-plain-object-DecAYLun.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object-DecAYLun.d.cts","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,uBACR,SAAS,OAAO,yBAAyB,YACtC,WAAW,GAAG,OAAO"}

package/dist/is-plain-object.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk7HFKYJCKcjs = require('./chunk-7HFKYJCK.cjs');require('./chunk-MBGSSEZN.cjs');exports.isPlainObject = _chunk7HFKYJCKcjs.a;
+const e=require(`./is-plain-object-D0HZzwPq.cjs`);exports.isPlainObject=e.isPlainObject;

package/dist/is-plain-object.d.cts

@@ -1,31 +1,3 @@
-import { N as NarrowedTo } from './narrowed-to-CDIykNaN.cjs';
-import 'type-fest';
-
-/**
- * Checks if `data` is a "plain" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.
- *
- * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `"object"` by JavaScript's `typeof`.
- *
- * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.
- *
- * @param data - The variable to check.
- * @returns The input type, narrowed to only plain objects.
- * @signature
- *    P.isPlainObject(data)
- * @example
- *    // true
- *    P.isPlainObject({}) //=> true
- *    P.isPlainObject({ a: 123 }) //=> true
- *
- *    // false
- *    P.isPlainObject([]) //=> false
- *    P.isPlainObject(Promise.resolve("something")) //=> false
- *    P.isPlainObject(new Date()) //=> false
- *    P.isPlainObject(new Error("error")) //=> false
- *    P.isPlainObject('somethingElse') //=> false
- *    P.isPlainObject(null) //=> false
- * @category Guard
- */
-declare function isPlainObject<T>(data: Readonly<Record<PropertyKey, unknown>> | T): data is NarrowedTo<T, Record<PropertyKey, unknown>>;
-
-export { isPlainObject };
+import "./narrowed-to-BTrqm7Xt.cjs";
+import { isPlainObject } from "./is-plain-object-DecAYLun.cjs";
+export { isPlainObject };

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

@@ -1,31 +1,3 @@
-import { N as NarrowedTo } from './narrowed-to-CDIykNaN.js';
-import 'type-fest';
-
-/**
- * Checks if `data` is a "plain" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.
- *
- * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `"object"` by JavaScript's `typeof`.
- *
- * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.
- *
- * @param data - The variable to check.
- * @returns The input type, narrowed to only plain objects.
- * @signature
- *    P.isPlainObject(data)
- * @example
- *    // true
- *    P.isPlainObject({}) //=> true
- *    P.isPlainObject({ a: 123 }) //=> true
- *
- *    // false
- *    P.isPlainObject([]) //=> false
- *    P.isPlainObject(Promise.resolve("something")) //=> false
- *    P.isPlainObject(new Date()) //=> false
- *    P.isPlainObject(new Error("error")) //=> false
- *    P.isPlainObject('somethingElse') //=> false
- *    P.isPlainObject(null) //=> false
- * @category Guard
- */
-declare function isPlainObject<T>(data: Readonly<Record<PropertyKey, unknown>> | T): data is NarrowedTo<T, Record<PropertyKey, unknown>>;
-
-export { isPlainObject };
+import "./narrowed-to-BLLrlAhb.js";
+import { isPlainObject } from "./is-plain-object-CDsM3KdY.js";
+export { isPlainObject };

package/dist/is-plain-object.js

@@ -1 +1 @@
-import{a}from"./chunk-6AFNPQW2.js";import"./chunk-EK7ODJWE.js";export{a as isPlainObject};
+import{isPlainObject as e}from"./is-plain-object-DOXTHODS.js";export{e as isPlainObject};

package/dist/is-promise-BpAIAlCO.d.ts

@@ -0,0 +1,18 @@
+//#region src/is-promise.d.ts
+/**
+ * A function that checks if the passed parameter is a Promise and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a Promise, false otherwise.
+ * @signature
+ *    P.isPromise(data)
+ * @example
+ *    P.isPromise(Promise.resolve(5)) //=> true
+ *    P.isPromise(Promise.reject(5)) //=> true
+ *    P.isPromise('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isPromise<T, S>(data: Promise<T> | S): data is Promise<T>;
+//#endregion
+export { isPromise };
+//# sourceMappingURL=is-promise-BpAIAlCO.d.ts.map

package/dist/is-promise-BpAIAlCO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-promise-BpAIAlCO.d.ts","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;;;;;;;iBAAgB,sBAAsB,QAAQ,KAAK,YAAY,QAAQ"}

package/dist/is-promise-DKPEFNFZ.js

@@ -0,0 +1,2 @@
+function e(e){return e instanceof Promise}export{e as isPromise};
+//# sourceMappingURL=is-promise-DKPEFNFZ.js.map

package/dist/is-promise-DKPEFNFZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-promise-DKPEFNFZ.js","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is a Promise and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Promise, false otherwise.\n * @signature\n *    P.isPromise(data)\n * @example\n *    P.isPromise(Promise.resolve(5)) //=> true\n *    P.isPromise(Promise.reject(5)) //=> true\n *    P.isPromise('somethingElse') //=> false\n * @category Guard\n */\nexport function isPromise<T, S>(data: Promise<T> | S): data is Promise<T> {\n  return data instanceof Promise;\n}\n"],"mappings":"AAaA,SAAgB,EAAgB,EAA0C,CACxE,OAAO,aAAgB"}

package/dist/is-promise-DRSq5wEE.cjs

@@ -0,0 +1 @@
+function e(e){return e instanceof Promise}Object.defineProperty(exports,`isPromise`,{enumerable:!0,get:function(){return e}});

package/dist/is-promise-saPDFGFp.d.cts

@@ -0,0 +1,18 @@
+//#region src/is-promise.d.ts
+/**
+ * A function that checks if the passed parameter is a Promise and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a Promise, false otherwise.
+ * @signature
+ *    P.isPromise(data)
+ * @example
+ *    P.isPromise(Promise.resolve(5)) //=> true
+ *    P.isPromise(Promise.reject(5)) //=> true
+ *    P.isPromise('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isPromise<T, S>(data: Promise<T> | S): data is Promise<T>;
+//#endregion
+export { isPromise };
+//# sourceMappingURL=is-promise-saPDFGFp.d.cts.map

package/dist/is-promise-saPDFGFp.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-promise-saPDFGFp.d.cts","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;;;;;;;iBAAgB,sBAAsB,QAAQ,KAAK,YAAY,QAAQ"}

package/dist/is-promise.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkWM4KSO6Ccjs = require('./chunk-WM4KSO6C.cjs');require('./chunk-MBGSSEZN.cjs');exports.isPromise = _chunkWM4KSO6Ccjs.a;
+const e=require(`./is-promise-DRSq5wEE.cjs`);exports.isPromise=e.isPromise;

package/dist/is-promise.d.cts

@@ -1,16 +1,2 @@
-/**
- * A function that checks if the passed parameter is a Promise and narrows its type accordingly.
- *
- * @param data - The variable to check.
- * @returns True if the passed input is a Promise, false otherwise.
- * @signature
- *    P.isPromise(data)
- * @example
- *    P.isPromise(Promise.resolve(5)) //=> true
- *    P.isPromise(Promise.reject(5)) //=> true
- *    P.isPromise('somethingElse') //=> false
- * @category Guard
- */
-declare function isPromise<T, S>(data: Promise<T> | S): data is Promise<T>;
-
-export { isPromise };
+import { isPromise } from "./is-promise-saPDFGFp.cjs";
+export { isPromise };

package/dist/is-promise.d.ts

@@ -1,16 +1,2 @@
-/**
- * A function that checks if the passed parameter is a Promise and narrows its type accordingly.
- *
- * @param data - The variable to check.
- * @returns True if the passed input is a Promise, false otherwise.
- * @signature
- *    P.isPromise(data)
- * @example
- *    P.isPromise(Promise.resolve(5)) //=> true
- *    P.isPromise(Promise.reject(5)) //=> true
- *    P.isPromise('somethingElse') //=> false
- * @category Guard
- */
-declare function isPromise<T, S>(data: Promise<T> | S): data is Promise<T>;
-
-export { isPromise };
+import { isPromise } from "./is-promise-BpAIAlCO.js";
+export { isPromise };

package/dist/is-promise.js

@@ -1 +1 @@
-import{a}from"./chunk-HFNVS6OX.js";import"./chunk-EK7ODJWE.js";export{a as isPromise};
+import{isPromise as e}from"./is-promise-DKPEFNFZ.js";export{e as isPromise};

package/dist/is-shallow-equal-B3YqLsBe.d.cts

@@ -0,0 +1,71 @@
+//#region src/is-shallow-equal.d.ts
+/**
+ * Performs a *shallow structural* comparison between two values to determine if
+ * they are equivalent. For primitive values this is equivalent to `===`, for
+ * arrays a **strict equality** check would be performed on every item, in
+ * order, and for objects props will be matched and checked for **strict
+ * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
+ * item and value.
+ *
+ * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they
+ * are semantically different (e.g. resolved promises); but `isDeepEqual` does
+ * compare the latter 2 semantically by-value.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isStrictEqual` if you don't need a deep comparison and just want to check
+ * for simple (`===`, `Object.is`) equality.
+ * - `isDeepEqual` for a recursively deep check of arrays and objects.
+ *
+ * @param data - The first value to compare.
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isShallowEqual(data, other)
+ * @example
+ *    P.isShallowEqual(1, 1) //=> true
+ *    P.isShallowEqual(1, '1') //=> false
+ *    P.isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true
+ *    P.isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false
+ * @dataFirst
+ * @category Guard
+ */
+declare function isShallowEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
+declare function isShallowEqual<T, S extends T = T>(data: T, other: S): boolean;
+/**
+ * Performs a *shallow structural* comparison between two values to determine if
+ * they are equivalent. For primitive values this is equivalent to `===`, for
+ * arrays a **strict equality** check would be performed on every item, in
+ * order, and for objects props will be matched and checked for **strict
+ * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
+ * item and value.
+ *
+ * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,
+ * even when they are semantically different (e.g. resolved promises). Use
+ * `isDeepEqual` instead.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isStrictEqual` if you don't need a deep comparison and just want to check
+ * for simple (`===`, `Object.is`) equality.
+ * - `isDeepEqual` for a recursively deep check of arrays and objects.
+ *
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isShallowEqual(other)(data)
+ * @example
+ *    P.pipe(1, P.isShallowEqual(1)) //=> true
+ *    P.pipe(1, P.isShallowEqual('1')) //=> false
+ *    P.pipe([1, 2, 3], P.isShallowEqual([1, 2, 3])) //=> true
+ *    P.pipe([[1], [2], [3]], P.isShallowEqual([[1], [2], [3]])) //=> false
+ * @dataFirst
+ * @category Guard
+ */
+declare function isShallowEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
+declare function isShallowEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
+//#endregion
+export { isShallowEqual };
+//# sourceMappingURL=is-shallow-equal-B3YqLsBe.d.cts.map

package/dist/is-shallow-equal-B3YqLsBe.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-shallow-equal-B3YqLsBe.d.cts","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":[],"mappings":";;AAkCA;;;;;;;;;;;AAIA;;;;;;;AAiCA;;;;;;;;;;;AAGA;;AACS,iBAzCO,cAyCP,CAAA,CAAA,EAAA,UAzCmC,CAyCnC,CAAA,CAAA,IAAA,EAxCD,CAwCC,EAAA,KAAA,EAvCA,CAuCA,SAvCU,OAuCV,CAvCkB,CAuClB,EAvCqB,CAuCrB,CAAA,GAvC0B,CAuC1B,GAAA,KAAA,CAAA,EAAA,IAAA,IAtCE,CAsCF;AACK,iBAtCE,cAsCF,CAAA,CAAA,EAAA,UAtC8B,CAsC9B,GAtCkC,CAsClC,CAAA,CAAA,IAAA,EAtC2C,CAsC3C,EAAA,KAAA,EAtCqD,CAsCrD,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBALE,4BAA4B,UACnC,UAAU,QAAQ,GAAG,KAAK,mBACzB,cAAc;iBACR,yBACP,eACK,IAAI,SAAS"}

package/dist/is-shallow-equal-DNhuWvj5.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;if(e instanceof Map&&t instanceof Map)return r(e,t);if(e instanceof Set&&t instanceof Set)return i(e,t);let n=Object.keys(e);if(n.length!==Object.keys(t).length)return!1;for(let r of n){if(!Object.prototype.hasOwnProperty.call(t,r))return!1;let{[r]:n}=e,{[r]:i}=t;if(n!==i||!Object.is(n,i))return!1}return!0}function r(e,t){if(e.size!==t.size)return!1;for(let[n,r]of e){let e=t.get(n);if(r!==e||!Object.is(r,e))return!1}return!0}function i(e,t){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}Object.defineProperty(exports,`isShallowEqual`,{enumerable:!0,get:function(){return t}});

package/dist/is-shallow-equal-Dayqg3hM.d.ts

@@ -0,0 +1,71 @@
+//#region src/is-shallow-equal.d.ts
+/**
+ * Performs a *shallow structural* comparison between two values to determine if
+ * they are equivalent. For primitive values this is equivalent to `===`, for
+ * arrays a **strict equality** check would be performed on every item, in
+ * order, and for objects props will be matched and checked for **strict
+ * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
+ * item and value.
+ *
+ * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they
+ * are semantically different (e.g. resolved promises); but `isDeepEqual` does
+ * compare the latter 2 semantically by-value.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isStrictEqual` if you don't need a deep comparison and just want to check
+ * for simple (`===`, `Object.is`) equality.
+ * - `isDeepEqual` for a recursively deep check of arrays and objects.
+ *
+ * @param data - The first value to compare.
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isShallowEqual(data, other)
+ * @example
+ *    P.isShallowEqual(1, 1) //=> true
+ *    P.isShallowEqual(1, '1') //=> false
+ *    P.isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true
+ *    P.isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false
+ * @dataFirst
+ * @category Guard
+ */
+declare function isShallowEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
+declare function isShallowEqual<T, S extends T = T>(data: T, other: S): boolean;
+/**
+ * Performs a *shallow structural* comparison between two values to determine if
+ * they are equivalent. For primitive values this is equivalent to `===`, for
+ * arrays a **strict equality** check would be performed on every item, in
+ * order, and for objects props will be matched and checked for **strict
+ * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
+ * item and value.
+ *
+ * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,
+ * even when they are semantically different (e.g. resolved promises). Use
+ * `isDeepEqual` instead.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isStrictEqual` if you don't need a deep comparison and just want to check
+ * for simple (`===`, `Object.is`) equality.
+ * - `isDeepEqual` for a recursively deep check of arrays and objects.
+ *
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isShallowEqual(other)(data)
+ * @example
+ *    P.pipe(1, P.isShallowEqual(1)) //=> true
+ *    P.pipe(1, P.isShallowEqual('1')) //=> false
+ *    P.pipe([1, 2, 3], P.isShallowEqual([1, 2, 3])) //=> true
+ *    P.pipe([[1], [2], [3]], P.isShallowEqual([[1], [2], [3]])) //=> false
+ * @dataFirst
+ * @category Guard
+ */
+declare function isShallowEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
+declare function isShallowEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
+//#endregion
+export { isShallowEqual };
+//# sourceMappingURL=is-shallow-equal-Dayqg3hM.d.ts.map

package/dist/is-shallow-equal-Dayqg3hM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-shallow-equal-Dayqg3hM.d.ts","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":[],"mappings":";;AAkCA;;;;;;;;;;;AAIA;;;;;;;AAiCA;;;;;;;;;;;AAGA;;AACS,iBAzCO,cAyCP,CAAA,CAAA,EAAA,UAzCmC,CAyCnC,CAAA,CAAA,IAAA,EAxCD,CAwCC,EAAA,KAAA,EAvCA,CAuCA,SAvCU,OAuCV,CAvCkB,CAuClB,EAvCqB,CAuCrB,CAAA,GAvC0B,CAuC1B,GAAA,KAAA,CAAA,EAAA,IAAA,IAtCE,CAsCF;AACK,iBAtCE,cAsCF,CAAA,CAAA,EAAA,UAtC8B,CAsC9B,GAtCkC,CAsClC,CAAA,CAAA,IAAA,EAtC2C,CAsC3C,EAAA,KAAA,EAtCqD,CAsCrD,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBALE,4BAA4B,UACnC,UAAU,QAAQ,GAAG,KAAK,mBACzB,cAAc;iBACR,yBACP,eACK,IAAI,SAAS"}

package/dist/is-shallow-equal-jy-Wc8By.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;if(e instanceof Map&&t instanceof Map)return r(e,t);if(e instanceof Set&&t instanceof Set)return i(e,t);let n=Object.keys(e);if(n.length!==Object.keys(t).length)return!1;for(let r of n){if(!Object.prototype.hasOwnProperty.call(t,r))return!1;let{[r]:n}=e,{[r]:i}=t;if(n!==i||!Object.is(n,i))return!1}return!0}function r(e,t){if(e.size!==t.size)return!1;for(let[n,r]of e){let e=t.get(n);if(r!==e||!Object.is(r,e))return!1}return!0}function i(e,t){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}export{t as isShallowEqual};
+//# sourceMappingURL=is-shallow-equal-jy-Wc8By.js.map

package/dist/is-shallow-equal-jy-Wc8By.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-shallow-equal-jy-Wc8By.js","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they\n * are semantically different (e.g. resolved promises); but `isDeepEqual` does\n * compare the latter 2 semantically by-value.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    P.isShallowEqual(data, other)\n * @example\n *    P.isShallowEqual(1, 1) //=> true\n *    P.isShallowEqual(1, '1') //=> false\n *    P.isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true\n *    P.isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isShallowEqual<T, S extends T = T>(data: T, other: S): boolean;\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,\n * even when they are semantically different (e.g. resolved promises). Use\n * `isDeepEqual` instead.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param other - The second value to compare.\n * @signature\n *    P.isShallowEqual(other)(data)\n * @example\n *    P.pipe(1, P.isShallowEqual(1)) //=> true\n *    P.pipe(1, P.isShallowEqual('1')) //=> false\n *    P.pipe([1, 2, 3], P.isShallowEqual([1, 2, 3])) //=> true\n *    P.pipe([[1], [2], [3]], P.isShallowEqual([[1], [2], [3]])) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isShallowEqual<S>(\n  other: S,\n): <T extends S = S>(data: T) => boolean;\n\nexport function isShallowEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isShallowEqualImplementation, args);\n}\n\nfunction isShallowEqualImplementation<T>(a: T, b: T): boolean {\n  if (a === b || Object.is(a, b)) {\n    return true;\n  }\n\n  if (\n    typeof a !== 'object'\n    || a === null\n    || typeof b !== 'object'\n    || b === null\n  ) {\n    return false;\n  }\n\n  if (a instanceof Map && b instanceof Map) {\n    return isMapShallowEqual(a, b);\n  }\n\n  if (a instanceof Set && b instanceof Set) {\n    return isSetShallowEqual(a, b);\n  }\n\n  const keys = Object.keys(a);\n  if (keys.length !== Object.keys(b).length) {\n    return false;\n  }\n\n  for (const key of keys) {\n    if (!Object.prototype.hasOwnProperty.call(b, key)) {\n      return false;\n    }\n\n    const { [key as keyof T]: valueA } = a;\n    const { [key as keyof T]: valueB } = b;\n\n    if (valueA !== valueB || !Object.is(valueA, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isMapShallowEqual(\n  a: ReadonlyMap<unknown, unknown>,\n  b: ReadonlyMap<unknown, unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const [key, value] of a) {\n    const valueB = b.get(key);\n    if (value !== valueB || !Object.is(value, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isSetShallowEqual(\n  a: ReadonlySet<unknown>,\n  b: ReadonlySet<unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const value of a) {\n    if (!b.has(value)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"4CA8EA,SAAgB,EAAe,GAAG,EAAuC,CACvE,OAAO,EAAM,EAA8B,EAAK,CAGlD,SAAS,EAAgC,EAAM,EAAe,CAC5D,GAAI,IAAM,GAAK,OAAO,GAAG,EAAG,EAAE,CAC5B,MAAO,GAGT,GACE,OAAO,GAAM,WACV,GACA,OAAO,GAAM,WACb,EAEH,MAAO,GAGT,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,IAAM,EAAO,OAAO,KAAK,EAAE,CAC3B,GAAI,EAAK,SAAW,OAAO,KAAK,EAAE,CAAC,OACjC,MAAO,GAGT,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,CAAC,OAAO,UAAU,eAAe,KAAK,EAAG,EAAI,CAC/C,MAAO,GAGT,GAAM,EAAG,GAAiB,GAAW,EAC/B,EAAG,GAAiB,GAAW,EAErC,GAAI,IAAW,GAAU,CAAC,OAAO,GAAG,EAAQ,EAAO,CACjD,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,GAAM,CAAC,EAAK,KAAU,EAAG,CAC5B,IAAM,EAAS,EAAE,IAAI,EAAI,CACzB,GAAI,IAAU,GAAU,CAAC,OAAO,GAAG,EAAO,EAAO,CAC/C,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,IAAM,KAAS,EAClB,GAAI,CAAC,EAAE,IAAI,EAAM,CACf,MAAO,GAIX,MAAO"}

package/dist/is-shallow-equal.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk7Y6PT4GTcjs = require('./chunk-7Y6PT4GT.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.isShallowEqual = _chunk7Y6PT4GTcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./is-shallow-equal-DNhuWvj5.cjs`);exports.isShallowEqual=e.isShallowEqual;

package/dist/is-shallow-equal.d.cts

@@ -1,69 +1,2 @@
-/**
- * Performs a *shallow structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays a **strict equality** check would be performed on every item, in
- * order, and for objects props will be matched and checked for **strict
- * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
- * item and value.
- *
- * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they
- * are semantically different (e.g. resolved promises); but `isDeepEqual` does
- * compare the latter 2 semantically by-value.
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isStrictEqual` if you don't need a deep comparison and just want to check
- * for simple (`===`, `Object.is`) equality.
- * - `isDeepEqual` for a recursively deep check of arrays and objects.
- *
- * @param data - The first value to compare.
- * @param other - The second value to compare.
- * @signature
- *    P.isShallowEqual(data, other)
- * @example
- *    P.isShallowEqual(1, 1) //=> true
- *    P.isShallowEqual(1, '1') //=> false
- *    P.isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true
- *    P.isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false
- * @dataFirst
- * @category Guard
- */
-declare function isShallowEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
-declare function isShallowEqual<T, S extends T = T>(data: T, other: S): boolean;
-/**
- * Performs a *shallow structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays a **strict equality** check would be performed on every item, in
- * order, and for objects props will be matched and checked for **strict
- * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
- * item and value.
- *
- * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,
- * even when they are semantically different (e.g. resolved promises). Use
- * `isDeepEqual` instead.
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isStrictEqual` if you don't need a deep comparison and just want to check
- * for simple (`===`, `Object.is`) equality.
- * - `isDeepEqual` for a recursively deep check of arrays and objects.
- *
- * @param other - The second value to compare.
- * @signature
- *    P.isShallowEqual(other)(data)
- * @example
- *    P.pipe(1, P.isShallowEqual(1)) //=> true
- *    P.pipe(1, P.isShallowEqual('1')) //=> false
- *    P.pipe([1, 2, 3], P.isShallowEqual([1, 2, 3])) //=> true
- *    P.pipe([[1], [2], [3]], P.isShallowEqual([[1], [2], [3]])) //=> false
- * @dataFirst
- * @category Guard
- */
-declare function isShallowEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
-declare function isShallowEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
-
-export { isShallowEqual };
+import { isShallowEqual } from "./is-shallow-equal-B3YqLsBe.cjs";
+export { isShallowEqual };

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

@@ -1,69 +1,2 @@
-/**
- * Performs a *shallow structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays a **strict equality** check would be performed on every item, in
- * order, and for objects props will be matched and checked for **strict
- * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
- * item and value.
- *
- * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they
- * are semantically different (e.g. resolved promises); but `isDeepEqual` does
- * compare the latter 2 semantically by-value.
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isStrictEqual` if you don't need a deep comparison and just want to check
- * for simple (`===`, `Object.is`) equality.
- * - `isDeepEqual` for a recursively deep check of arrays and objects.
- *
- * @param data - The first value to compare.
- * @param other - The second value to compare.
- * @signature
- *    P.isShallowEqual(data, other)
- * @example
- *    P.isShallowEqual(1, 1) //=> true
- *    P.isShallowEqual(1, '1') //=> false
- *    P.isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true
- *    P.isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false
- * @dataFirst
- * @category Guard
- */
-declare function isShallowEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
-declare function isShallowEqual<T, S extends T = T>(data: T, other: S): boolean;
-/**
- * Performs a *shallow structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays a **strict equality** check would be performed on every item, in
- * order, and for objects props will be matched and checked for **strict
- * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
- * item and value.
- *
- * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,
- * even when they are semantically different (e.g. resolved promises). Use
- * `isDeepEqual` instead.
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isStrictEqual` if you don't need a deep comparison and just want to check
- * for simple (`===`, `Object.is`) equality.
- * - `isDeepEqual` for a recursively deep check of arrays and objects.
- *
- * @param other - The second value to compare.
- * @signature
- *    P.isShallowEqual(other)(data)
- * @example
- *    P.pipe(1, P.isShallowEqual(1)) //=> true
- *    P.pipe(1, P.isShallowEqual('1')) //=> false
- *    P.pipe([1, 2, 3], P.isShallowEqual([1, 2, 3])) //=> true
- *    P.pipe([[1], [2], [3]], P.isShallowEqual([[1], [2], [3]])) //=> false
- * @dataFirst
- * @category Guard
- */
-declare function isShallowEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
-declare function isShallowEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
-
-export { isShallowEqual };
+import { isShallowEqual } from "./is-shallow-equal-Dayqg3hM.js";
+export { isShallowEqual };

package/dist/is-shallow-equal.js

@@ -1 +1 @@
-import{a}from"./chunk-H5KJ7ULU.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as isShallowEqual};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{isShallowEqual as e}from"./is-shallow-equal-jy-Wc8By.js";export{e as isShallowEqual};

package/dist/is-strict-equal-BQ047FFm.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e===t||Object.is(e,t)}Object.defineProperty(exports,`isStrictEqual`,{enumerable:!0,get:function(){return t}});

package/dist/is-strict-equal-BQM-tE1X.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){return e===t||Object.is(e,t)}export{t as isStrictEqual};
+//# sourceMappingURL=is-strict-equal-BQM-tE1X.js.map

package/dist/is-strict-equal-BQM-tE1X.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-strict-equal-BQM-tE1X.js","names":[],"sources":["../src/is-strict-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    P.isStrictEqual(data, other)\n * @example\n *    P.isStrictEqual(1, 1) //=> true\n *    P.isStrictEqual(1, '1') //=> false\n *    P.isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isStrictEqual<T, S extends T = T>(data: T, other: S): boolean;\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param other - The second value to compare.\n * @signature\n *    P.isStrictEqual(other)(data)\n * @example\n *    P.pipe(1, P.isStrictEqual(1)); //=> true\n *    P.pipe(1, P.isStrictEqual('1')); //=> false\n *    P.pipe([1, 2, 3], P.isStrictEqual([1, 2, 3])); //=> false\n * @dataLast\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isStrictEqual<S>(\n  other: S,\n): <T extends S = S>(data: T) => boolean;\n\nexport function isStrictEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isStrictlyEqualImplementation, args);\n}\n\nfunction isStrictlyEqualImplementation<T, S>(data: S | T, other: S): data is S {\n  return data === other || Object.is(data, other);\n}\n"],"mappings":"4CA0EA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA+B,EAAK,CAGnD,SAAS,EAAoC,EAAa,EAAqB,CAC7E,OAAO,IAAS,GAAS,OAAO,GAAG,EAAM,EAAM"}