@jsenv/server 16.1.1 → 16.2.0

package/dist/{jsenv_server_node_modules.js → formidable_index/jsenv_server_node_modules.js}

@@ -1,12 +1,12 @@
+import require$$0 from "node:domain";
+import { EventEmitter } from "node:events";
+import fsPromises from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import fsPromises from "node:fs/promises";
-import { EventEmitter } from "node:events";
 import { StringDecoder } from "node:string_decoder";
-import require$$0 from "node:domain";
-import { PassThrough, Transform, Stream } from "node:stream";
 import fs from "node:fs";
 import require$$1, { createHash } from "node:crypto";
+import { Transform, PassThrough, Stream } from "node:stream";
 
 /* eslint-disable no-underscore-dangle */
 
@@ -169,127 +169,870 @@ class VolatileFile extends EventEmitter {
   }
 }
 
-for(var r=256,n=[];r--;)n[r]=(r+256).toString(16).substring(1);function hexoid(r){r=r||16;var t="",o=0;return function(){if(!t||256===o){for(t="",o=(1+r)/2|0;o--;)t+=n[256*Math.random()|0];t=t.substring(o=0,r-2);}return t+n[o++]}}
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-function getDefaultExportFromCjs$1 (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+var cuid2 = {};
+
+var src = {};
+
+var sha3 = {};
+
+var _u64 = {};
+
+var hasRequired_u64;
+
+function require_u64 () {
+	if (hasRequired_u64) return _u64;
+	hasRequired_u64 = 1;
+	Object.defineProperty(_u64, "__esModule", { value: true });
+	_u64.toBig = _u64.shrSL = _u64.shrSH = _u64.rotrSL = _u64.rotrSH = _u64.rotrBL = _u64.rotrBH = _u64.rotr32L = _u64.rotr32H = _u64.rotlSL = _u64.rotlSH = _u64.rotlBL = _u64.rotlBH = _u64.add5L = _u64.add5H = _u64.add4L = _u64.add4H = _u64.add3L = _u64.add3H = void 0;
+	_u64.add = add;
+	_u64.fromBig = fromBig;
+	_u64.split = split;
+	/**
+	 * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+	 * @todo re-check https://issues.chromium.org/issues/42212588
+	 * @module
+	 */
+	const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+	const _32n = /* @__PURE__ */ BigInt(32);
+	function fromBig(n, le = false) {
+	    if (le)
+	        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
+	    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+	}
+	function split(lst, le = false) {
+	    const len = lst.length;
+	    let Ah = new Uint32Array(len);
+	    let Al = new Uint32Array(len);
+	    for (let i = 0; i < len; i++) {
+	        const { h, l } = fromBig(lst[i], le);
+	        [Ah[i], Al[i]] = [h, l];
+	    }
+	    return [Ah, Al];
+	}
+	const toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
+	_u64.toBig = toBig;
+	// for Shift in [0, 32)
+	const shrSH = (h, _l, s) => h >>> s;
+	_u64.shrSH = shrSH;
+	const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+	_u64.shrSL = shrSL;
+	// Right rotate for Shift in [1, 32)
+	const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
+	_u64.rotrSH = rotrSH;
+	const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+	_u64.rotrSL = rotrSL;
+	// Right rotate for Shift in (32, 64), NOTE: 32 is special case.
+	const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+	_u64.rotrBH = rotrBH;
+	const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+	_u64.rotrBL = rotrBL;
+	// Right rotate for shift===32 (just swaps l&h)
+	const rotr32H = (_h, l) => l;
+	_u64.rotr32H = rotr32H;
+	const rotr32L = (h, _l) => h;
+	_u64.rotr32L = rotr32L;
+	// Left rotate for Shift in [1, 32)
+	const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+	_u64.rotlSH = rotlSH;
+	const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
+	_u64.rotlSL = rotlSL;
+	// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
+	const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+	_u64.rotlBH = rotlBH;
+	const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+	_u64.rotlBL = rotlBL;
+	// JS uses 32-bit signed integers for bitwise operations which means we cannot
+	// simple take carry out of low bit sum by shift, we need to use division.
+	function add(Ah, Al, Bh, Bl) {
+	    const l = (Al >>> 0) + (Bl >>> 0);
+	    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+	}
+	// Addition with more than 2 elements
+	const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+	_u64.add3L = add3L;
+	const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+	_u64.add3H = add3H;
+	const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+	_u64.add4L = add4L;
+	const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+	_u64.add4H = add4H;
+	const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+	_u64.add5L = add5L;
+	const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
+	_u64.add5H = add5H;
+	// prettier-ignore
+	const u64 = {
+	    fromBig, split, toBig,
+	    shrSH, shrSL,
+	    rotrSH, rotrSL, rotrBH, rotrBL,
+	    rotr32H, rotr32L,
+	    rotlSH, rotlSL, rotlBH, rotlBL,
+	    add, add3L, add3H, add4L, add4H, add5H, add5L,
+	};
+	_u64.default = u64;
+	
+	return _u64;
 }
 
-var once = {exports: {}};
+var utils = {};
 
-var wrappy_1$1;
-var hasRequiredWrappy$1;
+var crypto = {};
 
-function requireWrappy$1 () {
-	if (hasRequiredWrappy$1) return wrappy_1$1;
-	hasRequiredWrappy$1 = 1;
-	// Returns a wrapper function that returns a wrapped callback
-	// The wrapper function should do some stuff, and return a
-	// presumably different callback function.
-	// This makes sure that own properties are retained, so that
-	// decorations and such are not lost along the way.
-	wrappy_1$1 = wrappy;
-	function wrappy (fn, cb) {
-	  if (fn && cb) return wrappy(fn)(cb)
+var hasRequiredCrypto;
 
-	  if (typeof fn !== 'function')
-	    throw new TypeError('need wrapper function')
+function requireCrypto () {
+	if (hasRequiredCrypto) return crypto;
+	hasRequiredCrypto = 1;
+	Object.defineProperty(crypto, "__esModule", { value: true });
+	crypto.crypto = void 0;
+	crypto.crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
+	
+	return crypto;
+}
 
-	  Object.keys(fn).forEach(function (k) {
-	    wrapper[k] = fn[k];
-	  });
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports) {
+		/**
+		 * Utilities for hex, bytes, CSPRNG.
+		 * @module
+		 */
+		/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.Hash = exports.nextTick = exports.swap32IfBE = exports.byteSwapIfBE = exports.swap8IfBE = exports.isLE = void 0;
+		exports.isBytes = isBytes;
+		exports.anumber = anumber;
+		exports.abytes = abytes;
+		exports.ahash = ahash;
+		exports.aexists = aexists;
+		exports.aoutput = aoutput;
+		exports.u8 = u8;
+		exports.u32 = u32;
+		exports.clean = clean;
+		exports.createView = createView;
+		exports.rotr = rotr;
+		exports.rotl = rotl;
+		exports.byteSwap = byteSwap;
+		exports.byteSwap32 = byteSwap32;
+		exports.bytesToHex = bytesToHex;
+		exports.hexToBytes = hexToBytes;
+		exports.asyncLoop = asyncLoop;
+		exports.utf8ToBytes = utf8ToBytes;
+		exports.bytesToUtf8 = bytesToUtf8;
+		exports.toBytes = toBytes;
+		exports.kdfInputToBytes = kdfInputToBytes;
+		exports.concatBytes = concatBytes;
+		exports.checkOpts = checkOpts;
+		exports.createHasher = createHasher;
+		exports.createOptHasher = createOptHasher;
+		exports.createXOFer = createXOFer;
+		exports.randomBytes = randomBytes;
+		// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+		// node.js versions earlier than v19 don't declare it in global scope.
+		// For node.js, package.json#exports field mapping rewrites import
+		// from `crypto` to `cryptoNode`, which imports native module.
+		// Makes the utils un-importable in browsers without a bundler.
+		// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+		const crypto_1 = requireCrypto();
+		/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+		function isBytes(a) {
+		    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+		}
+		/** Asserts something is positive integer. */
+		function anumber(n) {
+		    if (!Number.isSafeInteger(n) || n < 0)
+		        throw new Error('positive integer expected, got ' + n);
+		}
+		/** Asserts something is Uint8Array. */
+		function abytes(b, ...lengths) {
+		    if (!isBytes(b))
+		        throw new Error('Uint8Array expected');
+		    if (lengths.length > 0 && !lengths.includes(b.length))
+		        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+		}
+		/** Asserts something is hash */
+		function ahash(h) {
+		    if (typeof h !== 'function' || typeof h.create !== 'function')
+		        throw new Error('Hash should be wrapped by utils.createHasher');
+		    anumber(h.outputLen);
+		    anumber(h.blockLen);
+		}
+		/** Asserts a hash instance has not been destroyed / finished */
+		function aexists(instance, checkFinished = true) {
+		    if (instance.destroyed)
+		        throw new Error('Hash instance has been destroyed');
+		    if (checkFinished && instance.finished)
+		        throw new Error('Hash#digest() has already been called');
+		}
+		/** Asserts output is properly-sized byte array */
+		function aoutput(out, instance) {
+		    abytes(out);
+		    const min = instance.outputLen;
+		    if (out.length < min) {
+		        throw new Error('digestInto() expects output buffer of length at least ' + min);
+		    }
+		}
+		/** Cast u8 / u16 / u32 to u8. */
+		function u8(arr) {
+		    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+		}
+		/** Cast u8 / u16 / u32 to u32. */
+		function u32(arr) {
+		    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+		}
+		/** Zeroize a byte array. Warning: JS provides no guarantees. */
+		function clean(...arrays) {
+		    for (let i = 0; i < arrays.length; i++) {
+		        arrays[i].fill(0);
+		    }
+		}
+		/** Create DataView of an array for easy byte-level manipulation. */
+		function createView(arr) {
+		    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+		}
+		/** The rotate right (circular right shift) operation for uint32 */
+		function rotr(word, shift) {
+		    return (word << (32 - shift)) | (word >>> shift);
+		}
+		/** The rotate left (circular left shift) operation for uint32 */
+		function rotl(word, shift) {
+		    return (word << shift) | ((word >>> (32 - shift)) >>> 0);
+		}
+		/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+		exports.isLE = (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+		/** The byte swap operation for uint32 */
+		function byteSwap(word) {
+		    return (((word << 24) & 0xff000000) |
+		        ((word << 8) & 0xff0000) |
+		        ((word >>> 8) & 0xff00) |
+		        ((word >>> 24) & 0xff));
+		}
+		/** Conditionally byte swap if on a big-endian platform */
+		exports.swap8IfBE = exports.isLE
+		    ? (n) => n
+		    : (n) => byteSwap(n);
+		/** @deprecated */
+		exports.byteSwapIfBE = exports.swap8IfBE;
+		/** In place byte swap for Uint32Array */
+		function byteSwap32(arr) {
+		    for (let i = 0; i < arr.length; i++) {
+		        arr[i] = byteSwap(arr[i]);
+		    }
+		    return arr;
+		}
+		exports.swap32IfBE = exports.isLE
+		    ? (u) => u
+		    : byteSwap32;
+		// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
+		const hasHexBuiltin = /* @__PURE__ */ (() => 
+		// @ts-ignore
+		typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
+		// Array where index 0xf0 (240) is mapped to string 'f0'
+		const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+		/**
+		 * Convert byte array to hex string. Uses built-in function, when available.
+		 * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+		 */
+		function bytesToHex(bytes) {
+		    abytes(bytes);
+		    // @ts-ignore
+		    if (hasHexBuiltin)
+		        return bytes.toHex();
+		    // pre-caching improves the speed 6x
+		    let hex = '';
+		    for (let i = 0; i < bytes.length; i++) {
+		        hex += hexes[bytes[i]];
+		    }
+		    return hex;
+		}
+		// We use optimized technique to convert hex string to byte array
+		const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+		function asciiToBase16(ch) {
+		    if (ch >= asciis._0 && ch <= asciis._9)
+		        return ch - asciis._0; // '2' => 50-48
+		    if (ch >= asciis.A && ch <= asciis.F)
+		        return ch - (asciis.A - 10); // 'B' => 66-(65-10)
+		    if (ch >= asciis.a && ch <= asciis.f)
+		        return ch - (asciis.a - 10); // 'b' => 98-(97-10)
+		    return;
+		}
+		/**
+		 * Convert hex string to byte array. Uses built-in function, when available.
+		 * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+		 */
+		function hexToBytes(hex) {
+		    if (typeof hex !== 'string')
+		        throw new Error('hex string expected, got ' + typeof hex);
+		    // @ts-ignore
+		    if (hasHexBuiltin)
+		        return Uint8Array.fromHex(hex);
+		    const hl = hex.length;
+		    const al = hl / 2;
+		    if (hl % 2)
+		        throw new Error('hex string expected, got unpadded hex of length ' + hl);
+		    const array = new Uint8Array(al);
+		    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+		        const n1 = asciiToBase16(hex.charCodeAt(hi));
+		        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+		        if (n1 === undefined || n2 === undefined) {
+		            const char = hex[hi] + hex[hi + 1];
+		            throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+		        }
+		        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
+		    }
+		    return array;
+		}
+		/**
+		 * There is no setImmediate in browser and setTimeout is slow.
+		 * Call of async fn will return Promise, which will be fullfiled only on
+		 * next scheduler queue processing step and this is exactly what we need.
+		 */
+		const nextTick = async () => { };
+		exports.nextTick = nextTick;
+		/** Returns control to thread each 'tick' ms to avoid blocking. */
+		async function asyncLoop(iters, tick, cb) {
+		    let ts = Date.now();
+		    for (let i = 0; i < iters; i++) {
+		        cb(i);
+		        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
+		        const diff = Date.now() - ts;
+		        if (diff >= 0 && diff < tick)
+		            continue;
+		        await (0, exports.nextTick)();
+		        ts += diff;
+		    }
+		}
+		/**
+		 * Converts string to bytes using UTF8 encoding.
+		 * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+		 */
+		function utf8ToBytes(str) {
+		    if (typeof str !== 'string')
+		        throw new Error('string expected');
+		    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+		}
+		/**
+		 * Converts bytes to string using UTF8 encoding.
+		 * @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'
+		 */
+		function bytesToUtf8(bytes) {
+		    return new TextDecoder().decode(bytes);
+		}
+		/**
+		 * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+		 * Warning: when Uint8Array is passed, it would NOT get copied.
+		 * Keep in mind for future mutable operations.
+		 */
+		function toBytes(data) {
+		    if (typeof data === 'string')
+		        data = utf8ToBytes(data);
+		    abytes(data);
+		    return data;
+		}
+		/**
+		 * Helper for KDFs: consumes uint8array or string.
+		 * When string is passed, does utf8 decoding, using TextDecoder.
+		 */
+		function kdfInputToBytes(data) {
+		    if (typeof data === 'string')
+		        data = utf8ToBytes(data);
+		    abytes(data);
+		    return data;
+		}
+		/** Copies several Uint8Arrays into one. */
+		function concatBytes(...arrays) {
+		    let sum = 0;
+		    for (let i = 0; i < arrays.length; i++) {
+		        const a = arrays[i];
+		        abytes(a);
+		        sum += a.length;
+		    }
+		    const res = new Uint8Array(sum);
+		    for (let i = 0, pad = 0; i < arrays.length; i++) {
+		        const a = arrays[i];
+		        res.set(a, pad);
+		        pad += a.length;
+		    }
+		    return res;
+		}
+		function checkOpts(defaults, opts) {
+		    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
+		        throw new Error('options should be object or undefined');
+		    const merged = Object.assign(defaults, opts);
+		    return merged;
+		}
+		/** For runtime check if class implements interface */
+		class Hash {
+		}
+		exports.Hash = Hash;
+		/** Wraps hash function, creating an interface on top of it */
+		function createHasher(hashCons) {
+		    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+		    const tmp = hashCons();
+		    hashC.outputLen = tmp.outputLen;
+		    hashC.blockLen = tmp.blockLen;
+		    hashC.create = () => hashCons();
+		    return hashC;
+		}
+		function createOptHasher(hashCons) {
+		    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+		    const tmp = hashCons({});
+		    hashC.outputLen = tmp.outputLen;
+		    hashC.blockLen = tmp.blockLen;
+		    hashC.create = (opts) => hashCons(opts);
+		    return hashC;
+		}
+		function createXOFer(hashCons) {
+		    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+		    const tmp = hashCons({});
+		    hashC.outputLen = tmp.outputLen;
+		    hashC.blockLen = tmp.blockLen;
+		    hashC.create = (opts) => hashCons(opts);
+		    return hashC;
+		}
+		exports.wrapConstructor = createHasher;
+		exports.wrapConstructorWithOpts = createOptHasher;
+		exports.wrapXOFConstructorWithOpts = createXOFer;
+		/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
+		function randomBytes(bytesLength = 32) {
+		    if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === 'function') {
+		        return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+		    }
+		    // Legacy Node.js compatibility
+		    if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === 'function') {
+		        return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
+		    }
+		    throw new Error('crypto.getRandomValues must be defined');
+		}
+		
+	} (utils));
+	return utils;
+}
 
