├── .prettierrc.json
├── util.ts
├── router.ts
├── index.ts
├── LICENSE
└── index.d.ts


/.prettierrc.json:
--------------------------------------------------------------------------------
1 | {
2 |   "singleQuote": true,
3 |   "trailingComma": "all"
4 | }
5 | 


--------------------------------------------------------------------------------
/util.ts:
--------------------------------------------------------------------------------
1 | /**
2 |  * Get own property `prop` from `obj`.
3 |  */
4 | export const getOwn = <T, P extends keyof T>(
5 |   obj: T,
6 |   prop: P,
7 | ): T[P] | undefined =>
8 |   Object.prototype.hasOwnProperty.call(obj, prop) ? obj[prop] : undefined;
9 | 


--------------------------------------------------------------------------------
/router.ts:
--------------------------------------------------------------------------------
 1 | import { getOwn } from './util.ts';
 2 | 
 3 | export type RouteHandler = (
 4 |   url: URL,
 5 |   request: Request,
 6 | ) => Promise<Response> | Response;
 7 | type Route = RouteHandler | { [method: string]: RouteHandler };
 8 | 
 9 | const router = new Map<string, Route>();
10 | 
11 | function getRouteFunction(
12 |   route: Route,
13 |   method: string,
14 | ): RouteHandler | undefined {
15 |   if (typeof route === 'function') {
16 |     if (method === 'GET') return route;
17 |     return undefined;
18 |   }
19 | 
20 |   return getOwn(route, method) || getOwn(route, 'all');
21 | }
22 | 
23 | export const simpleErrorResponse = (status: number, message: string) =>
24 |   new Response(message, {
25 |     status,
26 |     headers: { 'Content-Type': 'text/plain' },
27 |   });
28 | 
29 | async function handleRequest(request: Request): Promise<Response> {
30 |   const url = new URL(request.url);
31 | 
32 |   const route = router.get(url.pathname);
33 | 
34 |   if (!route) return simpleErrorResponse(404, 'Not found');
35 | 
36 |   const routeHandler = getRouteFunction(route, request.method);
37 | 
38 |   if (!routeHandler) return simpleErrorResponse(405, 'Method not allowed');
39 | 
40 |   try {
41 |     return await routeHandler(url, request);
42 |   } catch (error) {
43 |     console.log(error);
44 |     return simpleErrorResponse(500, 'Internal server error');
45 |   }
46 | }
47 | 
48 | export function addRoute(path: string, route: Route) {
49 |   router.set(path, route);
50 | }
51 | 
52 | addEventListener('fetch', (event) =>
53 |   event.respondWith(handleRequest(event.request)),
54 | );
55 | 


--------------------------------------------------------------------------------
/index.ts:
--------------------------------------------------------------------------------
  1 | import { addRoute } from './router.ts';
  2 | 
  3 | addRoute('/psl', async () => {
  4 |   const pslResponse = await fetch(
  5 |     'https://publicsuffix.org/list/public_suffix_list.dat',
  6 |   );
  7 | 
  8 |   return new Response(pslResponse.body, {
  9 |     headers: {
 10 |       ...Object.fromEntries(pslResponse.headers),
 11 |       'Content-Security-Policy': 'sandbox',
 12 |       'Access-Control-Allow-Origin': '*',
 13 |     },
 14 |   });
 15 | });
 16 | 
 17 | type KeyValue = [key: string, value: string];
 18 | 
 19 | interface Details {
 20 |   preflightHeaders?: KeyValue[];
 21 |   headers?: KeyValue[];
 22 |   method?: string;
 23 | }
 24 | const detailsMap = new Map<string, Details>();
 25 | 
 26 | function getDetails(id: string | null): Details {
 27 |   // Just return a dummy object to make things easier.
 28 |   if (!id) return {};
 29 |   if (!detailsMap.has(id)) {
 30 |     detailsMap.set(id, {});
 31 |     // Only keep details around for a minute:
 32 |     setTimeout(() => detailsMap.delete(id), 60_000);
 33 |   }
 34 |   return detailsMap.get(id)!;
 35 | }
 36 | 
 37 | addRoute('/resource', {
 38 |   OPTIONS(url, request) {
 39 |     const details = getDetails(url.searchParams.get('id'));
 40 |     details.preflightHeaders = [...request.headers];
 41 |     const headers = new Headers();
 42 |     const status = Number(url.searchParams.get('preflight-status')) || 204;
 43 | 
 44 |     for (const acHeader of [
 45 |       'allow-origin',
 46 |       'allow-credentials',
 47 |       'allow-methods',
 48 |       'allow-headers',
 49 |     ]) {
 50 |       const fullHeader = `access-control-${acHeader}`;
 51 |       const queryKey = `preflight-${fullHeader}`;
 52 |       const value = url.searchParams.get(queryKey);
 53 |       if (value) headers.set(fullHeader, url.searchParams.get(queryKey)!);
 54 |     }
 55 | 
 56 |     return new Response(null, { status, headers });
 57 |   },
 58 |   all(url, request) {
 59 |     const details = getDetails(url.searchParams.get('id'));
 60 |     details.headers = [...request.headers];
 61 |     details.method = request.method;
 62 |     const headers = new Headers({
 63 |       foo: 'bar',
 64 |       hello: 'world',
 65 |       'Content-Type': 'text/plain; charset=utf-8',
 66 |       vary: 'cookie, origin',
 67 |     });
 68 |     const status = Number(url.searchParams.get('status')) || 200;
 69 | 
 70 |     for (const acHeader of [
 71 |       'allow-origin',
 72 |       'allow-credentials',
 73 |       'expose-headers',
 74 |     ]) {
 75 |       const fullHeader = `access-control-${acHeader}`;
 76 |       const value = url.searchParams.get(fullHeader);
 77 |       if (value) headers.set(fullHeader, url.searchParams.get(fullHeader)!);
 78 |     }
 79 | 
 80 |     const cookieValues = url.searchParams.getAll('cookie-value');
 81 | 
 82 |     for (const [i, name] of url.searchParams.getAll('cookie-name').entries()) {
 83 |       const value = cookieValues[i] || '';
 84 |       headers.append(
 85 |         'Set-Cookie',
 86 |         encodeURIComponent(name) +
 87 |           '=' +
 88 |           encodeURIComponent(value) +
 89 |           '; Max-Age=86400; SameSite=None; Secure',
 90 |       );
 91 |     }
 92 | 
 93 |     return new Response(status === 204 ? null : 'response! 😀', {
 94 |       status,
 95 |       headers,
 96 |     });
 97 |   },
 98 | });
 99 | 
