diff options
Diffstat (limited to 'node_modules/filesize')
| -rw-r--r-- | node_modules/filesize/LICENSE | 28 | ||||
| -rw-r--r-- | node_modules/filesize/README.md | 113 | ||||
| -rw-r--r-- | node_modules/filesize/dist/filesize.cjs | 238 | ||||
| -rw-r--r-- | node_modules/filesize/dist/filesize.esm.js | 231 | ||||
| -rw-r--r-- | node_modules/filesize/package.json | 60 | ||||
| -rw-r--r-- | node_modules/filesize/types/filesize.d.ts | 56 |
6 files changed, 726 insertions, 0 deletions
diff --git a/node_modules/filesize/LICENSE b/node_modules/filesize/LICENSE new file mode 100644 index 0000000..ed3d813 --- /dev/null +++ b/node_modules/filesize/LICENSE @@ -0,0 +1,28 @@ +Copyright (c) 2024, Jason Mulligan
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+* Neither the name of filesize nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/node_modules/filesize/README.md b/node_modules/filesize/README.md new file mode 100644 index 0000000..e3ac224 --- /dev/null +++ b/node_modules/filesize/README.md @@ -0,0 +1,113 @@ +# filesize.js
+
+[](https://www.npmjs.com/package/filesize) [](https://cdnjs.com/libraries/filesize)
+
+filesize.js provides a simple way to get a human-readable file size string from a number (float or integer) or string.
+
+```javascript
+import {filesize} from "filesize";
+filesize(265318, {standard: "jedec"}); // "259.1 KB"
+```
+
+## Testing
+
+filesize has 100% code coverage with its tests.
+
+```console
+--------------|---------|----------|---------|---------|-----------------------
+File | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
+--------------|---------|----------|---------|---------|-----------------------
+All files | 100 | 95.52 | 100 | 100 |
+ filesize.cjs | 100 | 95.52 | 100 | 100 | 77-78,173,196,199,210
+--------------|---------|----------|---------|---------|-----------------------
+```
+
+## Optional settings
+
+`filesize()` accepts an optional descriptor Object as a second argument, so you can customize the output.
+
+### base
+_*(number)*_ Number base, default is `10`
+
+### bits
+_*(boolean)*_ Enables `bit` sizes, default is `false`
+
+### exponent
+_*(number)*_ Specifies the symbol via exponent, e.g. `2` is `MB` for base 2, default is `-1`
+
+### fullform
+_*(boolean)*_ Enables full form of unit of measure, default is `false`
+
+### fullforms
+_*(array)*_ Array of full form overrides, default is `[]`
+
+### locale (overrides 'separator')
+_*(string || boolean)*_ BCP 47 language tag to specify a locale, or `true` to use default locale, default is `""`
+
+### localeOptions (overrides 'separator', requires string for 'locale' option)
+_*(object)*_ Dictionary of options defined by ECMA-402 ([Number.prototype.toLocaleString](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString)). Requires locale option to be explicitly passed as a string, otherwise is ignored.
+
+### output
+_*(string)*_ Output of function (`array`, `exponent`, `object`, or `string`), default is `string`
+
+### pad
+_*(boolean)*_ Decimal place end padding, default is `false`
+
+### precision
+_*(number)*_ Sets precision of numerical output, default is `0`
+
+### round
+_*(number)*_ Decimal place, default is `2`
+
+### roundingMethod
+_*(string)*_ Rounding method, can be `round`, `floor`, or `ceil`, default is `round`
+
+### separator
+_*(string)*_ Decimal separator character, default is an empty string.
+
+### spacer
+_*(string)*_ Character between the `result` and `symbol`, default is `" "`
+
+### standard
+_*(string)*_ Standard unit of measure, can be `iec`, `jedec`, or `si`. Default is `si` (base 10). The `si` option is an alias of `jedec`, such that it is not valid for other configuration options.
+
+### symbols
+_*(object)*_ Dictionary of IEC/JEDEC symbols to replace for localization, defaults to english if no match is found; SI is handled automatically with JEDEC values.
+
+## Examples
+
+```javascript
+filesize(500); // "500 B"
+filesize(500, {bits: true}); // "4 kbit"
+filesize(265318, {base: 2}); // "259.1 KiB"
+filesize(265318); // "265.32 kB"
+filesize(265318, {round: 0}); // "265 kB"
+filesize(265318, {output: "array"}); // [265.32, "kB"]
+filesize(265318, {output: "object"}); // {value: 265.32, symbol: "kB", exponent: 1, unit: "kB"}
+filesize(1, {symbols: {B: "Б"}}); // "1 Б"
+filesize(1024); // "1.02 kB"
+filesize(1024, {exponent: 0}); // "1024 B"
+filesize(1024, {output: "exponent"}); // 1
+filesize(265318, {standard: "jedec"}); // "259.1 KB"
+filesize(265318, {base: 2, fullform: true}); // "259.1 kibibytes"
+filesize(12, {fullform: true, fullforms: ["байтов"]}); // "12 байтов"
+filesize(265318, {separator: ","}); // "265,32 kB"
+filesize(265318, {locale: "de"}); // "265,32 kB"
+```
+
+
+## Partial Application
+`partial()` takes the second parameter of `filesize()` and returns a new function with the configuration applied
+upon execution. This can be used to reduce `Object` creation if you call `filesize()` without caching the `descriptor`
+in lexical scope.
+
+```javascript
+import {partial} from "filesize";
+const size = partial({standard: "jedec"});
+
+size(265318); // "259.1 KB"
+```
+
+## License
+Copyright (c) 2024 Jason Mulligan
+Licensed under the BSD-3 license.
diff --git a/node_modules/filesize/dist/filesize.cjs b/node_modules/filesize/dist/filesize.cjs new file mode 100644 index 0000000..dd6e6b7 --- /dev/null +++ b/node_modules/filesize/dist/filesize.cjs @@ -0,0 +1,238 @@ +/** + * filesize + * + * @copyright 2024 Jason Mulligan <jason.mulligan@avoidwork.com> + * @license BSD-3-Clause + * @version 10.1.6 + */ +'use strict'; + +const ARRAY = "array";
+const BIT = "bit";
+const BITS = "bits";
+const BYTE = "byte";
+const BYTES = "bytes";
+const EMPTY = "";
+const EXPONENT = "exponent";
+const FUNCTION = "function";
+const IEC = "iec";
+const INVALID_NUMBER = "Invalid number";
+const INVALID_ROUND = "Invalid rounding method";
+const JEDEC = "jedec";
+const OBJECT = "object";
+const PERIOD = ".";
+const ROUND = "round";
+const S = "s";
+const SI = "si";
+const SI_KBIT = "kbit";
+const SI_KBYTE = "kB";
+const SPACE = " ";
+const STRING = "string";
+const ZERO = "0";
+const STRINGS = {
+ symbol: {
+ iec: {
+ bits: ["bit", "Kibit", "Mibit", "Gibit", "Tibit", "Pibit", "Eibit", "Zibit", "Yibit"],
+ bytes: ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"]
+ },
+ jedec: {
+ bits: ["bit", "Kbit", "Mbit", "Gbit", "Tbit", "Pbit", "Ebit", "Zbit", "Ybit"],
+ bytes: ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
+ }
+ },
+ fullform: {
+ iec: ["", "kibi", "mebi", "gibi", "tebi", "pebi", "exbi", "zebi", "yobi"],
+ jedec: ["", "kilo", "mega", "giga", "tera", "peta", "exa", "zetta", "yotta"]
+ }
+}; + +function filesize (arg, {
+ bits = false,
+ pad = false,
+ base = -1,
+ round = 2,
+ locale = EMPTY,
+ localeOptions = {},
+ separator = EMPTY,
+ spacer = SPACE,
+ symbols = {},
+ standard = EMPTY,
+ output = STRING,
+ fullform = false,
+ fullforms = [],
+ exponent = -1,
+ roundingMethod = ROUND,
+ precision = 0
+} = {}) {
+ let e = exponent,
+ num = Number(arg),
+ result = [],
+ val = 0,
+ u = EMPTY;
+
+ // Sync base & standard
+ if (standard === SI) {
+ base = 10;
+ standard = JEDEC;
+ } else if (standard === IEC || standard === JEDEC) {
+ base = 2;
+ } else if (base === 2) {
+ standard = IEC;
+ } else {
+ base = 10;
+ standard = JEDEC;
+ }
+
+ const ceil = base === 10 ? 1000 : 1024,
+ full = fullform === true,
+ neg = num < 0,
+ roundingFunc = Math[roundingMethod];
+
+ if (typeof arg !== "bigint" && isNaN(arg)) {
+ throw new TypeError(INVALID_NUMBER);
+ }
+
+ if (typeof roundingFunc !== FUNCTION) {
+ throw new TypeError(INVALID_ROUND);
+ }
+
+ // Flipping a negative number to determine the size
+ if (neg) {
+ num = -num;
+ }
+
+ // Determining the exponent
+ if (e === -1 || isNaN(e)) {
+ e = Math.floor(Math.log(num) / Math.log(ceil));
+
+ if (e < 0) {
+ e = 0;
+ }
+ }
+
+ // Exceeding supported length, time to reduce & multiply
+ if (e > 8) {
+ if (precision > 0) {
+ precision += 8 - e;
+ }
+
+ e = 8;
+ }
+
+ if (output === EXPONENT) {
+ return e;
+ }
+
+ // Zero is now a special case because bytes divide by 1
+ if (num === 0) {
+ result[0] = 0;
+ u = result[1] = STRINGS.symbol[standard][bits ? BITS : BYTES][e];
+ } else {
+ val = num / (base === 2 ? Math.pow(2, e * 10) : Math.pow(1000, e));
+
+ if (bits) {
+ val = val * 8;
+
+ if (val >= ceil && e < 8) {
+ val = val / ceil;
+ e++;
+ }
+ }
+
+ const p = Math.pow(10, e > 0 ? round : 0);
+ result[0] = roundingFunc(val * p) / p;
+
+ if (result[0] === ceil && e < 8 && exponent === -1) {
+ result[0] = 1;
+ e++;
+ }
+
+ u = result[1] = base === 10 && e === 1 ? bits ? SI_KBIT : SI_KBYTE : STRINGS.symbol[standard][bits ? BITS : BYTES][e];
+ }
+
+ // Decorating a 'diff'
+ if (neg) {
+ result[0] = -result[0];
+ }
+
+ // Setting optional precision
+ if (precision > 0) {
+ result[0] = result[0].toPrecision(precision);
+ }
+
+ // Applying custom symbol
+ result[1] = symbols[result[1]] || result[1];
+
+ if (locale === true) {
+ result[0] = result[0].toLocaleString();
+ } else if (locale.length > 0) {
+ result[0] = result[0].toLocaleString(locale, localeOptions);
+ } else if (separator.length > 0) {
+ result[0] = result[0].toString().replace(PERIOD, separator);
+ }
+
+ if (pad && round > 0) {
+ const i = result[0].toString(),
+ x = separator || ((i.match(/(\D)/g) || []).pop() || PERIOD),
+ tmp = i.toString().split(x),
+ s = tmp[1] || EMPTY,
+ l = s.length,
+ n = round - l;
+
+ result[0] = `${tmp[0]}${x}${s.padEnd(l + n, ZERO)}`;
+ }
+
+ if (full) {
+ result[1] = fullforms[e] ? fullforms[e] : STRINGS.fullform[standard][e] + (bits ? BIT : BYTE) + (result[0] === 1 ? EMPTY : S);
+ }
+
+ // Returning Array, Object, or String (default)
+ return output === ARRAY ? result : output === OBJECT ? {
+ value: result[0],
+ symbol: result[1],
+ exponent: e,
+ unit: u
+ } : result.join(spacer);
+}
+
+// Partial application for functional programming
+function partial ({
+ bits = false,
+ pad = false,
+ base = -1,
+ round = 2,
+ locale = EMPTY,
+ localeOptions = {},
+ separator = EMPTY,
+ spacer = SPACE,
+ symbols = {},
+ standard = EMPTY,
+ output = STRING,
+ fullform = false,
+ fullforms = [],
+ exponent = -1,
+ roundingMethod = ROUND,
+ precision = 0
+} = {}) {
+ return arg => filesize(arg, {
+ bits,
+ pad,
+ base,
+ round,
+ locale,
+ localeOptions,
+ separator,
+ spacer,
+ symbols,
+ standard,
+ output,
+ fullform,
+ fullforms,
+ exponent,
+ roundingMethod,
+ precision
+ });
+} + +exports.filesize = filesize; +exports.partial = partial; diff --git a/node_modules/filesize/dist/filesize.esm.js b/node_modules/filesize/dist/filesize.esm.js new file mode 100644 index 0000000..15f8f1c --- /dev/null +++ b/node_modules/filesize/dist/filesize.esm.js @@ -0,0 +1,231 @@ +/** + * filesize + * + * @copyright 2024 Jason Mulligan <jason.mulligan@avoidwork.com> + * @license BSD-3-Clause + * @version 10.1.6 + */ +const ARRAY = "array";
+const BIT = "bit";
+const BITS = "bits";
+const BYTE = "byte";
+const BYTES = "bytes";
+const EMPTY = "";
+const EXPONENT = "exponent";
+const FUNCTION = "function";
+const IEC = "iec";
+const INVALID_NUMBER = "Invalid number";
+const INVALID_ROUND = "Invalid rounding method";
+const JEDEC = "jedec";
+const OBJECT = "object";
+const PERIOD = ".";
+const ROUND = "round";
+const S = "s";
+const SI = "si";
+const SI_KBIT = "kbit";
+const SI_KBYTE = "kB";
+const SPACE = " ";
+const STRING = "string";
+const ZERO = "0";
+const STRINGS = {
+ symbol: {
+ iec: {
+ bits: ["bit", "Kibit", "Mibit", "Gibit", "Tibit", "Pibit", "Eibit", "Zibit", "Yibit"],
+ bytes: ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"]
+ },
+ jedec: {
+ bits: ["bit", "Kbit", "Mbit", "Gbit", "Tbit", "Pbit", "Ebit", "Zbit", "Ybit"],
+ bytes: ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
+ }
+ },
+ fullform: {
+ iec: ["", "kibi", "mebi", "gibi", "tebi", "pebi", "exbi", "zebi", "yobi"],
+ jedec: ["", "kilo", "mega", "giga", "tera", "peta", "exa", "zetta", "yotta"]
+ }
+};function filesize (arg, {
+ bits = false,
+ pad = false,
+ base = -1,
+ round = 2,
+ locale = EMPTY,
+ localeOptions = {},
+ separator = EMPTY,
+ spacer = SPACE,
+ symbols = {},
+ standard = EMPTY,
+ output = STRING,
+ fullform = false,
+ fullforms = [],
+ exponent = -1,
+ roundingMethod = ROUND,
+ precision = 0
+} = {}) {
+ let e = exponent,
+ num = Number(arg),
+ result = [],
+ val = 0,
+ u = EMPTY;
+
+ // Sync base & standard
+ if (standard === SI) {
+ base = 10;
+ standard = JEDEC;
+ } else if (standard === IEC || standard === JEDEC) {
+ base = 2;
+ } else if (base === 2) {
+ standard = IEC;
+ } else {
+ base = 10;
+ standard = JEDEC;
+ }
+
+ const ceil = base === 10 ? 1000 : 1024,
+ full = fullform === true,
+ neg = num < 0,
+ roundingFunc = Math[roundingMethod];
+
+ if (typeof arg !== "bigint" && isNaN(arg)) {
+ throw new TypeError(INVALID_NUMBER);
+ }
+
+ if (typeof roundingFunc !== FUNCTION) {
+ throw new TypeError(INVALID_ROUND);
+ }
+
+ // Flipping a negative number to determine the size
+ if (neg) {
+ num = -num;
+ }
+
+ // Determining the exponent
+ if (e === -1 || isNaN(e)) {
+ e = Math.floor(Math.log(num) / Math.log(ceil));
+
+ if (e < 0) {
+ e = 0;
+ }
+ }
+
+ // Exceeding supported length, time to reduce & multiply
+ if (e > 8) {
+ if (precision > 0) {
+ precision += 8 - e;
+ }
+
+ e = 8;
+ }
+
+ if (output === EXPONENT) {
+ return e;
+ }
+
+ // Zero is now a special case because bytes divide by 1
+ if (num === 0) {
+ result[0] = 0;
+ u = result[1] = STRINGS.symbol[standard][bits ? BITS : BYTES][e];
+ } else {
+ val = num / (base === 2 ? Math.pow(2, e * 10) : Math.pow(1000, e));
+
+ if (bits) {
+ val = val * 8;
+
+ if (val >= ceil && e < 8) {
+ val = val / ceil;
+ e++;
+ }
+ }
+
+ const p = Math.pow(10, e > 0 ? round : 0);
+ result[0] = roundingFunc(val * p) / p;
+
+ if (result[0] === ceil && e < 8 && exponent === -1) {
+ result[0] = 1;
+ e++;
+ }
+
+ u = result[1] = base === 10 && e === 1 ? bits ? SI_KBIT : SI_KBYTE : STRINGS.symbol[standard][bits ? BITS : BYTES][e];
+ }
+
+ // Decorating a 'diff'
+ if (neg) {
+ result[0] = -result[0];
+ }
+
+ // Setting optional precision
+ if (precision > 0) {
+ result[0] = result[0].toPrecision(precision);
+ }
+
+ // Applying custom symbol
+ result[1] = symbols[result[1]] || result[1];
+
+ if (locale === true) {
+ result[0] = result[0].toLocaleString();
+ } else if (locale.length > 0) {
+ result[0] = result[0].toLocaleString(locale, localeOptions);
+ } else if (separator.length > 0) {
+ result[0] = result[0].toString().replace(PERIOD, separator);
+ }
+
+ if (pad && round > 0) {
+ const i = result[0].toString(),
+ x = separator || ((i.match(/(\D)/g) || []).pop() || PERIOD),
+ tmp = i.toString().split(x),
+ s = tmp[1] || EMPTY,
+ l = s.length,
+ n = round - l;
+
+ result[0] = `${tmp[0]}${x}${s.padEnd(l + n, ZERO)}`;
+ }
+
+ if (full) {
+ result[1] = fullforms[e] ? fullforms[e] : STRINGS.fullform[standard][e] + (bits ? BIT : BYTE) + (result[0] === 1 ? EMPTY : S);
+ }
+
+ // Returning Array, Object, or String (default)
+ return output === ARRAY ? result : output === OBJECT ? {
+ value: result[0],
+ symbol: result[1],
+ exponent: e,
+ unit: u
+ } : result.join(spacer);
+}
+
+// Partial application for functional programming
+function partial ({
+ bits = false,
+ pad = false,
+ base = -1,
+ round = 2,
+ locale = EMPTY,
+ localeOptions = {},
+ separator = EMPTY,
+ spacer = SPACE,
+ symbols = {},
+ standard = EMPTY,
+ output = STRING,
+ fullform = false,
+ fullforms = [],
+ exponent = -1,
+ roundingMethod = ROUND,
+ precision = 0
+} = {}) {
+ return arg => filesize(arg, {
+ bits,
+ pad,
+ base,
+ round,
+ locale,
+ localeOptions,
+ separator,
+ spacer,
+ symbols,
+ standard,
+ output,
+ fullform,
+ fullforms,
+ exponent,
+ roundingMethod,
+ precision
+ });
+}export{filesize,partial};
\ No newline at end of file diff --git a/node_modules/filesize/package.json b/node_modules/filesize/package.json new file mode 100644 index 0000000..7feb89b --- /dev/null +++ b/node_modules/filesize/package.json @@ -0,0 +1,60 @@ +{
+ "name": "filesize",
+ "description": "JavaScript library to generate a human readable String describing the file size",
+ "version": "10.1.6",
+ "homepage": "https://filesizejs.com",
+ "author": "Jason Mulligan <jason.mulligan@avoidwork.com>",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/avoidwork/filesize.js.git"
+ },
+ "bugs": {
+ "url": "https://github.com/avoidwork/filesize.js/issues"
+ },
+ "files": [
+ "dist/filesize.cjs",
+ "dist/filesize.esm.js",
+ "types/filesize.d.ts"
+ ],
+ "license": "BSD-3-Clause",
+ "main": "dist/filesize.cjs",
+ "module": "dist/filesize.esm.js",
+ "types": "types/filesize.d.ts",
+ "type": "module",
+ "sourceType": "module",
+ "engines": {
+ "node": ">= 10.4.0"
+ },
+ "scripts": {
+ "build": "npm run rollup",
+ "changelog": "auto-changelog -p",
+ "coverage": "nyc npm run test",
+ "lint": "eslint *.js src/*.js test/*.js",
+ "fix": "eslint --fix *.js src/*.js test/*.js",
+ "mocha": "nyc mocha test/*.js",
+ "rollup": "rollup --config",
+ "test": "npm run lint && npm run mocha",
+ "test-webpack": "mkdir -p test/webpack && rm -rf test/webpack/* && git clone git@github.com:rabelais88/typescript-webpack.git test/webpack && echo \"import { filesize } from 'filesize';console.log(filesize(1234));\" >> test/webpack/src/index.ts && cd test/webpack && npm install && mkdir -p node_modules/filesize/dist && cp ../../package.json node_modules/filesize/ && cp ../../dist/* node_modules/filesize/dist/ && npm run build",
+ "types": "npx -p typescript tsc src/*.js --declaration --allowJs --emitDeclarationOnly --outDir types",
+ "prepare": "husky"
+ },
+ "devDependencies": {
+ "@rollup/plugin-terser": "^0.4.4",
+ "auto-changelog": "^2.4.0",
+ "eslint": "^9.6.0",
+ "husky": "^9.0.11",
+ "mocha": "^10.6.0",
+ "nyc": "^17.0.0",
+ "rollup": "^4.18.1",
+ "typescript": "^5.5.3"
+ },
+ "keywords": [
+ "file",
+ "filesize",
+ "size",
+ "readable",
+ "file system",
+ "bytes",
+ "diff"
+ ]
+}
diff --git a/node_modules/filesize/types/filesize.d.ts b/node_modules/filesize/types/filesize.d.ts new file mode 100644 index 0000000..7359e37 --- /dev/null +++ b/node_modules/filesize/types/filesize.d.ts @@ -0,0 +1,56 @@ +interface FileSizeOptionsBase {
+ base?: 10 | 2;
+ bits?: boolean;
+ exponent?: number;
+ fullform?: boolean;
+ fullforms?: string[];
+ locale?: string | boolean;
+ localeOptions?: Intl.DateTimeFormatOptions;
+ pad?: boolean;
+ precision?: number;
+ round?: number;
+ roundingMethod?: 'round' | 'floor' | 'ceil';
+ separator?: string;
+ spacer?: string;
+ standard?: 'si' | 'iec' | 'jedec';
+ symbols?: {};
+}
+
+interface FileSizeOptionsArray extends FileSizeOptionsBase {
+ output: 'array'
+}
+
+interface FileSizeOptionsExponent extends FileSizeOptionsBase {
+ output: 'exponent'
+}
+
+interface FileSizeOptionsObject extends FileSizeOptionsBase {
+ output: 'object'
+}
+
+interface FileSizeOptionsString extends FileSizeOptionsBase {
+ output: 'string'
+}
+
+interface FileSizeReturnObject {
+ value: string,
+ symbol: string,
+ exponent: number,
+ unit: string,
+}
+
+type FileSizeReturnArray = [ number, string ]
+
+type FileSizeOptionStringOrBase = FileSizeOptionsString | FileSizeOptionsBase;
+type FileSizeOptions = FileSizeOptionsArray | FileSizeOptionsExponent | FileSizeOptionsObject | FileSizeOptionStringOrBase | undefined
+type FileSizeReturnType<Options extends FileSizeOptions> =
+ Options extends FileSizeOptionsArray
+ ? FileSizeReturnArray
+ : Options extends FileSizeOptionsExponent
+ ? number
+ : Options extends FileSizeOptionsObject
+ ? FileSizeReturnObject
+ : string;
+
+export function filesize<Options extends FileSizeOptions = undefined>(byteCount: number | string | bigint, options?: Options): FileSizeReturnType<Options>
+export function partial<Options extends FileSizeOptions = undefined>(options?: Options): (byteCount: number | string | bigint) => FileSizeReturnType<Options>
|