modelmix 1.0.2

package/demo/node_modules/formdata-node/lib/esm/FormData.js

@@ -0,0 +1,144 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FormData_instances, _FormData_entries, _FormData_setEntry;
+import { inspect } from "util";
+import { File } from "./File.js";
+import { isFile } from "./isFile.js";
+import { isBlob } from "./isBlob.js";
+import { isFunction } from "./isFunction.js";
+import { deprecateConstructorEntries } from "./deprecateConstructorEntries.js";
+export class FormData {
+    constructor(entries) {
+        _FormData_instances.add(this);
+        _FormData_entries.set(this, new Map());
+        if (entries) {
+            deprecateConstructorEntries();
+            entries.forEach(({ name, value, fileName }) => this.append(name, value, fileName));
+        }
+    }
+    static [(_FormData_entries = new WeakMap(), _FormData_instances = new WeakSet(), Symbol.hasInstance)](value) {
+        return Boolean(value
+            && isFunction(value.constructor)
+            && value[Symbol.toStringTag] === "FormData"
+            && isFunction(value.append)
+            && isFunction(value.set)
+            && isFunction(value.get)
+            && isFunction(value.getAll)
+            && isFunction(value.has)
+            && isFunction(value.delete)
+            && isFunction(value.entries)
+            && isFunction(value.values)
+            && isFunction(value.keys)
+            && isFunction(value[Symbol.iterator])
+            && isFunction(value.forEach));
+    }
+    append(name, value, fileName) {
+        __classPrivateFieldGet(this, _FormData_instances, "m", _FormData_setEntry).call(this, {
+            name,
+            fileName,
+            append: true,
+            rawValue: value,
+            argsLength: arguments.length
+        });
+    }
+    set(name, value, fileName) {
+        __classPrivateFieldGet(this, _FormData_instances, "m", _FormData_setEntry).call(this, {
+            name,
+            fileName,
+            append: false,
+            rawValue: value,
+            argsLength: arguments.length
+        });
+    }
+    get(name) {
+        const field = __classPrivateFieldGet(this, _FormData_entries, "f").get(String(name));
+        if (!field) {
+            return null;
+        }
+        return field[0];
+    }
+    getAll(name) {
+        const field = __classPrivateFieldGet(this, _FormData_entries, "f").get(String(name));
+        if (!field) {
+            return [];
+        }
+        return field.slice();
+    }
+    has(name) {
+        return __classPrivateFieldGet(this, _FormData_entries, "f").has(String(name));
+    }
+    delete(name) {
+        __classPrivateFieldGet(this, _FormData_entries, "f").delete(String(name));
+    }
+    *keys() {
+        for (const key of __classPrivateFieldGet(this, _FormData_entries, "f").keys()) {
+            yield key;
+        }
+    }
+    *entries() {
+        for (const name of this.keys()) {
+            const values = this.getAll(name);
+            for (const value of values) {
+                yield [name, value];
+            }
+        }
+    }
+    *values() {
+        for (const [, value] of this) {
+            yield value;
+        }
+    }
+    [(_FormData_setEntry = function _FormData_setEntry({ name, rawValue, append, fileName, argsLength }) {
+        const methodName = append ? "append" : "set";
+        if (argsLength < 2) {
+            throw new TypeError(`Failed to execute '${methodName}' on 'FormData': `
+                + `2 arguments required, but only ${argsLength} present.`);
+        }
+        name = String(name);
+        let value;
+        if (isFile(rawValue)) {
+            value = fileName === undefined
+                ? rawValue
+                : new File([rawValue], fileName, {
+                    type: rawValue.type,
+                    lastModified: rawValue.lastModified
+                });
+        }
+        else if (isBlob(rawValue)) {
+            value = new File([rawValue], fileName === undefined ? "blob" : fileName, {
+                type: rawValue.type
+            });
+        }
+        else if (fileName) {
+            throw new TypeError(`Failed to execute '${methodName}' on 'FormData': `
+                + "parameter 2 is not of type 'Blob'.");
+        }
+        else {
+            value = String(rawValue);
+        }
+        const values = __classPrivateFieldGet(this, _FormData_entries, "f").get(name);
+        if (!values) {
+            return void __classPrivateFieldGet(this, _FormData_entries, "f").set(name, [value]);
+        }
+        if (!append) {
+            return void __classPrivateFieldGet(this, _FormData_entries, "f").set(name, [value]);
+        }
+        values.push(value);
+    }, Symbol.iterator)]() {
+        return this.entries();
+    }
+    forEach(callback, thisArg) {
+        for (const [name, value] of this) {
+            callback.call(thisArg, value, name, this);
+        }
+    }
+    get [Symbol.toStringTag]() {
+        return "FormData";
+    }
+    [inspect.custom]() {
+        return this[Symbol.toStringTag];
+    }
+}