-	  return wrapper
+var hasRequiredSha3;
 
-	  function wrapper() {
-	    var args = new Array(arguments.length);
-	    for (var i = 0; i < args.length; i++) {
-	      args[i] = arguments[i];
+function requireSha3 () {
+	if (hasRequiredSha3) return sha3;
+	hasRequiredSha3 = 1;
+	Object.defineProperty(sha3, "__esModule", { value: true });
+	sha3.shake256 = sha3.shake128 = sha3.keccak_512 = sha3.keccak_384 = sha3.keccak_256 = sha3.keccak_224 = sha3.sha3_512 = sha3.sha3_384 = sha3.sha3_256 = sha3.sha3_224 = sha3.Keccak = void 0;
+	sha3.keccakP = keccakP;
+	/**
+	 * SHA3 (keccak) hash function, based on a new "Sponge function" design.
+	 * Different from older hashes, the internal state is bigger than output size.
+	 *
+	 * Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
+	 * [Website](https://keccak.team/keccak.html),
+	 * [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
+	 *
+	 * Check out `sha3-addons` module for cSHAKE, k12, and others.
+	 * @module
+	 */
+	const _u64_ts_1 = /*@__PURE__*/ require_u64();
+	// prettier-ignore
+	const utils_ts_1 = /*@__PURE__*/ requireUtils();
+	// No __PURE__ annotations in sha3 header:
+	// EVERYTHING is in fact used on every export.
+	// Various per round constants calculations
+	const _0n = BigInt(0);
+	const _1n = BigInt(1);
+	const _2n = BigInt(2);
+	const _7n = BigInt(7);
+	const _256n = BigInt(256);
+	const _0x71n = BigInt(0x71);
+	const SHA3_PI = [];
+	const SHA3_ROTL = [];
+	const _SHA3_IOTA = [];
+	for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+	    // Pi
+	    [x, y] = [y, (2 * x + 3 * y) % 5];
+	    SHA3_PI.push(2 * (5 * y + x));
+	    // Rotational
+	    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
+	    // Iota
+	    let t = _0n;
+	    for (let j = 0; j < 7; j++) {
+	        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;
+	        if (R & _2n)
+	            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);
 	    }
-	    var ret = fn.apply(this, args);
-	    var cb = args[args.length-1];
-	    if (typeof ret === 'function' && ret !== cb) {
-	      Object.keys(cb).forEach(function (k) {
-	        ret[k] = cb[k];
-	      });
+	    _SHA3_IOTA.push(t);
+	}
+	const IOTAS = (0, _u64_ts_1.split)(_SHA3_IOTA, true);
+	const SHA3_IOTA_H = IOTAS[0];
+	const SHA3_IOTA_L = IOTAS[1];
+	// Left rotation (without 0, 32, 64)
+	const rotlH = (h, l, s) => (s > 32 ? (0, _u64_ts_1.rotlBH)(h, l, s) : (0, _u64_ts_1.rotlSH)(h, l, s));
+	const rotlL = (h, l, s) => (s > 32 ? (0, _u64_ts_1.rotlBL)(h, l, s) : (0, _u64_ts_1.rotlSL)(h, l, s));
+	/** `keccakf1600` internal function, additionally allows to adjust round count. */
+	function keccakP(s, rounds = 24) {
+	    const B = new Uint32Array(5 * 2);
+	    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)
+	    for (let round = 24 - rounds; round < 24; round++) {
+	        // Theta θ
+	        for (let x = 0; x < 10; x++)
+	            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+	        for (let x = 0; x < 10; x += 2) {
+	            const idx1 = (x + 8) % 10;
+	            const idx0 = (x + 2) % 10;
+	            const B0 = B[idx0];
+	            const B1 = B[idx0 + 1];
+	            const Th = rotlH(B0, B1, 1) ^ B[idx1];
+	            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+	            for (let y = 0; y < 50; y += 10) {
+	                s[x + y] ^= Th;
+	                s[x + y + 1] ^= Tl;
+	            }
+	        }
+	        // Rho (ρ) and Pi (π)
+	        let curH = s[2];
+	        let curL = s[3];
+	        for (let t = 0; t < 24; t++) {
+	            const shift = SHA3_ROTL[t];
+	            const Th = rotlH(curH, curL, shift);
+	            const Tl = rotlL(curH, curL, shift);
+	            const PI = SHA3_PI[t];
+	            curH = s[PI];
+	            curL = s[PI + 1];
+	            s[PI] = Th;
+	            s[PI + 1] = Tl;
+	        }
+	        // Chi (χ)
+	        for (let y = 0; y < 50; y += 10) {
+	            for (let x = 0; x < 10; x++)
+	                B[x] = s[y + x];
+	            for (let x = 0; x < 10; x++)
+	                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+	        }
+	        // Iota (ι)
+	        s[0] ^= SHA3_IOTA_H[round];
+	        s[1] ^= SHA3_IOTA_L[round];
 	    }
-	    return ret
-	  }
+	    (0, utils_ts_1.clean)(B);
 	}
