initial commit

node_modules/defu/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Pooya Parsa <pooya@pi0.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/defu/README.md

@@ -0,0 +1,176 @@
+![defu](.github/banner.svg)
+
+# 🌊 defu
+
+> Assign default properties, recursively. Lightweight and Fast!
+
+[![Standard JS][standard-src]][standard-href]
+[![codecov][codecov-src]][codecov-href]
+[![npm version][npm-v-src]][npm-v-href]
+[![npm downloads][npm-dm-src]][npm-dm-href]
+[![package phobia][packagephobia-src]][packagephobia-href]
+[![bundle phobia][bundlephobia-src]][bundlephobia-href]
+
+## Install
+
+Install package:
+
+```bash
+# yarn
+yarn add defu
+# npm
+npm install defu
+# pnpm
+pnpm install defu
+```
+
+## Usage
+
+```js
+import { defu } from 'defu'
+
+const options = defu(object, ...defaults)
+```
+
+Leftmost arguments have more priority when assigning defaults.
+
+### Arguments
+
+- **object (Object):** The destination object.
+- **source (Object):** The source object.
+
+```js
+import { defu } from 'defu'
+
+console.log(defu({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }))
+// => { a: { b: 2, c: 3 } }
+```
+
+### Using with CommonJS
+
+```js
+const { defu } = require('defu')
+```
+
+## Custom Merger
+
+Sometimes default merging strategy is not desirable. Using `createDefu` we can create a custom instance with different merging strategy.
+
+This function accepts `obj` (source object), `key` and `value` (current value) and should return `true` if applied custom merging.
+
+**Example:** Sum numbers instead of overriding
+
+```js
+import { createDefu } from 'defu'
+
+const ext = createDefu((obj, key, value) => {
+  if (typeof obj[key] === 'number' && typeof value === 'number') {
+    obj[key] += val
+    return true
+  }
+})
+
+ext({ cost: 15 }, { cost: 10 }) // { cost: 25 }
+```
+
+## Function Merger
+
+Using `defuFn`, if user provided a function, it will be called with default value instead of merging.
+
+I can be useful for default values manipulation.
+
+**Example:** Filter some items from defaults (array) and add 20 to the count default value.
+
+```js
+import { defuFn } from 'defu'
+
+defuFn({
+  ignore: (val) => val.filter(item => item !== 'dist'),
+  count: (count) => count + 20
+ }, {
+   ignore: ['node_modules','dist'],
+   count: 10
+ })
+ /*
+ {
+    ignore: ['node_modules'],
+    count: 30
+  }
+  */
+```
+
+**Note:** if the default value is not defined, the function defined won't be called and kept as value.
+
+## Array Function Merger
+
+`defuArrayFn` is similar to `defuFn` but **only applies to array values defined in defaults**.
+
+**Example:** Filter some items from defaults (array) and add 20 to the count default value.
+
+```js
+import { defuArrayFn } from 'defu'
+
+defuArrayFn({
+  ignore(val) => val.filter(i => i !== 'dist'),
+  count: () => 20
+ }, {
+   ignore: [
+     'node_modules',
+     'dist'
+   ],
+   count: 10
+ })
+ /*
+  {
+    ignore: ['node_modules'],
+    count: () => 20
+  }
+  */
+```
+
+**Note:** the function is called only if the value defined in defaults is an aray.
+
+### Remarks
+
+- `object` and `defaults` are not modified
+- Nullish values ([`null`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null) and [`undefined`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)) are skipped. Please use [defaults-deep](https://www.npmjs.com/package/defaults-deep) or [omit-deep](http://npmjs.com/package/omit-deep) or [lodash.defaultsdeep](https://www.npmjs.com/package/lodash.defaultsdeep) if you need to preserve or different behavior.
+- Assignment of `__proto__` and `constructor` keys will be skipped to prevent security issues with object pollution.
+- Will concat `array` values (if default property is defined)
+```js
+console.log(defu({ array: ['b', 'c'] }, { array: ['a'] }))
+// => { array: ['a', 'b', 'c']}
+```
+
+## Type
+
+We expose `Defu` as a type utility to return a merged type that follows the rules that defu follows.
+
+```js
+import type { Defu } from 'defu'
+
+type Options = Defu<{ foo: 'bar' }, [{}, { bar: 'baz' }, { something: 42 }]>
+// returns { foo: 'bar', bar: 'baz', 'something': 42 }
+```
+
+## License
+
+MIT. Made with 💖
+
+<!-- Refs -->
+[standard-src]: https://flat.badgen.net/badge/code%20style/standard/green
+[standard-href]: https://standardjs.com
+
+[npm-v-src]: https://flat.badgen.net/npm/v/defu/latest
+[npm-v-href]: https://npmjs.com/package/defu
+
+[npm-dm-src]: https://flat.badgen.net/npm/dm/defu
+[npm-dm-href]: https://npmjs.com/package/defu
+
+[packagephobia-src]: https://flat.badgen.net/packagephobia/install/defu
+[packagephobia-href]: https://packagephobia.now.sh/result?p=defu
+
+[bundlephobia-src]: https://flat.badgen.net/bundlephobia/min/defu
+[bundlephobia-href]: https://bundlephobia.com/result?p=defu
+
+[codecov-src]: https://flat.badgen.net/codecov/c/github/unjs/defu/master
+[codecov-href]: https://codecov.io/gh/unjs/defu

node_modules/defu/dist/defu.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isObject(value) && isObject(object[key])) {
+      object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
+}
+const defu = createDefu();
+const defuFn = createDefu((object, key, currentValue, _namespace) => {
+  if (typeof object[key] !== "undefined" && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+const defuArrayFn = createDefu((object, key, currentValue, _namespace) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+
+exports.createDefu = createDefu;
+exports.default = defu;
+exports.defu = defu;
+exports.defuArrayFn = defuArrayFn;
+exports.defuFn = defuFn;

node_modules/defu/dist/defu.d.ts

@@ -0,0 +1,25 @@
+declare type Input = Record<string | number | symbol, any>;
+declare type IgnoredInput = boolean | number | null | any[] | Record<never, any> | undefined;
+declare type Merger = <T extends Input, K extends keyof T>(object: T, key: keyof T, value: T[K], namespace: string) => any;
+declare type nullish = null | undefined | void;
+declare type MergeObjects<Destination extends Input, Defaults extends Input> = Destination extends Defaults ? Destination : Omit<Destination, keyof Destination & keyof Defaults> & Omit<Defaults, keyof Destination & keyof Defaults> & {
+    -readonly [Key in keyof Destination & keyof Defaults]: Destination[Key] extends nullish ? Defaults[Key] extends nullish ? nullish : Defaults[Key] : Defaults[Key] extends nullish ? Destination[Key] : Merge<Destination[Key], Defaults[Key]>;
+};
+declare type Defu<S extends Input, D extends Array<Input | IgnoredInput>> = D extends [infer F, ...infer Rest] ? F extends Input ? Rest extends Array<Input | IgnoredInput> ? Defu<MergeObjects<S, F>, Rest> : MergeObjects<S, F> : F extends IgnoredInput ? Rest extends Array<Input | IgnoredInput> ? Defu<S, Rest> : S : S : S;
+declare type DefuFn = <Source extends Input, Defaults extends Array<Input | IgnoredInput>>(source: Source, ...defaults: Defaults) => Defu<Source, Defaults>;
+interface DefuInstance {
+    <Source extends Input, Defaults extends Array<Input | IgnoredInput>>(source: Source | IgnoredInput, ...defaults: Defaults): Defu<Source, Defaults>;
+    fn: DefuFn;
+    arrayFn: DefuFn;
+    extend(merger?: Merger): DefuFn;
+}
+declare type MergeArrays<Destination, Source> = Destination extends Array<infer DestinationType> ? Source extends Array<infer SourceType> ? Array<DestinationType | SourceType> : Source | Array<DestinationType> : Source | Destination;
+declare type Merge<Destination extends Input, Defaults extends Input> = Destination extends nullish ? Defaults extends nullish ? nullish : Defaults : Defaults extends nullish ? Destination : Destination extends Array<any> ? Defaults extends Array<any> ? MergeArrays<Destination, Defaults> : Destination | Defaults : Destination extends Function ? Destination | Defaults : Destination extends RegExp ? Destination | Defaults : Destination extends Promise<any> ? Destination | Defaults : Defaults extends Function ? Destination | Defaults : Defaults extends RegExp ? Destination | Defaults : Defaults extends Promise<any> ? Destination | Defaults : Destination extends Input ? Defaults extends Input ? MergeObjects<Destination, Defaults> : Destination | Defaults : Destination | Defaults;
+
+declare function createDefu(merger?: Merger): DefuFn;
+declare const defu: DefuInstance;
+
+declare const defuFn: DefuFn;
+declare const defuArrayFn: DefuFn;
+
+export { Defu, createDefu, defu as default, defu, defuArrayFn, defuFn };

node_modules/defu/dist/defu.mjs

@@ -0,0 +1,47 @@
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isObject(value) && isObject(object[key])) {
+      object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
+}
+const defu = createDefu();
+const defuFn = createDefu((object, key, currentValue, _namespace) => {
+  if (typeof object[key] !== "undefined" && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+const defuArrayFn = createDefu((object, key, currentValue, _namespace) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+
+export { createDefu, defu as default, defu, defuArrayFn, defuFn };

node_modules/defu/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "defu",
+  "version": "6.1.1",
+  "description": "Recursively assign default properties. Lightweight and Fast!",
+  "repository": "unjs/defu",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "require": "./dist/defu.cjs",
+      "import": "./dist/defu.mjs"
+    }
+  },
+  "main": "./dist/defu.cjs",
+  "module": "./dist/defu.mjs",
+  "types": "./dist/defu.d.ts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "@vitest/coverage-c8": "^0.25.2",
+    "eslint": "^8.27.0",
+    "eslint-config-unjs": "^0.0.2",
+    "expect-type": "^0.15.0",
+    "standard-version": "^9.5.0",
+    "typescript": "^4.8.4",
+    "unbuild": "^0.9.4",
+    "vitest": "^0.25.2"
+  },
+  "packageManager": "pnpm@7.13.5",
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint --ext .ts src",
+    "release": "pnpm test && standard-version && git push --follow-tags && pnpm publish",
+    "test": "pnpm lint && pnpm vitest run",
+    "test:types": "tsc --noEmit"
+  }
+}