@vinicunca/perkakas 1.7.1 → 1.8.0

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-BSiis5Fh.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-BMnz50TJ.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-D1qUxipp.js";export{e as split};

package/dist/string-to-path-C7H_9SeW.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-C7H_9SeW.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string-to-path-C7H_9SeW.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"}

package/dist/string-to-path-CS10CXKM.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-CS10CXKM.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string-to-path-CS10CXKM.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-D4HSg6rf.js

@@ -0,0 +1,2 @@
+const e=/^(?:0|[1-9]\d*)$/u;function t(n){let r=[],i=/\.{0,4096}(?<propName>[^.[\]]+)|\['(?<quoted>.{0,4096}?)'\]|\["(?<doubleQuoted>.{0,4096}?)"\]|\[(?<unquoted>.{0,4096}?)\]/uy,a;for(;(a=i.exec(n))!==null;){let{propName:n,quoted:i,doubleQuoted:o,unquoted:s}=a.groups;if(s!==void 0){r.push(...t(s));continue}r.push(n===void 0?i??o:e.test(n)?Number(n):n)}return r}export{t as stringToPath};
+//# sourceMappingURL=string-to-path-D4HSg6rf.js.map

package/dist/string-to-path-D4HSg6rf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-to-path-D4HSg6rf.js","names":["result: Array<string | number>","match: RegExpExecArray | null"],"sources":["../src/string-to-path.ts"],"sourcesContent":["/* eslint-disable no-nested-ternary */\nimport type { IsNumericLiteral, IsStringLiteral } from 'type-fest';\n\n// This is the most efficient way to check an arbitrary string if it is a simple\n// non-negative integer. We use character ranges instead of the `\\d` character\n// class to avoid matching non-ascii digits (e.g. Arabic-Indic digits), while\n// maintaining that the regular expression supports unicode.\nconst NON_NEGATIVE_INTEGER_RE = /^(?:0|[1-9]\\d*)$/u;\n\ntype StringToPath<S>\n  // We can only compute the path type for literals that TypeScript can\n  // break down further into parts.\n  = IsStringLiteral<S> extends true\n    ? StringToPathImpl<S>\n    : Array<string | number>;\n\ntype StringToPathImpl<S>\n  // We start by checking the 2 quoted variants of the square bracket access\n  // syntax. We do this in a single check and not in a subsequent check that\n  // would only extract the quoted part so that we can catch cases where the\n  // quoted part itself contains square brackets. This allows TypeScript to be\n  // \"greedy\" about what it infers into Quoted and DoubleQuoted.\n  = S extends `${infer Head}['${infer Quoted}']${infer Tail}`\n    ? [...StringToPath<Head>, Quoted, ...StringToPath<Tail>]\n    : S extends `${infer Head}[\"${infer DoubleQuoted}\"]${infer Tail}`\n      ? [...StringToPath<Head>, DoubleQuoted, ...StringToPath<Tail>]\n      // If we have an unquoted property access we also need to run the\n      // contents recursively too (unlike the quoted variants above).\n      : S extends `${infer Head}[${infer Unquoted}]${infer Tail}`\n        ? [\n            ...StringToPath<Head>,\n            ...StringToPath<Unquoted>,\n            ...StringToPath<Tail>,\n          ]\n        // Finally, we process any dots one after the other from left to\n        // right. TypeScript will be non-greedy here, putting *everything*\n        // after the first dot into the Tail.\n        : S extends `${infer Head}.${infer Tail}`\n          ? [...StringToPath<Head>, ...StringToPath<Tail>]\n          // Finally we need to handle the few cases of simple literals.\n          : '' extends S\n            // There are some edge-cases where Lodash will try to access an\n            // empty property, but those seem nonsensical in practice so we\n            // prefer just skipping these cases.\n            ? []\n            // We differ from Lodash in the way we handle numbers. Lodash\n            // returns everything in the path as a string, and relies on JS to\n            // coerce array accessors to numbers (or the other way around in\n            // practice, e.g., `myArray[123] === myArray['123']`), but from a\n            // typing perspective the two are not the same and we need the\n            // path to be accurate about it.\n            : S extends `${infer N extends number}`\n              ? [\n                  // TypeScript considers \" 123 \" to still extend `${number}`,\n                  // but would type is as `string` instead of a literal. We\n                  // can use that fact to make sure we only consider simple\n                  // number literals as numbers, and take the rest as strings.\n                  IsNumericLiteral<N> extends true ? N : S,\n                ]\n              // This simplest form of a path is just a single string literal.\n              : [S];\n\n/**\n * A utility to allow JSONPath-like strings to be used in other utilities which\n * take an array of path segments as input (e.g. `pathOr`, `setPath`, etc...).\n * The main purpose of this utility is to act as a bridge between the runtime\n * implementation that converts the path to an array, and the type-system that\n * parses the path string **type** into an array **type**. This type allows us\n * to return fine-grained types and to enforce correctness at the type-level.\n *\n * We **discourage** using this utility for new code. This utility is for legacy\n * code that already contains path strings (which are accepted by Lodash). We\n * strongly recommend using *path arrays* instead as they provide better\n * developer experience via significantly faster type-checking, fine-grained\n * error messages, and automatic typeahead suggestions for each segment of the\n * path.\n *\n * There are a bunch of limitations to this utility derived from the\n * limitations of the type itself, these are usually edge-cases around deeply\n * nested paths, escaping, whitespaces, and empty segments. This is true even\n * in cases where the runtime implementation can better handle them, this is\n * intentional. See the tests for this utility for more details and the\n * expected outputs*.\n *\n * @param path - A string path.\n * @signature\n *   P.stringToPath(path)\n * @example\n *   P.stringToPath('a.b[0].c') // => ['a', 'b', 0, 'c']\n * @dataFirst\n * @category Utility\n */\nexport function stringToPath<const Path extends string>(\n  path: Path,\n): StringToPath<Path> {\n  const result: Array<string | number> = [];\n\n  // There are four possible ways to define a path segment::\n  // - `propName`: is used to parse dot-notation paths, e.g. 'foo.bar.baz', we\n  // allow multiple sequential dots because our type allows them, but they are\n  // semantically meaningless. Note that this would also allow strings starting\n  // with a dot, e.g. `.foo`, this is fine because the dot itself is just used\n  // as a separator and is ignored in the final path.\n  // - `quoted`, `doubleQuoted`: used within square bracket notation to prevent\n  // any recursive parsing of their contents. As for the type itself, we only\n  // allow quote symbols to appear immediately after the opening square bracket\n  // and immediately before the closing square bracket, this allows us to handle\n  // more gracefully cases where a quote symbol might appear within the quoted\n  // part.\n  // - `unquoted`: If the contents of the square brackets are not quoted they\n  // will match this group (this is why the order is important here!). Contents\n  // of this group get parsed *recursively*.\n  //\n  // NOTE: We limit all repeats to 4096 characters to avoid a possible attack\n  // vector when the input to this function is controlled by the user. This is\n  // due to a DoS timing attack because regex backtracking is non-linear.\n  // @see: https://codeql.github.com/codeql-query-help/javascript/js-polynomial-redos/\n  const pathSegmentRe\n    = /\\.{0,4096}(?<propName>[^.[\\]]+)|\\['(?<quoted>.{0,4096}?)'\\]|\\[\"(?<doubleQuoted>.{0,4096}?)\"\\]|\\[(?<unquoted>.{0,4096}?)\\]/uy;\n\n  let match: RegExpExecArray | null;\n  // eslint-disable-next-line no-cond-assign\n  while ((match = pathSegmentRe.exec(path)) !== null) {\n    const { propName, quoted, doubleQuoted, unquoted } = match.groups!;\n\n    if (unquoted !== undefined) {\n      result.push(...stringToPath(unquoted));\n      continue;\n    }\n\n    result.push(\n      propName === undefined\n        ? (quoted ?? doubleQuoted!)\n        // The only way to differentiate between array indices and properties\n        // is to check if the property is a non-negative integer. In those\n        // cases we perform the conversion (unlike Lodash).\n        : NON_NEGATIVE_INTEGER_RE.test(propName)\n          ? Number(propName)\n          : propName,\n    );\n  }\n\n  return result;\n}\n"],"mappings":"AAOA,MAAM,EAA0B,oBAqFhC,SAAgB,EACd,EACoB,CACpB,IAAMA,EAAiC,EAAE,CAsBnC,EACF,8HAEAC,EAEJ,MAAQ,EAAQ,EAAc,KAAK,EAAK,IAAM,MAAM,CAClD,GAAM,CAAE,WAAU,SAAQ,eAAc,YAAa,EAAM,OAE3D,GAAI,IAAa,IAAA,GAAW,CAC1B,EAAO,KAAK,GAAG,EAAa,EAAS,CAAC,CACtC,SAGF,EAAO,KACL,IAAa,IAAA,GACR,GAAU,EAIX,EAAwB,KAAK,EAAS,CACpC,OAAO,EAAS,CAChB,EACP,CAGH,OAAO"}