package/demo/node_modules/formdata-node/lib/esm/blobHelpers.js

@@ -0,0 +1,75 @@
+/*! Based on fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> & David Frank */
+import { isFunction } from "./isFunction.js";
+const CHUNK_SIZE = 65536;
+async function* clonePart(part) {
+    const end = part.byteOffset + part.byteLength;
+    let position = part.byteOffset;
+    while (position !== end) {
+        const size = Math.min(end - position, CHUNK_SIZE);
+        const chunk = part.buffer.slice(position, position + size);
+        position += chunk.byteLength;
+        yield new Uint8Array(chunk);
+    }
+}
+async function* consumeNodeBlob(blob) {
+    let position = 0;
+    while (position !== blob.size) {
+        const chunk = blob.slice(position, Math.min(blob.size, position + CHUNK_SIZE));
+        const buffer = await chunk.arrayBuffer();
+        position += buffer.byteLength;
+        yield new Uint8Array(buffer);
+    }
+}
+export async function* consumeBlobParts(parts, clone = false) {
+    for (const part of parts) {
+        if (ArrayBuffer.isView(part)) {
+            if (clone) {
+                yield* clonePart(part);
+            }
+            else {
+                yield part;
+            }
+        }
+        else if (isFunction(part.stream)) {
+            yield* part.stream();
+        }
+        else {
+            yield* consumeNodeBlob(part);
+        }
+    }
+}
+export function* sliceBlob(blobParts, blobSize, start = 0, end) {
+    end !== null && end !== void 0 ? end : (end = blobSize);
+    let relativeStart = start < 0
+        ? Math.max(blobSize + start, 0)
+        : Math.min(start, blobSize);
+    let relativeEnd = end < 0
+        ? Math.max(blobSize + end, 0)
+        : Math.min(end, blobSize);
+    const span = Math.max(relativeEnd - relativeStart, 0);
+    let added = 0;
+    for (const part of blobParts) {
+        if (added >= span) {
+            break;
+        }
+        const partSize = ArrayBuffer.isView(part) ? part.byteLength : part.size;
+        if (relativeStart && partSize <= relativeStart) {
+            relativeStart -= partSize;
+            relativeEnd -= partSize;
+        }
+        else {
+            let chunk;
+            if (ArrayBuffer.isView(part)) {
+                chunk = part.subarray(relativeStart, Math.min(partSize, relativeEnd));
+                added += chunk.byteLength;
+            }
+            else {
+                chunk = part.slice(relativeStart, Math.min(partSize, relativeEnd));
+                added += chunk.size;
+            }
+            relativeEnd -= partSize;
+            relativeStart = 0;
+            yield chunk;
+        }
+    }
+}

package/demo/node_modules/formdata-node/lib/esm/browser.js

@@ -0,0 +1,10 @@
+const globalObject = (function () {
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    if (typeof self !== "undefined") {
+        return self;
+    }
+    return window;
+}());
+export const { FormData, Blob, File } = globalObject;

package/demo/node_modules/formdata-node/lib/esm/deprecateConstructorEntries.js

