Update Streams to official WebIDL

inputfiles/addedTypes.json

@@ -2166,38 +2166,6 @@
                     ]
                 }
             },
-            "TextDecoderStream": {
-                "properties": {
-                    "property": {
-                        "readable": {
-                            "name": "readable",
-                            "read-only": 1,
-                            "override-type": "ReadableStream<string>"
-                        },
-                        "writable": {
-                            "name": "writable",
-                            "read-only": 1,
-                            "override-type": "WritableStream<BufferSource>"
-                        }
-                    }
-                }
-            },
-            "TextEncoderStream": {
-                "properties": {
-                    "property": {
-                        "readable": {
-                            "name": "readable",
-                            "read-only": 1,
-                            "override-type": "ReadableStream<Uint8Array>"
-                        },
-                        "writable": {
-                            "name": "writable",
-                            "read-only": 1,
-                            "override-type": "WritableStream<string>"
-                        }
-                    }
-                }
-            },
             "Attr": {
                 "name": "Attr",
                 "properties": {
@@ -2320,6 +2288,44 @@
                         }
                     }
                 }
+            },
+            "ReadableStreamDefaultReadDoneResult": {
+                "name": "ReadableStreamDefaultReadDoneResult",
+                "members": {
+                    "member": {
+                        "done": {
+                            "name": "done",
+                            "override-type": "true",
+                            "required": 1
+                        },
+                        "value": {
+                            "name": "value",
+                            "override-type": "undefined"
+                        }
+                    }
+                }
+            },
+            "ReadableStreamDefaultReadValueResult": {
+                "name": "ReadableStreamDefaultReadValueResult",
+                "type-parameters": [
+                    {
+                        "name": "T"
+                    }
+                ],
+                "members": {
+                    "member": {
+                        "done": {
+                            "name": "done",
+                            "override-type": "false",
+                            "required": 1
+                        },
+                        "value": {
+                            "name": "value",
+                            "override-type": "T",
+                            "required": 1
+                        }
+                    }
+                }
             }
         }
     },
@@ -2418,6 +2424,37 @@
                         "type": "ModuleImports"
                     }
                 ]
+            },
+            {
+                "new-type": "ReadableStreamDefaultReadResult",
+                "type-parameters": [
+                    {
+                        "name": "T"
+                    }
+                ],
+                "type": [
+                    {
+                        "type": "ReadableStreamDefaultReadValueResult"
+                    },
+                    {
+                        "type": "ReadableStreamDefaultReadDoneResult"
+                    }
+                ],
+                "override-type": "ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult"
+            },
+            {
+                "new-type": "ReadableStreamReader",
+                "type-parameters": [
+                    {
+                        "name": "T"
+                    }
+                ],
+                "type": [
+                    {
+                        "type": "ReadableStreamDefaultReader"
+                    }
+                ],
+                "override-type": "ReadableStreamDefaultReader<T>"
             }
         ]
     }

inputfiles/idl/Encoding.commentmap.json

