Aktueller Stand

backend/node_modules/remeda/README.md

@@ -0,0 +1,79 @@
+# Remeda
+
+The first "data-first" and "data-last" utility library designed especially for TypeScript.
+
+[![GitHub License](https://img.shields.io/github/license/remeda/remeda?style=flat-square)](https://github.com/remeda/remeda?tab=MIT-1-ov-file#readme)
+![GitHub top language](https://img.shields.io/github/languages/top/remeda/remeda?logo=typescript&style=flat-square)
+[![NPM](https://img.shields.io/npm/v/remeda?logo=npm&style=flat-square)](https://www.npmjs.org/package/remeda)
+[![NPM Downloads](https://img.shields.io/npm/dm/remeda?logo=npm&style=flat-square)](https://npmtrends.com/remeda)
+![GitHub Repo stars](https://img.shields.io/github/stars/remeda/remeda?logo=github&style=flat-square)
+[![Libraries.io SourceRank](https://img.shields.io/librariesio/sourcerank/npm/remeda?logo=librariesdotio&style=flat-square)](https://libraries.io/npm/remeda/sourcerank)<br />
+[![Codecov](https://img.shields.io/codecov/c/github/remeda/remeda?logo=codecov&style=flat-square)](https://codecov.io/gh/remeda/remeda)
+[![GitHub branch status](https://img.shields.io/github/checks-status/remeda/remeda/main?logo=github&style=flat-square)](https://github.com/remeda/remeda/actions/workflows)
+[![GitHub Release Date](https://img.shields.io/github/release-date/remeda/remeda?logo=npm&style=flat-square)](https://github.com/remeda/remeda/releases)
+[![Commits](https://img.shields.io/github/commit-activity/y/remeda/remeda?logo=github&style=flat-square)](https://github.com/remeda/remeda/commits/main/)
+[![All contributors](https://img.shields.io/github/contributors/remeda/remeda?logo=github&style=flat-square)](https://github.com/remeda/remeda/graphs/contributors)
+
+## Documentation
+
+Read the full docs and API reference on [remedajs.com/docs](https://remedajs.com/docs).
+
+Migrating from other libraries? Check out our migration guides for [Lodash](https://remedajs.com/migrate/lodash) and [Ramda](https://remedajs.com/migrate/ramda)!
+
+Interested in contributing? Read the [contributing guide](https://github.com/remeda/remeda/blob/main/CONTRIBUTING.md).
+
+## Features
+
+- First-class TypeScript support, with types that are as specific as possible.
+- Supports data-first (`R.filter(array, fn)`) and data-last (`R.filter(fn)(array)`) approaches.
+- Lazy evaluation support with `pipe` and `piped`.
+- Runtime and types are both extensively tested, with full code coverage.
+- Tree-shakable, supports CJS and ESM.
+- Fully documented with JSDoc, supports in-editor function documentation.
+
+## Getting started
+
+### Installation
+
+```bash
+npm install remeda
+pnpm add remeda
+yarn add remeda
+bun install remeda
+deno add jsr:@remeda/remeda
+```
+
+### Usage
+
+```js
+// Import everything:
+import * as R from "remeda";
+
+// Or import methods individually:
+// import { pipe, tap, unique, take } from "remeda";
+
+R.pipe(
+  [1, 2, 2, 3, 3, 4, 5, 6],
+  R.tap((value) => console.log(`Got ${value}`)),
+  R.unique(),
+  R.take(3),
+); // => [1, 2, 3]
+
+// Console output:
+// Got 1
+// Got 2
+// Got 2
+// Got 3
+```
+
+### Getting help
+
+Questions, bug reports, and feature requests are tracked in [GitHub issues](https://github.com/remeda/remeda/issues).
+
+## Contributors
+
+<a href="https://github.com/remeda/remeda/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=remeda/remeda" />
+</a>
+
+Made with [contrib.rocks](https://contrib.rocks).

backend/node_modules/remeda/dist/add.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}const n=(e,t)=>e+t;exports.add=t;
+//# sourceMappingURL=add.cjs.map

backend/node_modules/remeda/dist/add.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.cjs","names":["purry"],"sources":["../src/add.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Adds two numbers.\n *\n * @param value - The number.\n * @param addend - The number to add to the value.\n * @signature\n *    R.add(value, addend);\n * @example\n *    R.add(10, 5) // => 15\n *    R.add(10, -5) // => 5\n * @dataFirst\n * @category Number\n */\nexport function add(value: bigint, addend: bigint): bigint;\nexport function add(value: number, addend: number): number;\n\n/**\n * Adds two numbers.\n *\n * @param addend - The number to add to the value.\n * @signature\n *    R.add(addend)(value);\n * @example\n *    R.add(5)(10) // => 15\n *    R.add(-5)(10) // => 5\n *    R.map([1, 2, 3, 4], R.add(1)) // => [2, 3, 4, 5]\n * @dataLast\n * @category Number\n */\nexport function add(addend: bigint): (value: bigint) => bigint;\nexport function add(addend: number): (value: number) => number;\n\nexport function add(...args: readonly unknown[]): unknown {\n  return purry(addImplementation, 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 addend would be of the same type.\nconst addImplementation = (value: number, addend: number): number =>\n  value + addend;\n"],"mappings":"wCAkCA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAOA,EAAAA,EAAM,EAAmB,EAAK,CAKvC,MAAM,GAAqB,EAAe,IACxC,EAAQ"}

backend/node_modules/remeda/dist/add.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}const n=(e,t)=>e+t;export{t as add};
+//# sourceMappingURL=add.js.map

backend/node_modules/remeda/dist/add.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.js","names":[],"sources":["../src/add.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Adds two numbers.\n *\n * @param value - The number.\n * @param addend - The number to add to the value.\n * @signature\n *    R.add(value, addend);\n * @example\n *    R.add(10, 5) // => 15\n *    R.add(10, -5) // => 5\n * @dataFirst\n * @category Number\n */\nexport function add(value: bigint, addend: bigint): bigint;\nexport function add(value: number, addend: number): number;\n\n/**\n * Adds two numbers.\n *\n * @param addend - The number to add to the value.\n * @signature\n *    R.add(addend)(value);\n * @example\n *    R.add(5)(10) // => 15\n *    R.add(-5)(10) // => 5\n *    R.map([1, 2, 3, 4], R.add(1)) // => [2, 3, 4, 5]\n * @dataLast\n * @category Number\n */\nexport function add(addend: bigint): (value: bigint) => bigint;\nexport function add(addend: number): (value: number) => number;\n\nexport function add(...args: readonly unknown[]): unknown {\n  return purry(addImplementation, 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 addend would be of the same type.\nconst addImplementation = (value: number, addend: number): number =>\n  value + addend;\n"],"mappings":"wCAkCA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAO,EAAM,EAAmB,EAAK,CAKvC,MAAM,GAAqB,EAAe,IACxC,EAAQ"}

backend/node_modules/remeda/dist/addProp.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}const n=(e,t,n)=>({...e,[t]:n});exports.addProp=t;
+//# sourceMappingURL=addProp.cjs.map

backend/node_modules/remeda/dist/addProp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"addProp.cjs","names":["purry"],"sources":["../src/addProp.ts"],"sourcesContent":["import type { UpsertProp } from \"./internal/types/UpsertProp\";\nimport { purry } from \"./purry\";\n\n/**\n * Add a new property to an object.\n *\n * The function doesn't do any checks on the input object. If the property\n * already exists it will be overwritten, and the type of the new value is not\n * checked against the previous type.\n *\n * Use `set` to override values explicitly with better protections.\n *\n * @param obj - The target object.\n * @param prop - The property name.\n * @param value - The property value.\n * @signature\n *    R.addProp(obj, prop, value)\n * @example\n *    R.addProp({firstName: 'john'}, 'lastName', 'doe') // => {firstName: 'john', lastName: 'doe'}\n * @dataFirst\n * @category Object\n */\nexport function addProp<T, K extends PropertyKey, V>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V>;\n\n/**\n * Add a new property to an object.\n *\n * The function doesn't do any checks on the input object. If the property\n * already exists it will be overwritten, and the type of the new value is not\n * checked against the previous type.\n *\n * Use `set` to override values explicitly with better protections.\n *\n * @param prop - The property name.\n * @param value - The property value.\n * @signature\n *    R.addProp(prop, value)(obj)\n * @example\n *    R.addProp('lastName', 'doe')({firstName: 'john'}) // => {firstName: 'john', lastName: 'doe'}\n * @dataLast\n * @category Object\n */\nexport function addProp<T, K extends PropertyKey, V>(\n  prop: K,\n  value: V,\n): (obj: T) => UpsertProp<T, K, V>;\n\nexport function addProp(...args: readonly unknown[]): unknown {\n  return purry(addPropImplementation, args);\n}\n\nconst addPropImplementation = <T, K extends PropertyKey, V>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V> =>\n  // @ts-expect-error [ts2322] - Hard to type...\n  ({ ...obj, [prop]: value });\n"],"mappings":"wCAmDA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,EACA,KAGC,CAAE,GAAG,GAAM,GAAO,EAAO"}

backend/node_modules/remeda/dist/addProp.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}const n=(e,t,n)=>({...e,[t]:n});export{t as addProp};
+//# sourceMappingURL=addProp.js.map

backend/node_modules/remeda/dist/addProp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addProp.js","names":[],"sources":["../src/addProp.ts"],"sourcesContent":["import type { UpsertProp } from \"./internal/types/UpsertProp\";\nimport { purry } from \"./purry\";\n\n/**\n * Add a new property to an object.\n *\n * The function doesn't do any checks on the input object. If the property\n * already exists it will be overwritten, and the type of the new value is not\n * checked against the previous type.\n *\n * Use `set` to override values explicitly with better protections.\n *\n * @param obj - The target object.\n * @param prop - The property name.\n * @param value - The property value.\n * @signature\n *    R.addProp(obj, prop, value)\n * @example\n *    R.addProp({firstName: 'john'}, 'lastName', 'doe') // => {firstName: 'john', lastName: 'doe'}\n * @dataFirst\n * @category Object\n */\nexport function addProp<T, K extends PropertyKey, V>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V>;\n\n/**\n * Add a new property to an object.\n *\n * The function doesn't do any checks on the input object. If the property\n * already exists it will be overwritten, and the type of the new value is not\n * checked against the previous type.\n *\n * Use `set` to override values explicitly with better protections.\n *\n * @param prop - The property name.\n * @param value - The property value.\n * @signature\n *    R.addProp(prop, value)(obj)\n * @example\n *    R.addProp('lastName', 'doe')({firstName: 'john'}) // => {firstName: 'john', lastName: 'doe'}\n * @dataLast\n * @category Object\n */\nexport function addProp<T, K extends PropertyKey, V>(\n  prop: K,\n  value: V,\n): (obj: T) => UpsertProp<T, K, V>;\n\nexport function addProp(...args: readonly unknown[]): unknown {\n  return purry(addPropImplementation, args);\n}\n\nconst addPropImplementation = <T, K extends PropertyKey, V>(\n  obj: T,\n  prop: K,\n  value: V,\n): UpsertProp<T, K, V> =>\n  // @ts-expect-error [ts2322] - Hard to type...\n  ({ ...obj, [prop]: value });\n"],"mappings":"wCAmDA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,EACA,KAGC,CAAE,GAAG,GAAM,GAAO,EAAO"}

backend/node_modules/remeda/dist/allPass.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}const n=(e,t)=>t.every(t=>t(e));exports.allPass=t;
+//# sourceMappingURL=allPass.cjs.map

backend/node_modules/remeda/dist/allPass.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"allPass.cjs","names":["purry"],"sources":["../src/allPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether all predicates returns true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    R.allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    R.allPass(12, fns) // => true\n *    R.allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether all predicates returns true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    R.allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    R.allPass(fns)(12) // => true\n *    R.allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function allPass(...args: readonly unknown[]): unknown {\n  return purry(allPassImplementation, args);\n}\n\nconst allPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.every((fn) => fn(data));\n"],"mappings":"wCA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,MAAO,GAAO,EAAG,EAAK,CAAC"}

backend/node_modules/remeda/dist/allPass.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}const n=(e,t)=>t.every(t=>t(e));export{t as allPass};
+//# sourceMappingURL=allPass.js.map

backend/node_modules/remeda/dist/allPass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allPass.js","names":[],"sources":["../src/allPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether all predicates returns true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    R.allPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    R.allPass(12, fns) // => true\n *    R.allPass(8, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function allPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether all predicates returns true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    R.allPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    R.allPass(fns)(12) // => true\n *    R.allPass(fns)(8) // => false\n * @dataLast\n * @category Array\n */\nexport function allPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function allPass(...args: readonly unknown[]): unknown {\n  return purry(allPassImplementation, args);\n}\n\nconst allPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.every((fn) => fn(data));\n"],"mappings":"wCA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,MAAO,GAAO,EAAG,EAAK,CAAC"}

backend/node_modules/remeda/dist/anyPass.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}const n=(e,t)=>t.some(t=>t(e));exports.anyPass=t;
+//# sourceMappingURL=anyPass.cjs.map

backend/node_modules/remeda/dist/anyPass.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"anyPass.cjs","names":["purry"],"sources":["../src/anyPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether any predicate returns true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    R.anyPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    R.anyPass(8, fns) // => true\n *    R.anyPass(11, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function anyPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether any predicate returns true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    R.anyPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    R.anyPass(fns)(8) // => true\n *    R.anyPass(fns)(11) // => false\n * @dataLast\n * @category Array\n */\nexport function anyPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function anyPass(...args: readonly unknown[]): unknown {\n  return purry(anyPassImplementation, args);\n}\n\nconst anyPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.some((fn) => fn(data));\n"],"mappings":"wCA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,KAAM,GAAO,EAAG,EAAK,CAAC"}

backend/node_modules/remeda/dist/anyPass.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}const n=(e,t)=>t.some(t=>t(e));export{t as anyPass};
+//# sourceMappingURL=anyPass.js.map

backend/node_modules/remeda/dist/anyPass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anyPass.js","names":[],"sources":["../src/anyPass.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Determines whether any predicate returns true for the input data.\n *\n * @param data - The input data for predicates.\n * @param fns - The list of predicates.\n * @signature\n *    R.anyPass(data, fns)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    R.anyPass(8, fns) // => true\n *    R.anyPass(11, fns) // => false\n * @dataFirst\n * @category Array\n */\nexport function anyPass<T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean;\n\n/**\n * Determines whether any predicate returns true for the input data.\n *\n * @param fns - The list of predicates.\n * @signature\n *    R.anyPass(fns)(data)\n * @example\n *    const isDivisibleBy3 = (x: number) => x % 3 === 0\n *    const isDivisibleBy4 = (x: number) => x % 4 === 0\n *    const fns = [isDivisibleBy3, isDivisibleBy4]\n *    R.anyPass(fns)(8) // => true\n *    R.anyPass(fns)(11) // => false\n * @dataLast\n * @category Array\n */\nexport function anyPass<T>(\n  fns: readonly ((data: T) => boolean)[],\n): (data: T) => boolean;\n\nexport function anyPass(...args: readonly unknown[]): unknown {\n  return purry(anyPassImplementation, args);\n}\n\nconst anyPassImplementation = <T>(\n  data: T,\n  fns: readonly ((data: T) => boolean)[],\n): boolean => fns.some((fn) => fn(data));\n"],"mappings":"wCA0CA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IACY,EAAI,KAAM,GAAO,EAAG,EAAK,CAAC"}

backend/node_modules/remeda/dist/binarySearchCutoffIndex-Bdl6tV2n.js

@@ -0,0 +1,2 @@
+function e(e,t){let n=0,r=e.length;for(;n<r;){let i=n+r>>>1,a=e[i];t(a,i,e)?n=i+1:r=i}return r}export{e as t};
+//# sourceMappingURL=binarySearchCutoffIndex-Bdl6tV2n.js.map

backend/node_modules/remeda/dist/binarySearchCutoffIndex-Bdl6tV2n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binarySearchCutoffIndex-Bdl6tV2n.js","names":[],"sources":["../src/internal/binarySearchCutoffIndex.ts"],"sourcesContent":["/**\n * A binary search implementation that finds the index at which `predicate`\n * stops returning `true` and starts returning `false` (consistently) when run\n * on the items of the array. It **assumes** that mapping the array via the\n * predicate results in the shape `[...true[], ...false[]]`. *For any other case\n * the result is unpredictable*.\n *\n * This is the base implementation of the `sortedIndex` functions which define\n * the predicate for the user, for common use-cases.\n *\n * It is similar to `findIndex`, but runs at O(logN), whereas the latter is\n * general purpose function which runs on any array and predicate, but runs at\n * O(N) time.\n */\nexport function binarySearchCutoffIndex<T>(\n  array: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => boolean,\n): number {\n  let lowIndex = 0;\n  let highIndex = array.length;\n\n  while (lowIndex < highIndex) {\n    // eslint-disable-next-line no-bitwise -- We use bitwise operator here as a way to find the mid-point and round it down using the same operation.\n    const pivotIndex = (lowIndex + highIndex) >>> 1;\n    const pivot = array[pivotIndex]!;\n\n    if (predicate(pivot, pivotIndex, array)) {\n      lowIndex = pivotIndex + 1;\n    } else {\n      highIndex = pivotIndex;\n    }\n  }\n\n  return highIndex;\n}\n"],"mappings":"AAcA,SAAgB,EACd,EACA,EACQ,CACR,IAAI,EAAW,EACX,EAAY,EAAM,OAEtB,KAAO,EAAW,GAAW,CAE3B,IAAM,EAAc,EAAW,IAAe,EACxC,EAAQ,EAAM,GAEhB,EAAU,EAAO,EAAY,EAAM,CACrC,EAAW,EAAa,EAExB,EAAY,EAIhB,OAAO"}

backend/node_modules/remeda/dist/binarySearchCutoffIndex-Cgz2eJ3b.cjs

@@ -0,0 +1,2 @@
+function e(e,t){let n=0,r=e.length;for(;n<r;){let i=n+r>>>1,a=e[i];t(a,i,e)?n=i+1:r=i}return r}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});
+//# sourceMappingURL=binarySearchCutoffIndex-Cgz2eJ3b.cjs.map

backend/node_modules/remeda/dist/binarySearchCutoffIndex-Cgz2eJ3b.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"binarySearchCutoffIndex-Cgz2eJ3b.cjs","names":[],"sources":["../src/internal/binarySearchCutoffIndex.ts"],"sourcesContent":["/**\n * A binary search implementation that finds the index at which `predicate`\n * stops returning `true` and starts returning `false` (consistently) when run\n * on the items of the array. It **assumes** that mapping the array via the\n * predicate results in the shape `[...true[], ...false[]]`. *For any other case\n * the result is unpredictable*.\n *\n * This is the base implementation of the `sortedIndex` functions which define\n * the predicate for the user, for common use-cases.\n *\n * It is similar to `findIndex`, but runs at O(logN), whereas the latter is\n * general purpose function which runs on any array and predicate, but runs at\n * O(N) time.\n */\nexport function binarySearchCutoffIndex<T>(\n  array: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => boolean,\n): number {\n  let lowIndex = 0;\n  let highIndex = array.length;\n\n  while (lowIndex < highIndex) {\n    // eslint-disable-next-line no-bitwise -- We use bitwise operator here as a way to find the mid-point and round it down using the same operation.\n    const pivotIndex = (lowIndex + highIndex) >>> 1;\n    const pivot = array[pivotIndex]!;\n\n    if (predicate(pivot, pivotIndex, array)) {\n      lowIndex = pivotIndex + 1;\n    } else {\n      highIndex = pivotIndex;\n    }\n  }\n\n  return highIndex;\n}\n"],"mappings":"AAcA,SAAgB,EACd,EACA,EACQ,CACR,IAAI,EAAW,EACX,EAAY,EAAM,OAEtB,KAAO,EAAW,GAAW,CAE3B,IAAM,EAAc,EAAW,IAAe,EACxC,EAAQ,EAAM,GAEhB,EAAU,EAAO,EAAY,EAAM,CACrC,EAAW,EAAa,EAExB,EAAY,EAIhB,OAAO"}

backend/node_modules/remeda/dist/capitalize.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}const n=e=>`${e[0]?.toUpperCase()??``}${e.slice(1)}`;exports.capitalize=t;
+//# sourceMappingURL=capitalize.cjs.map

backend/node_modules/remeda/dist/capitalize.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"capitalize.cjs","names":["purry"],"sources":["../src/capitalize.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   R.capitalize(data);\n * @example\n *   R.capitalize(\"hello world\"); // \"Hello world\"\n * @dataFirst\n * @category String\n */\nexport function capitalize<T extends string>(data: T): Capitalize<T>;\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   R.capitalize()(data);\n * @example\n *   R.pipe(\"hello world\", R.capitalize()); // \"Hello world\"\n * @dataLast\n * @category String\n */\nexport function capitalize(): <T extends string>(data: T) => Capitalize<T>;\n\nexport function capitalize(...args: readonly unknown[]): unknown {\n  return purry(capitalizeImplementation, args);\n}\n\nconst capitalizeImplementation = <T extends string>(data: T): Capitalize<T> =>\n  `${data[0]?.toUpperCase() ?? \"\"}${data.slice(1)}` as Capitalize<T>;\n"],"mappings":"wCAqDA,SAAgB,EAAW,GAAG,EAAmC,CAC/D,OAAOA,EAAAA,EAAM,EAA0B,EAAK,CAG9C,MAAM,EAA8C,GAClD,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}

backend/node_modules/remeda/dist/capitalize.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}const n=e=>`${e[0]?.toUpperCase()??``}${e.slice(1)}`;export{t as capitalize};
+//# sourceMappingURL=capitalize.js.map

backend/node_modules/remeda/dist/capitalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capitalize.js","names":[],"sources":["../src/capitalize.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   R.capitalize(data);\n * @example\n *   R.capitalize(\"hello world\"); // \"Hello world\"\n * @dataFirst\n * @category String\n */\nexport function capitalize<T extends string>(data: T): Capitalize<T>;\n\n/**\n * Makes the first character of a string uppercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * for the runtime and the built-in [`Capitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#capitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: uppercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#uppercase)\n * to capitalize it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   R.capitalize()(data);\n * @example\n *   R.pipe(\"hello world\", R.capitalize()); // \"Hello world\"\n * @dataLast\n * @category String\n */\nexport function capitalize(): <T extends string>(data: T) => Capitalize<T>;\n\nexport function capitalize(...args: readonly unknown[]): unknown {\n  return purry(capitalizeImplementation, args);\n}\n\nconst capitalizeImplementation = <T extends string>(data: T): Capitalize<T> =>\n  `${data[0]?.toUpperCase() ?? \"\"}${data.slice(1)}` as Capitalize<T>;\n"],"mappings":"wCAqDA,SAAgB,EAAW,GAAG,EAAmC,CAC/D,OAAO,EAAM,EAA0B,EAAK,CAG9C,MAAM,EAA8C,GAClD,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}

backend/node_modules/remeda/dist/ceil.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`),t=require(`./withPrecision-BWCostXm.cjs`);function n(...n){return e.t(t.t(Math.ceil),n)}exports.ceil=n;
+//# sourceMappingURL=ceil.cjs.map

backend/node_modules/remeda/dist/ceil.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceil.cjs","names":["purry","withPrecision"],"sources":["../src/ceil.ts"],"sourcesContent":["import { withPrecision } from \"./internal/withPrecision\";\nimport { purry } from \"./purry\";\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round up.\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    R.ceil(value, precision);\n * @example\n *    R.ceil(123.9876, 3) // => 123.988\n *    R.ceil(483.22243, 1) // => 483.3\n *    R.ceil(8541, -1) // => 8550\n *    R.ceil(456789, -3) // => 457000\n * @dataFirst\n * @category Number\n */\nexport function ceil(value: number, precision: number): number;\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    R.ceil(precision)(value);\n * @example\n *    R.ceil(3)(123.9876) // => 123.988\n *    R.ceil(1)(483.22243) // => 483.3\n *    R.ceil(-1)(8541) // => 8550\n *    R.ceil(-3)(456789) // => 457000\n * @dataLast\n * @category Number\n */\nexport function ceil(precision: number): (value: number) => number;\n\nexport function ceil(...args: readonly unknown[]): unknown {\n  return purry(withPrecision(Math.ceil), args);\n}\n"],"mappings":"kFAwCA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAOA,EAAAA,EAAMC,EAAAA,EAAc,KAAK,KAAK,CAAE,EAAK"}

backend/node_modules/remeda/dist/ceil.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";import{t}from"./withPrecision-CGLvbgFW.js";function n(...n){return e(t(Math.ceil),n)}export{n as ceil};
+//# sourceMappingURL=ceil.js.map

backend/node_modules/remeda/dist/ceil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceil.js","names":[],"sources":["../src/ceil.ts"],"sourcesContent":["import { withPrecision } from \"./internal/withPrecision\";\nimport { purry } from \"./purry\";\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round up.\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    R.ceil(value, precision);\n * @example\n *    R.ceil(123.9876, 3) // => 123.988\n *    R.ceil(483.22243, 1) // => 483.3\n *    R.ceil(8541, -1) // => 8550\n *    R.ceil(456789, -3) // => 457000\n * @dataFirst\n * @category Number\n */\nexport function ceil(value: number, precision: number): number;\n\n/**\n * Rounds up a given number to a specific precision.\n * If you'd like to round up to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.ceil` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round up to. Must be an integer between -15 and 15.\n * @signature\n *    R.ceil(precision)(value);\n * @example\n *    R.ceil(3)(123.9876) // => 123.988\n *    R.ceil(1)(483.22243) // => 483.3\n *    R.ceil(-1)(8541) // => 8550\n *    R.ceil(-3)(456789) // => 457000\n * @dataLast\n * @category Number\n */\nexport function ceil(precision: number): (value: number) => number;\n\nexport function ceil(...args: readonly unknown[]): unknown {\n  return purry(withPrecision(Math.ceil), args);\n}\n"],"mappings":"mFAwCA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAO,EAAM,EAAc,KAAK,KAAK,CAAE,EAAK"}

backend/node_modules/remeda/dist/chunk.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}function n(e,t){if(t<1)throw RangeError(`chunk: A chunk size of '${t.toString()}' would result in an infinite array`);if(e.length===0)return[];if(t>=e.length)return[[...e]];let n=Math.ceil(e.length/t),r=Array(n);if(t===1)for(let[t,n]of e.entries())r[t]=[n];else for(let i=0;i<n;i+=1){let n=i*t;r[i]=e.slice(n,n+t)}return r}exports.chunk=t;
+//# sourceMappingURL=chunk.cjs.map

backend/node_modules/remeda/dist/chunk.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}function n(e,t){if(t<1)throw RangeError(`chunk: A chunk size of '${t.toString()}' would result in an infinite array`);if(e.length===0)return[];if(t>=e.length)return[[...e]];let n=Math.ceil(e.length/t),r=Array(n);if(t===1)for(let[t,n]of e.entries())r[t]=[n];else for(let i=0;i<n;i+=1){let n=i*t;r[i]=e.slice(n,n+t)}return r}export{t as chunk};
+//# sourceMappingURL=chunk.js.map

backend/node_modules/remeda/dist/clamp.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}const n=(e,{min:t,max:n})=>t!==void 0&&e<t?t:n!==void 0&&e>n?n:e;exports.clamp=t;
+//# sourceMappingURL=clamp.cjs.map

backend/node_modules/remeda/dist/clamp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.cjs","names":["purry"],"sources":["../src/clamp.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\ntype Limits = {\n  readonly min?: number;\n  readonly max?: number;\n};\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param value - The number.\n * @param limits - The bounds limits.\n * @signature\n *    R.clamp(value, { min, max });\n * @example\n *    clamp(10, { min: 20 }) // => 20\n *    clamp(10, { max: 5 }) // => 5\n *    clamp(10, { max: 20, min: 5 }) // => 10\n * @dataFirst\n * @category Number\n */\nexport function clamp(value: number, limits: Limits): number;\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param limits - The bounds limits.\n * @signature\n *    R.clamp({ min, max })(value);\n * @example\n *    clamp({ min: 20 })(10) // => 20\n *    clamp({ max: 5 })(10) // => 5\n *    clamp({ max: 20, min: 5 })(10) // => 10\n * @dataLast\n * @category Number\n */\nexport function clamp(limits: Limits): (value: number) => number;\n\nexport function clamp(...args: readonly unknown[]): unknown {\n  return purry(clampImplementation, args);\n}\n\nconst clampImplementation = (value: number, { min, max }: Limits): number =>\n  min !== undefined && value < min\n    ? min\n    : max !== undefined && value > max\n      ? max\n      : value;\n"],"mappings":"wCAsCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAOA,EAAAA,EAAM,EAAqB,EAAK,CAGzC,MAAM,GAAuB,EAAe,CAAE,MAAK,SACjD,IAAQ,IAAA,IAAa,EAAQ,EACzB,EACA,IAAQ,IAAA,IAAa,EAAQ,EAC3B,EACA"}

backend/node_modules/remeda/dist/clamp.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}const n=(e,{min:t,max:n})=>t!==void 0&&e<t?t:n!==void 0&&e>n?n:e;export{t as clamp};
+//# sourceMappingURL=clamp.js.map

backend/node_modules/remeda/dist/clamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.js","names":[],"sources":["../src/clamp.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\ntype Limits = {\n  readonly min?: number;\n  readonly max?: number;\n};\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param value - The number.\n * @param limits - The bounds limits.\n * @signature\n *    R.clamp(value, { min, max });\n * @example\n *    clamp(10, { min: 20 }) // => 20\n *    clamp(10, { max: 5 }) // => 5\n *    clamp(10, { max: 20, min: 5 }) // => 10\n * @dataFirst\n * @category Number\n */\nexport function clamp(value: number, limits: Limits): number;\n\n/**\n * Clamp the given value within the inclusive min and max bounds.\n *\n * @param limits - The bounds limits.\n * @signature\n *    R.clamp({ min, max })(value);\n * @example\n *    clamp({ min: 20 })(10) // => 20\n *    clamp({ max: 5 })(10) // => 5\n *    clamp({ max: 20, min: 5 })(10) // => 10\n * @dataLast\n * @category Number\n */\nexport function clamp(limits: Limits): (value: number) => number;\n\nexport function clamp(...args: readonly unknown[]): unknown {\n  return purry(clampImplementation, args);\n}\n\nconst clampImplementation = (value: number, { min, max }: Limits): number =>\n  min !== undefined && value < min\n    ? min\n    : max !== undefined && value > max\n      ? max\n      : value;\n"],"mappings":"wCAsCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAO,EAAM,EAAqB,EAAK,CAGzC,MAAM,GAAuB,EAAe,CAAE,MAAK,SACjD,IAAQ,IAAA,IAAa,EAAQ,EACzB,EACA,IAAQ,IAAA,IAAa,EAAQ,EAC3B,EACA"}

backend/node_modules/remeda/dist/clone.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}function n(e,t=[],n=[]){if(typeof e==`function`)return e;if(typeof e!=`object`||!e)return structuredClone(e);let a=Object.getPrototypeOf(e);if(!Array.isArray(e)&&a!==null&&a!==Object.prototype)return structuredClone(e);let o=t.indexOf(e);return o===-1?(t.push(e),Array.isArray(e)?i(e,t,n):r(e,t,n)):n[o]}function r(e,t,r){let i={};r.push(i);for(let[a,o]of Object.entries(e))i[a]=n(o,t,r);return i}function i(e,t,r){let i=[];r.push(i);for(let[a,o]of e.entries())i[a]=n(o,t,r);return i}exports.clone=t;
+//# sourceMappingURL=clone.cjs.map

backend/node_modules/remeda/dist/clone.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.cjs","names":["purry","copiedValue: Record<PropertyKey, unknown>","copiedValue: unknown[]"],"sources":["../src/clone.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types --\n * The state needed to compute the clone is passed by reference via mutable\n * arrays.\n */\n\nimport { purry } from \"./purry\";\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @param data - The object to clone.\n * @signature\n *   R.clone(data)\n * @example\n *   R.clone({foo: 'bar'}) // {foo: 'bar'}\n * @dataFirst\n * @category Object\n */\nexport function clone<T>(data: T): T;\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @signature\n *   R.clone()(data)\n * @example\n *   R.pipe({foo: 'bar'}, R.clone()) // {foo: 'bar'}\n * @dataLast\n * @category Object\n */\nexport function clone(): <T>(data: T) => T;\n\nexport function clone(...args: readonly unknown[]): unknown {\n  return purry(cloneImplementation, args);\n}\n\nfunction cloneImplementation<T>(\n  value: T,\n  refFrom: unknown[] = [],\n  refTo: unknown[] = [],\n): T {\n  if (typeof value === \"function\") {\n    // Functions aren't cloned, we return the same instance.\n    return value;\n  }\n\n  if (typeof value !== \"object\" || value === null) {\n    // Only objects are interesting when cloning, everything else can use\n    // whatever JS does by default.\n    return structuredClone(value);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n  const prototype = Object.getPrototypeOf(value);\n  if (\n    !Array.isArray(value) &&\n    // Keep this check in sync with the same check in the impl of\n    // `isPlainObject`.\n    prototype !== null &&\n    prototype !== Object.prototype\n  ) {\n    // Our cloning logic is only designed for plain objects and arrays; other\n    // object types (like `Date`, `RegExp`, `File`, and user-defined classes)\n    // wouldn't clone properly. We fallback to the native cloning for them.\n    return structuredClone(value);\n  }\n\n  // In order to support cyclic/self-referential structures, and to support\n  // functions _within_ objects, we need to have our own cloning logic.\n\n  // First we check if we've already cloned this value.\n  const idx = refFrom.indexOf(value);\n  if (idx !== -1) {\n    return refTo[idx] as T;\n  }\n  // And if we haven't, we add it to our list of seen values so that it is kept\n  // and clone the deep structure.\n  refFrom.push(value);\n  return Array.isArray(value)\n    ? deepCloneArray(value, refFrom, refTo)\n    : deepCloneObject(value, refFrom, refTo);\n}\n\nfunction deepCloneObject<T extends object>(\n  value: T,\n  refFrom: unknown[],\n  refTo: unknown[],\n): T {\n  const copiedValue: Record<PropertyKey, unknown> = {};\n\n  // It's important to first push the cloned ref so that it's index is kept in\n  // sync with the ref to the original value in refFrom.\n  refTo.push(copiedValue);\n\n  for (const [k, v] of Object.entries(value)) {\n    copiedValue[k] = cloneImplementation(v, refFrom, refTo);\n  }\n\n  return copiedValue as T;\n}\n\nfunction deepCloneArray<T extends readonly unknown[]>(\n  value: T,\n  refFrom: unknown[],\n  refTo: unknown[],\n): T {\n  const copiedValue: unknown[] = [];\n\n  // It's important to first push the cloned ref so that it's index is kept in\n  // sync with the ref to the original value in refFrom.\n  refTo.push(copiedValue);\n\n  for (const [index, item] of value.entries()) {\n    copiedValue[index] = cloneImplementation(item, refFrom, refTo);\n  }\n\n  return copiedValue as unknown as T;\n}\n"],"mappings":"wCAwCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAOA,EAAAA,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EAAqB,EAAE,CACvB,EAAmB,EAAE,CAClB,CACH,GAAI,OAAO,GAAU,WAEnB,OAAO,EAGT,GAAI,OAAO,GAAU,WAAY,EAG/B,OAAO,gBAAgB,EAAM,CAI/B,IAAM,EAAY,OAAO,eAAe,EAAM,CAC9C,GACE,CAAC,MAAM,QAAQ,EAAM,EAGrB,IAAc,MACd,IAAc,OAAO,UAKrB,OAAO,gBAAgB,EAAM,CAO/B,IAAM,EAAM,EAAQ,QAAQ,EAAM,CAOlC,OANI,IAAQ,IAKZ,EAAQ,KAAK,EAAM,CACZ,MAAM,QAAQ,EAAM,CACvB,EAAe,EAAO,EAAS,EAAM,CACrC,EAAgB,EAAO,EAAS,EAAM,EAPjC,EAAM,GAUjB,SAAS,EACP,EACA,EACA,EACG,CACH,IAAMC,EAA4C,EAAE,CAIpD,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAG,KAAM,OAAO,QAAQ,EAAM,CACxC,EAAY,GAAK,EAAoB,EAAG,EAAS,EAAM,CAGzD,OAAO,EAGT,SAAS,EACP,EACA,EACA,EACG,CACH,IAAMC,EAAyB,EAAE,CAIjC,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,EAAY,GAAS,EAAoB,EAAM,EAAS,EAAM,CAGhE,OAAO"}

backend/node_modules/remeda/dist/clone.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}function n(e,t=[],n=[]){if(typeof e==`function`)return e;if(typeof e!=`object`||!e)return structuredClone(e);let a=Object.getPrototypeOf(e);if(!Array.isArray(e)&&a!==null&&a!==Object.prototype)return structuredClone(e);let o=t.indexOf(e);return o===-1?(t.push(e),Array.isArray(e)?i(e,t,n):r(e,t,n)):n[o]}function r(e,t,r){let i={};r.push(i);for(let[a,o]of Object.entries(e))i[a]=n(o,t,r);return i}function i(e,t,r){let i=[];r.push(i);for(let[a,o]of e.entries())i[a]=n(o,t,r);return i}export{t as clone};
+//# sourceMappingURL=clone.js.map

backend/node_modules/remeda/dist/clone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.js","names":["copiedValue: Record<PropertyKey, unknown>","copiedValue: unknown[]"],"sources":["../src/clone.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types --\n * The state needed to compute the clone is passed by reference via mutable\n * arrays.\n */\n\nimport { purry } from \"./purry\";\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @param data - The object to clone.\n * @signature\n *   R.clone(data)\n * @example\n *   R.clone({foo: 'bar'}) // {foo: 'bar'}\n * @dataFirst\n * @category Object\n */\nexport function clone<T>(data: T): T;\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @signature\n *   R.clone()(data)\n * @example\n *   R.pipe({foo: 'bar'}, R.clone()) // {foo: 'bar'}\n * @dataLast\n * @category Object\n */\nexport function clone(): <T>(data: T) => T;\n\nexport function clone(...args: readonly unknown[]): unknown {\n  return purry(cloneImplementation, args);\n}\n\nfunction cloneImplementation<T>(\n  value: T,\n  refFrom: unknown[] = [],\n  refTo: unknown[] = [],\n): T {\n  if (typeof value === \"function\") {\n    // Functions aren't cloned, we return the same instance.\n    return value;\n  }\n\n  if (typeof value !== \"object\" || value === null) {\n    // Only objects are interesting when cloning, everything else can use\n    // whatever JS does by default.\n    return structuredClone(value);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n  const prototype = Object.getPrototypeOf(value);\n  if (\n    !Array.isArray(value) &&\n    // Keep this check in sync with the same check in the impl of\n    // `isPlainObject`.\n    prototype !== null &&\n    prototype !== Object.prototype\n  ) {\n    // Our cloning logic is only designed for plain objects and arrays; other\n    // object types (like `Date`, `RegExp`, `File`, and user-defined classes)\n    // wouldn't clone properly. We fallback to the native cloning for them.\n    return structuredClone(value);\n  }\n\n  // In order to support cyclic/self-referential structures, and to support\n  // functions _within_ objects, we need to have our own cloning logic.\n\n  // First we check if we've already cloned this value.\n  const idx = refFrom.indexOf(value);\n  if (idx !== -1) {\n    return refTo[idx] as T;\n  }\n  // And if we haven't, we add it to our list of seen values so that it is kept\n  // and clone the deep structure.\n  refFrom.push(value);\n  return Array.isArray(value)\n    ? deepCloneArray(value, refFrom, refTo)\n    : deepCloneObject(value, refFrom, refTo);\n}\n\nfunction deepCloneObject<T extends object>(\n  value: T,\n  refFrom: unknown[],\n  refTo: unknown[],\n): T {\n  const copiedValue: Record<PropertyKey, unknown> = {};\n\n  // It's important to first push the cloned ref so that it's index is kept in\n  // sync with the ref to the original value in refFrom.\n  refTo.push(copiedValue);\n\n  for (const [k, v] of Object.entries(value)) {\n    copiedValue[k] = cloneImplementation(v, refFrom, refTo);\n  }\n\n  return copiedValue as T;\n}\n\nfunction deepCloneArray<T extends readonly unknown[]>(\n  value: T,\n  refFrom: unknown[],\n  refTo: unknown[],\n): T {\n  const copiedValue: unknown[] = [];\n\n  // It's important to first push the cloned ref so that it's index is kept in\n  // sync with the ref to the original value in refFrom.\n  refTo.push(copiedValue);\n\n  for (const [index, item] of value.entries()) {\n    copiedValue[index] = cloneImplementation(item, refFrom, refTo);\n  }\n\n  return copiedValue as unknown as T;\n}\n"],"mappings":"wCAwCA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EAAqB,EAAE,CACvB,EAAmB,EAAE,CAClB,CACH,GAAI,OAAO,GAAU,WAEnB,OAAO,EAGT,GAAI,OAAO,GAAU,WAAY,EAG/B,OAAO,gBAAgB,EAAM,CAI/B,IAAM,EAAY,OAAO,eAAe,EAAM,CAC9C,GACE,CAAC,MAAM,QAAQ,EAAM,EAGrB,IAAc,MACd,IAAc,OAAO,UAKrB,OAAO,gBAAgB,EAAM,CAO/B,IAAM,EAAM,EAAQ,QAAQ,EAAM,CAOlC,OANI,IAAQ,IAKZ,EAAQ,KAAK,EAAM,CACZ,MAAM,QAAQ,EAAM,CACvB,EAAe,EAAO,EAAS,EAAM,CACrC,EAAgB,EAAO,EAAS,EAAM,EAPjC,EAAM,GAUjB,SAAS,EACP,EACA,EACA,EACG,CACH,IAAMA,EAA4C,EAAE,CAIpD,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAG,KAAM,OAAO,QAAQ,EAAM,CACxC,EAAY,GAAK,EAAoB,EAAG,EAAS,EAAM,CAGzD,OAAO,EAGT,SAAS,EACP,EACA,EACA,EACG,CACH,IAAMC,EAAyB,EAAE,CAIjC,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,EAAY,GAAS,EAAoB,EAAM,EAAS,EAAM,CAGhE,OAAO"}