@@ -0,0 +1,3 @@
+import { deprecate } from "util";
+export const deprecateConstructorEntries = deprecate(() => { }, "Constructor \"entries\" argument is not spec-compliant "
+    + "and will be removed in next major release.");

package/demo/node_modules/formdata-node/lib/esm/fileFromPath.js

@@ -0,0 +1,79 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FileFromPath_path, _FileFromPath_start;
+import { statSync, createReadStream, promises as fs } from "fs";
+import { basename } from "path";
+import DOMException from "node-domexception";
+import { File } from "./File.js";
+import isPlainObject from "./isPlainObject.js";
+export * from "./isFile.js";
+const MESSAGE = "The requested file could not be read, "
+    + "typically due to permission problems that have occurred after a reference "
+    + "to a file was acquired.";
+class FileFromPath {
+    constructor(input) {
+        _FileFromPath_path.set(this, void 0);
+        _FileFromPath_start.set(this, void 0);
+        __classPrivateFieldSet(this, _FileFromPath_path, input.path, "f");
+        __classPrivateFieldSet(this, _FileFromPath_start, input.start || 0, "f");
+        this.name = basename(__classPrivateFieldGet(this, _FileFromPath_path, "f"));
+        this.size = input.size;
+        this.lastModified = input.lastModified;
+    }
+    slice(start, end) {
+        return new FileFromPath({
+            path: __classPrivateFieldGet(this, _FileFromPath_path, "f"),
+            lastModified: this.lastModified,
+            size: end - start,
+            start
+        });
+    }
+    async *stream() {
+        const { mtimeMs } = await fs.stat(__classPrivateFieldGet(this, _FileFromPath_path, "f"));
+        if (mtimeMs > this.lastModified) {
+            throw new DOMException(MESSAGE, "NotReadableError");
+        }
+        if (this.size) {
+            yield* createReadStream(__classPrivateFieldGet(this, _FileFromPath_path, "f"), {
+                start: __classPrivateFieldGet(this, _FileFromPath_start, "f"),
+                end: __classPrivateFieldGet(this, _FileFromPath_start, "f") + this.size - 1
+            });
+        }
+    }
+    get [(_FileFromPath_path = new WeakMap(), _FileFromPath_start = new WeakMap(), Symbol.toStringTag)]() {
+        return "File";
+    }
+}
+function createFileFromPath(path, { mtimeMs, size }, filenameOrOptions, options = {}) {
+    let filename;
+    if (isPlainObject(filenameOrOptions)) {
+        [options, filename] = [filenameOrOptions, undefined];
+    }
+    else {
+        filename = filenameOrOptions;
+    }
+    const file = new FileFromPath({ path, size, lastModified: mtimeMs });
+    if (!filename) {
+        filename = file.name;
+    }
+    return new File([file], filename, {
+        ...options, lastModified: file.lastModified
+    });
+}
+export function fileFromPathSync(path, filenameOrOptions, options = {}) {
+    const stats = statSync(path);
+    return createFileFromPath(path, stats, filenameOrOptions, options);
+}
+export async function fileFromPath(path, filenameOrOptions, options) {
+    const stats = await fs.stat(path);
+    return createFileFromPath(path, stats, filenameOrOptions, options);
+}

package/demo/node_modules/formdata-node/lib/esm/index.js

@@ -0,0 +1,3 @@
+export * from "./FormData.js";
+export * from "./Blob.js";
+export * from "./File.js";

package/demo/node_modules/formdata-node/lib/esm/isBlob.js

@@ -0,0 +1,2 @@
+import { Blob } from "./Blob.js";
+export const isBlob = (value) => value instanceof Blob;

package/demo/node_modules/formdata-node/lib/esm/isFile.js

@@ -0,0 +1,2 @@
+import { File } from "./File.js";
+export const isFile = (value) => value instanceof File;

package/demo/node_modules/formdata-node/lib/esm/isFunction.js

@@ -0,0 +1 @@
+export const isFunction = (value) => (typeof value === "function");

