From 7a52ddeba2a68388b544f529d2d92104420f77b0 Mon Sep 17 00:00:00 2001 From: Shipwreckt Date: Fri, 31 Oct 2025 20:02:14 +0000 Subject: Changed from static to 11ty! --- node_modules/filesize/LICENSE | 28 ++++ node_modules/filesize/README.md | 113 ++++++++++++++ node_modules/filesize/dist/filesize.cjs | 238 +++++++++++++++++++++++++++++ node_modules/filesize/dist/filesize.esm.js | 231 ++++++++++++++++++++++++++++ node_modules/filesize/package.json | 60 ++++++++ node_modules/filesize/types/filesize.d.ts | 56 +++++++ 6 files changed, 726 insertions(+) create mode 100644 node_modules/filesize/LICENSE create mode 100644 node_modules/filesize/README.md create mode 100644 node_modules/filesize/dist/filesize.cjs create mode 100644 node_modules/filesize/dist/filesize.esm.js create mode 100644 node_modules/filesize/package.json create mode 100644 node_modules/filesize/types/filesize.d.ts (limited to 'node_modules/filesize') 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 + +[![downloads](https://img.shields.io/npm/dt/filesize.svg)](https://www.npmjs.com/package/filesize) [![CDNJS version](https://img.shields.io/cdnjs/v/filesize.svg)](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 + * @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 + * @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 ", + "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 FileSizeOptionsArray + ? FileSizeReturnArray + : Options extends FileSizeOptionsExponent + ? number + : Options extends FileSizeOptionsObject + ? FileSizeReturnObject + : string; + +export function filesize(byteCount: number | string | bigint, options?: Options): FileSizeReturnType +export function partial(options?: Options): (byteCount: number | string | bigint) => FileSizeReturnType -- cgit v1.2.3