backend/node_modules/remeda/dist/concat.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}const n=(e,t)=>[...e,...t];exports.concat=t;
+//# sourceMappingURL=concat.cjs.map

backend/node_modules/remeda/dist/concat.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.cjs","names":["purry"],"sources":["../src/concat.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param data - The first items, these would be at the beginning of the new\n * array.\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    R.concat(data, other);\n * @example\n *    R.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']\n * @dataFirst\n * @category Array\n */\nexport function concat<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(data: T1, other: T2): [...T1, ...T2];\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    R.concat(arr2)(arr1);\n * @example\n *    R.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']\n * @dataLast\n * @category Array\n */\nexport function concat<T2 extends IterableContainer>(\n  other: T2,\n): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];\n\nexport function concat(...args: readonly unknown[]): unknown {\n  return purry(concatImplementation, args);\n}\n\nconst concatImplementation = <\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(\n  arr1: T1,\n  arr2: T2,\n): [...T1, ...T2] => [...arr1, ...arr2];\n"],"mappings":"wCA4CA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAOA,EAAAA,EAAM,EAAsB,EAAK,CAG1C,MAAM,GAIJ,EACA,IACmB,CAAC,GAAG,EAAM,GAAG,EAAK"}

backend/node_modules/remeda/dist/concat.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}const n=(e,t)=>[...e,...t];export{t as concat};
+//# sourceMappingURL=concat.js.map

