@vinicunca/perkakas 1.7.1 → 1.9.0

package/dist/split-D84V9L6V.d.ts

@@ -0,0 +1,62 @@
+import { ArraySlice, IsFloat, NonNegative, Split } from "type-fest";
+
+//#region src/split.d.ts
+type Split$1<S extends string, Separator extends string, N extends number | undefined = undefined> = string extends S ? Array<string> : string extends Separator ? Array<string> : number extends N ? Array<string> : IsFloat<N> extends true ? Array<string> : ArraySlice<Split<S, Separator>, 0, N extends number ? NonNegative<N> : never>;
+/**
+ * Takes a pattern and divides this string into an ordered list of substrings by
+ * searching for the pattern, puts these substrings into an array, and returns
+ * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+ * method.
+ *
+ * @param data - The string to split.
+ * @param separator - The pattern describing where each split should occur. Can
+ * be a string, or a regular expression.
+ * @param limit - A non-negative integer specifying a limit on the number of
+ * substrings to be included in the array. If provided, splits the string at
+ * each occurrence of the specified separator, but stops when limit entries have
+ * been placed in the array. Any leftover text is not included in the array at
+ * all. The array may contain fewer entries than limit if the end of the string
+ * is reached before the limit is reached. If limit is 0, [] is returned.
+ * @returns An Array of strings, split at each point where the separator occurs
+ * in the given string.
+ * @signature
+ *   R.split(data, separator, limit);
+ * @example
+ *   R.split("a,b,c", ","); //=> ["a", "b", "c"]
+ *   R.split("a,b,c", ",", 2); //=> ["a", "b"]
+ *   R.split("a1b2c3d", /\d/u); //=> ["a", "b", "c", "d"]
+ * @dataFirst
+ * @category String
+ */
+declare function split(data: string, separator: RegExp, limit?: number): Array<string>;
+declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(data: S, separator: Separator, limit?: N): Split$1<S, Separator, N>;
+/**
+ * Takes a pattern and divides this string into an ordered list of substrings by
+ * searching for the pattern, puts these substrings into an array, and returns
+ * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+ * method.
+ *
+ * @param separator - The pattern describing where each split should occur. Can
+ * be a string, or a regular expression.
+ * @param limit - A non-negative integer specifying a limit on the number of
+ * substrings to be included in the array. If provided, splits the string at
+ * each occurrence of the specified separator, but stops when limit entries have
+ * been placed in the array. Any leftover text is not included in the array at
+ * all. The array may contain fewer entries than limit if the end of the string
+ * is reached before the limit is reached. If limit is 0, [] is returned.
+ * @returns An Array of strings, split at each point where the separator occurs
+ * in the given string.
+ * @signature
+ *   R.split(separator, limit)(data);
+ * @example
+ *   R.pipe("a,b,c", R.split(",")); //=> ["a", "b", "c"]
+ *   R.pipe("a,b,c", R.split(",", 2)); //=> ["a", "b"]
+ *   R.pipe("a1b2c3d", R.split(/\d/u)); //=> ["a", "b", "c", "d"]
+ * @dataLast
+ * @category String
+ */
+declare function split(separator: RegExp, limit?: number): (data: string) => Array<string>;
+declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(separator: Separator, limit?: N): (data: S) => Split$1<S, Separator, N>;
+//#endregion
+export { split };
+//# sourceMappingURL=split-D84V9L6V.d.ts.map

package/dist/split-D84V9L6V.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-D84V9L6V.d.ts","names":[],"sources":["../src/split.ts"],"sourcesContent":[],"mappings":";;;KAOK,+GAIc,IACf,+BACe,YACb,+BACe,IACb,gBAEF,QAAQ,kBACJ,gBACA,WAIE,MAAU,GAAG,eAIb,mBAAmB,YAAY;;AAvBxB;;;;;;;;;;;;;;;;;;;AAoDnB;;;;;AAKA;AAAqB,iBALL,KAAA,CAKK,IAAA,EAAA,MAAA,EAAA,SAAA,EAHR,MAGQ,EAAA,KAAA,CAAA,EAAA,MAAA,CAAA,EADlB,KACkB,CAAA,MAAA,CAAA;AAIb,iBAJQ,KAIR,CAAA,UAAA,MAAA,EAAA,kBAAA,MAAA,EAAA,UAAA,MAAA,GAAA,SAAA,GAAA,SAAA,CAAA,CAAA,IAAA,EAAA,CAAA,EAAA,SAAA,EAAc,SAAd,EAAA,KAAA,CAAA,EAAiC,CAAjC,CAAA,EAAqC,OAArC,CAA2C,CAA3C,EAA8C,SAA9C,EAAyD,CAAzD,CAAA;;;;;;;;AA2BR;;;;;AAIA;;;;;;;;;;;;;iBAJgB,KAAA,YACH,2CAEQ;iBACL,uGAIH,mBAAmB,WAAW,MAAM,QAAM,GAAG,WAAW"}

package/dist/split-at-G5niCG-J.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){let n=Math.max(Math.min(t<0?e.length+t:t,e.length),0);return[e.slice(0,n),e.slice(n)]}export{t as splitAt};
+//# sourceMappingURL=split-at-G5niCG-J.js.map