package/demo/node_modules/formdata-node/lib/esm/isPlainObject.js

@@ -0,0 +1,13 @@
+const getType = (value) => (Object.prototype.toString.call(value).slice(8, -1).toLowerCase());
+function isPlainObject(value) {
+    if (getType(value) !== "object") {
+        return false;
+    }
+    const pp = Object.getPrototypeOf(value);
+    if (pp === null || pp === undefined) {
+        return true;
+    }
+    const Ctor = pp.constructor && pp.constructor.toString();
+    return Ctor === Object.toString();
+}
+export default isPlainObject;

package/demo/node_modules/formdata-node/lib/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/demo/node_modules/formdata-node/lib/node-domexception.d.ts

@@ -0,0 +1,5 @@
+declare class DOMException {
+  constructor(message: string, name: string)
+}
+
+export default DOMException

package/demo/node_modules/formdata-node/license

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

package/demo/node_modules/formdata-node/node_modules/web-streams-polyfill/LICENSE

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

package/demo/node_modules/formdata-node/node_modules/web-streams-polyfill/README.md

@@ -0,0 +1,135 @@
+# web-streams-polyfill
+
+Web Streams, based on the WHATWG spec reference implementation.  
+
+[![build status](https://api.travis-ci.com/MattiasBuelens/web-streams-polyfill.svg?branch=master)](https://travis-ci.com/MattiasBuelens/web-streams-polyfill)
+[![npm version](https://img.shields.io/npm/v/web-streams-polyfill.svg)](https://www.npmjs.com/package/web-streams-polyfill)
+[![license](https://img.shields.io/npm/l/web-streams-polyfill.svg)](https://github.com/MattiasBuelens/web-streams-polyfill/blob/master/LICENSE)
+[![Join the chat at https://gitter.im/web-streams-polyfill/Lobby](https://badges.gitter.im/web-streams-polyfill/Lobby.svg)](https://gitter.im/web-streams-polyfill/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+## Links
+
+ - [Official spec][spec]
+ - [Reference implementation][ref-impl]
+
+## Usage
+
+This library comes in multiple variants:
+* `web-streams-polyfill`: a [ponyfill] that provides the stream implementations 
+  without replacing any globals, targeting ES2015+ environments.
+  * ✅ Node 6+ through `import` or `require()`
+  * ✅ Modern web browsers through `import`/`export` or `<script type="module">`
+  * ✅ Web apps for modern browsers using a bundler (like webpack or Rollup)
+* `web-streams-polyfill/es5`: a ponyfill targeting ES5+ environments.
+  * ✅ Legacy Node through `require()`
+  * ✅ Legacy web browsers through [AMD][amd]
+  * ✅ Web apps for legacy browsers using a bundler (like webpack or Rollup)
+* `web-streams-polyfill/polyfill`: a polyfill that replaces the native stream implementations,
+  targeting ES2015+ environments.
+  * ✅ Modern web browsers through regular `<script>`
+* `web-streams-polyfill/polyfill/es5`: a polyfill targeting ES5+ environments.
+  * ✅ Legacy web browsers through regular `<script>`
+
+Each variant also includes TypeScript type definitions, compatible with the DOM type definitions for streams included in TypeScript.
+
+In version 4, the list of variants was reworked to have more modern defaults and to reduce the download size of the package.
+See the [migration guide][migrating] for more information.
+
+Usage as a polyfill:
+```html
+<!-- option 1: hosted by unpkg CDN -->
+<script src="https://unpkg.com/web-streams-polyfill/dist/polyfill.js"></script>
+<!-- option 2: self hosted -->
+<script src="/path/to/web-streams-polyfill/dist/polyfill.js"></script>
+<script>
+var readable = new ReadableStream();
+</script>
+```
+Usage as a Node module:
+```js
+var streams = require("web-streams-polyfill");
+var readable = new streams.ReadableStream();
+```
+Usage as a ponyfill from within a ES2015 module:
+```js
+import { ReadableStream } from "web-streams-polyfill";
+const readable = new ReadableStream();
+```
+Usage as a polyfill from within an ES2015 module:
+```js
+import "web-streams-polyfill/polyfill";
+const readable = new ReadableStream();
+```
+
+## Compatibility
+
+The default and `polyfill` variants work in any ES2015-compatible environment.
+
+The `es5` and `polyfill/es5` variants work in any ES5-compatible environment that has a global `Promise`.
+If you need to support older browsers or Node versions that do not have a native `Promise` implementation
+(check the [support table][promise-support]), you must first include a `Promise` polyfill
+(e.g. [promise-polyfill][promise-polyfill]).
+
+[Async iterable support for `ReadableStream`][rs-asynciterator] is available in all variants, but requires an ES2018-compatible environment or a polyfill for `Symbol.asyncIterator`.
+
+[`WritableStreamDefaultController.signal`][ws-controller-signal] is available in all variants, but requires a global `AbortController` constructor. If necessary, consider using a polyfill such as [abortcontroller-polyfill].
+
+## Compliance
+
+The polyfill implements [version `e9355ce` (18 Apr 2022)][spec-snapshot] of the streams specification.
+
+The polyfill is tested against the same [web platform tests][wpt] that are used by browsers to test their native implementations.
+It aims to pass all tests, although it allows some exceptions for practical reasons:
+* The default (ES2015) variant passes all of the tests, except for:
+  * The ["bad buffers and views" tests for readable byte streams][wpt-bad-buffers].
+    These tests require the implementation to synchronously transfer the contents of an `ArrayBuffer`, which is not yet possible from JavaScript (although there is a [proposal][proposal-arraybuffer-transfer] to make it possible).
+    The reference implementation "cheats" on these tests [by making a copy instead][ref-impl-transferarraybuffer], but that is unacceptable for the polyfill's performance ([#3][issue-3]).
+  * The [test for the prototype of `ReadableStream`'s async iterator][wpt-async-iterator-prototype].
+    Retrieving the correct `%AsyncIteratorPrototype%` requires using an async generator (`async function* () {}`), which is invalid syntax before ES2018.
+    Instead, the polyfill [creates its own version][stub-async-iterator-prototype] which is functionally equivalent to the real prototype.
+  * The tests [with patched globals][wpt-rs-patched-global] and [with `Object.prototype.then`][wpt-then-interception].
+    These tests are meant for browsers to ensure user-land modifications cannot affect the internal logic of `pipeTo()` and `tee()`. 
+    However, it's not reasonable or desirable for a user-land polyfill to try and isolate itself completely from using the global `Object`.
+  * Certain `pipeTo()` tests that require synchronous inspection of the stream's state  ([1][wpt-pipe-sync-state-1], [2][wpt-pipe-sync-state-2]).
+    Because the polyfill uses the public `getReader()` and `getWriter()` API to implement `pipeTo()`, it can only *asynchronously* observe if and when a stream becomes closed or errored.
+    Therefore, when the readable and the writable end become errored *at the exact same time*, it's difficult for the polyfill to observe these state changes in exactly the same order. 
+* The ES5 variant passes the same tests as the ES2015 variant, except for various tests about specific characteristics of the constructors, properties and methods.
+  These test failures do not affect the run-time behavior of the polyfill.
+  For example:
+  * The `name` property of down-leveled constructors is incorrect.
+  * The `length` property of down-leveled constructors and methods with optional arguments is incorrect.
+  * Not all properties and methods are correctly marked as non-enumerable.
+  * Down-leveled class methods are not correctly marked as non-constructable.
+
+The type definitions are compatible with the built-in stream types of TypeScript 3.3 and higher.
+
+## Contributors
+
+Thanks to these people for their work on [the original polyfill][creatorrr-polyfill]:
+
+ - Diwank Singh Tomer ([creatorrr](https://github.com/creatorrr))
+ - Anders Riutta ([ariutta](https://github.com/ariutta))
+
+[spec]: https://streams.spec.whatwg.org
+[ref-impl]: https://github.com/whatwg/streams
+[ponyfill]: https://github.com/sindresorhus/ponyfill
+[amd]: https://requirejs.org/docs/whyamd.html
+[migrating]: https://github.com/MattiasBuelens/web-streams-polyfill/blob/v4.0.0-beta.3/MIGRATING.md
+[promise-support]: https://kangax.github.io/compat-table/es6/#test-Promise
+[promise-polyfill]: https://www.npmjs.com/package/promise-polyfill
+[rs-asynciterator]: https://streams.spec.whatwg.org/#rs-asynciterator
+[ws-controller-signal]: https://streams.spec.whatwg.org/#ws-default-controller-signal
+[abortcontroller-polyfill]: https://www.npmjs.com/package/abortcontroller-polyfill
+[spec-snapshot]: https://streams.spec.whatwg.org/commit-snapshots/e9355ce79925947e8eb496563d599c329769d315/
+[wpt]: https://github.com/web-platform-tests/wpt/tree/6a46d9cb8d20c510a620141c721b81b460a4ee55/streams
+[wpt-bad-buffers]: https://github.com/web-platform-tests/wpt/blob/6a46d9cb8d20c510a620141c721b81b460a4ee55/streams/readable-byte-streams/bad-buffers-and-views.any.js
+[proposal-arraybuffer-transfer]: https://github.com/domenic/proposal-arraybuffer-transfer
+[ref-impl-transferarraybuffer]: https://github.com/whatwg/streams/blob/e9355ce79925947e8eb496563d599c329769d315/reference-implementation/lib/abstract-ops/ecmascript.js#L16
+[issue-3]: https://github.com/MattiasBuelens/web-streams-polyfill/issues/3
+[wpt-async-iterator-prototype]: https://github.com/web-platform-tests/wpt/blob/6a46d9cb8d20c510a620141c721b81b460a4ee55/streams/readable-streams/async-iterator.any.js#L24
+[stub-async-iterator-prototype]: https://github.com/MattiasBuelens/web-streams-polyfill/blob/v4.0.0-beta.3/src/lib/readable-stream/async-iterator.ts#L126-L134
+[wpt-rs-patched-global]: https://github.com/web-platform-tests/wpt/blob/887350c2f46def5b01c4dd1f8d2eee35dfb9c5bb/streams/readable-streams/patched-global.any.js
+[wpt-then-interception]: https://github.com/web-platform-tests/wpt/blob/cf33f00596af295ee0f207c88e23b5f8b0791307/streams/piping/then-interception.any.js
+[wpt-pipe-sync-state-1]: https://github.com/web-platform-tests/wpt/blob/e1e713c842e54ea0a9410ddc988b63d0e1d31973/streams/piping/multiple-propagation.any.js#L30-L53
+[wpt-pipe-sync-state-2]: https://github.com/web-platform-tests/wpt/blob/e1e713c842e54ea0a9410ddc988b63d0e1d31973/streams/piping/multiple-propagation.any.js#L114-L138
+[creatorrr-polyfill]: https://github.com/creatorrr/web-streams-polyfill

package/demo/node_modules/formdata-node/node_modules/web-streams-polyfill/es5/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "web-streams-polyfill",
+  "main": "../dist/ponyfill.es5.js",
+  "module": "../dist/ponyfill.es5.mjs",
+  "types": "../types/ponyfill.d.ts"
+}

package/demo/node_modules/formdata-node/node_modules/web-streams-polyfill/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "web-streams-polyfill",
+  "version": "4.0.0-beta.3",
+  "description": "Web Streams, based on the WHATWG spec reference implementation",
+  "main": "dist/ponyfill.js",
+  "module": "dist/ponyfill.mjs",
+  "types": "types/ponyfill.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/ponyfill.d.ts",
+      "import": "./dist/ponyfill.mjs",
+      "require": "./dist/ponyfill.js"
+    },
+    "./es5": {
+      "types": "./types/ponyfill.d.ts",
+      "import": "./dist/ponyfill.es5.mjs",
+      "require": "./dist/ponyfill.es5.js"
+    },
+    "./polyfill": {
+      "types": "./types/polyfill.d.ts",
+      "default": "./dist/polyfill.js"
+    },
+    "./polyfill/es5": {
+      "types": "./types/polyfill.d.ts",
+      "default": "./dist/polyfill.es5.js"
+    },
+    "./dist/*": "./dist/*",
+    "./types/*": "./types/*",
+    "./package": "./package.json",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "test": "npm run test:types && npm run test:unit && npm run test:wpt && npm run test:bundler",
+    "test:wpt": "npm run test:wpt:node && npm run test:wpt:chromium && npm run test:wpt:firefox",
+    "test:wpt:node": "node --expose_gc ./test/wpt/node/run.js",
+    "test:wpt:chromium": "node ./test/wpt/browser/run.js --browser chromium",
+    "test:wpt:firefox": "node ./test/wpt/browser/run.js --browser firefox",
+    "test:bundler": "npm run test:bundler:rollup && npm run test:bundler:webpack",
+    "test:bundler:rollup": "cd test/rollup && npm ci && npm test",
+    "test:bundler:webpack": "cd test/webpack && npm ci && npm test",
+    "test:types": "tsc -p ./test/types/tsconfig.json",
+    "test:unit": "node --experimental-import-meta-resolve ./node_modules/jasmine/bin/jasmine.js --config=test/unit/jasmine.json",
+    "lint": "eslint \"src/**/*.ts\"",
+    "build": "npm run build:bundle && npm run build:types",
+    "build:bundle": "rollup -c",
+    "build:types": "tsc --project . --emitDeclarationOnly --declarationDir ./lib && api-extractor run",
+    "accept:types": "tsc --project . --emitDeclarationOnly --declarationDir ./lib && api-extractor run --local",
+    "prepare": "npm run build"
+  },
+  "files": [
+    "dist",
+    "es5",
+    "polyfill",
+    "types"
+  ],
+  "engines": {
+    "node": ">= 14"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MattiasBuelens/web-streams-polyfill.git"
+  },
+  "keywords": [
+    "streams",
+    "whatwg",
+    "polyfill"
+  ],
+  "author": "Mattias Buelens <mattias@buelens.com>",
+  "contributors": [
+    "Diwank Singh <diwank.singh@gmail.com>"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/MattiasBuelens/web-streams-polyfill/issues"
+  },
+  "homepage": "https://github.com/MattiasBuelens/web-streams-polyfill#readme",
+  "devDependencies": {
+    "@microsoft/api-extractor": "^7.21.2",
+    "@rollup/plugin-inject": "^4.0.4",
+    "@rollup/plugin-replace": "^4.0.0",
+    "@rollup/plugin-strip": "^2.1.0",
+    "@rollup/plugin-typescript": "^8.3.1",
+    "@types/jasmine": "^4.0.2",
+    "@types/node": "^14.18.12",
+    "@typescript-eslint/eslint-plugin": "^5.19.0",
+    "@typescript-eslint/parser": "^5.19.0",
+    "@ungap/promise-all-settled": "^1.1.2",
+    "abort-controller": "^3.0.0",
+    "eslint": "^8.13.0",
+    "jasmine": "^4.0.2",
+    "micromatch": "^4.0.5",
+    "minimist": "^1.2.6",
+    "playwright": "^1.20.2",
+    "recursive-readdir": "^2.2.2",
+    "rollup": "^2.70.1",
+    "rollup-plugin-terser": "^7.0.2",
+    "tslib": "^2.3.1",
+    "typescript": "^4.7.0-beta",
+    "wpt-runner": "^4.1.0"
+  }
+}

package/demo/node_modules/formdata-node/node_modules/web-streams-polyfill/polyfill/es5/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "web-streams-polyfill",
+  "main": "../../dist/polyfill.es5.js",
+  "types": "../../types/polyfill.d.ts"
+}