backend/node_modules/remeda/dist/concat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.js","names":[],"sources":["../src/concat.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param data - The first items, these would be at the beginning of the new\n * array.\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    R.concat(data, other);\n * @example\n *    R.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']\n * @dataFirst\n * @category Array\n */\nexport function concat<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(data: T1, other: T2): [...T1, ...T2];\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    R.concat(arr2)(arr1);\n * @example\n *    R.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']\n * @dataLast\n * @category Array\n */\nexport function concat<T2 extends IterableContainer>(\n  other: T2,\n): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];\n\nexport function concat(...args: readonly unknown[]): unknown {\n  return purry(concatImplementation, args);\n}\n\nconst concatImplementation = <\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(\n  arr1: T1,\n  arr2: T2,\n): [...T1, ...T2] => [...arr1, ...arr2];\n"],"mappings":"wCA4CA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAO,EAAM,EAAsB,EAAK,CAG1C,MAAM,GAIJ,EACA,IACmB,CAAC,GAAG,EAAM,GAAG,EAAK"}

backend/node_modules/remeda/dist/conditional-CbyGGQT0.js

@@ -0,0 +1,2 @@
+function e(e,t,n){return e(n[0])?e=>t(e,...n):t(...n)}function t(...t){return e(r,n,t)}function n(e,...t){for(let n of t){if(typeof n==`function`)return n(e);let[t,r]=n;if(t(e))return r(e)}throw Error(`conditional: data failed for all cases`)}function r(e){if(!Array.isArray(e))return!1;let[t,n,...r]=e;return typeof t==`function`&&t.length<=1&&typeof n==`function`&&n.length<=1&&r.length===0}export{t};
+//# sourceMappingURL=conditional-CbyGGQT0.js.map

