web-streams-shim 1.0.4 → 1.0.6

package/README.md

@@ -1,69 +1,129 @@
-## Web Streams Shim Library
+## Web Streams Shim
 
-The Web Streams Shim Library is designed to create parity between the streaming interfaces within modern runtimes. This does not polyfill the interfaces if they are missing entirely. For that you will want [web-streams-polyfill](https://www.npmjs.com/package/web-streams-polyfill) which is not affiliated with the project.
+🛶 Web Streams Shim is designed to create parity between the streaming interfaces within modern runtimes. This does not polyfill the interfaces if they are missing entirely. For that you will want [web-streams-polyfill](https://www.npmjs.com/package/web-streams-polyfill) which is not affiliated with the project.
 
 This library provides essential polyfills and shims to ensure modern Web Streams functionality is available and compliant across environments where native support is missing or incomplete, particularly focusing on `ReadableStream`, `Request`, `Response`, and `Blob` objects.
 
+## Install
+
+At the top of your web page put
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/web-streams-shim/web-streams-core.js"></script>
+```
+
+Dynamic import
+
+`await import('`[https://cdn.jsdelivr.net/npm/web-streams-shim/web-streams-core.js](https://cdn.jsdelivr.net/npm/web-streams-shim/web-streams-core.js)`');`
+
 ***
 
 ## Key Features and Polyfills
 
-The library focuses on extending core browser APIs to meet the latest Web Stream and Fetch specifications.
+The library focuses on extending core browser APIs to meet the latest Web Stream and Fetch specifications. Compatibility tables are generated dynamically from mdn's caniuse api.
 
-### 1. ReadableStream Async Iteration
+### Conditional Filling
+
+Each polyfill performs feature detection before initializing. If a feature is detected as already present then it is skipped so as not to overwrite native behavior where possible.
+
+### ReadableStream Async Iteration
 
 The library adds **comprehensive support for modern JavaScript iteration patterns** to `ReadableStream` and its readers.
 
-| Target | Method/Property | Description |
+![ReadableStream.asyncIterator](https://caniuse.smokestack.workers.dev/?feature=ReadableStream.@@asyncIterator)
+
+| | | |
 | :--- | :--- | :--- |
-| [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) | `[Symbol.asyncIterator]` | Allows the stream to be directly iterable in `for-await-of` loops. |
-| [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) | `values()` | An alias for `[Symbol.asyncIterator]` for explicit iteration. |
+| [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) | [`[Symbol.asyncIterator]`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncIterator) | Allows the stream to be directly iterable in `for-await-of` loops. |
 
-![ReadableStream.asyncIterator](https://caniuse.smokestack.workers.dev/?feature=api.ReadableStream.@@asyncIterator)
 ![ReadableStream.values](https://caniuse.smokestack.workers.dev/?feature=api.ReadableStream.values)
 
-### 2. Stream Construction Utility
+| | | |
+| :--- | :--- | :--- |
+| [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) | `values()` | An alias for `[Symbol.asyncIterator]` for explicit iteration. |
+
+
+### Stream Construction Utility
 
 The library adds the static method for creating streams from existing data sources.
 
-| Target | Method/Property | Description |
+| | |  |
 | :--- | :--- | :--- |
 | [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) | [`from(obj)`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/from_static) | **Creates a new `ReadableStream` from any iterable or async iterable object**. It handles both synchronous and asynchronous iterators, including objects that yield `Promise`-like values. |
 
-![ReadableStream.from](https://caniuse.smokestack.workers.dev/?feature=api.ReadableStream.from)
+![ReadableStream.from](https://caniuse.smokestack.workers.dev/?feature=ReadableStream.from)
 
-### 3. Fetch and Body Integration Shims
+### Body Shim
 
-These shims ensure `Request` and `Response` objects (Records) consistently expose their body as a stream and provide the `bytes()` utility.
+This shim ensures `Request` and `Response` objects consistently expose their body as a stream.
 
-| Target | Method/Property | Description |
+![Request.body](https://caniuse.smokestack.workers.dev/?feature=Request.body)
+
+| | | |
 | :--- | :--- | :--- |
-| `Request` | [`body`](https://developer.mozilla.org/en-US/docs/Web/API/Request/body) | Polyfills the `body` property to return a **`ReadableStream` representation of the body content**. This is crucial for environments where `fetch` exists but streaming is absent. |
-| `Response` | [`body`](https://developer.mozilla.org/en-US/docs/Web/API/Response/body) | Provides the body content as a `ReadableStream`. The implementation clones the original record, converts the body to a `Blob`, gets the blob's stream, and enqueues chunks via a controller. |
-| [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request/bytes), [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response/bytes), [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob/bytes) | `bytes()` | Adds the `bytes()` method, which **asynchronously returns the object's body/content as a `Uint8Array`**. It achieves this by calling the native `arrayBuffer()` and wrapping the result. |
+| [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request/body) | [`body`](https://developer.mozilla.org/en-US/docs/Web/API/Request/body) | Polyfills the `body` property to return a **`ReadableStream` representation of the body content**. This is crucial for environments where `fetch` exists but streaming is absent. |
 
-![Request.body](https://caniuse.smokestack.workers.dev/?feature=api.Request.body)
 ![Response.body](https://caniuse.smokestack.workers.dev/?feature=api.Response.body)
-![Request.bytes](https://caniuse.smokestack.workers.dev/?feature=api.Request.bytes)
-![Response.bytes](https://caniuse.smokestack.workers.dev/?feature=api.Response.bytes)
-![Blob.bytes](https://caniuse.smokestack.workers.dev/?feature=api.Blob.bytes)
 
-### 4. Duplex Compliance Shim
+| | | |
+| :--- | :--- | :--- |
+| [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response/body)  | [`body`](https://developer.mozilla.org/en-US/docs/Web/API/Response/body) | Provides the body content as a `ReadableStream`. |
+
+
+### Bytes Shim
+
+This shim ensures `Request` and `Response`, and `Blob` objects consistently provide the `bytes()` utility.
+
+![Request.bytes](https://caniuse.smokestack.workers.dev/?feature=Request.bytes)
 
-To satisfy modern `fetch` specifications when streaming request bodies, the library ensures compliance for **half-duplex operations**.
+| | | |
+| :--- | :--- | :--- |
+| [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request/bytes) | [`bytes()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) | Adds the `bytes()` method, which **asynchronously returns the object's body/content as a `Uint8Array`**. |
+
+![Response.bytes](https://caniuse.smokestack.workers.dev/?feature=Response.bytes)
+
+| | | |
+| :--- | :--- | :--- |
+| [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response/bytes) | [`bytes()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) | Adds the `bytes()` method, which **asynchronously returns the object's body/content as a `Uint8Array`**. |
+
+![Blob.bytes](https://caniuse.smokestack.workers.dev/?feature=Blob.bytes)
+
+| | | |
+| :--- | :--- | :--- |
+| [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob/bytes) | [`bytes()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) | Adds the `bytes()` method, which **asynchronously returns the object's body/content as a `Uint8Array`**. |
+
+
+### Duplex Compliance Shim
+
+To satisfy modern `fetch` specifications when streaming request bodies, the library ensures compliance for **half-duplex operations**. This is in many ways a reverse shim as it allows legacy code to continue to work in the absence of a duplex parameter that did not exist when the code was implemented.
 
 *   **Property Injection:** The `duplex: 'half'` property is added to the prototypes of `Request`, `Response`, `ReadableStream`, and `Blob`.
 *   **Constructor Wrapping:** The global `Request` and `Response` constructors are subclassed and **wrapped** to automatically apply `duplex: 'half'` utility function to all arguments passed during instantiation.
 *   **Fetch Wrapping:** The global `fetch` function is **wrapped** to automatically apply `duplex: 'half'` to its arguments before execution, guaranteeing compliance when streams are used in options.
 
-![Request.duplex](https://caniuse.smokestack.workers.dev/?feature=api.Request.duplex)
+![Request.duplex](https://caniuse.smokestack.workers.dev/?feature=Request.duplex)
 
-### 5. ReadableStreamDefaultReader Constructor Support
+
+### ReadableStreamDefaultReader Constructor Support
 
 The library adds support for the `ReadableStreamDefaultReader` constructor.
 
-| Target | Method/Property | Description |
+![ReadableStreamDefaultReader.constructor](https://caniuse.smokestack.workers.dev/?feature=ReadableStreamDefaultReader.constructor)
+
+| | | |
 | :--- | :--- | :--- |
-| [`ReadableStreamDefaultReader`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader) | [`constructor(stream)`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream) | **Polyfills the `ReadableStreamDefaultReader` constructor** to accept a stream directly. In environments where the native constructor doesn't support this (like Bun), it delegates to `stream.getReader()` and properly sets up the prototype chain. This allows `new ReadableStreamDefaultReader(stream)` to work consistently across all runtimes. |
+| [`ReadableStreamDefaultReader`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader) | [`constructor(stream)`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader/ReadableStreamDefaultReader) | **Polyfills the `ReadableStreamDefaultReader` constructor** to accept a stream directly. In environments where the native constructor doesn't support this (like Bun), it delegates to `stream.getReader()` and properly sets up the prototype chain. This allows `new ReadableStreamDefaultReader(stream)` to work consistently across all runtimes. |
+
+
+### Additional Shims
+
+![ReadableStreamBYOBReader](https://caniuse.smokestack.workers.dev/?feature=ReadableStreamBYOBReader)
+
+![ReadableStreamBYOBReader.constructor](https://caniuse.smokestack.workers.dev/?feature=ReadableStreamBYOBReader.constructor)
+
+![ReadableStreamBYOBRequest](https://caniuse.smokestack.workers.dev/?feature=ReadableStreamBYOBRequest)
+
+![ReadableByteStreamContoller](https://caniuse.smokestack.workers.dev/?feature=ReadableByteStreamContoller)
+
 
-![ReadableStreamDefaultReader.constructor](https://caniuse.smokestack.workers.dev/?feature=api.ReadableStreamDefaultReader.constructor)
+![](https://cdn.jsdelivr.net/npm/web-streams-shim/web-streams-core.js)

package/ReadableStreamBYOBReader.js

@@ -0,0 +1,330 @@
+(() => {
+    const Q = fn => {
+        try {
+            return fn?.()
+        } catch {}
+    };
+    const $global = Q(() => globalThis) ?? Q(() => global) ?? Q(() => self) ?? Q(() => window) ?? this;
+    const constructPrototype = newClass => {
+        try {
+            if (newClass?.prototype) return newClass;
+            const constProto = newClass?.constructor?.prototype;
+            if (constProto) {
+                newClass.prototype = Q(() => constProto?.bind?.(constProto)) ?? Object.create(Object(constProto));
+                return newClass;
+            }
+            newClass.prototype = Q(() => newClass?.bind?.(newClass)) ?? Object.create(Object(newClass));
+        } catch (e) {
+            console.warn(e, newClass);
+        }
+    };
+    const extend = (thisClass, superClass) => {
+        try {
+            constructPrototype(thisClass);
+            constructPrototype(superClass);
+            Object.setPrototypeOf(thisClass.prototype, superClass?.prototype ?? superClass?.constructor?.prototype ?? superClass);
+            Object.setPrototypeOf(thisClass, superClass);
+        } catch (e) {
+            console.warn(e, {
+                thisClass,
+                superClass
+            });
+        }
+        return thisClass;
+    };
+    /**
+
+    - Creates a function that returns a string for all string conversion methods
+    - Used to provide consistent string representations for polyfilled functions
+    - @param {string} str - The string to return
+    - @returns {Function} A function that returns the string for all conversion methods
+    - @private
+      */
+    const makeStringer = str => {
+        const stringer = () => str;
+        ['valueOf', 'toString', 'toLocaleString', Symbol.toPrimitive].forEach(x => {
+            stringer[x] = stringer;
+        });
+        stringer[Symbol.toStringTag] = str;
+        return stringer;
+    };
+    /**
+
+    - Sets string conversion methods on a function to indicate it’s polyfill code
+    - Provides consistent debugging experience by showing polyfill status
+    - @param {Function} obj - The function to modify
+    - @returns {Function} The modified function
+    - @private
+      */
+    const setStrings = (obj) => {
+        let type = 'function';
+        if(String(obj).trim().startsWith('class')||/^[A-Z]|^.[A-Z]/.test(obj?.name)){
+            type = 'class';
+        }
+        if(String(obj).trim().startsWith('async')||/async/i.test(obj?.name)){
+            type = 'async function';
+        }
+        for (const str of ['toString', 'toLocaleString', Symbol.toStringTag]) {
+            Object.defineProperty(obj, str, {
+                value: makeStringer(`${type} ${obj.name} { [polyfill code] }`),
+                configurable: true,
+                writable: true,
+                enumerable: false,
+            });
+        }
+        return obj;
+    };
+    const assign = (target, source) => {
+        const props = Object.getOwnPropertyDescriptors(source);
+        for (const key in props) {
+            try {
+                Object.defineProperty(target, key, props[key]);
+            } catch (e) {
+                console.warn(e, key, props[key]);
+            }
+        }
+        for (const key in source) {
+            try {
+                target[key] ??= source[key];
+            } catch (e) {
+                console.warn(e, key, props[key]);
+            }
+        }
+        return target;
+    };
+    const cloneClass = $class => {
+        const clonePrototype = assign({}, $class.prototype);
+        const clone = $class.bind(clonePrototype);
+        assign(clone, $class);
+        clone.prototype = Object.setPrototypeOf(clonePrototype, Object.getPrototypeOf($class.prototype));
+        Object.setPrototypeOf(clone, Object.getPrototypeOf($class));
+        return clone;
+    };
+
+    const _closed = Object.getOwnPropertyDescriptor($global.ReadableStreamDefaultReader.prototype, 'closed')?.get;
+    if (_closed) {
+        Object.defineProperty($global.ReadableStreamDefaultReader.prototype, 'closed', {
+            get: extend(setStrings(async function closed() {
+                try {
+                    return await _closed.call(this);
+                } catch (e) {
+                    console.warn(e);
+                }
+            }), _closed),
+            enumerable: false,
+            configurable: true
+        });
+    }
+
+    if (!$global.ReadableStreamBYOBReader) {
+        $global.ReadableStreamBYOBReader ??= cloneClass(ReadableStreamDefaultReader);
+        Object.defineProperty(ReadableStreamBYOBReader, 'name', {
+            value: 'ReadableStreamBYOBReader',
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        setStrings(ReadableStreamBYOBReader);
+        const _getReader = ReadableStream.prototype.getReader;
+        ReadableStream.prototype.getReader = Object.setPrototypeOf(function getReader(options) {
+            const reader = _getReader.call(this);
+            if (options?.mode == 'byob') {
+                Object.setPrototypeOf(reader, ReadableStreamBYOBReader);
+            }
+            return reader;
+        }, _getReader);
+        extend(ReadableStreamBYOBReader, ReadableStreamDefaultReader);
+        const _read = ReadableStreamBYOBReader.prototype.read;
+        ReadableStreamBYOBReader.prototype.read = extend(setStrings(async function read(view) {
+            // If no view is provided, fall back to default behavior
+            if (!view) {
+                return _read.call(this, view);
+            }
+            // Read from the underlying stream (default reader behavior)
+            const result = await _read.call(this, view);
+            // If done, return with the view and done flag
+            if (result.done != false) {
+                return {
+                    value: view,
+                    done: true
+                };
+            }
+            // Convert the chunk to Uint8Array if needed
+            const chunk = result.value instanceof Uint8Array ? result.value : new Uint8Array(result.value);
+            // Determine how much data we can copy
+            const bytesToCopy = Math.min(chunk.byteLength, view.byteLength);
+            // Create a temporary view to copy into the provided view
+            const targetView = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+            // Copy the data into the provided buffer
+            targetView.set(chunk.subarray(0, bytesToCopy), 0);
+            // Create a view of the filled portion
+            const filledView = new view.constructor(view.buffer, view.byteOffset, bytesToCopy);
+            return {
+                value: filledView,
+                done: false
+            };
+        }), _read);
+    }
+    const supportsReadableStreamBYOBReaderConstructor = () => {
+        try {
+            const stream = new ReadableStream({
+                start(controller) {
+                    controller.enqueue(new Uint8Array([0]));
+                    controller.close();
+                },
+                type: 'bytes'
+            });
+            const reader = new ReadableStreamBYOBReader(stream);
+            reader.read(new Uint8Array([0])).catch((e) => console.warn(e));
+            return true;
+        } catch {
+            return false;
+        }
+    };
+    if (!supportsReadableStreamBYOBReaderConstructor()) {
+        const _ReadableStreamBYOBReader = $global.ReadableStreamBYOBReader;
+        const $ReadableStreamBYOBReader = function ReadableStreamBYOBReader(stream) {
+            return Object.setPrototypeOf(stream.getReader(), $global.ReadableStreamBYOBReader.prototype);
+        };
+        setStrings($ReadableStreamBYOBReader);
+        extend($ReadableStreamBYOBReader, _ReadableStreamBYOBReader);
+        $global.ReadableStreamBYOBReader = new Proxy($ReadableStreamBYOBReader, Object.setPrototypeOf({
+            construct: Object.setPrototypeOf(function construct(_, [stream]) {
+                return $ReadableStreamBYOBReader(stream);
+            }, $ReadableStreamBYOBReader.prototype)
+        }, $ReadableStreamBYOBReader));
+        $global.ReadableStreamBYOBReader.prototype.constructor = $global.ReadableStreamBYOBReader;
+    }
+    if (!$global.ReadableStreamBYOBRequest) {
+
+        const protectedProp = (obj, key, value) =>
+            Object.defineProperty(obj, `&${key}`, {
+                value,
+                writable: true,
+                enumerable: false,
+                configurable: true,
+            });
+
+        if (!$global.ReadableStreamBYOBRequest) {
+
+            class ReadableStreamBYOBRequest {
+                constructor(controller, view) {
+                    protectedProp(this, 'controller', controller);
+                    protectedProp(this, 'view', view);
+                    protectedProp(this, 'responded', false);
+                }
+
+                get view() {
+                    return this['&responded'] ? null : this['&view'];
+                }
+
+                respond(bytesWritten) {
+                    if (this['&responded']) {
+                        throw new TypeError('This BYOB request has already been responded to');
+                    }
+                    this['&responded'] = true;
+
+                    const filledView = new this['&view'].constructor(
+                        this['&view'].buffer,
+                        this['&view'].byteOffset,
+                        bytesWritten
+                    );
+
+                    this['&controller'].enqueue(filledView);
+                }
+
+                respondWithNewView(view) {
+                    if (this['&responded']) {
+                        throw new TypeError('This BYOB request has already been responded to');
+                    }
+                    this['&responded'] = true;
+                    this['&controller'].enqueue(view);
+                }
+            }
+
+            setStrings(ReadableStreamBYOBRequest);
+            $global.ReadableStreamBYOBRequest = ReadableStreamBYOBRequest;
+
+            // Symbols to link streams and controllers
+            const $stream = Symbol('*stream');
+            const $controller = Symbol('*controller');
+            const controllerPendingViews = new WeakMap();
+
+            // Add byobRequest property to default controller
+            if (!('byobRequest' in ReadableStreamDefaultController.prototype)) {
+                Object.defineProperty(ReadableStreamDefaultController.prototype, 'byobRequest', {
+                    get: extend(setStrings(function byobRequest() {
+                        const view = controllerPendingViews.get(this);
+                        if (view) {
+                            return new ReadableStreamBYOBRequest(this, view);
+                        }
+                        return null;
+                    }), ReadableStreamBYOBRequest),
+                    configurable: true,
+                    enumerable: true
+                });
+            }
+
+            // Wrap ReadableStream constructor
+            const _ReadableStream = ReadableStream;
+
+            $global.ReadableStream = extend(setStrings(function ReadableStream(underlyingSource = {}, strategy) {
+                const $this = this;
+
+                if (underlyingSource?.type === 'bytes') {
+                    const wrappedSource = Object.assign({}, underlyingSource);
+                    const originalStart = underlyingSource.start;
+                    const originalPull = underlyingSource.pull;
+
+                    wrappedSource.start = extend(setStrings(function start(controller) {
+                        controller[$stream] = $this;
+                        $this[$controller] = controller;
+                        return originalStart?.call(this, controller);
+                    }), originalStart ?? ReadableStreamDefaultController);
+
+                    wrappedSource.pull = extend(setStrings(function pull(controller) {
+                        controller[$stream] = $this;
+                        $this[$controller] = controller;
+                        return originalPull?.call(this, controller);
+                    }), originalPull ?? ReadableStreamDefaultController);
+
+                    const stream = new _ReadableStream(wrappedSource, strategy);
+                    return Object.setPrototypeOf($this, stream);
+                }
+
+                return new _ReadableStream(underlyingSource, strategy);
+            }), _ReadableStream);
+
+            // Patch getReader to connect BYOB readers with controllers
+            const _getReader = $global.ReadableStream.prototype.getReader;
+            $global.ReadableStream.prototype.getReader = extend(setStrings(function getReader(options) {
+                const reader = _getReader.call(this, options);
+
+                if (options?.mode === 'byob') {
+                    const _read = reader.read;
+
+                    reader.read = extend(setStrings(async function read(view) {
+                        const controller = this[$controller] ?? reader[$controller] ?? this[$stream]?.[$controller];
+
+                        if (controller && view) {
+                            controllerPendingViews.set(controller, view);
+                        }
+
+                        const result = await _read.call(this, view);
+
+                        if (controller) {
+                            controllerPendingViews.delete(controller);
+                        }
+
+                        return result;
+                    }), _read);
+                }
+
+                return reader;
+            }), _getReader);
+            if(typeof ReadableByteStreamController === 'undefined'){
+                $global.ReadableByteStreamContoller = setStrings(class ReadableByteStreamContoller extends ReadableStreamDefaultController{});
+            }
+        }
+    }
+})();

package/ReadableStreamDefaultReader-constructor.js

@@ -4,6 +4,7 @@
             return fn?.()
         } catch {}
     };
+    const $global = Q(()=>globalThis) ?? Q(()=>global) ?? Q(()=>self) ?? Q(()=>window) ?? this;
     const constructPrototype = newClass => {
         try {
             if (newClass?.prototype) return newClass;
@@ -92,18 +93,18 @@
 
 
     if (!supportsReadableStreamDefaultReaderConstructor()) {
-        const _ReadableStreamDefaultReader = globalThis.ReadableStreamDefaultReader;
+        const _ReadableStreamDefaultReader = $global.ReadableStreamDefaultReader;
         const $ReadableStreamDefaultReader = function ReadableStreamDefaultReader(stream) {
-            return Object.setPrototypeOf(stream.getReader(), globalThis.ReadableStreamDefaultReader.prototype);
+            return Object.setPrototypeOf(stream.getReader(), $global.ReadableStreamDefaultReader.prototype);
         };
         setStrings($ReadableStreamDefaultReader);
         extend($ReadableStreamDefaultReader, _ReadableStreamDefaultReader);
-        globalThis.ReadableStreamDefaultReader = new Proxy($ReadableStreamDefaultReader, Object.setPrototypeOf({
+        $global.ReadableStreamDefaultReader = new Proxy($ReadableStreamDefaultReader, Object.setPrototypeOf({
             construct:Object.setPrototypeOf(function construct(_, [stream]) {
                 return $ReadableStreamDefaultReader(stream)
             },$ReadableStreamDefaultReader.prototype)
         },$ReadableStreamDefaultReader));
-        globalThis.ReadableStreamDefaultReader.prototype.constructor = globalThis.ReadableStreamDefaultReader
+        $global.ReadableStreamDefaultReader.prototype.constructor = $global.ReadableStreamDefaultReader
     }
 
 })();

package/Record-duplex.js

@@ -89,7 +89,7 @@
     - Creates a new Request class that extends the original but processes arguments
       */
     (() => {
-        let $Request = Request;
+        const $Request = Request;
 
 
         /**
@@ -102,13 +102,13 @@
          *   body: new ReadableStream() 
          * }); // ReadableStream automatically gets duplex: 'half'
          */
-        $Request = class Request extends $Request {
+        const _Request = class Request extends $Request {
             constructor(...args) {
                 super(...args.map(duplexHalf));
             }
         };
 
-        $global.Request = $Request;
+        $global.Request = _Request;
 
 
     })();

package/extensions/file.js

@@ -0,0 +1,43 @@
+(() => {
+    const Q = fn => {
+        try {
+            return fn?.()
+        } catch {}
+    };
+    const $global = Q(() => globalThis) ?? Q(() => global) ?? Q(() => self) ?? Q(() => window) ?? this;
+    if (typeof File === 'undefined') {
+        // Sham File class extending Blob
+        $global.File = class File extends Blob {
+            constructor(bits, filename, options = {}) {
+                // Extract File-specific options
+                const {
+                    lastModified = Date.now(), ...blobOptions
+                } = options;
+
+                // Call Blob constructor with bits and blob options
+                super(bits, blobOptions);
+
+                // Add File-specific properties
+                this['&name'] = filename;
+                this['&lastModified'] = lastModified;
+                this['&lastModifiedDate'] = new Date(lastModified);
+            }
+
+            get name() {
+                return this['&name'];
+            }
+
+            get lastModified() {
+                return this['&lastModified'];
+            }
+
+            get lastModifiedDate() {
+                return this['&lastModifiedDate'];
+            }
+
+            get webkitRelativePath() {
+                return '';
+            }
+        }
+    }
+})();

package/extensions/location.js

@@ -0,0 +1,42 @@
+(() => {
+    const Q = fn => {
+        try {
+            return fn?.()
+        } catch {}
+    };
+    const $global = Q(() => globalThis) ?? Q(() => global) ?? Q(() => self) ?? Q(() => window) ?? this;
+
+    if (typeof Location === 'undefined') {
+        // Sham Location class extending URL
+        $global.Location = class Location extends URL {
+            constructor(href, base) {
+                super(href, base);
+            }
+
+            // Location properties that delegate to URL
+            get ancestorOrigins() {
+                return {
+                    length: 0
+                };
+            }
+
+            // Location methods
+            assign(url) {
+                this.href = url;
+            }
+
+            reload(forceReload = false) {
+                // Sham implementation - does nothing
+                console.log(`reload(${forceReload}) called`);
+            }
+
+            replace(url) {
+                this.href = url;
+            }
+
+            toString() {
+                return this.href;
+            }
+        }
+    }
+})();

package/extensions/web-streams-extensions.js

@@ -5,6 +5,7 @@
             return fn?.()
         } catch {}
     };
+    const $global = Q(() => globalThis) ?? Q(() => global) ?? Q(() => self) ?? Q(() => window) ?? this;
     const constructPrototype = newClass => {
         try {
             if (newClass?.prototype) return newClass;