package/dist/string-to-path-Q_OMxElX.cjs

@@ -0,0 +1 @@
+const e=/^(?:0|[1-9]\d*)$/u;function t(n){let r=[],i=/\.{0,4096}(?<propName>[^.[\]]+)|\['(?<quoted>.{0,4096}?)'\]|\["(?<doubleQuoted>.{0,4096}?)"\]|\[(?<unquoted>.{0,4096}?)\]/uy,a;for(;(a=i.exec(n))!==null;){let{propName:n,quoted:i,doubleQuoted:o,unquoted:s}=a.groups;if(s!==void 0){r.push(...t(s));continue}r.push(n===void 0?i??o:e.test(n)?Number(n):n)}return r}Object.defineProperty(exports,`stringToPath`,{enumerable:!0,get:function(){return t}});

package/dist/string-to-path.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkTSP3FU72cjs = require('./chunk-TSP3FU72.cjs');require('./chunk-MBGSSEZN.cjs');exports.stringToPath = _chunkTSP3FU72cjs.a;
+const e=require(`./string-to-path-Q_OMxElX.cjs`);exports.stringToPath=e.stringToPath;

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

@@ -1,43 +1,2 @@
-import { IsStringLiteral, IsNumericLiteral } from 'type-fest';
-
-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>;
-
-export { stringToPath };
+import { stringToPath } from "./string-to-path-C7H_9SeW.cjs";
+export { stringToPath };

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