-	return wrappy_1$1;
+	/** Keccak sponge function. */
+	class Keccak extends utils_ts_1.Hash {
+	    // NOTE: we accept arguments in bytes instead of bits here.
+	    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+	        super();
+	        this.pos = 0;
+	        this.posOut = 0;
+	        this.finished = false;
+	        this.destroyed = false;
+	        this.enableXOF = false;
+	        this.blockLen = blockLen;
+	        this.suffix = suffix;
+	        this.outputLen = outputLen;
+	        this.enableXOF = enableXOF;
+	        this.rounds = rounds;
+	        // Can be passed from user as dkLen
+	        (0, utils_ts_1.anumber)(outputLen);
+	        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
+	        // 0 < blockLen < 200
+	        if (!(0 < blockLen && blockLen < 200))
+	            throw new Error('only keccak-f1600 function is supported');
+	        this.state = new Uint8Array(200);
+	        this.state32 = (0, utils_ts_1.u32)(this.state);
+	    }
+	    clone() {
+	        return this._cloneInto();
+	    }
+	    keccak() {
+	        (0, utils_ts_1.swap32IfBE)(this.state32);
+	        keccakP(this.state32, this.rounds);
+	        (0, utils_ts_1.swap32IfBE)(this.state32);
+	        this.posOut = 0;
+	        this.pos = 0;
+	    }
+	    update(data) {
+	        (0, utils_ts_1.aexists)(this);
+	        data = (0, utils_ts_1.toBytes)(data);
+	        (0, utils_ts_1.abytes)(data);
+	        const { blockLen, state } = this;
+	        const len = data.length;
+	        for (let pos = 0; pos < len;) {
+	            const take = Math.min(blockLen - this.pos, len - pos);
+	            for (let i = 0; i < take; i++)
+	                state[this.pos++] ^= data[pos++];
+	            if (this.pos === blockLen)
+	                this.keccak();
+	        }
+	        return this;
+	    }
+	    finish() {
+	        if (this.finished)
+	            return;
+	        this.finished = true;
+	        const { state, suffix, pos, blockLen } = this;
+	        // Do the padding
+	        state[pos] ^= suffix;
+	        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)
+	            this.keccak();
+	        state[blockLen - 1] ^= 0x80;
+	        this.keccak();
+	    }
+	    writeInto(out) {
+	        (0, utils_ts_1.aexists)(this, false);
+	        (0, utils_ts_1.abytes)(out);
+	        this.finish();
+	        const bufferOut = this.state;
+	        const { blockLen } = this;
+	        for (let pos = 0, len = out.length; pos < len;) {
+	            if (this.posOut >= blockLen)
+	                this.keccak();
+	            const take = Math.min(blockLen - this.posOut, len - pos);
+	            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+	            this.posOut += take;
+	            pos += take;
+	        }
+	        return out;
+	    }
+	    xofInto(out) {
+	        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF
+	        if (!this.enableXOF)
+	            throw new Error('XOF is not possible for this instance');
+	        return this.writeInto(out);
+	    }
+	    xof(bytes) {
+	        (0, utils_ts_1.anumber)(bytes);
+	        return this.xofInto(new Uint8Array(bytes));
+	    }
+	    digestInto(out) {
+	        (0, utils_ts_1.aoutput)(out, this);
+	        if (this.finished)
+	            throw new Error('digest() was already called');
+	        this.writeInto(out);
+	        this.destroy();
+	        return out;
+	    }
+	    digest() {
+	        return this.digestInto(new Uint8Array(this.outputLen));
+	    }
+	    destroy() {
+	        this.destroyed = true;
+	        (0, utils_ts_1.clean)(this.state);
+	    }
+	    _cloneInto(to) {
+	        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+	        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+	        to.state32.set(this.state32);
+	        to.pos = this.pos;
+	        to.posOut = this.posOut;
+	        to.finished = this.finished;
+	        to.rounds = rounds;
+	        // Suffix can change in cSHAKE
+	        to.suffix = suffix;
+	        to.outputLen = outputLen;
+	        to.enableXOF = enableXOF;
+	        to.destroyed = this.destroyed;
+	        return to;
+	    }
+	}
+	sha3.Keccak = Keccak;
+	const gen = (suffix, blockLen, outputLen) => (0, utils_ts_1.createHasher)(() => new Keccak(blockLen, suffix, outputLen));
+	/** SHA3-224 hash function. */
+	sha3.sha3_224 = (() => gen(0x06, 144, 224 / 8))();
+	/** SHA3-256 hash function. Different from keccak-256. */
+	sha3.sha3_256 = (() => gen(0x06, 136, 256 / 8))();
+	/** SHA3-384 hash function. */
+	sha3.sha3_384 = (() => gen(0x06, 104, 384 / 8))();
+	/** SHA3-512 hash function. */
+	sha3.sha3_512 = (() => gen(0x06, 72, 512 / 8))();
+	/** keccak-224 hash function. */
+	sha3.keccak_224 = (() => gen(0x01, 144, 224 / 8))();
+	/** keccak-256 hash function. Different from SHA3-256. */
+	sha3.keccak_256 = (() => gen(0x01, 136, 256 / 8))();
+	/** keccak-384 hash function. */
+	sha3.keccak_384 = (() => gen(0x01, 104, 384 / 8))();
+	/** keccak-512 hash function. */
+	sha3.keccak_512 = (() => gen(0x01, 72, 512 / 8))();
+	const genShake = (suffix, blockLen, outputLen) => (0, utils_ts_1.createXOFer)((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));
+	/** SHAKE128 XOF with 128-bit security. */
+	sha3.shake128 = (() => genShake(0x1f, 168, 128 / 8))();
+	/** SHAKE256 XOF with 256-bit security. */
+	sha3.shake256 = (() => genShake(0x1f, 136, 256 / 8))();
+	
+	return sha3;
 }
 