backend/node_modules/remeda/dist/conditional-DAH-6cGE.cjs

@@ -0,0 +1,2 @@
+function e(e,t,n){return e(n[0])?e=>t(e,...n):t(...n)}function t(...t){return e(r,n,t)}function n(e,...t){for(let n of t){if(typeof n==`function`)return n(e);let[t,r]=n;if(t(e))return r(e)}throw Error(`conditional: data failed for all cases`)}function r(e){if(!Array.isArray(e))return!1;let[t,n,...r]=e;return typeof t==`function`&&t.length<=1&&typeof n==`function`&&n.length<=1&&r.length===0}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=conditional-DAH-6cGE.cjs.map

backend/node_modules/remeda/dist/conditional.cjs

@@ -0,0 +1 @@
+const e=require(`./conditional-DAH-6cGE.cjs`);exports.conditional=e.t;

backend/node_modules/remeda/dist/conditional.js

@@ -0,0 +1 @@
+import{t as e}from"./conditional-CbyGGQT0.js";export{e as conditional};

backend/node_modules/remeda/dist/constant.cjs

@@ -0,0 +1,2 @@
+function e(e){return()=>e}exports.constant=e;
+//# sourceMappingURL=constant.cjs.map

backend/node_modules/remeda/dist/constant.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant.cjs","names":[],"sources":["../src/constant.ts"],"sourcesContent":["/**\n * A function that takes any arguments and returns the provided `value` on every\n * invocation. This is useful to provide trivial implementations for APIs or in\n * combination with a ternary or other conditional execution to allow to short-\n * circuit more complex implementations for a specific case.\n *\n * Notice that this is a dataLast impl where the function needs to be invoked\n * to get the \"do nothing\" function.\n *\n * See also:\n * `doNothing` - A function that doesn't return anything.\n * `identity` - A function that returns the first argument it receives.\n *\n * @param value - The constant value that would be returned on every invocation.\n * The value is not copied/cloned on every invocation so care should be taken\n * with mutable objects (like arrays, objects, Maps, etc...).\n * @signature\n *   R.constant(value);\n * @example\n *   R.map([1, 2, 3], R.constant('a')); // => ['a', 'a', 'a']\n *   R.map(\n *     [1, 2, 3],\n *     isDemoMode ? R.add(1) : R.constant(0),\n *   ); // => [2, 3, 4] or [0, 0, 0]\n * @dataLast\n * @category Function\n */\nexport function constant<const T>(\n  value: T,\n): // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- There is no other way to make typescript infer the function arguments \"backwards\" in data-last invocations without the Args type parameter. @see: https://github.com/typescript-eslint/typescript-eslint/issues/9887\n<Args extends readonly unknown[]>(...args: Args) => T {\n  return () => value;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EAEoD,CACpD,UAAa"}

backend/node_modules/remeda/dist/constant.js

@@ -0,0 +1,2 @@
+function e(e){return()=>e}export{e as constant};
+//# sourceMappingURL=constant.js.map

backend/node_modules/remeda/dist/constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant.js","names":[],"sources":["../src/constant.ts"],"sourcesContent":["/**\n * A function that takes any arguments and returns the provided `value` on every\n * invocation. This is useful to provide trivial implementations for APIs or in\n * combination with a ternary or other conditional execution to allow to short-\n * circuit more complex implementations for a specific case.\n *\n * Notice that this is a dataLast impl where the function needs to be invoked\n * to get the \"do nothing\" function.\n *\n * See also:\n * `doNothing` - A function that doesn't return anything.\n * `identity` - A function that returns the first argument it receives.\n *\n * @param value - The constant value that would be returned on every invocation.\n * The value is not copied/cloned on every invocation so care should be taken\n * with mutable objects (like arrays, objects, Maps, etc...).\n * @signature\n *   R.constant(value);\n * @example\n *   R.map([1, 2, 3], R.constant('a')); // => ['a', 'a', 'a']\n *   R.map(\n *     [1, 2, 3],\n *     isDemoMode ? R.add(1) : R.constant(0),\n *   ); // => [2, 3, 4] or [0, 0, 0]\n * @dataLast\n * @category Function\n */\nexport function constant<const T>(\n  value: T,\n): // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- There is no other way to make typescript infer the function arguments \"backwards\" in data-last invocations without the Args type parameter. @see: https://github.com/typescript-eslint/typescript-eslint/issues/9887\n<Args extends readonly unknown[]>(...args: Args) => T {\n  return () => value;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EAEoD,CACpD,UAAa"}

backend/node_modules/remeda/dist/countBy.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}const n=(e,t)=>{let n=new Map;for(let[r,i]of e.entries()){let a=t(i,r,e);if(a!==void 0){let e=n.get(a);e===void 0?n.set(a,1):n.set(a,e+1)}}return Object.fromEntries(n)};exports.countBy=t;
+//# sourceMappingURL=countBy.cjs.map