package/dist/split-at-G5niCG-J.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-at-G5niCG-J.js","names":[],"sources":["../src/split-at.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Splits a given array at a given index.\n *\n * @param array - The array to split.\n * @param index - The index to split at.\n * @signature\n *    P.splitAt(array, index)\n * @example\n *    P.splitAt([1, 2, 3], 1) // => [[1], [2, 3]]\n *    P.splitAt([1, 2, 3, 4, 5], -1) // => [[1, 2, 3, 4], [5]]\n * @dataFirst\n * @category Array\n */\nexport function splitAt<T>(\n  array: ReadonlyArray<T>,\n  index: number,\n): [Array<T>, Array<T>];\n\n/**\n * Splits a given array at a given index.\n *\n * @param index - The index to split at.\n * @signature\n *    P.splitAt(index)(array)\n * @example\n *    P.splitAt(1)([1, 2, 3]) // => [[1], [2, 3]]\n *    P.splitAt(-1)([1, 2, 3, 4, 5]) // => [[1, 2, 3, 4], [5]]\n * @dataLast\n * @category Array\n */\nexport function splitAt<T>(\n  index: number,\n): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];\n\nexport function splitAt(...args: ReadonlyArray<unknown>): unknown {\n  return curry(splitAtImplementation, args);\n}\n\nfunction splitAtImplementation<T>(\n  array: ReadonlyArray<T>,\n  index: number,\n): [Array<T>, Array<T>] {\n  const effectiveIndex = Math.max(\n    Math.min(index < 0 ? array.length + index : index, array.length),\n    0,\n  );\n  return [array.slice(0, effectiveIndex), array.slice(effectiveIndex)];\n}\n"],"mappings":"4CAoCA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACsB,CACtB,IAAM,EAAiB,KAAK,IAC1B,KAAK,IAAI,EAAQ,EAAI,EAAM,OAAS,EAAQ,EAAO,EAAM,OAAO,CAChE,EACD,CACD,MAAO,CAAC,EAAM,MAAM,EAAG,EAAe,CAAE,EAAM,MAAM,EAAe,CAAC"}

package/dist/split-at-HLOqEHH2.d.cts

@@ -0,0 +1,31 @@
+//#region src/split-at.d.ts
+/**
+ * Splits a given array at a given index.
+ *
+ * @param array - The array to split.
+ * @param index - The index to split at.
+ * @signature
+ *    P.splitAt(array, index)
+ * @example
+ *    P.splitAt([1, 2, 3], 1) // => [[1], [2, 3]]
+ *    P.splitAt([1, 2, 3, 4, 5], -1) // => [[1, 2, 3, 4], [5]]
+ * @dataFirst
+ * @category Array
+ */
+declare function splitAt<T>(array: ReadonlyArray<T>, index: number): [Array<T>, Array<T>];
+/**
+ * Splits a given array at a given index.
+ *
+ * @param index - The index to split at.
+ * @signature
+ *    P.splitAt(index)(array)
+ * @example
+ *    P.splitAt(1)([1, 2, 3]) // => [[1], [2, 3]]
+ *    P.splitAt(-1)([1, 2, 3, 4, 5]) // => [[1, 2, 3, 4], [5]]
+ * @dataLast
+ * @category Array
+ */
+declare function splitAt<T>(index: number): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+//#endregion
+export { splitAt };
+//# sourceMappingURL=split-at-HLOqEHH2.d.cts.map

package/dist/split-at-HLOqEHH2.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-at-HLOqEHH2.d.cts","names":[],"sources":["../src/split-at.ts"],"sourcesContent":[],"mappings":";;AAeA;;;;;;;;;AAiBA;;;AAEW,iBAnBK,OAmBL,CAAA,CAAA,CAAA,CAAA,KAAA,EAlBF,aAkBE,CAlBY,CAkBZ,CAAA,EAAA,KAAA,EAAA,MAAA,CAAA,EAAA,CAhBP,KAgBO,CAhBD,CAgBC,CAAA,EAhBG,KAgBH,CAhBS,CAgBT,CAAA,CAAA;;;;;;;;;;;;;iBAFK,mCAEL,cAAc,QAAQ,MAAM,IAAI,MAAM"}

package/dist/split-at-Jc3Rqy7v.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n=Math.max(Math.min(t<0?e.length+t:t,e.length),0);return[e.slice(0,n),e.slice(n)]}Object.defineProperty(exports,`splitAt`,{enumerable:!0,get:function(){return t}});

package/dist/split-at-u6HErcio.d.ts

@@ -0,0 +1,31 @@
+//#region src/split-at.d.ts
+/**
+ * Splits a given array at a given index.
+ *
+ * @param array - The array to split.
+ * @param index - The index to split at.
+ * @signature
+ *    P.splitAt(array, index)
+ * @example
+ *    P.splitAt([1, 2, 3], 1) // => [[1], [2, 3]]
+ *    P.splitAt([1, 2, 3, 4, 5], -1) // => [[1, 2, 3, 4], [5]]
+ * @dataFirst
+ * @category Array
+ */
+declare function splitAt<T>(array: ReadonlyArray<T>, index: number): [Array<T>, Array<T>];
+/**
+ * Splits a given array at a given index.
+ *
+ * @param index - The index to split at.
+ * @signature
+ *    P.splitAt(index)(array)
+ * @example
+ *    P.splitAt(1)([1, 2, 3]) // => [[1], [2, 3]]
+ *    P.splitAt(-1)([1, 2, 3, 4, 5]) // => [[1, 2, 3, 4], [5]]
+ * @dataLast
+ * @category Array
+ */
+declare function splitAt<T>(index: number): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+//#endregion
+export { splitAt };
+//# sourceMappingURL=split-at-u6HErcio.d.ts.map