@@ -1,13 +1,13 @@
 {
     "textdecoder": "Returns a new TextDecoder object.\n\nIf label is either not a label or is a label for replacement, throws a RangeError.",
     "textdecodercommon-encoding": "Returns encoding's name, lowercased.",
-    "textdecodercommon-fatal": "Returns true if error mode is \"fatal\", and false otherwise.",
-    "textdecodercommon-ignorebom": "Returns true if ignore BOM flag is set, and false otherwise.",
-    "textdecoder-decode": "Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented stream. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.\n\n```\nvar string = \"\", decoder = new TextDecoder(encoding), buffer;\nwhile(buffer = next_chunk()) {\n  string += decoder.decode(buffer, {stream:true});\n}\nstring += decoder.decode(); // end-of-stream\n```\n\nIf the error mode is \"fatal\" and encoding's decoder returns error, throws a TypeError.",
+    "textdecodercommon-fatal": "Returns true if error mode is \"fatal\", otherwise false.",
+    "textdecodercommon-ignorebom": "Returns the value of ignore BOM.",
+    "textdecoder-decode": "Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented input. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.\n\n```\nvar string = \"\", decoder = new TextDecoder(encoding), buffer;\nwhile(buffer = next_chunk()) {\n  string += decoder.decode(buffer, {stream:true});\n}\nstring += decoder.decode(); // end-of-queue\n```\n\nIf the error mode is \"fatal\" and encoding's decoder returns error, throws a TypeError.",
     "textencoder": "Returns a new TextEncoder object.",
     "textencodercommon-encoding": "Returns \"utf-8\".",
     "textencoder-encode": "Returns the result of running UTF-8's encoder.",
-    "textencoder-encodeinto": "Runs the UTF-8 encoder on source, stores the result of that operation into destination, and returns the progress made as a dictionary whereby read is the number of converted code units of source and written is the number of bytes modified in destination.",
+    "textencoder-encodeinto": "Runs the UTF-8 encoder on source, stores the result of that operation into destination, and returns the progress made as an object wherein read is the number of converted code units of source and written is the number of bytes modified in destination.",
     "textdecoderstream": "Returns a new TextDecoderStream object.\n\nIf label is either not a label or is a label for replacement, throws a RangeError.",
     "generictransformstream-readable": "Returns a readable stream whose chunks are strings resulting from running encoding's decoder on the chunks written to writable.",
     "generictransformstream-writable": "Returns a writable stream which accepts [AllowShared] BufferSource chunks and runs them through encoding's decoder before making them available to readable.\n\nTypically this will be used via the pipeThrough() method on a ReadableStream source.\n\n```\nvar decoder = new TextDecoderStream(encoding);\nbyteReadable\n  .pipeThrough(decoder)\n  .pipeTo(textWritable);\n```\n\nIf the error mode is \"fatal\" and encoding's decoder returns error, both readable and writable will be errored with a TypeError.",

inputfiles/idl/Encoding.widl

@@ -39,11 +39,6 @@ interface TextEncoder {
 };
 TextEncoder includes TextEncoderCommon;
 
-interface mixin GenericTransformStream {
-  readonly attribute ReadableStream readable;
-  readonly attribute WritableStream writable;
-};
-
 [Exposed=(Window,Worker)]
 interface TextDecoderStream {
   constructor(optional DOMString label = "utf-8", optional TextDecoderOptions options = {});

inputfiles/idl/Streams.commentmap.json

@@ -1,7 +1,7 @@
 {
     "readablestreamgetreaderoptions-mode": "Creates a ReadableStreamBYOBReader and locks the stream to the new reader.\n\nThis call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle \"bring your own buffer\" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation.",
     "readablewritablepair-writable": "Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.\n\nPiping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.",
-    "streampipeoptions-preventclose": "Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.\n\nPiping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.\n\nErrors and closures of the source and destination streams propagate as follows:\n\nAn error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination.\n\nAn error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source.\n\nWhen this source readable stream closes, destination will be closed, unless preventCancel is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error.\n\nIf destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source.\n\nThe signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.",
+    "streampipeoptions-preventclose": "Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.\n\nPiping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.\n\nErrors and closures of the source and destination streams propagate as follows:\n\nAn error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination.\n\nAn error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source.\n\nWhen this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error.\n\nIf destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source.\n\nThe signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.",
     "readablestreamiteratoroptions-preventcancel": "Asynchronously iterates over the chunks in the stream's internal queue.\n\nAsynchronously iterating over the stream will lock it, preventing any other consumer from acquiring a reader. The lock will be released if the async iterator's return() method is called, e.g. by breaking out of the loop.\n\nBy default, calling the async iterator's return() method will also cancel the stream. To prevent this, use the stream's values() method, passing true for the preventCancel option.",
     "queuingstrategyinit-highwatermark": "Creates a new ByteLengthQueuingStrategy with the provided high water mark.\n\nNote that the provided high water mark will not be validated ahead of time. Instead, if it is negative, NaN, or not a number, the resulting ByteLengthQueuingStrategy will cause the corresponding stream constructor to throw."
 }

inputfiles/idl/Streams.widl

@@ -1,186 +1,221 @@
-[Constructor(optional UnderlyingSource underlyingSource, optional QueuingStrategy strategy),
- Constructor(optional UnderlyingByteSource underlyingSource, optional QueuingStrategy strategy),
- Exposed=(Window,Worker)]
+[Exposed=(Window,Worker,Worklet), Transferable]
 interface ReadableStream {
-    readonly attribute boolean locked;
-    Promise<void> cancel(optional any reason);
-    ReadableStreamBYOBReader getReader(any options);
-    ReadableStreamDefaultReader getReader();
-    any pipeThrough(any pair, optional PipeOptions options);
-    Promise<void> pipeTo(WritableStream dest, optional PipeOptions options);
-    [ReadableStream, ReadableStream] tee();
-};
+  constructor(optional object underlyingSource, optional QueuingStrategy strategy = {});
 
-callback QueuingStrategySizeCallback = double (any chunk);
+  readonly attribute boolean locked;
 
-dictionary QueuingStrategy {
-	unrestricted double? highWaterMark;
-	QueuingStrategySizeCallback? size;
+  Promise<undefined> cancel(optional any reason);
+  ReadableStreamReader getReader(optional ReadableStreamGetReaderOptions options = {});
+  ReadableStream pipeThrough(ReadableWritablePair transform, optional StreamPipeOptions options = {});
+  Promise<undefined> pipeTo(WritableStream destination, optional StreamPipeOptions options = {});
+  sequence<ReadableStream> tee();
+
+  async iterable<any>(optional ReadableStreamIteratorOptions options = {});
 };
 
-callback ReadableByteStreamControllerCallback = any (ReadableByteStreamController controller);
-callback ReadableStreamDefaultControllerCallback = any (ReadableStreamDefaultController controller);
-callback ReadableStreamErrorCallback = any (any reason);
+typedef (ReadableStreamDefaultReader or ReadableStreamBYOBReader) ReadableStreamReader;
 
-dictionary UnderlyingSource {
-    ReadableStreamDefaultControllerCallback? start;
-    ReadableStreamDefaultControllerCallback? pull;
-    ReadableStreamErrorCallback? cancel;
+enum ReadableStreamReaderMode { "byob" };
 
-    any type;
+dictionary ReadableStreamGetReaderOptions {
+  ReadableStreamReaderMode mode;
 };
 
-dictionary UnderlyingByteSource {
-    ReadableByteStreamControllerCallback? start;
-    ReadableByteStreamControllerCallback? pull;
-    ReadableStreamErrorCallback? cancel;
-
-    required DOMString type;
-    unsigned long? autoAllocateChunkSize;
+dictionary ReadableStreamIteratorOptions {
+  boolean preventCancel = false;
 };
 
-dictionary PipeOptions {
-    boolean? preventClose;
-    boolean? preventAbort;
-    boolean? preventCancel;
-    AbortSignal? signal;
+dictionary ReadableWritablePair {
+  required ReadableStream readable;
+  required WritableStream writable;
 };
 
-dictionary ReadableStreamReadValueResult {
-    required boolean done;
-    required any value;
+dictionary StreamPipeOptions {
+  boolean preventClose = false;
+  boolean preventAbort = false;
+  boolean preventCancel = false;
+  AbortSignal signal;
 };
 
-dictionary ReadableStreamReadDoneResult {
-    required boolean done;
-    any value;
+dictionary UnderlyingSource {
+  UnderlyingSourceStartCallback start;
+  UnderlyingSourcePullCallback pull;
+  UnderlyingSourceCancelCallback cancel;
+  ReadableStreamType type;
+  [EnforceRange] unsigned long long autoAllocateChunkSize;
 };
 
-[Exposed=(Window,Worker)]
-typedef (ReadableStreamReadValueResult or ReadableStreamReadDoneResult) ReadableStreamReadResult;
+typedef (ReadableStreamDefaultController or ReadableByteStreamController) ReadableStreamController;
+
+callback UnderlyingSourceStartCallback = any (ReadableStreamController controller);
+callback UnderlyingSourcePullCallback = Promise<undefined> (ReadableStreamController controller);
+callback UnderlyingSourceCancelCallback = Promise<undefined> (optional any reason);
+
+enum ReadableStreamType { "bytes" };
+
+interface mixin ReadableStreamGenericReader {
+  readonly attribute Promise<undefined> closed;
 
-[Exposed=(Window,Worker)]
+  Promise<undefined> cancel(optional any reason);
+};
+
+[Exposed=(Window,Worker,Worklet)]
 interface ReadableStreamDefaultReader {
-    readonly attribute Promise<void> closed;
+  constructor(ReadableStream stream);
 
-    Promise<void> cancel(optional any reason);
-    Promise<ReadableStreamReadResult> read();
-    void releaseLock();
+  Promise<ReadableStreamDefaultReadResult> read();
+  undefined releaseLock();
 };
+ReadableStreamDefaultReader includes ReadableStreamGenericReader;
 
-[Exposed=(Window,Worker)]
+dictionary ReadableStreamDefaultReadResult {
+ any value;
+ boolean done;
+};
+
+[Exposed=(Window,Worker,Worklet)]
 interface ReadableStreamBYOBReader {
-    readonly attribute Promise<void> closed;
+  constructor(ReadableStream stream);
 
-    Promise<void> cancel(optional any reason);
-    Promise<ReadableStreamReadResult> read(ArrayBufferView view);
-    void releaseLock();
+  Promise<ReadableStreamBYOBReadResult> read(ArrayBufferView view);
+  undefined releaseLock();
 };
+ReadableStreamBYOBReader includes ReadableStreamGenericReader;
 
-[Exposed=(Window,Worker)]
+dictionary ReadableStreamBYOBReadResult {
+ ArrayBufferView value;
+ boolean done;
+};
+
+[Exposed=(Window,Worker,Worklet)]
 interface ReadableStreamDefaultController {
-    readonly attribute unrestricted double? desiredSize;
+  readonly attribute unrestricted double? desiredSize;
 
-    void close();
-    void enqueue(any chunk);
-    void error(optional any error);
+  undefined close();
+  undefined enqueue(optional any chunk);
+  undefined error(optional any e);
 };
 
-[Exposed=(Window,Worker)]
+[Exposed=(Window,Worker,Worklet)]
 interface ReadableByteStreamController {
-    readonly attribute ReadableStreamBYOBRequest byobRequest;
-    readonly attribute unrestricted double? desiredSize;
+  readonly attribute ReadableStreamBYOBRequest? byobRequest;
+  readonly attribute unrestricted double? desiredSize;
 
-    void close();
-    void enqueue(ArrayBufferView chunk);
-    void error(optional any error);
+  undefined close();
+  undefined enqueue(ArrayBufferView chunk);
+  undefined error(optional any e);
 };
 
-[Exposed=(Window,Worker)]
+[Exposed=(Window,Worker,Worklet)]
 interface ReadableStreamBYOBRequest {
-    readonly attribute ArrayBufferView view;
+  readonly attribute ArrayBufferView? view;
 
-    void respond(unsigned long bytesWritten);
-    void respondWithNewView(ArrayBufferView view);
+  undefined respond([EnforceRange] unsigned long long bytesWritten);
+  undefined respondWithNewView(ArrayBufferView view);
 };
 
-[Constructor(optional UnderlyingSink underlyingSink, optional QueuingStrategy strategy),
- Exposed=(Window,Worker)]
+[Exposed=(Window,Worker,Worklet), Transferable]
 interface WritableStream {
-    readonly attribute boolean locked;
-    Promise<void> abort(optional any reason);
-    WritableStreamDefaultWriter getWriter();
-};
+  constructor(optional object underlyingSink, optional QueuingStrategy strategy = {});
 
-callback WritableStreamDefaultControllerStartCallback = any (WritableStreamDefaultController controller);
-callback WritableStreamDefaultControllerWriteCallback = any (any chunk, WritableStreamDefaultController controller);
-callback WritableStreamDefaultControllerCloseCallback = any ();
-callback WritableStreamErrorCallback = any (any reason);
+  readonly attribute boolean locked;
 
-dictionary UnderlyingSink {
-    WritableStreamDefaultControllerStartCallback? start;
-    WritableStreamDefaultControllerWriteCallback? write;
-    WritableStreamDefaultControllerCloseCallback? close;
-    WritableStreamErrorCallback? abort;
+  Promise<undefined> abort(optional any reason);
+  Promise<undefined> close();
+  WritableStreamDefaultWriter getWriter();
+};
 
-    any type;
+dictionary UnderlyingSink {
+  UnderlyingSinkStartCallback start;
+  UnderlyingSinkWriteCallback write;
+  UnderlyingSinkCloseCallback close;
+  UnderlyingSinkAbortCallback abort;
+  any type;
 };
 
-[Exposed=(Window,Worker)]
+callback UnderlyingSinkStartCallback = any (WritableStreamDefaultController controller);
+callback UnderlyingSinkWriteCallback = Promise<undefined> (any chunk, WritableStreamDefaultController controller);
+callback UnderlyingSinkCloseCallback = Promise<undefined> ();
+callback UnderlyingSinkAbortCallback = Promise<undefined> (optional any reason);
+
+[Exposed=(Window,Worker,Worklet)]
 interface WritableStreamDefaultWriter {
-    readonly attribute Promise<void> closed;
-    readonly attribute unrestricted double? desiredSize;
-    readonly attribute Promise<void> ready;
+  constructor(WritableStream stream);
+
+  readonly attribute Promise<undefined> closed;
+  readonly attribute unrestricted double? desiredSize;
+  readonly attribute Promise<undefined> ready;
 
-    Promise<void> abort(optional any reason);
-    Promise<void> close();
-    void releaseLock();
-    Promise<void> write(any chunk);
+  Promise<undefined> abort(optional any reason);
+  Promise<undefined> close();
+  undefined releaseLock();
+  Promise<undefined> write(optional any chunk);
 };
 
-[Exposed=(Window,Worker)]
+[Exposed=(Window,Worker,Worklet)]
 interface WritableStreamDefaultController {
-    void error(optional any error);
+  undefined error(optional any e);
 };
 
-[Constructor(optional Transformer transformer, optional QueuingStrategy writableStrategy, optional QueuingStrategy readableStrategy),
- Exposed=(Window,Worker)]
+[Exposed=(Window,Worker,Worklet), Transferable]
 interface TransformStream {
-    readonly attribute ReadableStream readable;
-    readonly attribute WritableStream writable;
-};
+  constructor(optional object transformer,
+              optional QueuingStrategy writableStrategy = {},
+              optional QueuingStrategy readableStrategy = {});
 
-callback TransformStreamDefaultControllerCallback = any (TransformStreamDefaultController controller);
-callback TransformStreamDefaultControllerTransformCallback = any (any chunk, TransformStreamDefaultController controller);
+  readonly attribute ReadableStream readable;
+  readonly attribute WritableStream writable;
+};
 
 dictionary Transformer {
-    TransformStreamDefaultControllerCallback? start;
-    TransformStreamDefaultControllerTransformCallback? transform;
-    TransformStreamDefaultControllerCallback? flush;
-
-    any readableType;
-    any writableType;
+  TransformerStartCallback start;
+  TransformerTransformCallback transform;
+  TransformerFlushCallback flush;
+  any readableType;
+  any writableType;
 };
 
-[Exposed=(Window,Worker)]
+callback TransformerStartCallback = any (TransformStreamDefaultController controller);
+callback TransformerFlushCallback = Promise<undefined> (TransformStreamDefaultController controller);
+callback TransformerTransformCallback = Promise<undefined> (any chunk, TransformStreamDefaultController controller);
+
+[Exposed=(Window,Worker,Worklet)]
 interface TransformStreamDefaultController {
-    readonly attribute unrestricted double? desiredSize;
+  readonly attribute unrestricted double? desiredSize;
 
-    void enqueue(any chunk);
-    void error(optional any reason);
-    void terminate();
+  undefined enqueue(optional any chunk);
+  undefined error(optional any reason);
+  undefined terminate();
 };
 
-[Constructor(any options),
- Exposed=(Window,Worker)]
-interface ByteLengthQueuingStrategy: QueuingStrategy {
-    attribute unrestricted double highWaterMark;
-    double size(ArrayBufferView chunk);
+dictionary QueuingStrategy {
+  unrestricted double highWaterMark;
+  QueuingStrategySize size;
+};
+
+callback QueuingStrategySize = unrestricted double (optional any chunk);
+
+dictionary QueuingStrategyInit {
+  required unrestricted double highWaterMark;
+};
+
+[Exposed=(Window,Worker,Worklet)]
+interface ByteLengthQueuingStrategy {
+  constructor(QueuingStrategyInit init);
+
+  readonly attribute unrestricted double highWaterMark;
+  readonly attribute Function size;
+};
+
+[Exposed=(Window,Worker,Worklet)]
+interface CountQueuingStrategy {
+  constructor(QueuingStrategyInit init);
+
+  readonly attribute unrestricted double highWaterMark;
+  readonly attribute Function size;
 };
 
-[Constructor(any options),
- Exposed=(Window,Worker)]
-interface CountQueuingStrategy: QueuingStrategy {
-    attribute unrestricted double highWaterMark;
-    double size(any chunk);
+interface mixin GenericTransformStream {
+  readonly attribute ReadableStream readable;
+  readonly attribute WritableStream writable;
 };

inputfiles/removedTypes.json

@@ -59,6 +59,8 @@
     "enums": {
         "enum": {
             "ClientType": null,
+            "ReadableStreamReaderMode": null,
+            "ReadableStreamType": null,
             "RequestType": null
         }
     },
@@ -246,6 +248,13 @@
             "PasswordCredential": null,
             "Position": null,
             "PositionError": null,
+            "ReadableByteStreamController": null,
+            "ReadableStream": {
+                "iterator": null
+            },
+            "ReadableStreamBYOBReader": null,
+            "ReadableStreamBYOBRequest": null,
+            "ReadableStreamReader": null,
             "RTCDataChannel": {
                 "properties": {
                     "property": {
@@ -384,6 +393,13 @@
                     "WindowConsole"
                 ]
             },
+            "WritableStream": {
+                "methods": {
+                    "method": {
+                        "close": null
+                    }
+                }
+            },
             "XPathNSResolver": null
         }
     },
@@ -406,12 +422,22 @@
                 }
             },
             "ObjectURLOptions": null,
+            "ReadableStreamBYOBReadResult": null,
+            "ReadableStreamDefaultReadResult": null,
+            "ReadableStreamGetReaderOptions": null,
             "RTCIceGatherOptions": {
                 "members": {
                     "member": {
                         "portRange": null
                     }
                 }
+            },
+            "UnderlyingSource": {
+                "members": {
+                    "member": {
+                        "autoAllocateChunkSize": null
+                    }
+                }
             }
         }
     },

src/idlfetcher.ts

@@ -10,7 +10,6 @@ interface IDLSource {
     url: string;
     title: string;
     deprecated?: boolean;
-    local?: boolean;
 }
 
 const idlSelector = [
@@ -30,9 +29,6 @@ async function fetchIDLs(filter: string[]) {
     const idlSources = (require("../inputfiles/idlSources.json") as IDLSource[])
         .filter(source => !filter.length || filter.includes(source.title));
     await Promise.all(idlSources.map(async source => {
-        if (source.local) {
-            return;
-        }
         const { idl, comments } = await fetchIDL(source);
         fs.writeFileSync(path.join(__dirname, `../inputfiles/idl/${source.title}.widl`), idl + '\n');
         if (comments) {