backend/node_modules/remeda/dist/countBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"countBy.cjs","names":["purry"],"sources":["../src/countBy.ts"],"sourcesContent":["import type { BoundedPartial } from \"./internal/types/BoundedPartial\";\nimport { purry } from \"./purry\";\n\n/**\n * Categorize and count elements in an array using a defined callback function.\n * The callback function is applied to each element in the array to determine\n * its category and then counts how many elements fall into each category.\n *\n * @param data - The array.\n * @param categorizationFn - The categorization function.\n * @signature\n *   R.countBy(data, categorizationFn)\n * @example\n *    R.countBy(\n *      [\"a\", \"b\", \"c\", \"B\", \"A\", \"a\"],\n *      R.toLowerCase()\n *    ); //=> { a: 3, b: 2, c: 1 }\n * @dataFirst\n * @category Array\n */\nexport function countBy<T, K extends PropertyKey>(\n  data: readonly T[],\n  categorizationFn: (\n    value: T,\n    index: number,\n    data: readonly T[],\n  ) => K | undefined,\n): BoundedPartial<Record<K, number>>;\n\n/**\n * Categorize and count elements in an array using a defined callback function.\n * The callback function is applied to each element in the array to determine\n * its category and then counts how many elements fall into each category.\n *\n * @param categorizationFn - The categorization function.\n * @signature\n *   R.countBy(categorizationFn)(data)\n * @example\n *    R.pipe(\n *      [\"a\", \"b\", \"c\", \"B\", \"A\", \"a\"],\n *      R.countBy(R.toLowerCase()),\n *    ); //=> { a: 3, b: 2, c: 1 }\n * @dataLast\n * @category Array\n */\nexport function countBy<T, K extends PropertyKey>(\n  categorizationFn: (\n    value: T,\n    index: number,\n    data: readonly T[],\n  ) => K | undefined,\n): (data: readonly T[]) => BoundedPartial<Record<K, number>>;\n\nexport function countBy(...args: readonly unknown[]): unknown {\n  return purry(countByImplementation, args);\n}\n\nconst countByImplementation = <T>(\n  data: readonly T[],\n  categorizationFn: (\n    value: T,\n    index: number,\n    data: readonly T[],\n  ) => PropertyKey | undefined,\n): BoundedPartial<Record<PropertyKey, number>> => {\n  const out = new Map<PropertyKey, number>();\n\n  for (const [index, item] of data.entries()) {\n    const category = categorizationFn(item, index, data);\n    if (category !== undefined) {\n      const count = out.get(category);\n      if (count === undefined) {\n        out.set(category, 1);\n      } else {\n        out.set(category, count + 1);\n      }\n    }\n  }\n\n  return Object.fromEntries(out);\n};\n"],"mappings":"wCAqDA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IAKgD,CAChD,IAAM,EAAM,IAAI,IAEhB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,IAAM,EAAW,EAAiB,EAAM,EAAO,EAAK,CACpD,GAAI,IAAa,IAAA,GAAW,CAC1B,IAAM,EAAQ,EAAI,IAAI,EAAS,CAC3B,IAAU,IAAA,GACZ,EAAI,IAAI,EAAU,EAAE,CAEpB,EAAI,IAAI,EAAU,EAAQ,EAAE,EAKlC,OAAO,OAAO,YAAY,EAAI"}

backend/node_modules/remeda/dist/countBy.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}const n=(e,t)=>{let n=new Map;for(let[r,i]of e.entries()){let a=t(i,r,e);if(a!==void 0){let e=n.get(a);e===void 0?n.set(a,1):n.set(a,e+1)}}return Object.fromEntries(n)};export{t as countBy};
+//# sourceMappingURL=countBy.js.map

backend/node_modules/remeda/dist/countBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"countBy.js","names":[],"sources":["../src/countBy.ts"],"sourcesContent":["import type { BoundedPartial } from \"./internal/types/BoundedPartial\";\nimport { purry } from \"./purry\";\n\n/**\n * Categorize and count elements in an array using a defined callback function.\n * The callback function is applied to each element in the array to determine\n * its category and then counts how many elements fall into each category.\n *\n * @param data - The array.\n * @param categorizationFn - The categorization function.\n * @signature\n *   R.countBy(data, categorizationFn)\n * @example\n *    R.countBy(\n *      [\"a\", \"b\", \"c\", \"B\", \"A\", \"a\"],\n *      R.toLowerCase()\n *    ); //=> { a: 3, b: 2, c: 1 }\n * @dataFirst\n * @category Array\n */\nexport function countBy<T, K extends PropertyKey>(\n  data: readonly T[],\n  categorizationFn: (\n    value: T,\n    index: number,\n    data: readonly T[],\n  ) => K | undefined,\n): BoundedPartial<Record<K, number>>;\n\n/**\n * Categorize and count elements in an array using a defined callback function.\n * The callback function is applied to each element in the array to determine\n * its category and then counts how many elements fall into each category.\n *\n * @param categorizationFn - The categorization function.\n * @signature\n *   R.countBy(categorizationFn)(data)\n * @example\n *    R.pipe(\n *      [\"a\", \"b\", \"c\", \"B\", \"A\", \"a\"],\n *      R.countBy(R.toLowerCase()),\n *    ); //=> { a: 3, b: 2, c: 1 }\n * @dataLast\n * @category Array\n */\nexport function countBy<T, K extends PropertyKey>(\n  categorizationFn: (\n    value: T,\n    index: number,\n    data: readonly T[],\n  ) => K | undefined,\n): (data: readonly T[]) => BoundedPartial<Record<K, number>>;\n\nexport function countBy(...args: readonly unknown[]): unknown {\n  return purry(countByImplementation, args);\n}\n\nconst countByImplementation = <T>(\n  data: readonly T[],\n  categorizationFn: (\n    value: T,\n    index: number,\n    data: readonly T[],\n  ) => PropertyKey | undefined,\n): BoundedPartial<Record<PropertyKey, number>> => {\n  const out = new Map<PropertyKey, number>();\n\n  for (const [index, item] of data.entries()) {\n    const category = categorizationFn(item, index, data);\n    if (category !== undefined) {\n      const count = out.get(category);\n      if (count === undefined) {\n        out.set(category, 1);\n      } else {\n        out.set(category, count + 1);\n      }\n    }\n  }\n\n  return Object.fromEntries(out);\n};\n"],"mappings":"wCAqDA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAO,EAAM,EAAuB,EAAK,CAG3C,MAAM,GACJ,EACA,IAKgD,CAChD,IAAM,EAAM,IAAI,IAEhB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,IAAM,EAAW,EAAiB,EAAM,EAAO,EAAK,CACpD,GAAI,IAAa,IAAA,GAAW,CAC1B,IAAM,EAAQ,EAAI,IAAI,EAAS,CAC3B,IAAU,IAAA,GACZ,EAAI,IAAI,EAAU,EAAE,CAEpB,EAAI,IAAI,EAAU,EAAQ,EAAE,EAKlC,OAAO,OAAO,YAAY,EAAI"}

backend/node_modules/remeda/dist/debounce.cjs

@@ -0,0 +1,2 @@
+function e(e,{waitMs:t,timing:n=`trailing`,maxWaitMs:r}){if(r!==void 0&&t!==void 0&&r<t)throw Error(`debounce: maxWaitMs (${r.toString()}) cannot be less than waitMs (${t.toString()})`);let i,a,o,s,c=()=>{if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}if(o===void 0)throw Error(`REMEDA[debounce]: latestCallArgs was unexpectedly undefined.`);let t=o;o=void 0,s=e(...t)},l=()=>{if(i===void 0)return;let e=i;i=void 0,clearTimeout(e),o!==void 0&&c()},u=e=>{o=e,r!==void 0&&a===void 0&&(a=setTimeout(c,r))};return{call:(...a)=>{if(i===void 0)n===`trailing`?u(a):s=e(...a);else{n!==`leading`&&u(a);let e=i;i=void 0,clearTimeout(e)}return i=setTimeout(l,t??r??0),s},cancel:()=>{if(i!==void 0){let e=i;i=void 0,clearTimeout(e)}if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}o=void 0},flush:()=>(l(),s),get isPending(){return i!==void 0},get cachedValue(){return s}}}exports.debounce=e;
+//# sourceMappingURL=debounce.cjs.map

backend/node_modules/remeda/dist/debounce.js

@@ -0,0 +1,2 @@
+function e(e,{waitMs:t,timing:n=`trailing`,maxWaitMs:r}){if(r!==void 0&&t!==void 0&&r<t)throw Error(`debounce: maxWaitMs (${r.toString()}) cannot be less than waitMs (${t.toString()})`);let i,a,o,s,c=()=>{if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}if(o===void 0)throw Error(`REMEDA[debounce]: latestCallArgs was unexpectedly undefined.`);let t=o;o=void 0,s=e(...t)},l=()=>{if(i===void 0)return;let e=i;i=void 0,clearTimeout(e),o!==void 0&&c()},u=e=>{o=e,r!==void 0&&a===void 0&&(a=setTimeout(c,r))};return{call:(...a)=>{if(i===void 0)n===`trailing`?u(a):s=e(...a);else{n!==`leading`&&u(a);let e=i;i=void 0,clearTimeout(e)}return i=setTimeout(l,t??r??0),s},cancel:()=>{if(i!==void 0){let e=i;i=void 0,clearTimeout(e)}if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}o=void 0},flush:()=>(l(),s),get isPending(){return i!==void 0},get cachedValue(){return s}}}export{e as debounce};
+//# sourceMappingURL=debounce.js.map

backend/node_modules/remeda/dist/defaultTo.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}const n=(e,t)=>e??t;exports.defaultTo=t;
+//# sourceMappingURL=defaultTo.cjs.map

backend/node_modules/remeda/dist/defaultTo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultTo.cjs","names":["purry"],"sources":["../src/defaultTo.ts"],"sourcesContent":["import type { IsEqual } from \"type-fest\";\nimport { purry } from \"./purry\";\nimport type { RemedaTypeError } from \"./internal/types/RemedaTypeError\";\n\ntype FallbackOf<T> =\n  IsEqual<T, NonNullable<T>> extends true\n    ? RemedaTypeError<\n        \"defaultTo\",\n        \"no unnecessary fallback\",\n        // The type is `never` because it will never be used ;)\n        { type: never; metadata: T }\n      >\n    : T;\n\n/**\n * A stricter wrapper around the [Nullish coalescing operator `??`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator)\n * that ensures that the fallback matches the type of the data. Only works\n * when data can be `null` or `undefined`.\n *\n * Notice that `Number.NaN` is not nullish and would not result in returning the\n * fallback!\n *\n * @param data - A nullish value.\n * @param fallback - A value of the same type as `data` that would be returned\n * when `data` is nullish.\n * @signature\n *   R.defaultTo(data, fallback);\n * @example\n *   R.defaultTo(\"hello\" as string | undefined, \"world\"); //=> \"hello\"\n *   R.defaultTo(undefined as string | undefined, \"world\"); //=> \"world\"\n * @dataFirst\n * @category Other\n */\nexport function defaultTo<T, const Fallback extends FallbackOf<T>>(\n  data: T,\n  fallback: Fallback,\n): NonNullable<T> | Fallback;\n\n/**\n * A stricter wrapper around the [Nullish coalescing operator `??`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator)\n * that ensures that the fallback matches the type of the data, and that the\n * data is nullish (`null` or `undefined`).\n *\n * Notice that `Number.NaN` is not nullish and would not result in returning the\n * fallback!\n *\n * @param fallback - A value of the same type as `data` that would be returned\n * when `data` is nullish.\n * @signature\n *   R.defaultTo(fallback)(data);\n * @example\n *   R.pipe(\"hello\" as string | undefined, R.defaultTo(\"world\")); //=> \"hello\"\n *   R.pipe(undefined as string | undefined, R.defaultTo(\"world\")); //=> \"world\"\n * @dataLast\n * @category Other\n */\nexport function defaultTo<T, const Fallback extends FallbackOf<T>>(\n  fallback: Fallback,\n): (data: T) => NonNullable<T> | Fallback;\n\nexport function defaultTo(...args: readonly unknown[]): unknown {\n  return purry(defaultToImplementation, args);\n}\n\nconst defaultToImplementation = <T, Fallback extends FallbackOf<T>>(\n  data: T,\n  fallback: Fallback,\n): NonNullable<T> | Fallback => data ?? fallback;\n"],"mappings":"wCA4DA,SAAgB,EAAU,GAAG,EAAmC,CAC9D,OAAOA,EAAAA,EAAM,EAAyB,EAAK,CAG7C,MAAM,GACJ,EACA,IAC8B,GAAQ"}

backend/node_modules/remeda/dist/defaultTo.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}const n=(e,t)=>e??t;export{t as defaultTo};
+//# sourceMappingURL=defaultTo.js.map