package/dist/split-at-u6HErcio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-at-u6HErcio.d.ts","names":[],"sources":["../src/split-at.ts"],"sourcesContent":[],"mappings":";;AAeA;;;;;;;;;AAiBA;;;AAEW,iBAnBK,OAmBL,CAAA,CAAA,CAAA,CAAA,KAAA,EAlBF,aAkBE,CAlBY,CAkBZ,CAAA,EAAA,KAAA,EAAA,MAAA,CAAA,EAAA,CAhBP,KAgBO,CAhBD,CAgBC,CAAA,EAhBG,KAgBH,CAhBS,CAgBT,CAAA,CAAA;;;;;;;;;;;;;iBAFK,mCAEL,cAAc,QAAQ,MAAM,IAAI,MAAM"}

package/dist/split-at.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkPM4GAQSEcjs = require('./chunk-PM4GAQSE.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.splitAt = _chunkPM4GAQSEcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./split-at-Jc3Rqy7v.cjs`);exports.splitAt=e.splitAt;

package/dist/split-at.d.cts

@@ -1,29 +1,2 @@
-/**
- * Splits a given array at a given index.
- *
- * @param array - The array to split.
- * @param index - The index to split at.
- * @signature
- *    P.splitAt(array, index)
- * @example
- *    P.splitAt([1, 2, 3], 1) // => [[1], [2, 3]]
- *    P.splitAt([1, 2, 3, 4, 5], -1) // => [[1, 2, 3, 4], [5]]
- * @dataFirst
- * @category Array
- */
-declare function splitAt<T>(array: ReadonlyArray<T>, index: number): [Array<T>, Array<T>];
-/**
- * Splits a given array at a given index.
- *
- * @param index - The index to split at.
- * @signature
- *    P.splitAt(index)(array)
- * @example
- *    P.splitAt(1)([1, 2, 3]) // => [[1], [2, 3]]
- *    P.splitAt(-1)([1, 2, 3, 4, 5]) // => [[1, 2, 3, 4], [5]]
- * @dataLast
- * @category Array
- */
-declare function splitAt<T>(index: number): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
-
-export { splitAt };
+import { splitAt } from "./split-at-HLOqEHH2.cjs";
+export { splitAt };

package/dist/split-at.d.ts

@@ -1,29 +1,2 @@
-/**
- * Splits a given array at a given index.
- *
- * @param array - The array to split.
- * @param index - The index to split at.
- * @signature
- *    P.splitAt(array, index)
- * @example
- *    P.splitAt([1, 2, 3], 1) // => [[1], [2, 3]]
- *    P.splitAt([1, 2, 3, 4, 5], -1) // => [[1, 2, 3, 4], [5]]
- * @dataFirst
- * @category Array
- */
-declare function splitAt<T>(array: ReadonlyArray<T>, index: number): [Array<T>, Array<T>];
-/**
- * Splits a given array at a given index.
- *
- * @param index - The index to split at.
- * @signature
- *    P.splitAt(index)(array)
- * @example
- *    P.splitAt(1)([1, 2, 3]) // => [[1], [2, 3]]
- *    P.splitAt(-1)([1, 2, 3, 4, 5]) // => [[1, 2, 3, 4], [5]]
- * @dataLast
- * @category Array
- */
-declare function splitAt<T>(index: number): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
-
-export { splitAt };
+import { splitAt } from "./split-at-u6HErcio.js";
+export { splitAt };

package/dist/split-at.js

@@ -1 +1 @@
-import{a}from"./chunk-N4LC5TR2.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as splitAt};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{splitAt as e}from"./split-at-G5niCG-J.js";export{e as splitAt};

package/dist/split-i3LJTbq2.js

@@ -0,0 +1,2 @@
+function e(e,t,n){return typeof t==`number`||t===void 0?n=>n.split(e,t):e.split(t,n)}export{e as split};
+//# sourceMappingURL=split-i3LJTbq2.js.map

package/dist/split-i3LJTbq2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-i3LJTbq2.js","names":[],"sources":["../src/split.ts"],"sourcesContent":["import type {\n  ArraySlice,\n  IsFloat,\n  NonNegative,\n  Split as SplitBase,\n} from 'type-fest';\n\ntype Split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n> = string extends S\n  ? Array<string>\n  : string extends Separator\n    ? Array<string>\n    : number extends N\n      ? Array<string>\n      : // TODO: We need a way to \"floor\" non-integer numbers, until then we return a lower fidelity type instead.\n      IsFloat<N> extends true\n        ? Array<string>\n        : ArraySlice<\n            // We can use the base (type-fest) split **only** if all the params\n            // are literals. For all other cases it would return the wrong type\n            // so we fallback to the built-in Array.prototype.split return type.\n            SplitBase<S, Separator>,\n            0,\n            // `undefined` and negative numbers are treated as non-limited\n            // splits, which is what we'd get when using `never` for ArraySlice.\n            N extends number ? NonNegative<N> : never\n          >;\n\n/**\n * Takes a pattern and divides this string into an ordered list of substrings by\n * searching for the pattern, puts these substrings into an array, and returns\n * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)\n * method.\n *\n * @param data - The string to split.\n * @param separator - The pattern describing where each split should occur. Can\n * be a string, or a regular expression.\n * @param limit - A non-negative integer specifying a limit on the number of\n * substrings to be included in the array. If provided, splits the string at\n * each occurrence of the specified separator, but stops when limit entries have\n * been placed in the array. Any leftover text is not included in the array at\n * all. The array may contain fewer entries than limit if the end of the string\n * is reached before the limit is reached. If limit is 0, [] is returned.\n * @returns An Array of strings, split at each point where the separator occurs\n * in the given string.\n * @signature\n *   R.split(data, separator, limit);\n * @example\n *   R.split(\"a,b,c\", \",\"); //=> [\"a\", \"b\", \"c\"]\n *   R.split(\"a,b,c\", \",\", 2); //=> [\"a\", \"b\"]\n *   R.split(\"a1b2c3d\", /\\d/u); //=> [\"a\", \"b\", \"c\", \"d\"]\n * @dataFirst\n * @category String\n */\nexport function split(\n  data: string,\n  separator: RegExp,\n  limit?: number,\n): Array<string>;\nexport function split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n>(data: S, separator: Separator, limit?: N): Split<S, Separator, N>;\n\n/**\n * Takes a pattern and divides this string into an ordered list of substrings by\n * searching for the pattern, puts these substrings into an array, and returns\n * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)\n * method.\n *\n * @param separator - The pattern describing where each split should occur. Can\n * be a string, or a regular expression.\n * @param limit - A non-negative integer specifying a limit on the number of\n * substrings to be included in the array. If provided, splits the string at\n * each occurrence of the specified separator, but stops when limit entries have\n * been placed in the array. Any leftover text is not included in the array at\n * all. The array may contain fewer entries than limit if the end of the string\n * is reached before the limit is reached. If limit is 0, [] is returned.\n * @returns An Array of strings, split at each point where the separator occurs\n * in the given string.\n * @signature\n *   R.split(separator, limit)(data);\n * @example\n *   R.pipe(\"a,b,c\", R.split(\",\")); //=> [\"a\", \"b\", \"c\"]\n *   R.pipe(\"a,b,c\", R.split(\",\", 2)); //=> [\"a\", \"b\"]\n *   R.pipe(\"a1b2c3d\", R.split(/\\d/u)); //=> [\"a\", \"b\", \"c\", \"d\"]\n * @dataLast\n * @category String\n */\nexport function split(\n  separator: RegExp,\n  limit?: number,\n): (data: string) => Array<string>;\nexport function split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n>(separator: Separator, limit?: N): (data: S) => Split<S, Separator, N>;\n\nexport function split(\n  dataOrSeparator: RegExp | string,\n  separatorOrLimit?: RegExp | number | string,\n  limit?: number,\n): unknown {\n  return typeof separatorOrLimit === 'number' || separatorOrLimit === undefined\n    // dataLast\n    ? (data: string) => data.split(dataOrSeparator, separatorOrLimit)\n    // dataFirst\n    : (dataOrSeparator as string).split(separatorOrLimit, limit);\n}\n"],"mappings":"AAuGA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAqB,UAAY,IAAqB,IAAA,GAE/D,GAAiB,EAAK,MAAM,EAAiB,EAAiB,CAE9D,EAA2B,MAAM,EAAkB,EAAM"}

package/dist/split-when-CI6Rp9P6.d.ts

@@ -0,0 +1,29 @@
+//#region src/split-when.d.ts
+/**
+ * Splits a given array at the first index where the given predicate returns true.
+ *
+ * @param data - The array to split.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.splitWhen(array, fn)
+ * @example
+ *    P.splitWhen([1, 2, 3], x => x === 2) // => [[1], [2, 3]]
+ * @dataFirst
+ * @category Array
+ */
+declare function splitWhen<T>(data: ReadonlyArray<T>, predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): [Array<T>, Array<T>];
+/**
+ * Splits a given array at an index where the given predicate returns true.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.splitWhen(fn)(array)
+ * @example
+ *    P.splitWhen(x => x === 2)([1, 2, 3]) // => [[1], [2, 3]]
+ * @dataLast
+ * @category Array
+ */
+declare function splitWhen<T>(predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+//#endregion
+export { splitWhen };
+//# sourceMappingURL=split-when-CI6Rp9P6.d.ts.map

package/dist/split-when-CI6Rp9P6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-when-CI6Rp9P6.d.ts","names":[],"sources":["../src/split-when.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;;;;;;;AAGmB,iBAHH,SAGG,CAAA,CAAA,CAAA,CAAA,IAAA,EAFX,aAEW,CAFG,CAEH,CAAA,EAAA,SAAA,EAAA,CAAA,IAAA,EADC,CACD,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADyB,aACzB,CADuC,CACvC,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAf,KAAe,CAAT,CAAS,CAAA,EAAL,KAAK,CAAC,CAAD,CAAA,CAAA;AAanB;;;;;;;;;;;AAEgD,iBAFhC,SAEgC,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAD5B,CAC4B,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADJ,aACI,CADU,CACV,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,KAAA,EAArC,aAAqC,CAAvB,CAAuB,CAAA,EAAA,GAAA,CAAf,KAAe,CAAT,CAAS,CAAA,EAAL,KAAK,CAAC,CAAD,CAAA,CAAA"}

package/dist/split-when-CSgkl-FL.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n=e.findIndex(t);return n===-1?[[...e],[]]:[e.slice(0,n),e.slice(n)]}Object.defineProperty(exports,`splitWhen`,{enumerable:!0,get:function(){return t}});

package/dist/split-when-D7haKyST.d.cts

@@ -0,0 +1,29 @@
+//#region src/split-when.d.ts
+/**
+ * Splits a given array at the first index where the given predicate returns true.
+ *
+ * @param data - The array to split.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.splitWhen(array, fn)
+ * @example
+ *    P.splitWhen([1, 2, 3], x => x === 2) // => [[1], [2, 3]]
+ * @dataFirst
+ * @category Array
+ */
+declare function splitWhen<T>(data: ReadonlyArray<T>, predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): [Array<T>, Array<T>];
+/**
+ * Splits a given array at an index where the given predicate returns true.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.splitWhen(fn)(array)
+ * @example
+ *    P.splitWhen(x => x === 2)([1, 2, 3]) // => [[1], [2, 3]]
+ * @dataLast
+ * @category Array
+ */
+declare function splitWhen<T>(predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
+//#endregion
+export { splitWhen };
+//# sourceMappingURL=split-when-D7haKyST.d.cts.map

package/dist/split-when-D7haKyST.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-when-D7haKyST.d.cts","names":[],"sources":["../src/split-when.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;;;;;;;AAGmB,iBAHH,SAGG,CAAA,CAAA,CAAA,CAAA,IAAA,EAFX,aAEW,CAFG,CAEH,CAAA,EAAA,SAAA,EAAA,CAAA,IAAA,EADC,CACD,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADyB,aACzB,CADuC,CACvC,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAf,KAAe,CAAT,CAAS,CAAA,EAAL,KAAK,CAAC,CAAD,CAAA,CAAA;AAanB;;;;;;;;;;;AAEgD,iBAFhC,SAEgC,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAD5B,CAC4B,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADJ,aACI,CADU,CACV,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,KAAA,EAArC,aAAqC,CAAvB,CAAuB,CAAA,EAAA,GAAA,CAAf,KAAe,CAAT,CAAS,CAAA,EAAL,KAAK,CAAC,CAAD,CAAA,CAAA"}

package/dist/split-when-b4N1TSSY.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){let n=e.findIndex(t);return n===-1?[[...e],[]]:[e.slice(0,n),e.slice(n)]}export{t as splitWhen};
+//# sourceMappingURL=split-when-b4N1TSSY.js.map

package/dist/split-when-b4N1TSSY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-when-b4N1TSSY.js","names":[],"sources":["../src/split-when.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Splits a given array at the first index where the given predicate returns true.\n *\n * @param data - The array to split.\n * @param predicate - The predicate.\n * @signature\n *    P.splitWhen(array, fn)\n * @example\n *    P.splitWhen([1, 2, 3], x => x === 2) // => [[1], [2, 3]]\n * @dataFirst\n * @category Array\n */\nexport function splitWhen<T>(\n  data: ReadonlyArray<T>,\n  predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean,\n): [Array<T>, Array<T>];\n\n/**\n * Splits a given array at an index where the given predicate returns true.\n *\n * @param predicate - The predicate.\n * @signature\n *    P.splitWhen(fn)(array)\n * @example\n *    P.splitWhen(x => x === 2)([1, 2, 3]) // => [[1], [2, 3]]\n * @dataLast\n * @category Array\n */\nexport function splitWhen<T>(\n  predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];\n\nexport function splitWhen(...args: ReadonlyArray<unknown>): unknown {\n  return curry(splitWhenImplementation, args);\n}\n\nfunction splitWhenImplementation<T>(\n  data: ReadonlyArray<T>,\n  predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean,\n): [Array<T>, Array<T>] {\n  const index = data.findIndex(predicate);\n  return index === -1\n    ? [[...data], []]\n    : [data.slice(0, index), data.slice(index)];\n}\n"],"mappings":"4CAkCA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACsB,CACtB,IAAM,EAAQ,EAAK,UAAU,EAAU,CACvC,OAAO,IAAU,GACb,CAAC,CAAC,GAAG,EAAK,CAAE,EAAE,CAAC,CACf,CAAC,EAAK,MAAM,EAAG,EAAM,CAAE,EAAK,MAAM,EAAM,CAAC"}

package/dist/split-when.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkOCVPUGMZcjs = require('./chunk-OCVPUGMZ.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.splitWhen = _chunkOCVPUGMZcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./split-when-CSgkl-FL.cjs`);exports.splitWhen=e.splitWhen;

package/dist/split-when.d.cts

@@ -1,27 +1,2 @@
-/**
- * Splits a given array at the first index where the given predicate returns true.
- *
- * @param data - The array to split.
- * @param predicate - The predicate.
- * @signature
- *    P.splitWhen(array, fn)
- * @example
- *    P.splitWhen([1, 2, 3], x => x === 2) // => [[1], [2, 3]]
- * @dataFirst
- * @category Array
- */
-declare function splitWhen<T>(data: ReadonlyArray<T>, predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): [Array<T>, Array<T>];
-/**
- * Splits a given array at an index where the given predicate returns true.
- *
- * @param predicate - The predicate.
- * @signature
- *    P.splitWhen(fn)(array)
- * @example
- *    P.splitWhen(x => x === 2)([1, 2, 3]) // => [[1], [2, 3]]
- * @dataLast
- * @category Array
- */
-declare function splitWhen<T>(predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
-
-export { splitWhen };
+import { splitWhen } from "./split-when-D7haKyST.cjs";
+export { splitWhen };

package/dist/split-when.d.ts

@@ -1,27 +1,2 @@
-/**
- * Splits a given array at the first index where the given predicate returns true.
- *
- * @param data - The array to split.
- * @param predicate - The predicate.
- * @signature
- *    P.splitWhen(array, fn)
- * @example
- *    P.splitWhen([1, 2, 3], x => x === 2) // => [[1], [2, 3]]
- * @dataFirst
- * @category Array
- */
-declare function splitWhen<T>(data: ReadonlyArray<T>, predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): [Array<T>, Array<T>];
-/**
- * Splits a given array at an index where the given predicate returns true.
- *
- * @param predicate - The predicate.
- * @signature
- *    P.splitWhen(fn)(array)
- * @example
- *    P.splitWhen(x => x === 2)([1, 2, 3]) // => [[1], [2, 3]]
- * @dataLast
- * @category Array
- */
-declare function splitWhen<T>(predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];
-
-export { splitWhen };
+import { splitWhen } from "./split-when-CI6Rp9P6.js";
+export { splitWhen };

package/dist/split-when.js

@@ -1 +1 @@
-import{a}from"./chunk-6LM7XJ2A.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as splitWhen};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{splitWhen as e}from"./split-when-b4N1TSSY.js";export{e as splitWhen};

package/dist/split.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkTFN3JWPScjs = require('./chunk-TFN3JWPS.cjs');require('./chunk-MBGSSEZN.cjs');exports.split = _chunkTFN3JWPScjs.a;
+const e=require(`./split-BCgeOz9S.cjs`);exports.split=e.split;

package/dist/split.d.cts

@@ -1,60 +1,2 @@
-import { IsFloat, ArraySlice, Split as Split$1, NonNegative } from 'type-fest';
-
-type Split<S extends string, Separator extends string, N extends number | undefined = undefined> = string extends S ? Array<string> : string extends Separator ? Array<string> : number extends N ? Array<string> : IsFloat<N> extends true ? Array<string> : ArraySlice<Split$1<S, Separator>, 0, N extends number ? NonNegative<N> : never>;
-/**
- * Takes a pattern and divides this string into an ordered list of substrings by
- * searching for the pattern, puts these substrings into an array, and returns
- * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
- * method.
- *
- * @param data - The string to split.
- * @param separator - The pattern describing where each split should occur. Can
- * be a string, or a regular expression.
- * @param limit - A non-negative integer specifying a limit on the number of
- * substrings to be included in the array. If provided, splits the string at
- * each occurrence of the specified separator, but stops when limit entries have
- * been placed in the array. Any leftover text is not included in the array at
- * all. The array may contain fewer entries than limit if the end of the string
- * is reached before the limit is reached. If limit is 0, [] is returned.
- * @returns An Array of strings, split at each point where the separator occurs
- * in the given string.
- * @signature
- *   R.split(data, separator, limit);
- * @example
- *   R.split("a,b,c", ","); //=> ["a", "b", "c"]
- *   R.split("a,b,c", ",", 2); //=> ["a", "b"]
- *   R.split("a1b2c3d", /\d/u); //=> ["a", "b", "c", "d"]
- * @dataFirst
- * @category String
- */
-declare function split(data: string, separator: RegExp, limit?: number): Array<string>;
-declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(data: S, separator: Separator, limit?: N): Split<S, Separator, N>;
-/**
- * Takes a pattern and divides this string into an ordered list of substrings by
- * searching for the pattern, puts these substrings into an array, and returns
- * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
- * method.
- *
- * @param separator - The pattern describing where each split should occur. Can
- * be a string, or a regular expression.
- * @param limit - A non-negative integer specifying a limit on the number of
- * substrings to be included in the array. If provided, splits the string at
- * each occurrence of the specified separator, but stops when limit entries have
- * been placed in the array. Any leftover text is not included in the array at
- * all. The array may contain fewer entries than limit if the end of the string
- * is reached before the limit is reached. If limit is 0, [] is returned.
- * @returns An Array of strings, split at each point where the separator occurs
- * in the given string.
- * @signature
- *   R.split(separator, limit)(data);
- * @example
- *   R.pipe("a,b,c", R.split(",")); //=> ["a", "b", "c"]
- *   R.pipe("a,b,c", R.split(",", 2)); //=> ["a", "b"]
- *   R.pipe("a1b2c3d", R.split(/\d/u)); //=> ["a", "b", "c", "d"]
- * @dataLast
- * @category String
- */
-declare function split(separator: RegExp, limit?: number): (data: string) => Array<string>;
-declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(separator: Separator, limit?: N): (data: S) => Split<S, Separator, N>;
-
-export { split };
+import { split } from "./split-4732uYSL.cjs";
+export { split };

package/dist/split.d.ts

@@ -1,60 +1,2 @@
-import { IsFloat, ArraySlice, Split as Split$1, NonNegative } from 'type-fest';
-
-type Split<S extends string, Separator extends string, N extends number | undefined = undefined> = string extends S ? Array<string> : string extends Separator ? Array<string> : number extends N ? Array<string> : IsFloat<N> extends true ? Array<string> : ArraySlice<Split$1<S, Separator>, 0, N extends number ? NonNegative<N> : never>;
-/**
- * Takes a pattern and divides this string into an ordered list of substrings by
- * searching for the pattern, puts these substrings into an array, and returns
- * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
- * method.
- *
- * @param data - The string to split.
- * @param separator - The pattern describing where each split should occur. Can
- * be a string, or a regular expression.
- * @param limit - A non-negative integer specifying a limit on the number of
- * substrings to be included in the array. If provided, splits the string at
- * each occurrence of the specified separator, but stops when limit entries have
- * been placed in the array. Any leftover text is not included in the array at
- * all. The array may contain fewer entries than limit if the end of the string
- * is reached before the limit is reached. If limit is 0, [] is returned.
- * @returns An Array of strings, split at each point where the separator occurs
- * in the given string.
- * @signature
- *   R.split(data, separator, limit);
- * @example
- *   R.split("a,b,c", ","); //=> ["a", "b", "c"]
- *   R.split("a,b,c", ",", 2); //=> ["a", "b"]
- *   R.split("a1b2c3d", /\d/u); //=> ["a", "b", "c", "d"]
- * @dataFirst
- * @category String
- */
-declare function split(data: string, separator: RegExp, limit?: number): Array<string>;
-declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(data: S, separator: Separator, limit?: N): Split<S, Separator, N>;
-/**
- * Takes a pattern and divides this string into an ordered list of substrings by
- * searching for the pattern, puts these substrings into an array, and returns
- * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
- * method.
- *
- * @param separator - The pattern describing where each split should occur. Can
- * be a string, or a regular expression.
- * @param limit - A non-negative integer specifying a limit on the number of
- * substrings to be included in the array. If provided, splits the string at
- * each occurrence of the specified separator, but stops when limit entries have
- * been placed in the array. Any leftover text is not included in the array at
- * all. The array may contain fewer entries than limit if the end of the string
- * is reached before the limit is reached. If limit is 0, [] is returned.
- * @returns An Array of strings, split at each point where the separator occurs
- * in the given string.
- * @signature
- *   R.split(separator, limit)(data);
- * @example
- *   R.pipe("a,b,c", R.split(",")); //=> ["a", "b", "c"]
- *   R.pipe("a,b,c", R.split(",", 2)); //=> ["a", "b"]
- *   R.pipe("a1b2c3d", R.split(/\d/u)); //=> ["a", "b", "c", "d"]
- * @dataLast
- * @category String
- */
-declare function split(separator: RegExp, limit?: number): (data: string) => Array<string>;
-declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(separator: Separator, limit?: N): (data: S) => Split<S, Separator, N>;
-
-export { split };
+import { split } from "./split-D84V9L6V.js";
+export { split };

package/dist/split.js

@@ -1 +1 @@
-import{a}from"./chunk-RBODUO3Q.js";import"./chunk-EK7ODJWE.js";export{a as split};
+import{split as e}from"./split-i3LJTbq2.js";export{e as split};

package/dist/string-to-path-BNoivDR4.d.ts

@@ -0,0 +1,39 @@
+import { IsNumericLiteral, IsStringLiteral } from "type-fest";
+
+//#region src/string-to-path.d.ts
+type StringToPath<S> = IsStringLiteral<S> extends true ? StringToPathImpl<S> : Array<string | number>;
+type StringToPathImpl<S> = S extends `${infer Head}['${infer Quoted}']${infer Tail}` ? [...StringToPath<Head>, Quoted, ...StringToPath<Tail>] : S extends `${infer Head}["${infer DoubleQuoted}"]${infer Tail}` ? [...StringToPath<Head>, DoubleQuoted, ...StringToPath<Tail>] : S extends `${infer Head}[${infer Unquoted}]${infer Tail}` ? [...StringToPath<Head>, ...StringToPath<Unquoted>, ...StringToPath<Tail>] : S extends `${infer Head}.${infer Tail}` ? [...StringToPath<Head>, ...StringToPath<Tail>] : '' extends S ? [] : S extends `${infer N extends number}` ? [IsNumericLiteral<N> extends true ? N : S] : [S];
+/**
+ * A utility to allow JSONPath-like strings to be used in other utilities which
+ * take an array of path segments as input (e.g. `pathOr`, `setPath`, etc...).
+ * The main purpose of this utility is to act as a bridge between the runtime
+ * implementation that converts the path to an array, and the type-system that
+ * parses the path string **type** into an array **type**. This type allows us
+ * to return fine-grained types and to enforce correctness at the type-level.
+ *
+ * We **discourage** using this utility for new code. This utility is for legacy
+ * code that already contains path strings (which are accepted by Lodash). We
+ * strongly recommend using *path arrays* instead as they provide better
+ * developer experience via significantly faster type-checking, fine-grained
+ * error messages, and automatic typeahead suggestions for each segment of the
+ * path.
+ *
+ * There are a bunch of limitations to this utility derived from the
+ * limitations of the type itself, these are usually edge-cases around deeply
+ * nested paths, escaping, whitespaces, and empty segments. This is true even
+ * in cases where the runtime implementation can better handle them, this is
+ * intentional. See the tests for this utility for more details and the
+ * expected outputs*.
+ *
+ * @param path - A string path.
+ * @signature
+ *   P.stringToPath(path)
+ * @example
+ *   P.stringToPath('a.b[0].c') // => ['a', 'b', 0, 'c']
+ * @dataFirst
+ * @category Utility
+ */
+declare function stringToPath<const Path extends string>(path: Path): StringToPath<Path>;
+//#endregion
+export { stringToPath };
+//# sourceMappingURL=string-to-path-BNoivDR4.d.ts.map

package/dist/string-to-path-BNoivDR4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-to-path-BNoivDR4.d.ts","names":[],"sources":["../src/string-to-path.ts"],"sourcesContent":[],"mappings":";;;KASK,kBAGD,gBAAgB,kBACd,iBAAiB,KACjB;KAED,sBAMD,gEACM,aAAa,OAAO,WAAW,aAAa,SAChD,sEACM,aAAa,OAAO,iBAAiB,aAAa,SAGtD,6DAnBH,GAqBU,YArBE,CAqBW,IArBX,CAAA,EAAA,GAsBF,YAtBE,CAsBW,QAtBX,CAAA,KAuBF,YApBK,CAoBQ,IApBR,CAAA,IAyBV,UAzBN,GAAA,KAAA,KAAA,IAAA,KAAA,KAAA,EAAA,GAAA,CAAA,GA0BY,YA1BZ,CA0ByB,IA1BzB,CAAA,EAAA,GA0BmC,YA1BnC,CA0BgD,IA1BhD,CAAA,CAAA,GAAA,EAAA,SA4BmB,CA5BnB,GAAA,EAAA,GAuCU,CAvCV,SAAA,GAAA,KAAA,WAAA,MAAA,EAAA,GAAA,CA6Cc,gBA5CK,CA4CY,CA5CZ,CAAA,SAAA,IAAA,GA4C8B,CA5C9B,GA4CkC,CA5ClC,KA+CN,EA/CX;;;AACK;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CwB,iBAmCnB,YAnCmB,CAAA,mBAAA,MAAA,CAAA,CAAA,IAAA,EAoC3B,IApC2B,CAAA,EAqChC,YArCgC,CAqCnB,IArCmB,CAAA"}

package/dist/string-to-path-CjAuFrpj.d.cts

@@ -0,0 +1,39 @@
+import { IsNumericLiteral, IsStringLiteral } from "type-fest";
+
+//#region src/string-to-path.d.ts
+type StringToPath<S> = IsStringLiteral<S> extends true ? StringToPathImpl<S> : Array<string | number>;
+type StringToPathImpl<S> = S extends `${infer Head}['${infer Quoted}']${infer Tail}` ? [...StringToPath<Head>, Quoted, ...StringToPath<Tail>] : S extends `${infer Head}["${infer DoubleQuoted}"]${infer Tail}` ? [...StringToPath<Head>, DoubleQuoted, ...StringToPath<Tail>] : S extends `${infer Head}[${infer Unquoted}]${infer Tail}` ? [...StringToPath<Head>, ...StringToPath<Unquoted>, ...StringToPath<Tail>] : S extends `${infer Head}.${infer Tail}` ? [...StringToPath<Head>, ...StringToPath<Tail>] : '' extends S ? [] : S extends `${infer N extends number}` ? [IsNumericLiteral<N> extends true ? N : S] : [S];
+/**
+ * A utility to allow JSONPath-like strings to be used in other utilities which
+ * take an array of path segments as input (e.g. `pathOr`, `setPath`, etc...).
+ * The main purpose of this utility is to act as a bridge between the runtime
+ * implementation that converts the path to an array, and the type-system that
+ * parses the path string **type** into an array **type**. This type allows us
+ * to return fine-grained types and to enforce correctness at the type-level.
+ *
+ * We **discourage** using this utility for new code. This utility is for legacy
+ * code that already contains path strings (which are accepted by Lodash). We
+ * strongly recommend using *path arrays* instead as they provide better
+ * developer experience via significantly faster type-checking, fine-grained
+ * error messages, and automatic typeahead suggestions for each segment of the
+ * path.
+ *
+ * There are a bunch of limitations to this utility derived from the
+ * limitations of the type itself, these are usually edge-cases around deeply
+ * nested paths, escaping, whitespaces, and empty segments. This is true even
+ * in cases where the runtime implementation can better handle them, this is
+ * intentional. See the tests for this utility for more details and the
+ * expected outputs*.
+ *
+ * @param path - A string path.
+ * @signature
+ *   P.stringToPath(path)
+ * @example
+ *   P.stringToPath('a.b[0].c') // => ['a', 'b', 0, 'c']
+ * @dataFirst
+ * @category Utility
+ */
+declare function stringToPath<const Path extends string>(path: Path): StringToPath<Path>;
+//#endregion
+export { stringToPath };
+//# sourceMappingURL=string-to-path-CjAuFrpj.d.cts.map

package/dist/string-to-path-CjAuFrpj.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-to-path-CjAuFrpj.d.cts","names":[],"sources":["../src/string-to-path.ts"],"sourcesContent":[],"mappings":";;;KASK,kBAGD,gBAAgB,kBACd,iBAAiB,KACjB;KAED,sBAMD,gEACM,aAAa,OAAO,WAAW,aAAa,SAChD,sEACM,aAAa,OAAO,iBAAiB,aAAa,SAGtD,6DAnBH,GAqBU,YArBE,CAqBW,IArBX,CAAA,EAAA,GAsBF,YAtBE,CAsBW,QAtBX,CAAA,KAuBF,YApBK,CAoBQ,IApBR,CAAA,IAyBV,UAzBN,GAAA,KAAA,KAAA,IAAA,KAAA,KAAA,EAAA,GAAA,CAAA,GA0BY,YA1BZ,CA0ByB,IA1BzB,CAAA,EAAA,GA0BmC,YA1BnC,CA0BgD,IA1BhD,CAAA,CAAA,GAAA,EAAA,SA4BmB,CA5BnB,GAAA,EAAA,GAuCU,CAvCV,SAAA,GAAA,KAAA,WAAA,MAAA,EAAA,GAAA,CA6Cc,gBA5CK,CA4CY,CA5CZ,CAAA,SAAA,IAAA,GA4C8B,CA5C9B,GA4CkC,CA5ClC,KA+CN,EA/CX;;;AACK;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CwB,iBAmCnB,YAnCmB,CAAA,mBAAA,MAAA,CAAA,CAAA,IAAA,EAoC3B,IApC2B,CAAA,EAqChC,YArCgC,CAqCnB,IArCmB,CAAA"}