-var hasRequiredOnce;
+/* global global, window, module */
 
-function requireOnce () {
-	if (hasRequiredOnce) return once.exports;
-	hasRequiredOnce = 1;
-	var wrappy = requireWrappy$1();
-	once.exports = wrappy(once$1);
-	once.exports.strict = wrappy(onceStrict);
+var hasRequiredSrc;
 
-	once$1.proto = once$1(function () {
-	  Object.defineProperty(Function.prototype, 'once', {
-	    value: function () {
-	      return once$1(this)
-	    },
-	    configurable: true
-	  });
+function requireSrc () {
+	if (hasRequiredSrc) return src;
+	hasRequiredSrc = 1;
+	const { sha3_512: sha3 } = /*@__PURE__*/ requireSha3();
 
-	  Object.defineProperty(Function.prototype, 'onceStrict', {
-	    value: function () {
-	      return onceStrict(this)
-	    },
-	    configurable: true
-	  });
-	});
+	const defaultLength = 24;
+	const bigLength = 32;
 
-	function once$1 (fn) {
-	  var f = function () {
-	    if (f.called) return f.value
-	    f.called = true;
-	    return f.value = fn.apply(this, arguments)
-	  };
-	  f.called = false;
-	  return f
+	const createEntropy = (length = 4, random = Math.random) => {
+	  let entropy = "";
+
+	  while (entropy.length < length) {
+	    entropy = entropy + Math.floor(random() * 36).toString(36);
+	  }
+	  return entropy;
+	};
+
+	/*
+	 * Adapted from https://github.com/juanelas/bigint-conversion
+	 * MIT License Copyright (c) 2018 Juan Hernández Serrano
+	 */
+	function bufToBigInt(buf) {
+	  let bits = 8n;
+
+	  let value = 0n;
+	  for (const i of buf.values()) {
+	    const bi = BigInt(i);
+	    value = (value << bits) + bi;
+	  }
+	  return value;
 	}
 
-	function onceStrict (fn) {
-	  var f = function () {
-	    if (f.called)
-	      throw new Error(f.onceError)
-	    f.called = true;
-	    return f.value = fn.apply(this, arguments)
+	const hash = (input = "") => {
+	  // Drop the first character because it will bias the histogram
+	  // to the left.
+	  return bufToBigInt(sha3(input)).toString(36).slice(1);
+	};
+
+	const alphabet = Array.from({ length: 26 }, (x, i) =>
+	  String.fromCharCode(i + 97)
+	);
+
+	const randomLetter = (random) =>
+	  alphabet[Math.floor(random() * alphabet.length)];
+
+	/*
+	This is a fingerprint of the host environment. It is used to help
+	prevent collisions when generating ids in a distributed system.
+	If no global object is available, you can pass in your own, or fall back
+	on a random string.
+	*/
+	const createFingerprint = ({
+	  globalObj = typeof commonjsGlobal !== "undefined"
+	    ? commonjsGlobal
+	    : typeof window !== "undefined"
+	    ? window
+	    : {},
+	  random = Math.random,
+	} = {}) => {
+	  const globals = Object.keys(globalObj).toString();
+	  const sourceString = globals.length
+	    ? globals + createEntropy(bigLength, random)
+	    : createEntropy(bigLength, random);
+
+	  return hash(sourceString).substring(0, bigLength);
+	};
+
+	const createCounter = (count) => () => {
+	  return count++;
+	};
+
+	// ~22k hosts before 50% chance of initial counter collision
+	// with a remaining counter range of 9.0e+15 in JavaScript.
+	const initialCountMax = 476782367;
+
+	const init = ({
+	  // Fallback if the user does not pass in a CSPRNG. This should be OK
+	  // because we don't rely solely on the random number generator for entropy.
+	  // We also use the host fingerprint, current time, and a session counter.
+	  random = Math.random,
+	  counter = createCounter(Math.floor(random() * initialCountMax)),
+	  length = defaultLength,
+	  fingerprint = createFingerprint({ random }),
+	} = {}) => {
+	  return function cuid2() {
+	    const firstLetter = randomLetter(random);
+
+	    // If we're lucky, the `.toString(36)` calls may reduce hashing rounds
+	    // by shortening the input to the hash function a little.
+	    const time = Date.now().toString(36);
+	    const count = counter().toString(36);
+
+	    // The salt should be long enough to be globally unique across the full
+	    // length of the hash. For simplicity, we use the same length as the
+	    // intended id output.
+	    const salt = createEntropy(length, random);
+	    const hashInput = `${time + salt + count + fingerprint}`;
+
+	    return `${firstLetter + hash(hashInput).substring(1, length)}`;
 	  };
-	  var name = fn.name || 'Function wrapped with `once`';
-	  f.onceError = name + " shouldn't be called more than once";
-	  f.called = false;
-	  return f
-	}
-	return once.exports;
+	};
+
+	const createId = init();
+
+	const isCuid = (id, { minLength = 2, maxLength = bigLength } = {}) => {
+	  const length = id.length;
+	  const regex = /^[0-9a-z]+$/;
+
+	  try {
+	    if (
+	      typeof id === "string" &&
+	      length >= minLength &&
+	      length <= maxLength &&
+	      regex.test(id)
+	    )
+	      return true;
+	  } finally {
+	  }
+
+	  return false;
+	};
+
+	src.getConstants = () => ({ defaultLength, bigLength });
+	src.init = init;
+	src.createId = createId;
+	src.bufToBigInt = bufToBigInt;
+	src.createCounter = createCounter;
+	src.createFingerprint = createFingerprint;
+	src.isCuid = isCuid;
+	return src;
 }
 
-var onceExports = requireOnce();
-var __jsenv_default_import__$1 = /*@__PURE__*/getDefaultExportFromCjs$1(onceExports);
+var hasRequiredCuid2;
 
-onceExports.strict;
+function requireCuid2 () {
+	if (hasRequiredCuid2) return cuid2;
+	hasRequiredCuid2 = 1;
+	const { createId, init, getConstants, isCuid } = requireSrc();
 
-function getDefaultExportFromCjs (x) {
+	cuid2.createId = createId;
+	cuid2.init = init;
+	cuid2.getConstants = getConstants;
+	cuid2.isCuid = isCuid;
+	return cuid2;
+}
+
+var cuid2Exports = requireCuid2();
+
+cuid2Exports.createId;
+cuid2Exports.getConstants;
+var init$3 = cuid2Exports.init;
+cuid2Exports.isCuid;
+
+function getDefaultExportFromCjs$1 (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-var wrappy_1;
-var hasRequiredWrappy;
+var wrappy_1$1;
+var hasRequiredWrappy$1;
 
-function requireWrappy () {
-	if (hasRequiredWrappy) return wrappy_1;
-	hasRequiredWrappy = 1;
+function requireWrappy$1 () {
+	if (hasRequiredWrappy$1) return wrappy_1$1;
+	hasRequiredWrappy$1 = 1;
 	// Returns a wrapper function that returns a wrapped callback
 	// The wrapper function should do some stuff, and return a
 	// presumably different callback function.
 	// This makes sure that own properties are retained, so that
 	// decorations and such are not lost along the way.
-	wrappy_1 = wrappy;
+	wrappy_1$1 = wrappy;
 	function wrappy (fn, cb) {
 	  if (fn && cb) return wrappy(fn)(cb)
 
@@ -317,7 +1060,7 @@ function requireWrappy () {
 	    return ret
 	  }
 	}
-	return wrappy_1;
+	return wrappy_1$1;
 }
 
 var raw;
@@ -507,7 +1250,7 @@ var hasRequiredDezalgo;
 function requireDezalgo () {
 	if (hasRequiredDezalgo) return dezalgo_1;
 	hasRequiredDezalgo = 1;
-	var wrappy = requireWrappy();
+	var wrappy = requireWrappy$1();
 	dezalgo_1 = wrappy(dezalgo);
 
 	var asap = requireAsap();
@@ -533,169 +1276,111 @@ function requireDezalgo () {
 }
 
 var dezalgoExports = requireDezalgo();
-var __jsenv_default_import__ = /*@__PURE__*/getDefaultExportFromCjs(dezalgoExports);
-
-class OctetStreamParser extends PassThrough {
-  constructor(options = {}) {
-    super();
-    this.globalOptions = { ...options };
-  }
-}
-
-/* eslint-disable no-underscore-dangle */
-
-
-const octetStreamType = 'octet-stream';
-// the `options` is also available through the `options` / `formidable.options`
-async function plugin$3(formidable, options) {
-  // the `this` context is always formidable, as the first argument of a plugin
-  // but this allows us to customize/test each plugin
-
-  /* istanbul ignore next */
-  const self = this || formidable;
-
-  if (/octet-stream/i.test(self.headers['content-type'])) {
-    await init$2.call(self, self, options);
-  }
-  return self;
-}
-
-// Note that it's a good practice (but it's up to you) to use the `this.options` instead
-// of the passed `options` (second) param, because when you decide
-// to test the plugin you can pass custom `this` context to it (and so `this.options`)
-async function init$2(_self, _opts) {
-  this.type = octetStreamType;
-  const originalFilename = this.headers['x-file-name'];
-  const mimetype = this.headers['content-type'];
-
-  const thisPart = {
-    originalFilename,
-    mimetype,
-  };
-  const newFilename = this._getNewName(thisPart);
-  const filepath = this._joinDirectoryName(newFilename);
-  const file = await this._newFile({
-    newFilename,
-    filepath,
-    originalFilename,
-    mimetype,
-  });
-
-  this.emit('fileBegin', originalFilename, file);
-  file.open();
-  this.openedFiles.push(file);
-  this._flushing += 1;
-
-  this._parser = new OctetStreamParser(this.options);
-
-  // Keep track of writes that haven't finished so we don't emit the file before it's done being written
-  let outstandingWrites = 0;
-
-  this._parser.on('data', (buffer) => {
-    this.pause();
-    outstandingWrites += 1;
-
-    file.write(buffer, () => {
-      outstandingWrites -= 1;
-      this.resume();
-
-      if (this.ended) {
-        this._parser.emit('doneWritingFile');
-      }
-    });
-  });
-
-  this._parser.on('end', () => {
-    this._flushing -= 1;
-    this.ended = true;
+var __jsenv_default_import__$1 = /*@__PURE__*/getDefaultExportFromCjs$1(dezalgoExports);
 
-    const done = () => {
-      file.end(() => {
-        this.emit('file', 'file', file);
-        this._maybeEnd();
-      });
-    };
-
-    if (outstandingWrites === 0) {
-      done();
-    } else {
-      this._parser.once('doneWritingFile', done);
-    }
-  });
-
-  return this;
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-/* eslint-disable no-underscore-dangle */
-
-
-// This is a buffering parser, have a look at StreamingQuerystring.js for a streaming parser
-class QuerystringParser extends Transform {
-  constructor(options = {}) {
-    super({ readableObjectMode: true });
-    this.globalOptions = { ...options };
-    this.buffer = '';
-    this.bufferLength = 0;
-  }
-
-  _transform(buffer, encoding, callback) {
-    this.buffer += buffer.toString('ascii');
-    this.bufferLength = this.buffer.length;
-    callback();
-  }
+var once = {exports: {}};
 
-  _flush(callback) {
-    const fields = new URLSearchParams(this.buffer);
-    for (const [key, value] of fields) {
-      this.push({
-        key,
-        value,
-      });
-    }
-    this.buffer = '';
-    callback();
-  }
-}
+var wrappy_1;
+var hasRequiredWrappy;
 
-/* eslint-disable no-underscore-dangle */
+function requireWrappy () {
+	if (hasRequiredWrappy) return wrappy_1;
+	hasRequiredWrappy = 1;
+	// Returns a wrapper function that returns a wrapped callback
+	// The wrapper function should do some stuff, and return a
+	// presumably different callback function.
+	// This makes sure that own properties are retained, so that
+	// decorations and such are not lost along the way.
+	wrappy_1 = wrappy;
+	function wrappy (fn, cb) {
+	  if (fn && cb) return wrappy(fn)(cb)
 
+	  if (typeof fn !== 'function')
+	    throw new TypeError('need wrapper function')
 
-const querystringType = 'urlencoded';
-// the `options` is also available through the `this.options` / `formidable.options`
-function plugin$2(formidable, options) {
-  // the `this` context is always formidable, as the first argument of a plugin
-  // but this allows us to customize/test each plugin
+	  Object.keys(fn).forEach(function (k) {
+	    wrapper[k] = fn[k];
+	  });
 
-  /* istanbul ignore next */
-  const self = this || formidable;
+	  return wrapper
 
-  if (/urlencoded/i.test(self.headers['content-type'])) {
-    init$1.call(self, self, options);
-  }
-  return self;
-}
-// Note that it's a good practice (but it's up to you) to use the `this.options` instead
-// of the passed `options` (second) param, because when you decide
-// to test the plugin you can pass custom `this` context to it (and so `this.options`)
-function init$1(_self, _opts) {
-  this.type = querystringType;
+	  function wrapper() {
+	    var args = new Array(arguments.length);
+	    for (var i = 0; i < args.length; i++) {
+	      args[i] = arguments[i];
+	    }
+	    var ret = fn.apply(this, args);
+	    var cb = args[args.length-1];
+	    if (typeof ret === 'function' && ret !== cb) {
+	      Object.keys(cb).forEach(function (k) {
+	        ret[k] = cb[k];
+	      });
+	    }
+	    return ret
+	  }
+	}
+	return wrappy_1;
+}
 
-  const parser = new QuerystringParser(this.options);
+var hasRequiredOnce;
 
-  parser.on('data', ({ key, value }) => {
-    this.emit('field', key, value);
-  });
+function requireOnce () {
+	if (hasRequiredOnce) return once.exports;
+	hasRequiredOnce = 1;
+	var wrappy = requireWrappy();
+	once.exports = wrappy(once$1);
+	once.exports.strict = wrappy(onceStrict);
 
-  parser.once('end', () => {
-    this.ended = true;
-    this._maybeEnd();
-  });
+	once$1.proto = once$1(function () {
+	  Object.defineProperty(Function.prototype, 'once', {
+	    value: function () {
+	      return once$1(this)
+	    },
+	    configurable: true
+	  });
 
-  this._parser = parser;
+	  Object.defineProperty(Function.prototype, 'onceStrict', {
+	    value: function () {
+	      return onceStrict(this)
+	    },
+	    configurable: true
+	  });
+	});
 
-  return this;
+	function once$1 (fn) {
+	  var f = function () {
+	    if (f.called) return f.value
+	    f.called = true;
+	    return f.value = fn.apply(this, arguments)
+	  };
+	  f.called = false;
+	  return f
+	}
+
+	function onceStrict (fn) {
+	  var f = function () {
+	    if (f.called)
+	      throw new Error(f.onceError)
+	    f.called = true;
+	    return f.value = fn.apply(this, arguments)
+	  };
+	  var name = fn.name || 'Function wrapped with `once`';
+	  f.onceError = name + " shouldn't be called more than once";
+	  f.called = false;
+	  return f
+	}
+	return once.exports;
 }
 
+var onceExports = requireOnce();
+var __jsenv_default_import__ = /*@__PURE__*/getDefaultExportFromCjs(onceExports);
+
+onceExports.strict;
+
 const missingPlugin = 1000;
 const pluginFunction = 1001;
 const aborted = 1002;
@@ -724,6 +1409,23 @@ const FormidableError = class extends Error {
   }
 };
 
+/* eslint-disable no-underscore-dangle */
+
+
+class DummyParser extends Transform {
+  constructor(incomingForm, options = {}) {
+    super();
+    this.globalOptions = { ...options };
+    this.incomingForm = incomingForm;
+  }
+
+  _flush(callback) {
+    this.incomingForm.ended = true;
+    this.incomingForm._maybeEnd();
+    callback();
+  }
+}
+
 /* eslint-disable no-fallthrough */
 /* eslint-disable no-bitwise */
 /* eslint-disable no-plusplus */
@@ -1078,6 +1780,167 @@ MultipartParser.stateToString = (stateNumber) => {
 
 const MultipartParser$1 = Object.assign(MultipartParser, { STATES });
 
+class OctetStreamParser extends PassThrough {
+  constructor(options = {}) {
+    super();
+    this.globalOptions = { ...options };
+  }
+}
+
+/* eslint-disable no-underscore-dangle */
+
+
+const octetStreamType = 'octet-stream';
+// the `options` is also available through the `options` / `formidable.options`
+async function plugin$3(formidable, options) {
+  // the `this` context is always formidable, as the first argument of a plugin
+  // but this allows us to customize/test each plugin
+
+  /* istanbul ignore next */
+  const self = this || formidable;
+
+  if (/octet-stream/i.test(self.headers['content-type'])) {
+    await init$2.call(self, self, options);
+  }
+  return self;
+}
+
+// Note that it's a good practice (but it's up to you) to use the `this.options` instead
+// of the passed `options` (second) param, because when you decide
+// to test the plugin you can pass custom `this` context to it (and so `this.options`)
+async function init$2(_self, _opts) {
+  this.type = octetStreamType;
+  const originalFilename = this.headers['x-file-name'];
+  const mimetype = this.headers['content-type'];
+
+  const thisPart = {
+    originalFilename,
+    mimetype,
+  };
+  const newFilename = this._getNewName(thisPart);
+  const filepath = this._joinDirectoryName(newFilename);
+  const file = await this._newFile({
+    newFilename,
+    filepath,
+    originalFilename,
+    mimetype,
+  });
+
+  this.emit('fileBegin', originalFilename, file);
+  file.open();
+  this.openedFiles.push(file);
+  this._flushing += 1;
+
+  this._parser = new OctetStreamParser(this.options);
+
+  // Keep track of writes that haven't finished so we don't emit the file before it's done being written
+  let outstandingWrites = 0;
+
+  this._parser.on('data', (buffer) => {
+    this.pause();
+    outstandingWrites += 1;
+
+    file.write(buffer, () => {
+      outstandingWrites -= 1;
+      this.resume();
+
+      if (this.ended) {
+        this._parser.emit('doneWritingFile');
+      }
+    });
+  });
+
+  this._parser.on('end', () => {
+    this._flushing -= 1;
+    this.ended = true;
+
+    const done = () => {
+      file.end(() => {
+        this.emit('file', 'file', file);
+        this._maybeEnd();
+      });
+    };
+
+    if (outstandingWrites === 0) {
+      done();
+    } else {
+      this._parser.once('doneWritingFile', done);
+    }
+  });
+
+  return this;
+}
+
+/* eslint-disable no-underscore-dangle */
+
+
+// This is a buffering parser, have a look at StreamingQuerystring.js for a streaming parser
+class QuerystringParser extends Transform {
+  constructor(options = {}) {
+    super({ readableObjectMode: true });
+    this.globalOptions = { ...options };
+    this.buffer = '';
+    this.bufferLength = 0;
+  }
+
+  _transform(buffer, encoding, callback) {
+    this.buffer += buffer.toString('ascii');
+    this.bufferLength = this.buffer.length;
+    callback();
+  }
+
+  _flush(callback) {
+    const fields = new URLSearchParams(this.buffer);
+    for (const [key, value] of fields) {
+      this.push({
+        key,
+        value,
+      });
+    }
+    this.buffer = '';
+    callback();
+  }
+}
+
+/* eslint-disable no-underscore-dangle */
+
+
+const querystringType = 'urlencoded';
+// the `options` is also available through the `this.options` / `formidable.options`
+function plugin$2(formidable, options) {
+  // the `this` context is always formidable, as the first argument of a plugin
+  // but this allows us to customize/test each plugin
+
+  /* istanbul ignore next */
+  const self = this || formidable;
+
+  if (/urlencoded/i.test(self.headers['content-type'])) {
+    init$1.call(self, self, options);
+  }
+  return self;
+}
+// Note that it's a good practice (but it's up to you) to use the `this.options` instead
+// of the passed `options` (second) param, because when you decide
+// to test the plugin you can pass custom `this` context to it (and so `this.options`)
+function init$1(_self, _opts) {
+  this.type = querystringType;
+
+  const parser = new QuerystringParser(this.options);
+
+  parser.on('data', ({ key, value }) => {
+    this.emit('field', key, value);
+  });
+
+  parser.once('end', () => {
+    this.ended = true;
+    this._maybeEnd();
+  });
+
+  this._parser = parser;
+
+  return this;
+}
+
 /* eslint-disable no-underscore-dangle */
 
 
@@ -1314,28 +2177,13 @@ function init(_self, _opts) {
   this._parser = parser;
 }
 
-/* eslint-disable no-underscore-dangle */
-
-
-class DummyParser extends Transform {
-  constructor(incomingForm, options = {}) {
-    super();
-    this.globalOptions = { ...options };
-    this.incomingForm = incomingForm;
-  }
-
-  _flush(callback) {
-    this.incomingForm.ended = true;
-    this.incomingForm._maybeEnd();
-    callback();
-  }
-}
-
 /* eslint-disable class-methods-use-this */
 /* eslint-disable no-underscore-dangle */
 
 
-const toHexoId = hexoid(25);
+const CUID2_FINGERPRINT = `${("production")}-${os.platform()}-${os.hostname()}`;
+const createId = init$3({ length: 25, fingerprint: CUID2_FINGERPRINT.toLowerCase() });
+
 const DEFAULT_OPTIONS = {
   maxFields: 1000,
   maxFieldsSize: 20 * 1024 * 1024,
@@ -1517,7 +2365,7 @@ class IncomingForm extends EventEmitter {
         }
       };
     }
-    const callback = __jsenv_default_import__$1(__jsenv_default_import__(cb));
+    const callback = __jsenv_default_import__(__jsenv_default_import__$1(cb));
     this.fields = {};
     const files = {};
 
@@ -1940,7 +2788,7 @@ class IncomingForm extends EventEmitter {
       };
     } else {
       this._getNewName = (part) => {
-        const name = toHexoId();
+        const name = createId();
 
         if (part && this.options.keepExtensions) {
           const originalFilename =