backend/node_modules/remeda/dist/defaultTo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultTo.js","names":[],"sources":["../src/defaultTo.ts"],"sourcesContent":["import type { IsEqual } from \"type-fest\";\nimport { purry } from \"./purry\";\nimport type { RemedaTypeError } from \"./internal/types/RemedaTypeError\";\n\ntype FallbackOf<T> =\n  IsEqual<T, NonNullable<T>> extends true\n    ? RemedaTypeError<\n        \"defaultTo\",\n        \"no unnecessary fallback\",\n        // The type is `never` because it will never be used ;)\n        { type: never; metadata: T }\n      >\n    : T;\n\n/**\n * A stricter wrapper around the [Nullish coalescing operator `??`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator)\n * that ensures that the fallback matches the type of the data. Only works\n * when data can be `null` or `undefined`.\n *\n * Notice that `Number.NaN` is not nullish and would not result in returning the\n * fallback!\n *\n * @param data - A nullish value.\n * @param fallback - A value of the same type as `data` that would be returned\n * when `data` is nullish.\n * @signature\n *   R.defaultTo(data, fallback);\n * @example\n *   R.defaultTo(\"hello\" as string | undefined, \"world\"); //=> \"hello\"\n *   R.defaultTo(undefined as string | undefined, \"world\"); //=> \"world\"\n * @dataFirst\n * @category Other\n */\nexport function defaultTo<T, const Fallback extends FallbackOf<T>>(\n  data: T,\n  fallback: Fallback,\n): NonNullable<T> | Fallback;\n\n/**\n * A stricter wrapper around the [Nullish coalescing operator `??`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator)\n * that ensures that the fallback matches the type of the data, and that the\n * data is nullish (`null` or `undefined`).\n *\n * Notice that `Number.NaN` is not nullish and would not result in returning the\n * fallback!\n *\n * @param fallback - A value of the same type as `data` that would be returned\n * when `data` is nullish.\n * @signature\n *   R.defaultTo(fallback)(data);\n * @example\n *   R.pipe(\"hello\" as string | undefined, R.defaultTo(\"world\")); //=> \"hello\"\n *   R.pipe(undefined as string | undefined, R.defaultTo(\"world\")); //=> \"world\"\n * @dataLast\n * @category Other\n */\nexport function defaultTo<T, const Fallback extends FallbackOf<T>>(\n  fallback: Fallback,\n): (data: T) => NonNullable<T> | Fallback;\n\nexport function defaultTo(...args: readonly unknown[]): unknown {\n  return purry(defaultToImplementation, args);\n}\n\nconst defaultToImplementation = <T, Fallback extends FallbackOf<T>>(\n  data: T,\n  fallback: Fallback,\n): NonNullable<T> | Fallback => data ?? fallback;\n"],"mappings":"wCA4DA,SAAgB,EAAU,GAAG,EAAmC,CAC9D,OAAO,EAAM,EAAyB,EAAK,CAG7C,MAAM,GACJ,EACA,IAC8B,GAAQ"}

backend/node_modules/remeda/dist/difference.cjs

@@ -0,0 +1,2 @@
+const e=require(`./utilityEvaluators-CEX-n1-J.cjs`),t=require(`./purryFromLazy-tuFvR-GT.cjs`);function n(...e){return t.t(r,e)}function r(t){if(t.length===0)return e.r;let n=new Map;for(let e of t)n.set(e,(n.get(e)??0)+1);return t=>{let r=n.get(t);return r===void 0||r===0?{done:!1,hasNext:!0,next:t}:(n.set(t,r-1),e.t)}}exports.difference=n;
+//# sourceMappingURL=difference.cjs.map

backend/node_modules/remeda/dist/difference.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference.cjs","names":["purryFromLazy","lazyIdentityEvaluator","SKIP_ITEM"],"sources":["../src/difference.ts"],"sourcesContent":["import { purryFromLazy } from \"./internal/purryFromLazy\";\nimport type { LazyEvaluator } from \"./internal/types/LazyEvaluator\";\nimport { SKIP_ITEM, lazyIdentityEvaluator } from \"./internal/utilityEvaluators\";\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param data - The input items.\n * @param other - The values to exclude.\n * @signature\n *    R.difference(data, other)\n * @example\n *    R.difference([1, 2, 3, 4], [2, 5, 3]); // => [1, 4]\n *    R.difference([1, 1, 2, 2], [1]); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(data: readonly T[], other: readonly T[]): T[];\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param other - The values to exclude.\n * @signature\n *    R.difference(other)(data)\n * @example\n *    R.pipe([1, 2, 3, 4], R.difference([2, 5, 3])); // => [1, 4]\n *    R.pipe([1, 1, 2, 2], R.difference([1])); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(other: readonly T[]): (data: readonly T[]) => T[];\n\nexport function difference(...args: readonly unknown[]): unknown {\n  return purryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(other: readonly T[]): LazyEvaluator<T> {\n  if (other.length === 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  // We need to build a more efficient data structure that would allow us to\n  // keep track of the number of times we've seen a value in the other array.\n  const remaining = new Map<T, number>();\n  for (const value of other) {\n    remaining.set(value, (remaining.get(value) ?? 0) + 1);\n  }\n\n  return (value) => {\n    const copies = remaining.get(value);\n\n    if (copies === undefined || copies === 0) {\n      // The item is either not part of the other array or we've dropped enough\n      // copies of it so we return it.\n      return { done: false, hasNext: true, next: value };\n    }\n\n    // The item is equal to an item in the other array and there are still\n    // copies of it to \"account\" for so we skip this one and remove it from our\n    // ongoing tally.\n    remaining.set(value, copies - 1);\n    return SKIP_ITEM;\n  };\n}\n"],"mappings":"8FAuCA,SAAgB,EAAW,GAAG,EAAmC,CAC/D,OAAOA,EAAAA,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAsB,EAAuC,CACpE,GAAI,EAAM,SAAW,EACnB,OAAOC,EAAAA,EAKT,IAAM,EAAY,IAAI,IACtB,IAAK,IAAM,KAAS,EAClB,EAAU,IAAI,GAAQ,EAAU,IAAI,EAAM,EAAI,GAAK,EAAE,CAGvD,MAAQ,IAAU,CAChB,IAAM,EAAS,EAAU,IAAI,EAAM,CAYnC,OAVI,IAAW,IAAA,IAAa,IAAW,EAG9B,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,EAMpD,EAAU,IAAI,EAAO,EAAS,EAAE,CACzBC,EAAAA"}

backend/node_modules/remeda/dist/difference.js

@@ -0,0 +1,2 @@
+import{r as e,t}from"./utilityEvaluators-D7O7U3FY.js";import{t as n}from"./purryFromLazy-C1RBdBlx.js";function r(...e){return n(i,e)}function i(n){if(n.length===0)return e;let r=new Map;for(let e of n)r.set(e,(r.get(e)??0)+1);return e=>{let n=r.get(e);return n===void 0||n===0?{done:!1,hasNext:!0,next:e}:(r.set(e,n-1),t)}}export{r as difference};
+//# sourceMappingURL=difference.js.map

backend/node_modules/remeda/dist/difference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference.js","names":[],"sources":["../src/difference.ts"],"sourcesContent":["import { purryFromLazy } from \"./internal/purryFromLazy\";\nimport type { LazyEvaluator } from \"./internal/types/LazyEvaluator\";\nimport { SKIP_ITEM, lazyIdentityEvaluator } from \"./internal/utilityEvaluators\";\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param data - The input items.\n * @param other - The values to exclude.\n * @signature\n *    R.difference(data, other)\n * @example\n *    R.difference([1, 2, 3, 4], [2, 5, 3]); // => [1, 4]\n *    R.difference([1, 1, 2, 2], [1]); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(data: readonly T[], other: readonly T[]): T[];\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param other - The values to exclude.\n * @signature\n *    R.difference(other)(data)\n * @example\n *    R.pipe([1, 2, 3, 4], R.difference([2, 5, 3])); // => [1, 4]\n *    R.pipe([1, 1, 2, 2], R.difference([1])); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(other: readonly T[]): (data: readonly T[]) => T[];\n\nexport function difference(...args: readonly unknown[]): unknown {\n  return purryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(other: readonly T[]): LazyEvaluator<T> {\n  if (other.length === 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  // We need to build a more efficient data structure that would allow us to\n  // keep track of the number of times we've seen a value in the other array.\n  const remaining = new Map<T, number>();\n  for (const value of other) {\n    remaining.set(value, (remaining.get(value) ?? 0) + 1);\n  }\n\n  return (value) => {\n    const copies = remaining.get(value);\n\n    if (copies === undefined || copies === 0) {\n      // The item is either not part of the other array or we've dropped enough\n      // copies of it so we return it.\n      return { done: false, hasNext: true, next: value };\n    }\n\n    // The item is equal to an item in the other array and there are still\n    // copies of it to \"account\" for so we skip this one and remove it from our\n    // ongoing tally.\n    remaining.set(value, copies - 1);\n    return SKIP_ITEM;\n  };\n}\n"],"mappings":"sGAuCA,SAAgB,EAAW,GAAG,EAAmC,CAC/D,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAsB,EAAuC,CACpE,GAAI,EAAM,SAAW,EACnB,OAAO,EAKT,IAAM,EAAY,IAAI,IACtB,IAAK,IAAM,KAAS,EAClB,EAAU,IAAI,GAAQ,EAAU,IAAI,EAAM,EAAI,GAAK,EAAE,CAGvD,MAAQ,IAAU,CAChB,IAAM,EAAS,EAAU,IAAI,EAAM,CAYnC,OAVI,IAAW,IAAA,IAAa,IAAW,EAG9B,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,EAMpD,EAAU,IAAI,EAAO,EAAS,EAAE,CACzB"}

backend/node_modules/remeda/dist/differenceWith.cjs

@@ -0,0 +1,2 @@
+const e=require(`./utilityEvaluators-CEX-n1-J.cjs`),t=require(`./purryFromLazy-tuFvR-GT.cjs`);function n(...e){return t.t(r,e)}const r=(t,n)=>r=>t.every(e=>!n(r,e))?{done:!1,hasNext:!0,next:r}:e.t;exports.differenceWith=n;
+//# sourceMappingURL=differenceWith.cjs.map

backend/node_modules/remeda/dist/differenceWith.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceWith.cjs","names":["purryFromLazy","SKIP_ITEM"],"sources":["../src/differenceWith.ts"],"sourcesContent":["import { purryFromLazy } from \"./internal/purryFromLazy\";\nimport type { LazyEvaluator } from \"./internal/types/LazyEvaluator\";\nimport { SKIP_ITEM } from \"./internal/utilityEvaluators\";\n\ntype IsEqual<T, Other> = (data: T, other: Other) => boolean;\n\n/**\n * Excludes the values from `other` array.\n * Elements are compared by custom comparator isEquals.\n *\n * @param data - The source array.\n * @param other - The values to exclude.\n * @param isEqual - The comparator.\n * @signature\n *    R.differenceWith(data, other, isEqual)\n * @example\n *    R.differenceWith(\n *      [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }],\n *      [2, 5, 3],\n *      ({ a }, b) => a === b,\n *    ); //=> [{ a: 1 }, { a: 4 }]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function differenceWith<T, Other>(\n  data: readonly T[],\n  other: readonly Other[],\n  isEqual: IsEqual<T, Other>,\n): T[];\n\n/**\n * Excludes the values from `other` array.\n * Elements are compared by custom comparator isEquals.\n *\n * @param other - The values to exclude.\n * @param isEqual - The comparator.\n * @signature\n *    R.differenceWith(other, isEqual)(data)\n * @example\n *    R.pipe(\n *      [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }, { a: 6 }],\n *      R.differenceWith([2, 3], ({ a }, b) => a === b),\n *    ); //=> [{ a: 1 }, { a: 4 }, { a: 5 }, { a: 6 }]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function differenceWith<T, Other>(\n  other: readonly Other[],\n  isEqual: IsEqual<T, Other>,\n): (data: readonly T[]) => T[];\n\nexport function differenceWith(...args: readonly unknown[]): unknown {\n  return purryFromLazy(lazyImplementation, args);\n}\n\nconst lazyImplementation =\n  <T, Other>(\n    other: readonly Other[],\n    isEqual: IsEqual<T, Other>,\n  ): LazyEvaluator<T> =>\n  (value) =>\n    other.every((otherValue) => !isEqual(value, otherValue))\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n"],"mappings":"8FAqDA,SAAgB,EAAe,GAAG,EAAmC,CACnE,OAAOA,EAAAA,EAAc,EAAoB,EAAK,CAGhD,MAAM,GAEF,EACA,IAED,GACC,EAAM,MAAO,GAAe,CAAC,EAAQ,EAAO,EAAW,CAAC,CACpD,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3CC,EAAAA"}

backend/node_modules/remeda/dist/differenceWith.js

@@ -0,0 +1,2 @@
+import{t as e}from"./utilityEvaluators-D7O7U3FY.js";import{t}from"./purryFromLazy-C1RBdBlx.js";function n(...e){return t(r,e)}const r=(t,n)=>r=>t.every(e=>!n(r,e))?{done:!1,hasNext:!0,next:r}:e;export{n as differenceWith};
+//# sourceMappingURL=differenceWith.js.map