100 | addRoute('/resource-details', (url) => {
101 |   const details = getDetails(url.searchParams.get('id'));
102 |   return new Response(JSON.stringify(details), {
103 |     headers: {
104 |       'Content-Type': 'application/json',
105 |       'Access-Control-Allow-Origin': '*',
106 |     },
107 |   });
108 | });
109 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright [yyyy] [name of copyright owner]
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/index.d.ts:
--------------------------------------------------------------------------------
   1 | // Copyright 2018-2021 Deno Land Inc. All rights reserved. MIT license.
   2 | 
   3 | // deno-lint-ignore-file
   4 | 
   5 | /// <reference no-default-lib="true" />
   6 | /// <reference lib="esnext" />
   7 | 
   8 | /** Deno provides extra properties on `import.meta`.  These are included here
   9 |  * to ensure that these are still available when using the Deno namespace in
  10 |  * conjunction with other type libs, like `dom`. */
  11 | declare interface ImportMeta {
  12 |   /** A string representation of the fully qualified module URL. */
  13 |   url: string;
  14 | 
  15 |   /** A flag that indicates if the current module is the main module that was
  16 |    * called when starting the program under Deno.
  17 |    *
  18 |    * ```ts
  19 |    * if (import.meta.main) {
  20 |    *   // this was loaded as the main module, maybe do some bootstrapping
  21 |    * }
  22 |    * ```
  23 |    */
  24 |   main: boolean;
  25 | }
  26 | 
  27 | declare namespace Deno {
  28 |   export const env: {
  29 |     /** Retrieve the value of an environment variable. Returns undefined if that
  30 |      * key doesn't exist.
  31 |      *
  32 |      * ```ts
  33 |      * console.log(Deno.env.get("HOME"));  // e.g. outputs "/home/alice"
  34 |      * console.log(Deno.env.get("MADE_UP_VAR"));  // outputs "Undefined"
  35 |      * ```
  36 |      */
  37 |     get(key: string): string | undefined;
  38 | 
  39 |     /** Set the value of an environment variable.
  40 |      *
  41 |      * ```ts
  42 |      * Deno.env.set("SOME_VAR", "Value"));
  43 |      * Deno.env.get("SOME_VAR");  // outputs "Value"
  44 |      * ```
  45 |      */
  46 |     set(key: string, value: string): void;
  47 | 
  48 |     /** Delete the value of an environment variable.
  49 |      *
  50 |      * ```ts
  51 |      * Deno.env.set("SOME_VAR", "Value"));
  52 |      * Deno.env.delete("SOME_VAR");  // outputs "Undefined"
  53 |      * ```
  54 |      */
  55 |     delete(key: string): void;
  56 | 
  57 |     /** Returns a snapshot of the environment variables at invocation.
  58 |      *
  59 |      * ```ts
  60 |      * Deno.env.set("TEST_VAR", "A");
  61 |      * const myEnv = Deno.env.toObject();
  62 |      * console.log(myEnv.SHELL);
  63 |      * Deno.env.set("TEST_VAR", "B");
  64 |      * console.log(myEnv.TEST_VAR);  // outputs "A"
  65 |      * ```
  66 |      */
  67 |     toObject(): { [index: string]: string };
  68 |   };
  69 | 
  70 |   /** Build related information. */
  71 |   export const build: {
  72 |     /** The LLVM target triple */
  73 |     target: string;
  74 |     /** Instruction set architecture */
  75 |     arch: "x86_64";
  76 |     /** Operating system */
  77 |     os: "darwin" | "linux" | "windows";
  78 |     /** Computer vendor */
  79 |     vendor: string;
  80 |     /** Optional environment */
  81 |     env?: string;
  82 |   };
  83 | 
  84 |   /** Reflects the `NO_COLOR` environment variable. This is always set to `true`
  85 |    * on Deno Deploy, as the logs page supports ANSI colors.
  86 |    *
  87 |    * See: https://no-color.org/ */
  88 |   export const noColor: boolean;
  89 | 
  90 |   export interface InspectOptions {
  91 |     /** Stylize output with ANSI colors. Defaults to false. */
  92 |     colors?: boolean;
  93 |     /** Try to fit more than one entry of a collection on the same line.
  94 |      * Defaults to true. */
  95 |     compact?: boolean;
  96 |     /** Traversal depth for nested objects. Defaults to 4. */
  97 |     depth?: number;
  98 |     /** The maximum number of iterable entries to print. Defaults to 100. */
  99 |     iterableLimit?: number;
 100 |     /** Show a Proxy's target and handler. Defaults to false. */
 101 |     showProxy?: boolean;
 102 |     /** Sort Object, Set and Map entries by key. Defaults to false. */
 103 |     sorted?: boolean;
 104 |     /** Add a trailing comma for multiline collections. Defaults to false. */
 105 |     trailingComma?: boolean;
 106 |     /*** Evaluate the result of calling getters. Defaults to false. */
 107 |     getters?: boolean;
 108 |     /** Show an object's non-enumerable properties. Defaults to false. */
 109 |     showHidden?: boolean;
 110 |   }
 111 | 
 112 |   /** Converts the input into a string that has the same format as printed by
 113 |    * `console.log()`.
 114 |    *
 115 |    * ```ts
 116 |    * const obj = {};
 117 |    * obj.propA = 10;
 118 |    * obj.propB = "hello";
 119 |    * const objAsString = Deno.inspect(obj); // { propA: 10, propB: "hello" }
 120 |    * console.log(obj);  // prints same value as objAsString, e.g. { propA: 10, propB: "hello" }
 121 |    * ```
 122 |    *
 123 |    * You can also register custom inspect functions, via the `customInspect` Deno
 124 |    * symbol on objects, to control and customize the output.
 125 |    *
 126 |    * ```ts
 127 |    * class A {
 128 |    *   x = 10;
 129 |    *   y = "hello";
 130 |    *   [Deno.customInspect](): string {
 131 |    *     return "x=" + this.x + ", y=" + this.y;
 132 |    *   }
 133 |    * }
 134 |    * ```
 135 |    *
 136 |    *      const inStringFormat = Deno.inspect(new A()); // "x=10, y=hello"
 137 |    *      console.log(inStringFormat);  // prints "x=10, y=hello"
 138 |    *
 139 |    * Finally, you can also specify the depth to which it will format.
 140 |    *
 141 |    *      Deno.inspect({a: {b: {c: {d: 'hello'}}}}, {depth: 2}); // { a: { b: [Object] } }
 142 |    *
 143 |    */
 144 |   export function inspect(value: unknown, options?: InspectOptions): string;
 145 | 
 146 |   export interface NetAddr {
 147 |     transport: "tcp" | "udp";
 148 |     hostname: string;
 149 |     port: number;
 150 |   }
 151 | 
 152 |   export type Addr = NetAddr;
 153 | 
 154 |   export interface Reader {
 155 |     /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number of
 156 |      * bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
 157 |      * encountered. Even if `read()` resolves to `n` < `p.byteLength`, it may
 158 |      * use all of `p` as scratch space during the call. If some data is
 159 |      * available but not `p.byteLength` bytes, `read()` conventionally resolves
 160 |      * to what is available instead of waiting for more.
 161 |      *
 162 |      * When `read()` encounters end-of-file condition, it resolves to EOF
 163 |      * (`null`).
 164 |      *
 165 |      * When `read()` encounters an error, it rejects with an error.
 166 |      *
 167 |      * Callers should always process the `n` > `0` bytes returned before
 168 |      * considering the EOF (`null`). Doing so correctly handles I/O errors that
 169 |      * happen after reading some bytes and also both of the allowed EOF
 170 |      * behaviors.
 171 |      *
 172 |      * Implementations should not retain a reference to `p`.
 173 |      *
 174 |      * Use iter() from https://deno.land/std/io/util.ts to turn a Reader into an
 175 |      * AsyncIterator.
 176 |      */
 177 |     read(p: Uint8Array): Promise<number | null>;
 178 |   }
 179 | 
 180 |   export interface Writer {
 181 |     /** Writes `p.byteLength` bytes from `p` to the underlying data stream. It
 182 |      * resolves to the number of bytes written from `p` (`0` <= `n` <=
 183 |      * `p.byteLength`) or reject with the error encountered that caused the
 184 |      * write to stop early. `write()` must reject with a non-null error if
 185 |      * would resolve to `n` < `p.byteLength`. `write()` must not modify the
 186 |      * slice data, even temporarily.
 187 |      *
 188 |      * Implementations should not retain a reference to `p`.
 189 |      */
 190 |     write(p: Uint8Array): Promise<number>;
 191 |   }
 192 | 
 193 |   export interface Closer {
 194 |     close(): void;
 195 |   }
 196 | 
 197 |   export interface Conn extends Reader, Writer, Closer {
 198 |     /** The local address of the connection. */
 199 |     readonly localAddr: Addr;
 200 |     /** The remote address of the connection. */
 201 |     readonly remoteAddr: Addr;
 202 |     /** The resource ID of the connection. */
 203 |     readonly rid: number;
 204 |     /** Shuts down (`shutdown(2)`) the write side of the connection. Most
 205 |    * callers should just use `close()`. */
 206 |     closeWrite(): Promise<void>;
 207 |   }
 208 | 
 209 |   /** A generic network listener for stream-oriented protocols. */
 210 |   export interface Listener extends AsyncIterable<Conn> {
 211 |     /** Waits for and resolves to the next connection to the `Listener`. */
 212 |     accept(): Promise<Conn>;
 213 |     /** Close closes the listener. Any pending accept promises will be rejected
 214 |      * with errors. */
 215 |     close(): void;
 216 |     /** Return the address of the `Listener`. */
 217 |     readonly addr: Addr;
 218 | 
 219 |     /** Return the rid of the `Listener`. */
 220 |     readonly rid: number;
 221 | 
 222 |     [Symbol.asyncIterator](): AsyncIterableIterator<Conn>;
 223 |   }
 224 | 
 225 |   export interface ListenOptions {
 226 |     /** The port to listen on. */
 227 |     port: number;
 228 |     /** A literal IP address or host name that can be resolved to an IP address.
 229 |     * If not specified, defaults to `0.0.0.0`. */
 230 |     hostname?: string;
 231 |   }
 232 | 
 233 |   /** Listen announces on the local transport address.
 234 |    *
 235 |    * ```ts
 236 |    * const listener1 = Deno.listen({ port: 80 })
 237 |    * const listener2 = Deno.listen({ hostname: "192.0.2.1", port: 80 })
 238 |    * const listener3 = Deno.listen({ hostname: "[2001:db8::1]", port: 80 });
 239 |    * const listener4 = Deno.listen({ hostname: "golang.org", port: 80, transport: "tcp" });
 240 |    * ```
 241 |    *
 242 |    * Requires `allow-net` permission. */
 243 |   export function listen(
 244 |     options: ListenOptions & { transport?: "tcp" },
 245 |   ): Listener;
 246 | 
 247 |   export interface RequestEvent {
 248 |     readonly request: Request;
 249 |     respondWith(r: Response | Promise<Response>): Promise<void>;
 250 |   }
 251 | 
 252 |   export interface HttpConn extends AsyncIterable<RequestEvent> {
 253 |     readonly rid: number;
 254 | 
 255 |     nextRequest(): Promise<RequestEvent | null>;
 256 |     close(): void;
 257 |   }
 258 | 
 259 |   /**
 260 |    * Services HTTP requests given a TCP or TLS socket.
 261 |    *
 262 |    * ```ts
 263 |    * const conn = await Deno.connect({ port: 80, hostname: "127.0.0.1" });
 264 |    * const httpConn = Deno.serveHttp(conn);
 265 |    * const e = await httpConn.nextRequest();
 266 |    * if (e) {
 267 |    *   e.respondWith(new Response("Hello World"));
 268 |    * }
 269 |    * ```
 270 |    *
 271 |    * If `httpConn.nextRequest()` encounters an error or returns `null`
 272 |    * then the underlying HttpConn resource is closed automatically.
 273 |    *
 274 |    * Alternatively, you can also use the Async Iterator approach:
 275 |    *
 276 |    * ```ts
 277 |    * async function handleHttp(conn: Deno.Conn) {
 278 |    *   for await (const e of Deno.serveHttp(conn)) {
 279 |    *     e.respondWith(new Response("Hello World"));
 280 |    *   }
 281 |    * }
 282 |    *
 283 |    * for await (const conn of Deno.listen({ port: 80 })) {
 284 |    *   handleHttp(conn);
 285 |    * }
 286 |    * ```
 287 |    */
 288 |   export function serveHttp(conn: Conn): HttpConn;
 289 | 
 290 |   export interface WebSocketUpgrade {
 291 |     response: Response;
 292 |     socket: WebSocket;
 293 |   }
 294 | 
 295 |   export interface UpgradeWebSocketOptions {
 296 |     protocol?: string;
 297 |   }
 298 | 
 299 |   /** Used to upgrade an incoming HTTP request to a WebSocket.
 300 |    *
 301 |    * Given a request, returns a pair of WebSocket and Response. The original
 302 |    * request must be responded to with the returned response for the websocket
 303 |    * upgrade to be successful.
 304 |    *
 305 |    * ```ts
 306 |    * const conn = await Deno.connect({ port: 80, hostname: "127.0.0.1" });
 307 |    * const httpConn = Deno.serveHttp(conn);
 308 |    * const e = await httpConn.nextRequest();
 309 |    * if (e) {
 310 |    *   const { socket, response } = Deno.upgradeWebSocket(e.request);
 311 |    *   socket.onopen = () => {
 312 |    *     socket.send("Hello World!");
 313 |    *   };
 314 |    *   socket.onmessage = (e) => {
 315 |    *     console.log(e.data);
 316 |    *     socket.close();
 317 |    *   };
 318 |    *   socket.onclose = () => console.log("WebSocket has been closed.");
 319 |    *   socket.onerror = (e) => console.error("WebSocket error:", e.message);
 320 |    *   e.respondWith(response);
 321 |    * }
 322 |    * ```
 323 |    *
 324 |    * If the request body is disturbed (read from) before the upgrade is
 325 |    * completed, upgrading fails.
 326 |    *
 327 |    * This operation does not yet consume the request or open the websocket. This
 328 |    * only happens once the returned response has been passed to `respondWith`.
 329 |    */
 330 |   export function upgradeWebSocket(
 331 |     request: Request,
 332 |     options?: UpgradeWebSocketOptions,
 333 |   ): WebSocketUpgrade;
 334 | 
 335 |   /** Asynchronously reads and returns the entire contents of a file as utf8
 336 |    *  encoded string. Reading a directory throws an error.
 337 |    *
 338 |    * ```ts
 339 |    * const data = await Deno.readTextFile("hello.txt");
 340 |    * console.log(data);
 341 |    * ```
 342 |    */
 343 |   export function readTextFile(path: string | URL): Promise<string>;
 344 | 
 345 |   /** Reads and resolves to the entire contents of a file as an array of bytes.
 346 |    * `TextDecoder` can be used to transform the bytes to string if required.
 347 |    * Reading a directory returns an empty data array.
 348 |    *
 349 |    * ```ts
 350 |    * const decoder = new TextDecoder("utf-8");
 351 |    * const data = await Deno.readFile("hello.txt");
 352 |    * console.log(decoder.decode(data));
 353 |    * ```
 354 |    */
 355 |   export function readFile(path: string | URL): Promise<Uint8Array>;
 356 | 
 357 |   /**
 358 |    * Return a string representing the current working directory.
 359 |    *
 360 |    * If the current directory can be reached via multiple paths (due to symbolic
 361 |    * links), `cwd()` may return any one of them.
 362 |    *
 363 |    * ```ts
 364 |    * const currentWorkingDirectory = Deno.cwd();
 365 |    * ```
 366 |    *
 367 |    * Throws `Deno.errors.NotFound` if directory not available.
 368 |    */
 369 |   export function cwd(): string;
 370 | }
 371 | 
 372 | // Copyright 2018-2021 Deno Land Inc. All rights reserved. MIT license.
 373 | 
 374 | // deno-lint-ignore-file
 375 | 
 376 | // Documentation partially adapted from [MDN](https://developer.mozilla.org/),
 377 | // by Mozilla Contributors, which is licensed under CC-BY-SA 2.5.
 378 | 
 379 | /// <reference no-default-lib="true" />
 380 | /// <reference lib="esnext" />
 381 | 
 382 | declare class DOMException extends Error {
 383 |   constructor(message?: string, name?: string);
 384 |   readonly name: string;
 385 |   readonly message: string;
 386 |   readonly code: number;
 387 | }
 388 | 
 389 | interface EventInit {
 390 |   bubbles?: boolean;
 391 |   cancelable?: boolean;
 392 |   composed?: boolean;
 393 | }
 394 | 
 395 | /** An event which takes place in the DOM. */
 396 | declare class Event {
 397 |   constructor(type: string, eventInitDict?: EventInit);
 398 |   /** Returns true or false depending on how event was initialized. True if
 399 |    * event goes through its target's ancestors in reverse tree order, and
 400 |    * false otherwise. */
 401 |   readonly bubbles: boolean;
 402 |   cancelBubble: boolean;
 403 |   /** Returns true or false depending on how event was initialized. Its return
 404 |    * value does not always carry meaning, but true can indicate that part of the
 405 |    * operation during which event was dispatched, can be canceled by invoking
 406 |    * the preventDefault() method. */
 407 |   readonly cancelable: boolean;
 408 |   /** Returns true or false depending on how event was initialized. True if
 409 |    * event invokes listeners past a ShadowRoot node that is the root of its
 410 |    * target, and false otherwise. */
 411 |   readonly composed: boolean;
 412 |   /** Returns the object whose event listener's callback is currently being
 413 |    * invoked. */
 414 |   readonly currentTarget: EventTarget | null;
 415 |   /** Returns true if preventDefault() was invoked successfully to indicate
 416 |    * cancellation, and false otherwise. */
 417 |   readonly defaultPrevented: boolean;
 418 |   /** Returns the event's phase, which is one of NONE, CAPTURING_PHASE,
 419 |    * AT_TARGET, and BUBBLING_PHASE. */
 420 |   readonly eventPhase: number;
 421 |   /** Returns true if event was dispatched by the user agent, and false
 422 |    * otherwise. */
 423 |   readonly isTrusted: boolean;
 424 |   /** Returns the object to which event is dispatched (its target). */
 425 |   readonly target: EventTarget | null;
 426 |   /** Returns the event's timestamp as the number of milliseconds measured
 427 |    * relative to the time origin. */
 428 |   readonly timeStamp: number;
 429 |   /** Returns the type of event, e.g. "click", "hashchange", or "submit". */
 430 |   readonly type: string;
 431 |   /** Returns the invocation target objects of event's path (objects on which
 432 |    * listeners will be invoked), except for any nodes in shadow trees of which
 433 |    * the shadow root's mode is "closed" that are not reachable from event's
 434 |    * currentTarget. */
 435 |   composedPath(): EventTarget[];
 436 |   /** If invoked when the cancelable attribute value is true, and while
 437 |    * executing a listener for the event with passive set to false, signals to
 438 |    * the operation that caused event to be dispatched that it needs to be
 439 |    * canceled. */
 440 |   preventDefault(): void;
 441 |   /** Invoking this method prevents event from reaching any registered event
 442 |    * listeners after the current one finishes running and, when dispatched in a
 443 |    * tree, also prevents event from reaching any other objects. */
 444 |   stopImmediatePropagation(): void;
 445 |   /** When dispatched in a tree, invoking this method prevents event from
 446 |    * reaching any objects other than the current object. */
 447 |   stopPropagation(): void;
 448 |   readonly AT_TARGET: number;
 449 |   readonly BUBBLING_PHASE: number;
 450 |   readonly CAPTURING_PHASE: number;
 451 |   readonly NONE: number;
 452 |   static readonly AT_TARGET: number;
 453 |   static readonly BUBBLING_PHASE: number;
 454 |   static readonly CAPTURING_PHASE: number;
 455 |   static readonly NONE: number;
 456 | }
 457 | 
 458 | /**
 459 |  * EventTarget is a DOM interface implemented by objects that can receive events
 460 |  * and may have listeners for them.
 461 |  */
 462 | declare class EventTarget {
 463 |   /** Appends an event listener for events whose type attribute value is type.
 464 |    * The callback argument sets the callback that will be invoked when the event
 465 |    * is dispatched.
 466 |    *
 467 |    * The options argument sets listener-specific options. For compatibility this
 468 |    * can be a boolean, in which case the method behaves exactly as if the value
 469 |    * was specified as options's capture.
 470 |    *
 471 |    * When set to true, options's capture prevents callback from being invoked
 472 |    * when the event's eventPhase attribute value is BUBBLING_PHASE. When false
 473 |    * (or not present), callback will not be invoked when event's eventPhase
 474 |    * attribute value is CAPTURING_PHASE. Either way, callback will be invoked if
 475 |    * event's eventPhase attribute value is AT_TARGET.
 476 |    *
 477 |    * When set to true, options's passive indicates that the callback will not
 478 |    * cancel the event by invoking preventDefault(). This is used to enable
 479 |    * performance optimizations described in § 2.8 Observing event listeners.
 480 |    *
 481 |    * When set to true, options's once indicates that the callback will only be
 482 |    * invoked once after which the event listener will be removed.
 483 |    *
 484 |    * The event listener is appended to target's event listener list and is not
 485 |    * appended if it has the same type, callback, and capture. */
 486 |   addEventListener(
 487 |     type: string,
 488 |     listener: EventListenerOrEventListenerObject | null,
 489 |     options?: boolean | AddEventListenerOptions,
 490 |   ): void;
 491 |   /** Dispatches a synthetic event event to target and returns true if either
 492 |    * event's cancelable attribute value is false or its preventDefault() method
 493 |    * was not invoked, and false otherwise. */
 494 |   dispatchEvent(event: Event): boolean;
 495 |   /** Removes the event listener in target's event listener list with the same
 496 |    * type, callback, and options. */
 497 |   removeEventListener(
 498 |     type: string,
 499 |     callback: EventListenerOrEventListenerObject | null,
 500 |     options?: EventListenerOptions | boolean,
 501 |   ): void;
 502 |   [Symbol.toStringTag]: string;
 503 | }
 504 | 
 505 | interface EventListener<Evt extends Event = Event> {
 506 |   (evt: Evt): void | Promise<void>;
 507 | }
 508 | 
 509 | interface EventListenerObject<Evt extends Event = Event> {
 510 |   handleEvent(evt: Evt): void | Promise<void>;
 511 | }
 512 | 
 513 | declare type EventListenerOrEventListenerObject<Evt extends Event = Event> =
 514 |   | EventListener<Evt>
 515 |   | EventListenerObject<Evt>;
 516 | 
 517 | interface AddEventListenerOptions extends EventListenerOptions {
 518 |   once?: boolean;
 519 |   passive?: boolean;
 520 | }
 521 | 
 522 | interface EventListenerOptions {
 523 |   capture?: boolean;
 524 | }
 525 | 
 526 | interface ProgressEventInit extends EventInit {
 527 |   lengthComputable?: boolean;
 528 |   loaded?: number;
 529 |   total?: number;
 530 | }
 531 | 
 532 | /** Events measuring progress of an underlying process, like an HTTP request
 533 |  * (for an XMLHttpRequest, or the loading of the underlying resource of an
 534 |  * <img>, <audio>, <video>, <style> or <link>). */
 535 | declare class ProgressEvent<T extends EventTarget = EventTarget> extends Event {
 536 |   constructor(type: string, eventInitDict?: ProgressEventInit);
 537 |   readonly lengthComputable: boolean;
 538 |   readonly loaded: number;
 539 |   readonly target: T | null;
 540 |   readonly total: number;
 541 | }
 542 | 
 543 | /** Decodes a string of data which has been encoded using base-64 encoding.
 544 |  *
 545 |  *     console.log(atob("aGVsbG8gd29ybGQ=")); // outputs 'hello world'
 546 |  */
 547 | declare function atob(s: string): string;
 548 | 
 549 | /** Creates a base-64 ASCII encoded string from the input string.
 550 |  *
 551 |  *     console.log(btoa("hello world"));  // outputs "aGVsbG8gd29ybGQ="
 552 |  */
 553 | declare function btoa(s: string): string;
 554 | 
 555 | declare class TextDecoder {
 556 |   /** Returns encoding's name, lowercased. */
 557 |   readonly encoding: string;
 558 |   /** Returns `true` if error mode is "fatal", and `false` otherwise. */
 559 |   readonly fatal: boolean;
 560 |   /** Returns `true` if ignore BOM flag is set, and `false` otherwise. */
 561 |   readonly ignoreBOM = false;
 562 |   constructor(
 563 |     label?: string,
 564 |     options?: { fatal?: boolean; ignoreBOM?: boolean },
 565 |   );
 566 |   /** Returns the result of running encoding's decoder. */
 567 |   decode(input?: BufferSource, options?: { stream?: false }): string;
 568 |   readonly [Symbol.toStringTag]: string;
 569 | }
 570 | 
 571 | declare class TextEncoder {
 572 |   /** Returns "utf-8". */
 573 |   readonly encoding = "utf-8";
 574 |   /** Returns the result of running UTF-8's encoder. */
 575 |   encode(input?: string): Uint8Array;
 576 |   encodeInto(
 577 |     input: string,
 578 |     dest: Uint8Array,
 579 |   ): { read: number; written: number };
 580 |   readonly [Symbol.toStringTag]: string;
 581 | }
 582 | 
 583 | /** A controller object that allows you to abort one or more DOM requests as and
 584 |  * when desired. */
 585 | declare class AbortController {
 586 |   /** Returns the AbortSignal object associated with this object. */
 587 |   readonly signal: AbortSignal;
 588 |   /** Invoking this method will set this object's AbortSignal's aborted flag and
 589 |    * signal to any observers that the associated activity is to be aborted. */
 590 |   abort(): void;
 591 | }
 592 | 
 593 | interface AbortSignalEventMap {
 594 |   abort: Event;
 595 | }
 596 | 
 597 | /** A signal object that allows you to communicate with a DOM request (such as a
 598 |  * Fetch) and abort it if required via an AbortController object. */
 599 | interface AbortSignal extends EventTarget {
 600 |   /** Returns true if this AbortSignal's AbortController has signaled to abort,
 601 |    * and false otherwise. */
 602 |   readonly aborted: boolean;
 603 |   onabort: ((this: AbortSignal, ev: Event) => any) | null;
 604 |   addEventListener<K extends keyof AbortSignalEventMap>(
 605 |     type: K,
 606 |     listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any,
 607 |     options?: boolean | AddEventListenerOptions,
 608 |   ): void;
 609 |   addEventListener(
 610 |     type: string,
 611 |     listener: EventListenerOrEventListenerObject,
 612 |     options?: boolean | AddEventListenerOptions,
 613 |   ): void;
 614 |   removeEventListener<K extends keyof AbortSignalEventMap>(
 615 |     type: K,
 616 |     listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any,
 617 |     options?: boolean | EventListenerOptions,
 618 |   ): void;
 619 |   removeEventListener(
 620 |     type: string,
 621 |     listener: EventListenerOrEventListenerObject,
 622 |     options?: boolean | EventListenerOptions,
 623 |   ): void;
 624 | }
 625 | 
 626 | declare var AbortSignal: {
 627 |   prototype: AbortSignal;
 628 |   new (): AbortSignal;
 629 | };
 630 | 
 631 | interface FileReaderEventMap {
 632 |   abort: ProgressEvent<FileReader>;
 633 |   error: ProgressEvent<FileReader>;
 634 |   load: ProgressEvent<FileReader>;
 635 |   loadend: ProgressEvent<FileReader>;
 636 |   loadstart: ProgressEvent<FileReader>;
 637 |   progress: ProgressEvent<FileReader>;
 638 | }
 639 | 
 640 | /** Lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using File or Blob objects to specify the file or data to read. */
 641 | interface FileReader extends EventTarget {
 642 |   readonly error: DOMException | null;
 643 |   onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
 644 |   onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
 645 |   onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
 646 |   onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
 647 |   onloadstart:
 648 |     | ((this: FileReader, ev: ProgressEvent<FileReader>) => any)
 649 |     | null;
 650 |   onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
 651 |   readonly readyState: number;
 652 |   readonly result: string | ArrayBuffer | null;
 653 |   abort(): void;
 654 |   readAsArrayBuffer(blob: Blob): void;
 655 |   readAsBinaryString(blob: Blob): void;
 656 |   readAsDataURL(blob: Blob): void;
 657 |   readAsText(blob: Blob, encoding?: string): void;
 658 |   readonly DONE: number;
 659 |   readonly EMPTY: number;
 660 |   readonly LOADING: number;
 661 |   addEventListener<K extends keyof FileReaderEventMap>(
 662 |     type: K,
 663 |     listener: (this: FileReader, ev: FileReaderEventMap[K]) => any,
 664 |     options?: boolean | AddEventListenerOptions,
 665 |   ): void;
 666 |   addEventListener(
 667 |     type: string,
 668 |     listener: EventListenerOrEventListenerObject,
 669 |     options?: boolean | AddEventListenerOptions,
 670 |   ): void;
 671 |   removeEventListener<K extends keyof FileReaderEventMap>(
 672 |     type: K,
 673 |     listener: (this: FileReader, ev: FileReaderEventMap[K]) => any,
 674 |     options?: boolean | EventListenerOptions,
 675 |   ): void;
 676 |   removeEventListener(
 677 |     type: string,
 678 |     listener: EventListenerOrEventListenerObject,
 679 |     options?: boolean | EventListenerOptions,
 680 |   ): void;
 681 | }
 682 | 
 683 | declare var FileReader: {
 684 |   prototype: FileReader;
 685 |   new (): FileReader;
 686 |   readonly DONE: number;
 687 |   readonly EMPTY: number;
 688 |   readonly LOADING: number;
 689 | };
 690 | 
 691 | declare class URLSearchParams {
 692 |   constructor(
 693 |     init?: string[][] | Record<string, string> | string | URLSearchParams,
 694 |   );
 695 |   static toString(): string;
 696 | 
 697 |   /** Appends a specified key/value pair as a new search parameter.
 698 |    *
 699 |    * ```ts
 700 |    * let searchParams = new URLSearchParams();
 701 |    * searchParams.append('name', 'first');
 702 |    * searchParams.append('name', 'second');
 703 |    * ```
 704 |    */
 705 |   append(name: string, value: string): void;
 706 | 
 707 |   /** Deletes the given search parameter and its associated value,
 708 |    * from the list of all search parameters.
 709 |    *
 710 |    * ```ts
 711 |    * let searchParams = new URLSearchParams([['name', 'value']]);
 712 |    * searchParams.delete('name');
 713 |    * ```
 714 |    */
 715 |   delete(name: string): void;
 716 | 
 717 |   /** Returns all the values associated with a given search parameter
 718 |    * as an array.
 719 |    *
 720 |    * ```ts
 721 |    * searchParams.getAll('name');
 722 |    * ```
 723 |    */
 724 |   getAll(name: string): string[];
 725 | 
 726 |   /** Returns the first value associated to the given search parameter.
 727 |    *
 728 |    * ```ts
 729 |    * searchParams.get('name');
 730 |    * ```
 731 |    */
 732 |   get(name: string): string | null;
 733 | 
 734 |   /** Returns a Boolean that indicates whether a parameter with the
 735 |    * specified name exists.
 736 |    *
 737 |    * ```ts
 738 |    * searchParams.has('name');
 739 |    * ```
 740 |    */
 741 |   has(name: string): boolean;
 742 | 
 743 |   /** Sets the value associated with a given search parameter to the
 744 |    * given value. If there were several matching values, this method
 745 |    * deletes the others. If the search parameter doesn't exist, this
 746 |    * method creates it.
 747 |    *
 748 |    * ```ts
 749 |    * searchParams.set('name', 'value');
 750 |    * ```
 751 |    */
 752 |   set(name: string, value: string): void;
 753 | 
 754 |   /** Sort all key/value pairs contained in this object in place and
 755 |    * return undefined. The sort order is according to Unicode code
 756 |    * points of the keys.
 757 |    *
 758 |    * ```ts
 759 |    * searchParams.sort();
 760 |    * ```
 761 |    */
 762 |   sort(): void;
 763 | 
 764 |   /** Calls a function for each element contained in this object in
 765 |    * place and return undefined. Optionally accepts an object to use
 766 |    * as this when executing callback as second argument.
 767 |    *
 768 |    * ```ts
 769 |    * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
 770 |    * params.forEach((value, key, parent) => {
 771 |    *   console.log(value, key, parent);
 772 |    * });
 773 |    * ```
 774 |    *
 775 |    */
 776 |   forEach(
 777 |     callbackfn: (value: string, key: string, parent: this) => void,
 778 |     thisArg?: any,
 779 |   ): void;
 780 | 
 781 |   /** Returns an iterator allowing to go through all keys contained
 782 |    * in this object.
 783 |    *
 784 |    * ```ts
 785 |    * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
 786 |    * for (const key of params.keys()) {
 787 |    *   console.log(key);
 788 |    * }
 789 |    * ```
 790 |    */
 791 |   keys(): IterableIterator<string>;
 792 | 
 793 |   /** Returns an iterator allowing to go through all values contained
 794 |    * in this object.
 795 |    *
 796 |    * ```ts
 797 |    * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
 798 |    * for (const value of params.values()) {
 799 |    *   console.log(value);
 800 |    * }
 801 |    * ```
 802 |    */
 803 |   values(): IterableIterator<string>;
 804 | 
 805 |   /** Returns an iterator allowing to go through all key/value
 806 |    * pairs contained in this object.
 807 |    *
 808 |    * ```ts
 809 |    * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
 810 |    * for (const [key, value] of params.entries()) {
 811 |    *   console.log(key, value);
 812 |    * }
 813 |    * ```
 814 |    */
 815 |   entries(): IterableIterator<[string, string]>;
 816 | 
 817 |   /** Returns an iterator allowing to go through all key/value
 818 |    * pairs contained in this object.
 819 |    *
 820 |    * ```ts
 821 |    * const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
 822 |    * for (const [key, value] of params) {
 823 |    *   console.log(key, value);
 824 |    * }
 825 |    * ```
 826 |    */
 827 |   [Symbol.iterator](): IterableIterator<[string, string]>;
 828 | 
 829 |   /** Returns a query string suitable for use in a URL.
 830 |    *
 831 |    * ```ts
 832 |    * searchParams.toString();
 833 |    * ```
 834 |    */
 835 |   toString(): string;
 836 | }
 837 | 
 838 | /** The URL interface represents an object providing static methods used for creating object URLs. */
 839 | declare class URL {
 840 |   constructor(url: string, base?: string | URL);
 841 |   createObjectURL(object: any): string;
 842 |   revokeObjectURL(url: string): void;
 843 | 
 844 |   hash: string;
 845 |   host: string;
 846 |   hostname: string;
 847 |   href: string;
 848 |   toString(): string;
 849 |   readonly origin: string;
 850 |   password: string;
 851 |   pathname: string;
 852 |   port: string;
 853 |   protocol: string;
 854 |   search: string;
 855 |   readonly searchParams: URLSearchParams;
 856 |   username: string;
 857 |   toJSON(): string;
 858 | }
 859 | 
 860 | interface DomIterable<K, V> {
 861 |   keys(): IterableIterator<K>;
 862 |   values(): IterableIterator<V>;
 863 |   entries(): IterableIterator<[K, V]>;
 864 |   [Symbol.iterator](): IterableIterator<[K, V]>;
 865 |   forEach(
 866 |     callback: (value: V, key: K, parent: this) => void,
 867 |     thisArg?: any,
 868 |   ): void;
 869 | }
 870 | 
 871 | interface ReadableStreamReadDoneResult<T> {
 872 |   done: true;
 873 |   value?: T;
 874 | }
 875 | 
 876 | interface ReadableStreamReadValueResult<T> {
 877 |   done: false;
 878 |   value: T;
 879 | }
 880 | 
 881 | type ReadableStreamReadResult<T> =
 882 |   | ReadableStreamReadValueResult<T>
 883 |   | ReadableStreamReadDoneResult<T>;
 884 | 
 885 | interface ReadableStreamDefaultReader<R = any> {
 886 |   readonly closed: Promise<void>;
 887 |   cancel(reason?: any): Promise<void>;
 888 |   read(): Promise<ReadableStreamReadResult<R>>;
 889 |   releaseLock(): void;
 890 | }
 891 | 
 892 | declare var ReadableStreamDefaultReader: {
 893 |   prototype: ReadableStreamDefaultReader;
 894 |   new <R>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
 895 | };
 896 | 
 897 | interface ReadableStreamReader<R = any> {
 898 |   cancel(): Promise<void>;
 899 |   read(): Promise<ReadableStreamReadResult<R>>;
 900 |   releaseLock(): void;
 901 | }
 902 | 
 903 | declare var ReadableStreamReader: {
 904 |   prototype: ReadableStreamReader;
 905 |   new (): ReadableStreamReader;
 906 | };
 907 | 
 908 | interface ReadableByteStreamControllerCallback {
 909 |   (controller: ReadableByteStreamController): void | PromiseLike<void>;
 910 | }
 911 | 
 912 | interface UnderlyingByteSource {
 913 |   autoAllocateChunkSize?: number;
 914 |   cancel?: ReadableStreamErrorCallback;
 915 |   pull?: ReadableByteStreamControllerCallback;
 916 |   start?: ReadableByteStreamControllerCallback;
 917 |   type: "bytes";
 918 | }
 919 | 
 920 | interface UnderlyingSink<W = any> {
 921 |   abort?: WritableStreamErrorCallback;
 922 |   close?: WritableStreamDefaultControllerCloseCallback;
 923 |   start?: WritableStreamDefaultControllerStartCallback;
 924 |   type?: undefined;
 925 |   write?: WritableStreamDefaultControllerWriteCallback<W>;
 926 | }
 927 | 
 928 | interface UnderlyingSource<R = any> {
 929 |   cancel?: ReadableStreamErrorCallback;
 930 |   pull?: ReadableStreamDefaultControllerCallback<R>;
 931 |   start?: ReadableStreamDefaultControllerCallback<R>;
 932 |   type?: undefined;
 933 | }
 934 | 
 935 | interface ReadableStreamErrorCallback {
 936 |   (reason: any): void | PromiseLike<void>;
 937 | }
 938 | 
 939 | interface ReadableStreamDefaultControllerCallback<R> {
 940 |   (controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
 941 | }
 942 | 
 943 | interface ReadableStreamDefaultController<R = any> {
 944 |   readonly desiredSize: number | null;
 945 |   close(): void;
 946 |   enqueue(chunk: R): void;
 947 |   error(error?: any): void;
 948 | }
 949 | 
 950 | declare var ReadableStreamDefaultController: {
 951 |   prototype: ReadableStreamDefaultController;
 952 |   new (): ReadableStreamDefaultController;
 953 | };
 954 | 
 955 | interface ReadableByteStreamController {
 956 |   readonly byobRequest: undefined;
 957 |   readonly desiredSize: number | null;
 958 |   close(): void;
 959 |   enqueue(chunk: ArrayBufferView): void;
 960 |   error(error?: any): void;
 961 | }
 962 | 
 963 | declare var ReadableByteStreamController: {
 964 |   prototype: ReadableByteStreamController;
 965 |   new (): ReadableByteStreamController;
 966 | };
 967 | 
 968 | interface PipeOptions {
 969 |   preventAbort?: boolean;
 970 |   preventCancel?: boolean;
 971 |   preventClose?: boolean;
 972 |   signal?: AbortSignal;
 973 | }
 974 | 
 975 | interface QueuingStrategySizeCallback<T = any> {
 976 |   (chunk: T): number;
 977 | }
 978 | 
 979 | interface QueuingStrategy<T = any> {
 980 |   highWaterMark?: number;
 981 |   size?: QueuingStrategySizeCallback<T>;
 982 | }
 983 | 
 984 | /** This Streams API interface provides a built-in byte length queuing strategy
 985 |  * that can be used when constructing streams. */
 986 | declare class CountQueuingStrategy implements QueuingStrategy {
 987 |   constructor(options: { highWaterMark: number });
 988 |   highWaterMark: number;
 989 |   size(chunk: any): 1;
 990 | }
 991 | 
 992 | declare class ByteLengthQueuingStrategy
 993 |   implements QueuingStrategy<ArrayBufferView> {
 994 |   constructor(options: { highWaterMark: number });
 995 |   highWaterMark: number;
 996 |   size(chunk: ArrayBufferView): number;
 997 | }
 998 | 
 999 | /** This Streams API interface represents a readable stream of byte data. The
1000 |  * Fetch API offers a concrete instance of a ReadableStream through the body
1001 |  * property of a Response object. */
1002 | interface ReadableStream<R = any> {
1003 |   readonly locked: boolean;
1004 |   cancel(reason?: any): Promise<void>;
1005 |   /**
1006 |    * @deprecated This is no longer part of the Streams standard and the async
1007 |    *             iterable should be obtained by just using the stream as an
1008 |    *             async iterator.
1009 |    */
1010 |   getIterator(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
1011 |   getReader(): ReadableStreamDefaultReader<R>;
1012 |   pipeThrough<T>(
1013 |     {
1014 |       writable,
1015 |       readable,
1016 |     }: {
1017 |       writable: WritableStream<R>;
1018 |       readable: ReadableStream<T>;
1019 |     },
1020 |     options?: PipeOptions,
1021 |   ): ReadableStream<T>;
1022 |   pipeTo(dest: WritableStream<R>, options?: PipeOptions): Promise<void>;
1023 |   tee(): [ReadableStream<R>, ReadableStream<R>];
1024 |   [Symbol.asyncIterator](options?: {
1025 |     preventCancel?: boolean;
1026 |   }): AsyncIterableIterator<R>;
1027 | }
1028 | 
1029 | declare var ReadableStream: {
1030 |   prototype: ReadableStream;
1031 |   new (
1032 |     underlyingSource: UnderlyingByteSource,
1033 |     strategy?: { highWaterMark?: number; size?: undefined },
1034 |   ): ReadableStream<Uint8Array>;
1035 |   new <R = any>(
1036 |     underlyingSource?: UnderlyingSource<R>,
1037 |     strategy?: QueuingStrategy<R>,
1038 |   ): ReadableStream<R>;
1039 | };
1040 | 
1041 | interface WritableStreamDefaultControllerCloseCallback {
1042 |   (): void | PromiseLike<void>;
1043 | }
1044 | 
1045 | interface WritableStreamDefaultControllerStartCallback {
1046 |   (controller: WritableStreamDefaultController): void | PromiseLike<void>;
1047 | }
1048 | 
1049 | interface WritableStreamDefaultControllerWriteCallback<W> {
1050 |   (
1051 |     chunk: W,
1052 |     controller: WritableStreamDefaultController,
1053 |   ): void | PromiseLike<void>;
1054 | }
1055 | 
1056 | interface WritableStreamErrorCallback {
1057 |   (reason: any): void | PromiseLike<void>;
1058 | }
1059 | 
1060 | /** This Streams API interface provides a standard abstraction for writing
1061 |  * streaming data to a destination, known as a sink. This object comes with
1062 |  * built-in backpressure and queuing. */
1063 | interface WritableStream<W = any> {
1064 |   readonly locked: boolean;
1065 |   abort(reason?: any): Promise<void>;
1066 |   getWriter(): WritableStreamDefaultWriter<W>;
1067 | }
1068 | 
1069 | declare var WritableStream: {
1070 |   prototype: WritableStream;
1071 |   new <W = any>(
1072 |     underlyingSink?: UnderlyingSink<W>,
1073 |     strategy?: QueuingStrategy<W>,
1074 |   ): WritableStream<W>;
1075 | };
1076 | 
1077 | /** This Streams API interface represents a controller allowing control of a
1078 |  * WritableStream's state. When constructing a WritableStream, the underlying
1079 |  * sink is given a corresponding WritableStreamDefaultController instance to
1080 |  * manipulate. */
1081 | interface WritableStreamDefaultController {
1082 |   error(error?: any): void;
1083 | }
1084 | 
1085 | /** This Streams API interface is the object returned by
1086 |  * WritableStream.getWriter() and once created locks the < writer to the
1087 |  * WritableStream ensuring that no other streams can write to the underlying
1088 |  * sink. */
1089 | interface WritableStreamDefaultWriter<W = any> {
1090 |   readonly closed: Promise<void>;
1091 |   readonly desiredSize: number | null;
1092 |   readonly ready: Promise<void>;
1093 |   abort(reason?: any): Promise<void>;
1094 |   close(): Promise<void>;
1095 |   releaseLock(): void;
1096 |   write(chunk: W): Promise<void>;
1097 | }
1098 | 
1099 | declare var WritableStreamDefaultWriter: {
1100 |   prototype: WritableStreamDefaultWriter;
1101 |   new (): WritableStreamDefaultWriter;
1102 | };
1103 | 
1104 | interface TransformStream<I = any, O = any> {
1105 |   readonly readable: ReadableStream<O>;
1106 |   readonly writable: WritableStream<I>;
1107 | }
1108 | 
1109 | declare var TransformStream: {
1110 |   prototype: TransformStream;
1111 |   new <I = any, O = any>(
1112 |     transformer?: Transformer<I, O>,
1113 |     writableStrategy?: QueuingStrategy<I>,
1114 |     readableStrategy?: QueuingStrategy<O>,
1115 |   ): TransformStream<I, O>;
1116 | };
1117 | 
1118 | interface TransformStreamDefaultController<O = any> {
1119 |   readonly desiredSize: number | null;
1120 |   enqueue(chunk: O): void;
1121 |   error(reason?: any): void;
1122 |   terminate(): void;
1123 | }
1124 | 
1125 | interface Transformer<I = any, O = any> {
1126 |   flush?: TransformStreamDefaultControllerCallback<O>;
1127 |   readableType?: undefined;
1128 |   start?: TransformStreamDefaultControllerCallback<O>;
1129 |   transform?: TransformStreamDefaultControllerTransformCallback<I, O>;
1130 |   writableType?: undefined;
1131 | }
1132 | 
1133 | interface TransformStreamDefaultControllerCallback<O> {
1134 |   (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
1135 | }
1136 | 
1137 | interface TransformStreamDefaultControllerTransformCallback<I, O> {
1138 |   (
1139 |     chunk: I,
1140 |     controller: TransformStreamDefaultController<O>,
1141 |   ): void | PromiseLike<void>;
1142 | }
1143 | 
1144 | type BlobPart = BufferSource | Blob | string;
1145 | 
1146 | interface BlobPropertyBag {
1147 |   type?: string;
1148 |   endings?: "transparent" | "native";
1149 | }
1150 | 
1151 | /** A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. */
1152 | declare class Blob {
1153 |   constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);
1154 | 
1155 |   readonly size: number;
1156 |   readonly type: string;
1157 |   arrayBuffer(): Promise<ArrayBuffer>;
1158 |   slice(start?: number, end?: number, contentType?: string): Blob;
1159 |   stream(): ReadableStream;
1160 |   text(): Promise<string>;
1161 | }
1162 | 
1163 | interface FilePropertyBag extends BlobPropertyBag {
1164 |   lastModified?: number;
1165 | }
1166 | 
1167 | /** Provides information about files and allows JavaScript in a web page to
1168 |  * access their content. */
1169 | declare class File extends Blob {
1170 |   constructor(
1171 |     fileBits: BlobPart[],
1172 |     fileName: string,
1173 |     options?: FilePropertyBag,
1174 |   );
1175 | 
1176 |   readonly lastModified: number;
1177 |   readonly name: string;
1178 | }
1179 | 
1180 | type FormDataEntryValue = File | string;
1181 | 
1182 | /** Provides a way to easily construct a set of key/value pairs representing
1183 |  * form fields and their values, which can then be easily sent using the
1184 |  * XMLHttpRequest.send() method. It uses the same format a form would use if the
1185 |  * encoding type were set to "multipart/form-data". */
1186 | declare class FormData implements DomIterable<string, FormDataEntryValue> {
1187 |   // TODO(ry) FormData constructor is non-standard.
1188 |   // new(form?: HTMLFormElement): FormData;
1189 |   constructor();
1190 | 
1191 |   append(name: string, value: string | Blob, fileName?: string): void;
1192 |   delete(name: string): void;
1193 |   get(name: string): FormDataEntryValue | null;
1194 |   getAll(name: string): FormDataEntryValue[];
1195 |   has(name: string): boolean;
1196 |   set(name: string, value: string | Blob, fileName?: string): void;
1197 |   keys(): IterableIterator<string>;
1198 |   values(): IterableIterator<string>;
1199 |   entries(): IterableIterator<[string, FormDataEntryValue]>;
1200 |   [Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
1201 |   forEach(
1202 |     callback: (value: FormDataEntryValue, key: string, parent: this) => void,
1203 |     thisArg?: any,
1204 |   ): void;
1205 | }
1206 | 
1207 | interface Body {
1208 |   /** A simple getter used to expose a `ReadableStream` of the body contents. */
1209 |   readonly body: ReadableStream<Uint8Array> | null;
1210 |   /** Stores a `Boolean` that declares whether the body has been used in a
1211 |    * response yet.
1212 |    */
1213 |   readonly bodyUsed: boolean;
1214 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1215 |    * that resolves with an `ArrayBuffer`.
1216 |    */
1217 |   arrayBuffer(): Promise<ArrayBuffer>;
1218 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1219 |    * that resolves with a `Blob`.
1220 |    */
1221 |   blob(): Promise<Blob>;
1222 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1223 |    * that resolves with a `FormData` object.
1224 |    */
1225 |   formData(): Promise<FormData>;
1226 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1227 |    * that resolves with the result of parsing the body text as JSON.
1228 |    */
1229 |   json(): Promise<any>;
1230 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1231 |    * that resolves with a `USVString` (text).
1232 |    */
1233 |   text(): Promise<string>;
1234 | }
1235 | 
1236 | type HeadersInit = Headers | string[][] | Record<string, string>;
1237 | 
1238 | /** This Fetch API interface allows you to perform various actions on HTTP
1239 |  * request and response headers. These actions include retrieving, setting,
1240 |  * adding to, and removing. A Headers object has an associated header list,
1241 |  * which is initially empty and consists of zero or more name and value pairs.
1242 |  * You can add to this using methods like append() (see Examples). In all
1243 |  * methods of this interface, header names are matched by case-insensitive byte
1244 |  * sequence. */
1245 | declare class Headers implements DomIterable<string, string> {
1246 |   constructor(init?: HeadersInit);
1247 | 
1248 |   /** Appends a new value onto an existing header inside a `Headers` object, or
1249 |    * adds the header if it does not already exist.
1250 |    */
1251 |   append(name: string, value: string): void;
1252 |   /** Deletes a header from a `Headers` object. */
1253 |   delete(name: string): void;
1254 |   /** Returns an iterator allowing to go through all key/value pairs
1255 |    * contained in this Headers object. The both the key and value of each pairs
1256 |    * are ByteString objects.
1257 |    */
1258 |   entries(): IterableIterator<[string, string]>;
1259 |   /** Returns a `ByteString` sequence of all the values of a header within a
1260 |    * `Headers` object with a given name.
1261 |    */
1262 |   get(name: string): string | null;
1263 |   /** Returns a boolean stating whether a `Headers` object contains a certain
1264 |    * header.
1265 |    */
1266 |   has(name: string): boolean;
1267 |   /** Returns an iterator allowing to go through all keys contained in
1268 |    * this Headers object. The keys are ByteString objects.
1269 |    */
1270 |   keys(): IterableIterator<string>;
1271 |   /** Sets a new value for an existing header inside a Headers object, or adds
1272 |    * the header if it does not already exist.
1273 |    */
1274 |   set(name: string, value: string): void;
1275 |   /** Returns an iterator allowing to go through all values contained in
1276 |    * this Headers object. The values are ByteString objects.
1277 |    */
1278 |   values(): IterableIterator<string>;
1279 |   forEach(
1280 |     callbackfn: (value: string, key: string, parent: this) => void,
1281 |     thisArg?: any,
1282 |   ): void;
1283 |   /** The Symbol.iterator well-known symbol specifies the default
1284 |    * iterator for this Headers object
1285 |    */
1286 |   [Symbol.iterator](): IterableIterator<[string, string]>;
1287 | }
1288 | 
1289 | type RequestInfo = Request | string;
1290 | type RequestCache =
1291 |   | "default"
1292 |   | "force-cache"
1293 |   | "no-cache"
1294 |   | "no-store"
1295 |   | "only-if-cached"
1296 |   | "reload";
1297 | type RequestCredentials = "include" | "omit" | "same-origin";
1298 | type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
1299 | type RequestRedirect = "error" | "follow" | "manual";
1300 | type ReferrerPolicy =
1301 |   | ""
1302 |   | "no-referrer"
1303 |   | "no-referrer-when-downgrade"
1304 |   | "origin"
1305 |   | "origin-when-cross-origin"
1306 |   | "same-origin"
1307 |   | "strict-origin"
1308 |   | "strict-origin-when-cross-origin"
1309 |   | "unsafe-url";
1310 | type BodyInit =
1311 |   | Blob
1312 |   | BufferSource
1313 |   | FormData
1314 |   | URLSearchParams
1315 |   | ReadableStream<Uint8Array>
1316 |   | string;
1317 | type RequestDestination =
1318 |   | ""
1319 |   | "audio"
1320 |   | "audioworklet"
1321 |   | "document"
1322 |   | "embed"
1323 |   | "font"
1324 |   | "image"
1325 |   | "manifest"
1326 |   | "object"
1327 |   | "paintworklet"
1328 |   | "report"
1329 |   | "script"
1330 |   | "sharedworker"
1331 |   | "style"
1332 |   | "track"
1333 |   | "video"
1334 |   | "worker"
1335 |   | "xslt";
1336 | 
1337 | interface RequestInit {
1338 |   /**
1339 |    * A BodyInit object or null to set request's body.
1340 |    */
1341 |   body?: BodyInit | null;
1342 |   /**
1343 |    * A string indicating how the request will interact with the browser's cache
1344 |    * to set request's cache.
1345 |    */
1346 |   cache?: RequestCache;
1347 |   /**
1348 |    * A string indicating whether credentials will be sent with the request
1349 |    * always, never, or only when sent to a same-origin URL. Sets request's
1350 |    * credentials.
1351 |    */
1352 |   credentials?: RequestCredentials;
1353 |   /**
1354 |    * A Headers object, an object literal, or an array of two-item arrays to set
1355 |    * request's headers.
1356 |    */
1357 |   headers?: HeadersInit;
1358 |   /**
1359 |    * A cryptographic hash of the resource to be fetched by request. Sets
1360 |    * request's integrity.
1361 |    */
1362 |   integrity?: string;
1363 |   /**
1364 |    * A boolean to set request's keepalive.
1365 |    */
1366 |   keepalive?: boolean;
1367 |   /**
1368 |    * A string to set request's method.
1369 |    */
1370 |   method?: string;
1371 |   /**
1372 |    * A string to indicate whether the request will use CORS, or will be
1373 |    * restricted to same-origin URLs. Sets request's mode.
1374 |    */
1375 |   mode?: RequestMode;
1376 |   /**
1377 |    * A string indicating whether request follows redirects, results in an error
1378 |    * upon encountering a redirect, or returns the redirect (in an opaque
1379 |    * fashion). Sets request's redirect.
1380 |    */
1381 |   redirect?: RequestRedirect;
1382 |   /**
1383 |    * A string whose value is a same-origin URL, "about:client", or the empty
1384 |    * string, to set request's referrer.
1385 |    */
1386 |   referrer?: string;
1387 |   /**
1388 |    * A referrer policy to set request's referrerPolicy.
1389 |    */
1390 |   referrerPolicy?: ReferrerPolicy;
1391 |   /**
1392 |    * An AbortSignal to set request's signal.
1393 |    */
1394 |   signal?: AbortSignal | null;
1395 |   /**
1396 |    * Can only be null. Used to disassociate request from any Window.
1397 |    */
1398 |   window?: any;
1399 | }
1400 | 
1401 | /** This Fetch API interface represents a resource request. */
1402 | declare class Request implements Body {
1403 |   constructor(input: RequestInfo, init?: RequestInit);
1404 | 
1405 |   /**
1406 |    * Returns the cache mode associated with request, which is a string
1407 |    * indicating how the request will interact with the browser's cache when
1408 |    * fetching.
1409 |    */
1410 |   readonly cache: RequestCache;
1411 |   /**
1412 |    * Returns the credentials mode associated with request, which is a string
1413 |    * indicating whether credentials will be sent with the request always, never,
1414 |    * or only when sent to a same-origin URL.
1415 |    */
1416 |   readonly credentials: RequestCredentials;
1417 |   /**
1418 |    * Returns the kind of resource requested by request, e.g., "document" or "script".
1419 |    */
1420 |   readonly destination: RequestDestination;
1421 |   /**
1422 |    * Returns a Headers object consisting of the headers associated with request.
1423 |    * Note that headers added in the network layer by the user agent will not be
1424 |    * accounted for in this object, e.g., the "Host" header.
1425 |    */
1426 |   readonly headers: Headers;
1427 |   /**
1428 |    * Returns request's subresource integrity metadata, which is a cryptographic
1429 |    * hash of the resource being fetched. Its value consists of multiple hashes
1430 |    * separated by whitespace. [SRI]
1431 |    */
1432 |   readonly integrity: string;
1433 |   /**
1434 |    * Returns a boolean indicating whether or not request is for a history
1435 |    * navigation (a.k.a. back-forward navigation).
1436 |    */
1437 |   readonly isHistoryNavigation: boolean;
1438 |   /**
1439 |    * Returns a boolean indicating whether or not request is for a reload
1440 |    * navigation.
1441 |    */
1442 |   readonly isReloadNavigation: boolean;
1443 |   /**
1444 |    * Returns a boolean indicating whether or not request can outlive the global
1445 |    * in which it was created.
1446 |    */
1447 |   readonly keepalive: boolean;
1448 |   /**
1449 |    * Returns request's HTTP method, which is "GET" by default.
1450 |    */
1451 |   readonly method: string;
1452 |   /**
1453 |    * Returns the mode associated with request, which is a string indicating
1454 |    * whether the request will use CORS, or will be restricted to same-origin
1455 |    * URLs.
1456 |    */
1457 |   readonly mode: RequestMode;
1458 |   /**
1459 |    * Returns the redirect mode associated with request, which is a string
1460 |    * indicating how redirects for the request will be handled during fetching. A
1461 |    * request will follow redirects by default.
1462 |    */
1463 |   readonly redirect: RequestRedirect;
1464 |   /**
1465 |    * Returns the referrer of request. Its value can be a same-origin URL if
1466 |    * explicitly set in init, the empty string to indicate no referrer, and
1467 |    * "about:client" when defaulting to the global's default. This is used during
1468 |    * fetching to determine the value of the `Referer` header of the request
1469 |    * being made.
1470 |    */
1471 |   readonly referrer: string;
1472 |   /**
1473 |    * Returns the referrer policy associated with request. This is used during
1474 |    * fetching to compute the value of the request's referrer.
1475 |    */
1476 |   readonly referrerPolicy: ReferrerPolicy;
1477 |   /**
1478 |    * Returns the signal associated with request, which is an AbortSignal object
1479 |    * indicating whether or not request has been aborted, and its abort event
1480 |    * handler.
1481 |    */
1482 |   readonly signal: AbortSignal;
1483 |   /**
1484 |    * Returns the URL of request as a string.
1485 |    */
1486 |   readonly url: string;
1487 |   clone(): Request;
1488 | 
1489 |   /** A simple getter used to expose a `ReadableStream` of the body contents. */
1490 |   readonly body: ReadableStream<Uint8Array> | null;
1491 |   /** Stores a `Boolean` that declares whether the body has been used in a
1492 |    * response yet.
1493 |    */
1494 |   readonly bodyUsed: boolean;
1495 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1496 |    * that resolves with an `ArrayBuffer`.
1497 |    */
1498 |   arrayBuffer(): Promise<ArrayBuffer>;
1499 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1500 |    * that resolves with a `Blob`.
1501 |    */
1502 |   blob(): Promise<Blob>;
1503 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1504 |    * that resolves with a `FormData` object.
1505 |    */
1506 |   formData(): Promise<FormData>;
1507 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1508 |    * that resolves with the result of parsing the body text as JSON.
1509 |    */
1510 |   json(): Promise<any>;
1511 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1512 |    * that resolves with a `USVString` (text).
1513 |    */
1514 |   text(): Promise<string>;
1515 | }
1516 | 
1517 | interface ResponseInit {
1518 |   headers?: HeadersInit;
1519 |   status?: number;
1520 |   statusText?: string;
1521 | }
1522 | 
1523 | type ResponseType =
1524 |   | "basic"
1525 |   | "cors"
1526 |   | "default"
1527 |   | "error"
1528 |   | "opaque"
1529 |   | "opaqueredirect";
1530 | 
1531 | /** This Fetch API interface represents the response to a request. */
1532 | declare class Response implements Body {
1533 |   constructor(body?: BodyInit | null, init?: ResponseInit);
1534 |   static error(): Response;
1535 |   static redirect(url: string, status?: number): Response;
1536 | 
1537 |   readonly headers: Headers;
1538 |   readonly ok: boolean;
1539 |   readonly redirected: boolean;
1540 |   readonly status: number;
1541 |   readonly statusText: string;
1542 |   readonly trailer: Promise<Headers>;
1543 |   readonly type: ResponseType;
1544 |   readonly url: string;
1545 |   clone(): Response;
1546 | 
1547 |   /** A simple getter used to expose a `ReadableStream` of the body contents. */
1548 |   readonly body: ReadableStream<Uint8Array> | null;
1549 |   /** Stores a `Boolean` that declares whether the body has been used in a
1550 |    * response yet.
1551 |    */
1552 |   readonly bodyUsed: boolean;
1553 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1554 |    * that resolves with an `ArrayBuffer`.
1555 |    */
1556 |   arrayBuffer(): Promise<ArrayBuffer>;
1557 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1558 |    * that resolves with a `Blob`.
1559 |    */
1560 |   blob(): Promise<Blob>;
1561 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1562 |    * that resolves with a `FormData` object.
1563 |    */
1564 |   formData(): Promise<FormData>;
1565 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1566 |    * that resolves with the result of parsing the body text as JSON.
1567 |    */
1568 |   json(): Promise<any>;
1569 |   /** Takes a `Response` stream and reads it to completion. It returns a promise
1570 |    * that resolves with a `USVString` (text).
1571 |    */
1572 |   text(): Promise<string>;
1573 | }
1574 | 
1575 | /** Fetch a resource from the network. It returns a Promise that resolves to the
1576 |  * Response to that request, whether it is successful or not.
1577 |  *
1578 |  *     const response = await fetch("http://my.json.host/data.json");
1579 |  *     console.log(response.status);  // e.g. 200
1580 |  *     console.log(response.statusText); // e.g. "OK"
1581 |  *     const jsonData = await response.json();
1582 |  */
1583 | declare function fetch(
1584 |   input: Request | URL | string,
1585 |   init?: RequestInit,
1586 | ): Promise<Response>;
1587 | 
1588 | interface CloseEventInit extends EventInit {
1589 |   code?: number;
1590 |   reason?: string;
1591 |   wasClean?: boolean;
1592 | }
1593 | 
1594 | declare class CloseEvent extends Event {
1595 |   constructor(type: string, eventInitDict?: CloseEventInit);
1596 |   /**
1597 |    * Returns the WebSocket connection close code provided by the server.
1598 |    */
1599 |   readonly code: number;
1600 |   /**
1601 |    * Returns the WebSocket connection close reason provided by the server.
1602 |    */
1603 |   readonly reason: string;
1604 |   /**
1605 |    * Returns true if the connection closed cleanly; false otherwise.
1606 |    */
1607 |   readonly wasClean: boolean;
1608 | }
1609 | 
1610 | interface WebSocketEventMap {
1611 |   close: CloseEvent;
1612 |   error: Event;
1613 |   message: MessageEvent;
1614 |   open: Event;
1615 | }
1616 | 
1617 | /** Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection. */
1618 | declare class WebSocket extends EventTarget {
1619 |   constructor(url: string, protocols?: string | string[]);
1620 | 
1621 |   static readonly CLOSED: number;
1622 |   static readonly CLOSING: number;
1623 |   static readonly CONNECTING: number;
1624 |   static readonly OPEN: number;
1625 | 
1626 |   /**
1627 |    * Returns a string that indicates how binary data from the WebSocket object is exposed to scripts:
1628 |    *
1629 |    * Can be set, to change how binary data is returned. The default is "blob".
1630 |    */
1631 |   binaryType: BinaryType;
1632 |   /**
1633 |    * Returns the number of bytes of application data (UTF-8 text and binary data) that have been queued using send() but not yet been transmitted to the network.
1634 |    *
1635 |    * If the WebSocket connection is closed, this attribute's value will only increase with each call to the send() method. (The number does not reset to zero once the connection closes.)
1636 |    */
1637 |   readonly bufferedAmount: number;
1638 |   /**
1639 |    * Returns the extensions selected by the server, if any.
1640 |    */
1641 |   readonly extensions: string;
1642 |   onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
1643 |   onerror: ((this: WebSocket, ev: Event | ErrorEvent) => any) | null;
1644 |   onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
1645 |   onopen: ((this: WebSocket, ev: Event) => any) | null;
1646 |   /**
1647 |    * Returns the subprotocol selected by the server, if any. It can be used in conjunction with the array form of the constructor's second argument to perform subprotocol negotiation.
1648 |    */
1649 |   readonly protocol: string;
1650 |   /**
1651 |    * Returns the state of the WebSocket object's connection. It can have the values described below.
1652 |    */
1653 |   readonly readyState: number;
1654 |   /**
1655 |    * Returns the URL that was used to establish the WebSocket connection.
1656 |    */
1657 |   readonly url: string;
1658 |   /**
1659 |    * Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason.
1660 |    */
1661 |   close(code?: number, reason?: string): void;
1662 |   /**
1663 |    * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
1664 |    */
1665 |   send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
1666 |   readonly CLOSED: number;
1667 |   readonly CLOSING: number;
1668 |   readonly CONNECTING: number;
1669 |   readonly OPEN: number;
1670 |   addEventListener<K extends keyof WebSocketEventMap>(
1671 |     type: K,
1672 |     listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
1673 |     options?: boolean | AddEventListenerOptions,
1674 |   ): void;
1675 |   addEventListener(
1676 |     type: string,
1677 |     listener: EventListenerOrEventListenerObject,
1678 |     options?: boolean | AddEventListenerOptions,
1679 |   ): void;
1680 |   removeEventListener<K extends keyof WebSocketEventMap>(
1681 |     type: K,
1682 |     listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
1683 |     options?: boolean | EventListenerOptions,
1684 |   ): void;
1685 |   removeEventListener(
1686 |     type: string,
1687 |     listener: EventListenerOrEventListenerObject,
1688 |     options?: boolean | EventListenerOptions,
1689 |   ): void;
1690 | }
1691 | 
1692 | type BinaryType = "arraybuffer" | "blob";
1693 | 
1694 | declare namespace WebAssembly {
1695 |   /**
1696 |    * The `WebAssembly.CompileError` object indicates an error during WebAssembly decoding or validation.
1697 |    *
1698 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError)
1699 |    */
1700 |   export class CompileError extends Error {
1701 |     /** Creates a new `WebAssembly.CompileError` object. */
1702 |     constructor();
1703 |   }
1704 | 
1705 |   /**
1706 |    * A `WebAssembly.Global` object represents a global variable instance, accessible from
1707 |    * both JavaScript and importable/exportable across one or more `WebAssembly.Module`
1708 |    * instances. This allows dynamic linking of multiple modules.
1709 |    *
1710 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global)
1711 |    */
1712 |   export class Global {
1713 |     /** Creates a new `Global` object. */
1714 |     constructor(descriptor: GlobalDescriptor, v?: any);
1715 | 
1716 |     /**
1717 |      * The value contained inside the global variable — this can be used to directly set
1718 |      * and get the global's value.
1719 |      */
1720 |     value: any;
1721 | 
1722 |     /** Old-style method that returns the value contained inside the global variable. */
1723 |     valueOf(): any;
1724 |   }
1725 | 
1726 |   /**
1727 |    * A `WebAssembly.Instance` object is a stateful, executable instance of a `WebAssembly.Module`.
1728 |    * Instance objects contain all the Exported WebAssembly functions that allow calling into
1729 |    * WebAssembly code from JavaScript.
1730 |    *
1731 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance)
1732 |    */
1733 |   export class Instance {
1734 |     /** Creates a new Instance object. */
1735 |     constructor(module: Module, importObject?: Imports);
1736 | 
1737 |     /**
1738 |      * Returns an object containing as its members all the functions exported from the
1739 |      * WebAssembly module instance, to allow them to be accessed and used by JavaScript.
1740 |      * Read-only.
1741 |      */
1742 |     readonly exports: Exports;
1743 |   }
1744 | 
1745 |   /**
1746 |    * The `WebAssembly.LinkError` object indicates an error during module instantiation
1747 |    * (besides traps from the start function).
1748 |    *
1749 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError)
1750 |    */
1751 |   export class LinkError extends Error {
1752 |     /** Creates a new WebAssembly.LinkError object. */
1753 |     constructor();
1754 |   }
1755 | 
1756 |   /**
1757 |    * The `WebAssembly.Memory` object is a resizable `ArrayBuffer` or `SharedArrayBuffer` that
1758 |    * holds the raw bytes of memory accessed by a WebAssembly Instance.
1759 |    *
1760 |    * A memory created by JavaScript or in WebAssembly code will be accessible and mutable
1761 |    * from both JavaScript and WebAssembly.
1762 |    *
1763 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory)
1764 |    */
1765 |   export class Memory {
1766 |     /** Creates a new `Memory` object. */
1767 |     constructor(descriptor: MemoryDescriptor);
1768 | 
1769 |     /** An accessor property that returns the buffer contained in the memory. */
1770 |     readonly buffer: ArrayBuffer;
1771 | 
1772 |     /**
1773 |      * Increases the size of the memory instance by a specified number of WebAssembly
1774 |      * pages (each one is 64KB in size).
1775 |      */
1776 |     grow(delta: number): number;
1777 |   }
1778 | 
1779 |   /**
1780 |    * A `WebAssembly.Module` object contains stateless WebAssembly code that has already been compiled
1781 |    * by the browser — this can be efficiently shared with Workers, and instantiated multiple times.
1782 |    *
1783 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module)
1784 |    */
1785 |   export class Module {
1786 |     /** Creates a new `Module` object. */
1787 |     constructor(bytes: BufferSource);
1788 | 
1789 |     /**
1790 |      * Given a `Module` and string, returns a copy of the contents of all custom sections in the
1791 |      * module with the given string name.
1792 |      * */
1793 |     static customSections(
1794 |       moduleObject: Module,
1795 |       sectionName: string,
1796 |     ): ArrayBuffer[];
1797 | 
1798 |     /** Given a `Module`, returns an array containing descriptions of all the declared exports. */
1799 |     static exports(moduleObject: Module): ModuleExportDescriptor[];
1800 | 
1801 |     /** Given a `Module`, returns an array containing descriptions of all the declared imports. */
1802 |     static imports(moduleObject: Module): ModuleImportDescriptor[];
1803 |   }
1804 | 
1805 |   /**
1806 |    * The `WebAssembly.RuntimeError` object is the error type that is thrown whenever WebAssembly
1807 |    * specifies a trap.
1808 |    *
1809 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError)
1810 |    */
1811 |   export class RuntimeError extends Error {
1812 |     /** Creates a new `WebAssembly.RuntimeError` object. */
1813 |     constructor();
1814 |   }
1815 | 
1816 |   /**
1817 |    * The `WebAssembly.Table()` object is a JavaScript wrapper object — an array-like structure
1818 |    * representing a WebAssembly Table, which stores function references. A table created by
1819 |    * JavaScript or in WebAssembly code will be accessible and mutable from both JavaScript
1820 |    * and WebAssembly.
1821 |    *
1822 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table)
1823 |    */
1824 |   export class Table {
1825 |     /** Creates a new `Table` object. */
1826 |     constructor(descriptor: TableDescriptor);
1827 | 
1828 |     /** Returns the length of the table, i.e. the number of elements. */
1829 |     readonly length: number;
1830 | 
1831 |     /** Accessor function — gets the element stored at a given index. */
1832 |     get(index: number): Function | null;
1833 | 
1834 |     /** Increases the size of the `Table` instance by a specified number of elements. */
1835 |     grow(delta: number): number;
1836 | 
1837 |     /** Sets an element stored at a given index to a given value. */
1838 |     set(index: number, value: Function | null): void;
1839 |   }
1840 | 
1841 |   /** The `GlobalDescriptor` describes the options you can pass to `new WebAssembly.Global()`. */
1842 |   export interface GlobalDescriptor {
1843 |     mutable?: boolean;
1844 |     value: ValueType;
1845 |   }
1846 | 
1847 |   /** The `MemoryDescriptor` describes the options you can pass to `new WebAssembly.Memory()`. */
1848 |   export interface MemoryDescriptor {
1849 |     initial: number;
1850 |     maximum?: number;
1851 |   }
1852 | 
1853 |   /** A `ModuleExportDescriptor` is the description of a declared export in a `WebAssembly.Module`. */
1854 |   export interface ModuleExportDescriptor {
1855 |     kind: ImportExportKind;
1856 |     name: string;
1857 |   }
1858 | 
1859 |   /** A `ModuleImportDescriptor` is the description of a declared import in a `WebAssembly.Module`. */
1860 |   export interface ModuleImportDescriptor {
1861 |     kind: ImportExportKind;
1862 |     module: string;
1863 |     name: string;
1864 |   }
1865 | 
1866 |   /** The `TableDescriptor` describes the options you can pass to `new WebAssembly.Table()`. */
1867 |   export interface TableDescriptor {
1868 |     element: TableKind;
1869 |     initial: number;
1870 |     maximum?: number;
1871 |   }
1872 | 
1873 |   /** The value returned from `WebAssembly.instantiate` and `WebAssembly.instantiateStreaming`. */
1874 |   export interface WebAssemblyInstantiatedSource {
1875 |     /* A `WebAssembly.Instance` object that contains all the exported WebAssembly functions. */
1876 |     instance: Instance;
1877 | 
1878 |     /**
1879 |      * A `WebAssembly.Module` object representing the compiled WebAssembly module.
1880 |      * This `Module` can be instantiated again, or shared via postMessage().
1881 |      */
1882 |     module: Module;
1883 |   }
1884 | 
1885 |   export type ImportExportKind = "function" | "global" | "memory" | "table";
1886 |   export type TableKind = "anyfunc";
1887 |   export type ValueType = "f32" | "f64" | "i32" | "i64";
1888 |   export type ExportValue = Function | Global | Memory | Table;
1889 |   export type Exports = Record<string, ExportValue>;
1890 |   export type ImportValue = ExportValue | number;
1891 |   export type ModuleImports = Record<string, ImportValue>;
1892 |   export type Imports = Record<string, ModuleImports>;
1893 | 
1894 |   /**
1895 |    * The `WebAssembly.compile()` function compiles WebAssembly binary code into a
1896 |    * `WebAssembly.Module` object. This function is useful if it is necessary to compile
1897 |    * a module before it can be instantiated (otherwise, the `WebAssembly.instantiate()`
1898 |    * function should be used).
1899 |    *
1900 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compile)
1901 |    */
1902 |   export function compile(bytes: BufferSource): Promise<Module>;
1903 | 
1904 |   /**
1905 |    * The `WebAssembly.compileStreaming()` function compiles a `WebAssembly.Module`
1906 |    * directly from a streamed underlying source.  This function is useful if it
1907 |    * is necessary to a compile a module before it can be instantiated (otherwise,
1908 |    * the `WebAssembly.instantiateStreaming()` function should be used).
1909 |    *
1910 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming)
1911 |    */
1912 |   export function compileStreaming(
1913 |     source: Response | Promise<Response>,
1914 |   ): Promise<Module>;
1915 | 
1916 |   /**
1917 |    * The WebAssembly.instantiate() function allows you to compile and instantiate
1918 |    * WebAssembly code.
1919 |    *
1920 |    * This overload takes the WebAssembly binary code, in the form of a typed
1921 |    * array or ArrayBuffer, and performs both compilation and instantiation in one step.
1922 |    * The returned Promise resolves to both a compiled WebAssembly.Module and its first
1923 |    * WebAssembly.Instance.
1924 |    *
1925 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate)
1926 |    */
1927 |   export function instantiate(
1928 |     bytes: BufferSource,
1929 |     importObject?: Imports,
1930 |   ): Promise<WebAssemblyInstantiatedSource>;
1931 | 
1932 |   /**
1933 |    * The WebAssembly.instantiate() function allows you to compile and instantiate
1934 |    * WebAssembly code.
1935 |    *
1936 |    * This overload takes an already-compiled WebAssembly.Module and returns
1937 |    * a Promise that resolves to an Instance of that Module. This overload is useful
1938 |    * if the Module has already been compiled.
1939 |    *
1940 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate)
1941 |    */
1942 |   export function instantiate(
1943 |     moduleObject: Module,
1944 |     importObject?: Imports,
1945 |   ): Promise<Instance>;
1946 | 
1947 |   /**
1948 |    * The `WebAssembly.instantiateStreaming()` function compiles and instantiates a
1949 |    * WebAssembly module directly from a streamed underlying source. This is the most
1950 |    * efficient, optimized way to load WebAssembly code.
1951 |    *
1952 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming)
1953 |    */
1954 |   export function instantiateStreaming(
1955 |     response: Response | PromiseLike<Response>,
1956 |     importObject?: Imports,
1957 |   ): Promise<WebAssemblyInstantiatedSource>;
1958 | 
1959 |   /**
1960 |    * The `WebAssembly.validate()` function validates a given typed array of
1961 |    * WebAssembly binary code, returning whether the bytes form a valid wasm
1962 |    * module (`true`) or not (`false`).
1963 |    *
1964 |    * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/validate)
1965 |    */
1966 |   export function validate(bytes: BufferSource): boolean;
1967 | }
1968 | 
1969 | interface VoidFunction {
1970 |   (): void;
1971 | }
1972 | 
1973 | /** A microtask is a short function which is executed after the function or
1974 |  * module which created it exits and only if the JavaScript execution stack is
1975 |  * empty, but before returning control to the event loop being used to drive the
1976 |  * script's execution environment. This event loop may be either the main event
1977 |  * loop or the event loop driving a web worker.
1978 |  *
1979 |  *     queueMicrotask(() => { console.log('This event loop stack is complete'); });
1980 |  */
1981 | declare function queueMicrotask(func: VoidFunction): void;
1982 | 
1983 | /** Registers an event listener in the global scope, which will be called
1984 |  * synchronously whenever the event `type` is dispatched.
1985 |  *
1986 |  *     addEventListener('unload', () => { console.log('All finished!'); });
1987 |  *     ...
1988 |  *     dispatchEvent(new Event('unload'));
1989 |  */
1990 | declare function addEventListener(
1991 |   type: string,
1992 |   callback: EventListenerOrEventListenerObject | null,
1993 |   options?: boolean | AddEventListenerOptions | undefined,
1994 | ): void;
1995 | 
1996 | /** Dispatches an event in the global scope, synchronously invoking any
1997 |  * registered event listeners for this event in the appropriate order. Returns
1998 |  * false if event is cancelable and at least one of the event handlers which
1999 |  * handled this event called Event.preventDefault(). Otherwise it returns true.
2000 |  *
2001 |  *     dispatchEvent(new Event('unload'));
2002 |  */
2003 | declare function dispatchEvent(event: Event): boolean;
2004 | 
2005 | /** Remove a previously registered event listener from the global scope
2006 |  *
2007 |  *     const lstnr = () => { console.log('hello'); };
2008 |  *     addEventListener('load', lstnr);
2009 |  *     removeEventListener('load', lstnr);
2010 |  */
2011 | declare function removeEventListener(
2012 |   type: string,
2013 |   callback: EventListenerOrEventListenerObject | null,
2014 |   options?: boolean | EventListenerOptions | undefined,
2015 | ): void;
2016 | 
2017 | interface DOMStringList {
2018 |   /** Returns the number of strings in strings. */
2019 |   readonly length: number;
2020 |   /** Returns true if strings contains string, and false otherwise. */
2021 |   contains(string: string): boolean;
2022 |   /** Returns the string with index index from strings. */
2023 |   item(index: number): string | null;
2024 |   [index: number]: string;
2025 | }
2026 | 
2027 | type BufferSource = ArrayBufferView | ArrayBuffer;
2028 | 
2029 | declare interface Console {
2030 |   assert(condition?: boolean, ...data: any[]): void;
2031 |   clear(): void;
2032 |   count(label?: string): void;
2033 |   countReset(label?: string): void;
2034 |   debug(...data: any[]): void;
2035 |   dir(item?: any, options?: any): void;
2036 |   dirxml(...data: any[]): void;
2037 |   error(...data: any[]): void;
2038 |   group(...data: any[]): void;
2039 |   groupCollapsed(...data: any[]): void;
2040 |   groupEnd(): void;
2041 |   info(...data: any[]): void;
2042 |   log(...data: any[]): void;
2043 |   table(tabularData?: any, properties?: string[]): void;
2044 |   time(label?: string): void;
2045 |   timeEnd(label?: string): void;
2046 |   timeLog(label?: string, ...data: any[]): void;
2047 |   timeStamp(label?: string): void;
2048 |   trace(...data: any[]): void;
2049 |   warn(...data: any[]): void;
2050 | }
2051 | 
2052 | declare var console: Console;
2053 | 
2054 | interface MessageEventInit<T = any> extends EventInit {
2055 |   data?: T;
2056 |   origin?: string;
2057 |   lastEventId?: string;
2058 | }
2059 | 
2060 | declare class MessageEvent<T = any> extends Event {
2061 |   /**
2062 |    * Returns the data of the message.
2063 |    */
2064 |   readonly data: T;
2065 |   /**
2066 |    * Returns the last event ID string, for server-sent events.
2067 |    */
2068 |   readonly lastEventId: string;
2069 |   constructor(type: string, eventInitDict?: MessageEventInit);
2070 | }
2071 | 
2072 | interface ErrorEventInit extends EventInit {
2073 |   message?: string;
2074 |   filename?: string;
2075 |   lineno?: number;
2076 |   colno?: number;
2077 |   error?: any;
2078 | }
2079 | 
2080 | declare class ErrorEvent extends Event {
2081 |   readonly message: string;
2082 |   readonly filename: string;
2083 |   readonly lineno: number;
2084 |   readonly colno: number;
2085 |   readonly error: any;
2086 |   constructor(type: string, eventInitDict?: ErrorEventInit);
2087 | }
2088 | 
2089 | declare interface CustomEventInit<T = any> extends EventInit {
2090 |   detail?: T;
2091 | }
2092 | 
2093 | declare class CustomEvent<T = any> extends Event {
2094 |   constructor(typeArg: string, eventInitDict?: CustomEventInit<T>);
2095 |   /** Returns any custom data event was created with. Typically used for
2096 |    * synthetic events. */
2097 |   readonly detail: T;
2098 | }
2099 | 
2100 | interface ErrorConstructor {
2101 |   /** See https://v8.dev/docs/stack-trace-api#stack-trace-collection-for-custom-exceptions. */
2102 |   captureStackTrace(error: Object, constructor?: Function): void;
2103 |   // TODO(nayeemrmn): Support `Error.prepareStackTrace()`. We currently use this
2104 |   // internally in a way that makes it unavailable for users.
2105 | }
2106 | 
2107 | declare class Window extends EventTarget {
2108 |   new(): Window;
2109 |   readonly window: Window & typeof globalThis;
2110 |   readonly self: Window & typeof globalThis;
2111 |   Deno: typeof Deno;
2112 | }
2113 | 
2114 | declare var window: Window & typeof globalThis;
2115 | declare var self: Window & typeof globalThis;
2116 | 
2117 | declare var crypto: Crypto;
2118 | 
2119 | declare interface Crypto {
2120 |   readonly subtle: null;
2121 |   getRandomValues<
2122 |     T extends
2123 |       | Int8Array
2124 |       | Int16Array
2125 |       | Int32Array
2126 |       | Uint8Array
2127 |       | Uint16Array
2128 |       | Uint32Array
2129 |       | Uint8ClampedArray
2130 |       | Float32Array
2131 |       | Float64Array
2132 |       | DataView
2133 |       | null,
2134 |   >(
2135 |     array: T,
2136 |   ): T;
2137 | }
2138 | 
2139 | /** Sets a timer which executes a function once after the timer expires. Returns
2140 |  * an id which may be used to cancel the timeout.
2141 |  *
2142 |  *     setTimeout(() => { console.log('hello'); }, 500);
2143 |  */
2144 | declare function setTimeout(
2145 |   /** callback function to execute when timer expires */
2146 |   cb: (...args: any[]) => void,
2147 |   /** delay in ms */
2148 |   delay?: number,
2149 |   /** arguments passed to callback function */
2150 |   ...args: any[]
2151 | ): number;
2152 | 
2153 | /** Repeatedly calls a function , with a fixed time delay between each call.
2154 |  *
2155 |  *     // Outputs 'hello' to the console every 500ms
2156 |  *     setInterval(() => { console.log('hello'); }, 500);
2157 |  */
2158 | declare function setInterval(
2159 |   /** callback function to execute when timer expires */
2160 |   cb: (...args: any[]) => void,
2161 |   /** delay in ms */
2162 |   delay?: number,
2163 |   /** arguments passed to callback function */
2164 |   ...args: any[]
2165 | ): number;
2166 | 
2167 | /** Cancels a timed, repeating action which was previously started by a call
2168 |  * to `setInterval()`
2169 |  *
2170 |  *     const id = setInterval(() => {console.log('hello');}, 500);
2171 |  *     ...
2172 |  *     clearInterval(id);
2173 |  */
2174 | declare function clearInterval(id?: number): void;
2175 | 
2176 | /** Cancels a scheduled action initiated by `setTimeout()`
2177 |  *
2178 |  *     const id = setTimeout(() => {console.log('hello');}, 500);
2179 |  *     ...
2180 |  *     clearTimeout(id);
2181 |  */
2182 | declare function clearTimeout(id?: number): void;
2183 | 
2184 | // Copyright 2018-2021 Deno Land Inc. All rights reserved. MIT license.
2185 | 
2186 | // deno-lint-ignore-file
2187 | 
2188 | /// <reference no-default-lib="true" />
2189 | /// <reference lib="esnext" />
2190 | 
2191 | declare class FetchEvent extends Event {
2192 |   request: Request;
2193 |   respondWith(response: Response | Promise<Response>): void;
2194 | }
2195 | 
2196 | declare type FetchEventListenerOrFetchEventListenerObject =
2197 |   | FetchEventListener
2198 |   | FetchEventListenerObject;
2199 | 
2200 | interface FetchEventListener {
2201 |   (evt: FetchEvent): void | Promise<void>;
2202 | }
2203 | 
2204 | interface FetchEventListenerObject {
2205 |   handleEvent(evt: FetchEvent): void | Promise<void>;
2206 | }
2207 | 
2208 | declare function addEventListener(
2209 |   type: "fetch",
2210 |   callback: FetchEventListenerOrFetchEventListenerObject | null,
2211 |   options?: boolean | AddEventListenerOptions | undefined,
2212 | ): void;
2213 | 
2214 | 


--------------------------------------------------------------------------------