@@ -1,43 +1,2 @@
-import { IsStringLiteral, IsNumericLiteral } from 'type-fest';
-
-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>;
-
-export { stringToPath };
+import { stringToPath } from "./string-to-path-CS10CXKM.js";
+export { stringToPath };

package/dist/string-to-path.js

@@ -1 +1 @@
-import{a}from"./chunk-ZMG3NQDL.js";import"./chunk-EK7ODJWE.js";export{a as stringToPath};
+import{stringToPath as e}from"./string-to-path-D4HSg6rf.js";export{e as stringToPath};

package/dist/subtract-CktIeIei.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}export{t as subtract};
+//# sourceMappingURL=subtract-CktIeIei.js.map

package/dist/subtract-CktIeIei.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtract-CktIeIei.js","names":[],"sources":["../src/subtract.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Subtracts two numbers.\n *\n * @param value - The number.\n * @param subtrahend - The number to subtract from the value.\n * @signature\n *    P.subtract(value, subtrahend);\n * @example\n *    P.subtract(10, 5) // => 5\n *    P.subtract(10, -5) // => 15\n *    P.reduce([1, 2, 3, 4], P.subtract, 20) // => 10\n * @dataFirst\n * @category Number\n */\nexport function subtract(value: bigint, subtrahend: bigint): bigint;\nexport function subtract(value: number, subtrahend: number): number;\n\n/**\n * Subtracts two numbers.\n *\n * @param subtrahend - The number to subtract from the value.\n * @signature\n *    P.subtract(subtrahend)(value);\n * @example\n *    P.subtract(5)(10) // => 5\n *    P.subtract(-5)(10) // => 15\n *    P.map([1, 2, 3, 4], P.subtract(1)) // => [0, 1, 2, 3]\n * @dataLast\n * @category Number\n */\nexport function subtract(subtrahend: bigint): (value: bigint) => bigint;\nexport function subtract(subtrahend: number): (value: number) => number;\n\nexport function subtract(...args: ReadonlyArray<unknown>): unknown {\n  return curry(subtractImplementation, args);\n}\n\n// The implementation only uses `number` types, but that's just because it's\n// hard to tell typescript that both value and subtrahend would be of the same\n// type.\nfunction subtractImplementation(value: number, subtrahend: number): number {\n  return value - subtrahend;\n}\n"],"mappings":"4CAmCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAM5C,SAAS,EAAuB,EAAe,EAA4B,CACzE,OAAO,EAAQ"}

package/dist/subtract-Crhaj882.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.defineProperty(exports,`subtract`,{enumerable:!0,get:function(){return t}});

package/dist/subtract-DxrBj9Ir.d.ts