backend/node_modules/remeda/dist/differenceWith.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"differenceWith.js","names":[],"sources":["../src/differenceWith.ts"],"sourcesContent":["import { purryFromLazy } from \"./internal/purryFromLazy\";\nimport type { LazyEvaluator } from \"./internal/types/LazyEvaluator\";\nimport { SKIP_ITEM } from \"./internal/utilityEvaluators\";\n\ntype IsEqual<T, Other> = (data: T, other: Other) => boolean;\n\n/**\n * Excludes the values from `other` array.\n * Elements are compared by custom comparator isEquals.\n *\n * @param data - The source array.\n * @param other - The values to exclude.\n * @param isEqual - The comparator.\n * @signature\n *    R.differenceWith(data, other, isEqual)\n * @example\n *    R.differenceWith(\n *      [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }],\n *      [2, 5, 3],\n *      ({ a }, b) => a === b,\n *    ); //=> [{ a: 1 }, { a: 4 }]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function differenceWith<T, Other>(\n  data: readonly T[],\n  other: readonly Other[],\n  isEqual: IsEqual<T, Other>,\n): T[];\n\n/**\n * Excludes the values from `other` array.\n * Elements are compared by custom comparator isEquals.\n *\n * @param other - The values to exclude.\n * @param isEqual - The comparator.\n * @signature\n *    R.differenceWith(other, isEqual)(data)\n * @example\n *    R.pipe(\n *      [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }, { a: 6 }],\n *      R.differenceWith([2, 3], ({ a }, b) => a === b),\n *    ); //=> [{ a: 1 }, { a: 4 }, { a: 5 }, { a: 6 }]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function differenceWith<T, Other>(\n  other: readonly Other[],\n  isEqual: IsEqual<T, Other>,\n): (data: readonly T[]) => T[];\n\nexport function differenceWith(...args: readonly unknown[]): unknown {\n  return purryFromLazy(lazyImplementation, args);\n}\n\nconst lazyImplementation =\n  <T, Other>(\n    other: readonly Other[],\n    isEqual: IsEqual<T, Other>,\n  ): LazyEvaluator<T> =>\n  (value) =>\n    other.every((otherValue) => !isEqual(value, otherValue))\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n"],"mappings":"+FAqDA,SAAgB,EAAe,GAAG,EAAmC,CACnE,OAAO,EAAc,EAAoB,EAAK,CAGhD,MAAM,GAEF,EACA,IAED,GACC,EAAM,MAAO,GAAe,CAAC,EAAQ,EAAO,EAAW,CAAC,CACpD,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3C"}

backend/node_modules/remeda/dist/divide.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}const n=(e,t)=>e/t;exports.divide=t;
+//# sourceMappingURL=divide.cjs.map

backend/node_modules/remeda/dist/divide.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"divide.cjs","names":["purry"],"sources":["../src/divide.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Divides two numbers.\n *\n * @param value - The number.\n * @param divisor - The number to divide the value by.\n * @signature\n *    R.divide(value, divisor);\n * @example\n *    R.divide(12, 3) // => 4\n *    R.reduce([1, 2, 3, 4], R.divide, 24) // => 1\n * @dataFirst\n * @category Number\n */\nexport function divide(value: bigint, divisor: bigint): bigint;\nexport function divide(value: number, divisor: number): number;\n\n/**\n * Divides two numbers.\n *\n * @param divisor - The number to divide the value by.\n * @signature\n *    R.divide(divisor)(value);\n * @example\n *    R.divide(3)(12) // => 4\n *    R.map([2, 4, 6, 8], R.divide(2)) // => [1, 2, 3, 4]\n * @dataLast\n * @category Number\n */\nexport function divide(divisor: bigint): (value: bigint) => bigint;\nexport function divide(divisor: number): (value: number) => number;\n\nexport function divide(...args: readonly unknown[]): unknown {\n  return purry(divideImplementation, 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 divisor would be of the same\n// type.\nconst divideImplementation = (value: number, divisor: number): number =>\n  value / divisor;\n"],"mappings":"wCAiCA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAOA,EAAAA,EAAM,EAAsB,EAAK,CAM1C,MAAM,GAAwB,EAAe,IAC3C,EAAQ"}

backend/node_modules/remeda/dist/divide.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}const n=(e,t)=>e/t;export{t as divide};
+//# sourceMappingURL=divide.js.map

backend/node_modules/remeda/dist/divide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"divide.js","names":[],"sources":["../src/divide.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Divides two numbers.\n *\n * @param value - The number.\n * @param divisor - The number to divide the value by.\n * @signature\n *    R.divide(value, divisor);\n * @example\n *    R.divide(12, 3) // => 4\n *    R.reduce([1, 2, 3, 4], R.divide, 24) // => 1\n * @dataFirst\n * @category Number\n */\nexport function divide(value: bigint, divisor: bigint): bigint;\nexport function divide(value: number, divisor: number): number;\n\n/**\n * Divides two numbers.\n *\n * @param divisor - The number to divide the value by.\n * @signature\n *    R.divide(divisor)(value);\n * @example\n *    R.divide(3)(12) // => 4\n *    R.map([2, 4, 6, 8], R.divide(2)) // => [1, 2, 3, 4]\n * @dataLast\n * @category Number\n */\nexport function divide(divisor: bigint): (value: bigint) => bigint;\nexport function divide(divisor: number): (value: number) => number;\n\nexport function divide(...args: readonly unknown[]): unknown {\n  return purry(divideImplementation, 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 divisor would be of the same\n// type.\nconst divideImplementation = (value: number, divisor: number): number =>\n  value / divisor;\n"],"mappings":"wCAiCA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAO,EAAM,EAAsB,EAAK,CAM1C,MAAM,GAAwB,EAAe,IAC3C,EAAQ"}

backend/node_modules/remeda/dist/doNothing.cjs

@@ -0,0 +1,2 @@
+function e(){return t}function t(...e){}exports.doNothing=e;
+//# sourceMappingURL=doNothing.cjs.map

backend/node_modules/remeda/dist/doNothing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"doNothing.cjs","names":[],"sources":["../src/doNothing.ts"],"sourcesContent":["/**\n * A function that takes any arguments and does nothing with them. This is\n * useful as a placeholder for any function or API that requires a **void**\n * function (a function that doesn't return a value). This could also be used in\n * combination with a ternary or other conditional execution to allow disabling\n * a function call for a specific case.\n *\n * Notice that this is a dataLast impl where the function needs to be invoked\n * to get the \"do nothing\" function.\n *\n * See also:\n * * `constant` - A function that ignores it's arguments and returns the same value on every invocation.\n * * `identity` - A function that returns the first argument it receives.\n *\n * @signature\n *   R.doNothing();\n * @example\n *   myApi({ onSuccess: handleSuccess, onError: R.doNothing() });\n *   myApi({ onSuccess: isDemoMode ? R.doNothing(): handleSuccess });\n * @dataLast\n * @category Function\n */\nexport function doNothing(): typeof doesNothing {\n  // Notice that the exported identity function is just the \"factory\" for the\n  // function. We do it this way so that all \"Function\" utilities have a similar\n  // API where the function is called, and not just used \"headless\". e.g.\n  // `doNothing()` and not `doNothing`, just like the API for `constant(1)`.\n  return doesNothing;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- There is no other way to make typescript infer the function arguments \"backwards\" in data-last invocations without the Args type parameter. @see: https://github.com/typescript-eslint/typescript-eslint/issues/9887\nfunction doesNothing<Args extends readonly unknown[]>(..._args: Args): void {\n  /* do nothing */\n}\n"],"mappings":"AAsBA,SAAgB,GAAgC,CAK9C,OAAO,EAIT,SAAS,EAA6C,GAAG,EAAmB"}

backend/node_modules/remeda/dist/doNothing.js

@@ -0,0 +1,2 @@
+function e(){return t}function t(...e){}export{e as doNothing};
+//# sourceMappingURL=doNothing.js.map

backend/node_modules/remeda/dist/doNothing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doNothing.js","names":[],"sources":["../src/doNothing.ts"],"sourcesContent":["/**\n * A function that takes any arguments and does nothing with them. This is\n * useful as a placeholder for any function or API that requires a **void**\n * function (a function that doesn't return a value). This could also be used in\n * combination with a ternary or other conditional execution to allow disabling\n * a function call for a specific case.\n *\n * Notice that this is a dataLast impl where the function needs to be invoked\n * to get the \"do nothing\" function.\n *\n * See also:\n * * `constant` - A function that ignores it's arguments and returns the same value on every invocation.\n * * `identity` - A function that returns the first argument it receives.\n *\n * @signature\n *   R.doNothing();\n * @example\n *   myApi({ onSuccess: handleSuccess, onError: R.doNothing() });\n *   myApi({ onSuccess: isDemoMode ? R.doNothing(): handleSuccess });\n * @dataLast\n * @category Function\n */\nexport function doNothing(): typeof doesNothing {\n  // Notice that the exported identity function is just the \"factory\" for the\n  // function. We do it this way so that all \"Function\" utilities have a similar\n  // API where the function is called, and not just used \"headless\". e.g.\n  // `doNothing()` and not `doNothing`, just like the API for `constant(1)`.\n  return doesNothing;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- There is no other way to make typescript infer the function arguments \"backwards\" in data-last invocations without the Args type parameter. @see: https://github.com/typescript-eslint/typescript-eslint/issues/9887\nfunction doesNothing<Args extends readonly unknown[]>(..._args: Args): void {\n  /* do nothing */\n}\n"],"mappings":"AAsBA,SAAgB,GAAgC,CAK9C,OAAO,EAIT,SAAS,EAA6C,GAAG,EAAmB"}

backend/node_modules/remeda/dist/drop.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`),t=require(`./utilityEvaluators-CEX-n1-J.cjs`);function n(...t){return e.t(r,t,i)}const r=(e,t)=>t<0?[...e]:e.slice(t);function i(e){if(e<=0)return t.r;let n=e;return e=>n>0?(--n,t.t):{done:!1,hasNext:!0,next:e}}exports.drop=n;
+//# sourceMappingURL=drop.cjs.map

backend/node_modules/remeda/dist/drop.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";import{r as t,t as n}from"./utilityEvaluators-D7O7U3FY.js";function r(...t){return e(i,t,a)}const i=(e,t)=>t<0?[...e]:e.slice(t);function a(e){if(e<=0)return t;let r=e;return e=>r>0?(--r,n):{done:!1,hasNext:!0,next:e}}export{r as drop};
+//# sourceMappingURL=drop.js.map

backend/node_modules/remeda/dist/dropFirstBy.cjs

@@ -0,0 +1,2 @@
+const e=require(`./heap-BAgaPbFD.cjs`),t=require(`./purryOrderRules-Si4oUxGJ.cjs`);function n(...e){return t.n(r,e)}function r(t,n,r){if(r>=t.length)return[];if(r<=0)return[...t];let i=t.slice(0,r);e.n(i,n);let a=[],o=t.slice(r);for(let t of o){let r=e.t(i,n,t);a.push(r??t)}return a}exports.dropFirstBy=n;
+//# sourceMappingURL=dropFirstBy.cjs.map

backend/node_modules/remeda/dist/dropFirstBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropFirstBy.cjs","names":["purryOrderRulesWithArgument","heapMaybeInsert"],"sources":["../src/dropFirstBy.ts"],"sourcesContent":["import { heapify, heapMaybeInsert } from \"./internal/heap\";\nimport {\n  purryOrderRulesWithArgument,\n  type OrderRule,\n} from \"./internal/purryOrderRules\";\nimport type { CompareFunction } from \"./internal/types/CompareFunction\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param data - The input array.\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   R.dropFirstBy(data, n, ...rules);\n * @example\n *   R.dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaa', 'aaaa']\n * @dataFirst\n * @category Array\n */\nexport function dropFirstBy<T>(\n  data: readonly T[],\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): T[];\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   R.dropFirstBy(n, ...rules)(data);\n * @example\n *   R.pipe(['aa', 'aaaa', 'a', 'aaa'], R.dropFirstBy(2, x => x.length)); // => ['aaa', 'aaaa']\n * @dataLast\n * @category Array\n */\nexport function dropFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: readonly T[]) => T[];\n\nexport function dropFirstBy(...args: readonly unknown[]): unknown {\n  return purryOrderRulesWithArgument(dropFirstByImplementation, args);\n}\n\nfunction dropFirstByImplementation<T>(\n  data: readonly T[],\n  compareFn: CompareFunction<T>,\n  n: number,\n): T[] {\n  if (n >= data.length) {\n    return [];\n  }\n\n  if (n <= 0) {\n    return [...data];\n  }\n\n  const heap = data.slice(0, n);\n  heapify(heap, compareFn);\n\n  const out = [];\n\n  const rest = data.slice(n);\n  for (const item of rest) {\n    const previousHead = heapMaybeInsert(heap, compareFn, item);\n    out.push(previousHead ?? item);\n  }\n\n  return out;\n}\n"],"mappings":"mFAkDA,SAAgB,EAAY,GAAG,EAAmC,CAChE,OAAOA,EAAAA,EAA4B,EAA2B,EAAK,CAGrE,SAAS,EACP,EACA,EACA,EACK,CACL,GAAI,GAAK,EAAK,OACZ,MAAO,EAAE,CAGX,GAAI,GAAK,EACP,MAAO,CAAC,GAAG,EAAK,CAGlB,IAAM,EAAO,EAAK,MAAM,EAAG,EAAE,CAC7B,EAAA,EAAQ,EAAM,EAAU,CAExB,IAAM,EAAM,EAAE,CAER,EAAO,EAAK,MAAM,EAAE,CAC1B,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAeC,EAAAA,EAAgB,EAAM,EAAW,EAAK,CAC3D,EAAI,KAAK,GAAgB,EAAK,CAGhC,OAAO"}

backend/node_modules/remeda/dist/dropFirstBy.js

@@ -0,0 +1,2 @@
+import{n as e,t}from"./heap-CmRflSHM.js";import{n}from"./purryOrderRules-LBeHSsQr.js";function r(...e){return n(i,e)}function i(n,r,i){if(i>=n.length)return[];if(i<=0)return[...n];let a=n.slice(0,i);e(a,r);let o=[],s=n.slice(i);for(let e of s){let n=t(a,r,e);o.push(n??e)}return o}export{r as dropFirstBy};
+//# sourceMappingURL=dropFirstBy.js.map

backend/node_modules/remeda/dist/dropFirstBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropFirstBy.js","names":[],"sources":["../src/dropFirstBy.ts"],"sourcesContent":["import { heapify, heapMaybeInsert } from \"./internal/heap\";\nimport {\n  purryOrderRulesWithArgument,\n  type OrderRule,\n} from \"./internal/purryOrderRules\";\nimport type { CompareFunction } from \"./internal/types/CompareFunction\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param data - The input array.\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   R.dropFirstBy(data, n, ...rules);\n * @example\n *   R.dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaa', 'aaaa']\n * @dataFirst\n * @category Array\n */\nexport function dropFirstBy<T>(\n  data: readonly T[],\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): T[];\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to keep `n` elements) see `takeFirstBy`.\n *\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   R.dropFirstBy(n, ...rules)(data);\n * @example\n *   R.pipe(['aa', 'aaaa', 'a', 'aaa'], R.dropFirstBy(2, x => x.length)); // => ['aaa', 'aaaa']\n * @dataLast\n * @category Array\n */\nexport function dropFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: readonly T[]) => T[];\n\nexport function dropFirstBy(...args: readonly unknown[]): unknown {\n  return purryOrderRulesWithArgument(dropFirstByImplementation, args);\n}\n\nfunction dropFirstByImplementation<T>(\n  data: readonly T[],\n  compareFn: CompareFunction<T>,\n  n: number,\n): T[] {\n  if (n >= data.length) {\n    return [];\n  }\n\n  if (n <= 0) {\n    return [...data];\n  }\n\n  const heap = data.slice(0, n);\n  heapify(heap, compareFn);\n\n  const out = [];\n\n  const rest = data.slice(n);\n  for (const item of rest) {\n    const previousHead = heapMaybeInsert(heap, compareFn, item);\n    out.push(previousHead ?? item);\n  }\n\n  return out;\n}\n"],"mappings":"sFAkDA,SAAgB,EAAY,GAAG,EAAmC,CAChE,OAAO,EAA4B,EAA2B,EAAK,CAGrE,SAAS,EACP,EACA,EACA,EACK,CACL,GAAI,GAAK,EAAK,OACZ,MAAO,EAAE,CAGX,GAAI,GAAK,EACP,MAAO,CAAC,GAAG,EAAK,CAGlB,IAAM,EAAO,EAAK,MAAM,EAAG,EAAE,CAC7B,EAAQ,EAAM,EAAU,CAExB,IAAM,EAAM,EAAE,CAER,EAAO,EAAK,MAAM,EAAE,CAC1B,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAe,EAAgB,EAAM,EAAW,EAAK,CAC3D,EAAI,KAAK,GAAgB,EAAK,CAGhC,OAAO"}

backend/node_modules/remeda/dist/dropLast.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}const n=(e,t)=>t>0?e.slice(0,Math.max(0,e.length-t)):[...e];exports.dropLast=t;
+//# sourceMappingURL=dropLast.cjs.map

backend/node_modules/remeda/dist/dropLast.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropLast.cjs","names":["purry"],"sources":["../src/dropLast.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\n\n/**\n * Removes last `n` elements from the `array`.\n *\n * @param array - The target array.\n * @param n - The number of elements to skip.\n * @signature\n *    R.dropLast(array, n)\n * @example\n *    R.dropLast([1, 2, 3, 4, 5], 2) // => [1, 2, 3]\n * @dataFirst\n * @category Array\n */\nexport function dropLast<T extends IterableContainer>(\n  array: T,\n  n: number,\n): T[number][];\n\n/**\n * Removes last `n` elements from the `array`.\n *\n * @param n - The number of elements to skip.\n * @signature\n *    R.dropLast(n)(array)\n * @example\n *    R.dropLast(2)([1, 2, 3, 4, 5]) // => [1, 2, 3]\n * @dataLast\n * @category Array\n */\nexport function dropLast(\n  n: number,\n): <T extends IterableContainer>(array: T) => T[number][];\n\nexport function dropLast(...args: readonly unknown[]): unknown {\n  return purry(dropLastImplementation, args);\n}\n\nconst dropLastImplementation = <T extends IterableContainer>(\n  array: T,\n  n: number,\n): T[number][] =>\n  n > 0 ? array.slice(0, Math.max(0, array.length - n)) : [...array];\n"],"mappings":"wCAmCA,SAAgB,EAAS,GAAG,EAAmC,CAC7D,OAAOA,EAAAA,EAAM,EAAwB,EAAK,CAG5C,MAAM,GACJ,EACA,IAEA,EAAI,EAAI,EAAM,MAAM,EAAG,KAAK,IAAI,EAAG,EAAM,OAAS,EAAE,CAAC,CAAG,CAAC,GAAG,EAAM"}

backend/node_modules/remeda/dist/dropLast.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}const n=(e,t)=>t>0?e.slice(0,Math.max(0,e.length-t)):[...e];export{t as dropLast};
+//# sourceMappingURL=dropLast.js.map

backend/node_modules/remeda/dist/dropLast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropLast.js","names":[],"sources":["../src/dropLast.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\n\n/**\n * Removes last `n` elements from the `array`.\n *\n * @param array - The target array.\n * @param n - The number of elements to skip.\n * @signature\n *    R.dropLast(array, n)\n * @example\n *    R.dropLast([1, 2, 3, 4, 5], 2) // => [1, 2, 3]\n * @dataFirst\n * @category Array\n */\nexport function dropLast<T extends IterableContainer>(\n  array: T,\n  n: number,\n): T[number][];\n\n/**\n * Removes last `n` elements from the `array`.\n *\n * @param n - The number of elements to skip.\n * @signature\n *    R.dropLast(n)(array)\n * @example\n *    R.dropLast(2)([1, 2, 3, 4, 5]) // => [1, 2, 3]\n * @dataLast\n * @category Array\n */\nexport function dropLast(\n  n: number,\n): <T extends IterableContainer>(array: T) => T[number][];\n\nexport function dropLast(...args: readonly unknown[]): unknown {\n  return purry(dropLastImplementation, args);\n}\n\nconst dropLastImplementation = <T extends IterableContainer>(\n  array: T,\n  n: number,\n): T[number][] =>\n  n > 0 ? array.slice(0, Math.max(0, array.length - n)) : [...array];\n"],"mappings":"wCAmCA,SAAgB,EAAS,GAAG,EAAmC,CAC7D,OAAO,EAAM,EAAwB,EAAK,CAG5C,MAAM,GACJ,EACA,IAEA,EAAI,EAAI,EAAM,MAAM,EAAG,KAAK,IAAI,EAAG,EAAM,OAAS,EAAE,CAAC,CAAG,CAAC,GAAG,EAAM"}

backend/node_modules/remeda/dist/dropLastWhile.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}function n(e,t){for(let n=e.length-1;n>=0;n--)if(!t(e[n],n,e))return e.slice(0,n+1);return[]}exports.dropLastWhile=t;
+//# sourceMappingURL=dropLastWhile.cjs.map

backend/node_modules/remeda/dist/dropLastWhile.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropLastWhile.cjs","names":["purry"],"sources":["../src/dropLastWhile.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\n\n/**\n * Removes elements from the end of the array until the predicate returns false.\n *\n * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    R.dropLastWhile(data, predicate)\n * @example\n *    R.dropLastWhile([1, 2, 10, 3, 4], x => x < 10) // => [1, 2, 10]\n * @dataFirst\n * @category Array\n */\nexport function dropLastWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): T[number][];\n\n/**\n * Removes elements from the end of the array until the predicate returns false.\n *\n * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.\n *\n * @param predicate - The predicate.\n * @signature\n *    R.dropLastWhile(predicate)(data)\n * @example\n *    R.pipe([1, 2, 10, 3, 4], R.dropLastWhile(x => x < 10))  // => [1, 2, 10]\n * @dataLast\n * @category Array\n */\nexport function dropLastWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (data: T) => T[number][];\n\nexport function dropLastWhile(...args: readonly unknown[]): unknown {\n  return purry(dropLastWhileImplementation, args);\n}\n\nfunction dropLastWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): T[number][] {\n  for (let i = data.length - 1; i >= 0; i--) {\n    if (!predicate(data[i], i, data)) {\n      return data.slice(0, i + 1);\n    }\n  }\n  return [];\n}\n"],"mappings":"wCAuCA,SAAgB,EAAc,GAAG,EAAmC,CAClE,OAAOA,EAAAA,EAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACa,CACb,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,CAAC,EAAU,EAAK,GAAI,EAAG,EAAK,CAC9B,OAAO,EAAK,MAAM,EAAG,EAAI,EAAE,CAG/B,MAAO,EAAE"}

backend/node_modules/remeda/dist/dropLastWhile.js

@@ -0,0 +1,2 @@
+import{t as e}from"./purry-GjwKKIlp.js";function t(...t){return e(n,t)}function n(e,t){for(let n=e.length-1;n>=0;n--)if(!t(e[n],n,e))return e.slice(0,n+1);return[]}export{t as dropLastWhile};
+//# sourceMappingURL=dropLastWhile.js.map

backend/node_modules/remeda/dist/dropLastWhile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropLastWhile.js","names":[],"sources":["../src/dropLastWhile.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\n\n/**\n * Removes elements from the end of the array until the predicate returns false.\n *\n * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    R.dropLastWhile(data, predicate)\n * @example\n *    R.dropLastWhile([1, 2, 10, 3, 4], x => x < 10) // => [1, 2, 10]\n * @dataFirst\n * @category Array\n */\nexport function dropLastWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): T[number][];\n\n/**\n * Removes elements from the end of the array until the predicate returns false.\n *\n * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.\n *\n * @param predicate - The predicate.\n * @signature\n *    R.dropLastWhile(predicate)(data)\n * @example\n *    R.pipe([1, 2, 10, 3, 4], R.dropLastWhile(x => x < 10))  // => [1, 2, 10]\n * @dataLast\n * @category Array\n */\nexport function dropLastWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (data: T) => T[number][];\n\nexport function dropLastWhile(...args: readonly unknown[]): unknown {\n  return purry(dropLastWhileImplementation, args);\n}\n\nfunction dropLastWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): T[number][] {\n  for (let i = data.length - 1; i >= 0; i--) {\n    if (!predicate(data[i], i, data)) {\n      return data.slice(0, i + 1);\n    }\n  }\n  return [];\n}\n"],"mappings":"wCAuCA,SAAgB,EAAc,GAAG,EAAmC,CAClE,OAAO,EAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACa,CACb,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,CAAC,EAAU,EAAK,GAAI,EAAG,EAAK,CAC9B,OAAO,EAAK,MAAM,EAAG,EAAI,EAAE,CAG/B,MAAO,EAAE"}

backend/node_modules/remeda/dist/dropWhile.cjs

@@ -0,0 +1,2 @@
+const e=require(`./purry-3_3M-Pet.cjs`);function t(...t){return e.t(n,t)}function n(e,t){for(let[n,r]of e.entries())if(!t(r,n,e))return e.slice(n);return[]}exports.dropWhile=t;
+//# sourceMappingURL=dropWhile.cjs.map