@@ -0,0 +1,35 @@
+//#region src/subtract.d.ts
+/**
+ * Subtracts two numbers.
+ *
+ * @param value - The number.
+ * @param subtrahend - The number to subtract from the value.
+ * @signature
+ *    P.subtract(value, subtrahend);
+ * @example
+ *    P.subtract(10, 5) // => 5
+ *    P.subtract(10, -5) // => 15
+ *    P.reduce([1, 2, 3, 4], P.subtract, 20) // => 10
+ * @dataFirst
+ * @category Number
+ */
+declare function subtract(value: bigint, subtrahend: bigint): bigint;
+declare function subtract(value: number, subtrahend: number): number;
+/**
+ * Subtracts two numbers.
+ *
+ * @param subtrahend - The number to subtract from the value.
+ * @signature
+ *    P.subtract(subtrahend)(value);
+ * @example
+ *    P.subtract(5)(10) // => 5
+ *    P.subtract(-5)(10) // => 15
+ *    P.map([1, 2, 3, 4], P.subtract(1)) // => [0, 1, 2, 3]
+ * @dataLast
+ * @category Number
+ */
+declare function subtract(subtrahend: bigint): (value: bigint) => bigint;
+declare function subtract(subtrahend: number): (value: number) => number;
+//#endregion
+export { subtract };
+//# sourceMappingURL=subtract-DxrBj9Ir.d.ts.map

package/dist/subtract-DxrBj9Ir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtract-DxrBj9Ir.d.ts","names":[],"sources":["../src/subtract.ts"],"sourcesContent":[],"mappings":";;AAgBA;AACA;AAeA;AACA;;;;;;;;;;iBAjBgB,QAAA;iBACA,QAAA;;;;;;;;;;;;;;iBAeA,QAAA;iBACA,QAAA"}

package/dist/subtract-WxyebhP-.d.cts

@@ -0,0 +1,35 @@
+//#region src/subtract.d.ts
+/**
+ * Subtracts two numbers.
+ *
+ * @param value - The number.
+ * @param subtrahend - The number to subtract from the value.
+ * @signature
+ *    P.subtract(value, subtrahend);
+ * @example
+ *    P.subtract(10, 5) // => 5
+ *    P.subtract(10, -5) // => 15
+ *    P.reduce([1, 2, 3, 4], P.subtract, 20) // => 10
+ * @dataFirst
+ * @category Number
+ */
+declare function subtract(value: bigint, subtrahend: bigint): bigint;
+declare function subtract(value: number, subtrahend: number): number;
+/**
+ * Subtracts two numbers.
+ *
+ * @param subtrahend - The number to subtract from the value.
+ * @signature
+ *    P.subtract(subtrahend)(value);
+ * @example
+ *    P.subtract(5)(10) // => 5
+ *    P.subtract(-5)(10) // => 15
+ *    P.map([1, 2, 3, 4], P.subtract(1)) // => [0, 1, 2, 3]
+ * @dataLast
+ * @category Number
+ */
+declare function subtract(subtrahend: bigint): (value: bigint) => bigint;
+declare function subtract(subtrahend: number): (value: number) => number;
+//#endregion
+export { subtract };
+//# sourceMappingURL=subtract-WxyebhP-.d.cts.map

package/dist/subtract-WxyebhP-.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtract-WxyebhP-.d.cts","names":[],"sources":["../src/subtract.ts"],"sourcesContent":[],"mappings":";;AAgBA;AACA;AAeA;AACA;;;;;;;;;;iBAjBgB,QAAA;iBACA,QAAA;;;;;;;;;;;;;;iBAeA,QAAA;iBACA,QAAA"}

package/dist/subtract.cjs

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

package/dist/subtract.d.cts

@@ -1,33 +1,2 @@
-/**
- * Subtracts two numbers.
- *
- * @param value - The number.
- * @param subtrahend - The number to subtract from the value.
- * @signature
- *    P.subtract(value, subtrahend);
- * @example
- *    P.subtract(10, 5) // => 5
- *    P.subtract(10, -5) // => 15
- *    P.reduce([1, 2, 3, 4], P.subtract, 20) // => 10
- * @dataFirst
- * @category Number
- */
-declare function subtract(value: bigint, subtrahend: bigint): bigint;
-declare function subtract(value: number, subtrahend: number): number;
-/**
- * Subtracts two numbers.
- *
- * @param subtrahend - The number to subtract from the value.
- * @signature
- *    P.subtract(subtrahend)(value);
- * @example
- *    P.subtract(5)(10) // => 5
- *    P.subtract(-5)(10) // => 15
- *    P.map([1, 2, 3, 4], P.subtract(1)) // => [0, 1, 2, 3]
- * @dataLast
- * @category Number
- */
-declare function subtract(subtrahend: bigint): (value: bigint) => bigint;
-declare function subtract(subtrahend: number): (value: number) => number;
-
-export { subtract };
+import { subtract } from "./subtract-WxyebhP-.cjs";
+export { subtract };

package/dist/subtract.d.ts

@@ -1,33 +1,2 @@
-/**
- * Subtracts two numbers.
- *
- * @param value - The number.
- * @param subtrahend - The number to subtract from the value.
- * @signature
- *    P.subtract(value, subtrahend);
- * @example
- *    P.subtract(10, 5) // => 5
- *    P.subtract(10, -5) // => 15
- *    P.reduce([1, 2, 3, 4], P.subtract, 20) // => 10
- * @dataFirst
- * @category Number
- */
-declare function subtract(value: bigint, subtrahend: bigint): bigint;
-declare function subtract(value: number, subtrahend: number): number;
-/**
- * Subtracts two numbers.
- *
- * @param subtrahend - The number to subtract from the value.
- * @signature
- *    P.subtract(subtrahend)(value);
- * @example
- *    P.subtract(5)(10) // => 5
- *    P.subtract(-5)(10) // => 15
- *    P.map([1, 2, 3, 4], P.subtract(1)) // => [0, 1, 2, 3]
- * @dataLast
- * @category Number
- */
-declare function subtract(subtrahend: bigint): (value: bigint) => bigint;
-declare function subtract(subtrahend: number): (value: number) => number;
-
-export { subtract };
+import { subtract } from "./subtract-DxrBj9Ir.js";
+export { subtract };

package/dist/subtract.js

@@ -1 +1 @@
-import{a}from"./chunk-2H7RTCCP.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as subtract};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{subtract as e}from"./subtract-CktIeIei.js";export{e as subtract};

package/dist/sum-BL8tGYgI.cjs

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

package/dist/sum-CcpwR68x.d.cts

@@ -0,0 +1,50 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+
+//#region src/sum.d.ts
+type Sum<T extends IterableContainer<bigint> | IterableContainer<number>> = T extends readonly [] ? 0 : T extends readonly [bigint, ...ReadonlyArray<unknown>] ? bigint : T[number] extends bigint ? 0 | bigint : number;
+/**
+ * Sums the numbers in the array, or return 0 for an empty array.
+ *
+ * Works for both `number` and `bigint` arrays, but not arrays that contain both
+ * types.
+ *
+ * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of
+ * the type of the array; to avoid adding this to the return type for cases
+ * where the array is known to be non-empty you can use `hasAtLeast` or
+ * `isEmpty` to guard against this case.
+ *
+ * @param data - The array of numbers.
+ * @signature
+ *   P.sum(data);
+ * @example
+ *   P.sum([1, 2, 3]); // => 6
+ *   P.sum([1n, 2n, 3n]); // => 6n
+ *   P.sum([]); // => 0
+ * @dataFirst
+ * @category Number
+ */
+declare function sum<T extends IterableContainer<bigint> | IterableContainer<number>>(data: T): Sum<T>;
+/**
+ * Sums the numbers in the array, or return 0 for an empty array.
+ *
+ * Works for both `number` and `bigint` arrays, but not arrays that contain both
+ * types.
+ *
+ * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of
+ * the type of the array; to avoid adding this to the return type for cases
+ * where the array is known to be non-empty you can use `hasAtLeast` or
+ * `isEmpty`to guard against this case.
+ *
+ * @signature
+ *   P.sum()(data);
+ * @example
+ *   P.pipe([1, 2, 3], P.sum()); // => 6
+ *   P.pipe([1n, 2n, 3n], R.sum()); // => 6n
+ *   P.pipe([], P.sum()); // => 0
+ * @dataLast
+ * @category Number
+ */
+declare function sum(): <T extends IterableContainer<bigint> | IterableContainer<number>>(data: T) => Sum<T>;
+//#endregion
+export { sum };
+//# sourceMappingURL=sum-CcpwR68x.d.cts.map

package/dist/sum-CcpwR68x.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sum-CcpwR68x.d.cts","names":[],"sources":["../src/sum.ts"],"sourcesContent":[],"mappings":";;;KAIK,cAAc,4BAA4B,6BAE3C,4BAGE,+BAA+B,mCAG7B;;AAZqE;;;;;;;;;AAsC7E;;;;;;;;AAwBA;;;AACwC,iBAzBxB,GAyBwB,CAAA,UAxB5B,iBAwB4B,CAAA,MAAA,CAAA,GAxBA,iBAwBA,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EAvBhC,CAuBgC,CAAA,EAvB5B,GAuB4B,CAvBxB,CAuBwB,CAAA;;;;;;;;;;;;;;;;;;;;;iBADxB,GAAA,CAAA,cACJ,4BAA4B,iCAEhC,MACH,IAAI"}