@comapeo/map-server 1.0.0-pre.0

package/node_modules/@whatwg-node/server/typings/types.d.ts

@@ -0,0 +1,100 @@
+import type { RequestListener } from 'node:http';
+import type { MaybePromise, MaybePromiseLike } from '@whatwg-node/promise-helpers';
+import type { NodeRequest, NodeResponse } from './utils.js';
+import { UWSHandler, UWSRequest, UWSResponse } from './uwebsockets.js';
+export interface FetchEvent extends Event {
+    waitUntil(f: MaybePromise<void>): void;
+    request: Request;
+    respondWith(r: MaybePromiseLike<Response>): void;
+}
+export interface ServerAdapterBaseObject<TServerContext, THandleRequest extends ServerAdapterRequestHandler<TServerContext> = ServerAdapterRequestHandler<TServerContext>> {
+    /**
+     * An async function that takes `Request` and the server context and returns a `Response`.
+     * If you use `requestListener`, the server context is `{ req: IncomingMessage, res: ServerResponse }`.
+     */
+    handle: THandleRequest;
+}
+export interface ServerAdapterObject<TServerContext> extends EventListenerObject, AsyncDisposable {
+    /**
+     * A basic request listener that takes a `Request` with the server context and returns a `Response`.
+     */
+    handleRequest: (request: Request, ctx: TServerContext & Partial<ServerAdapterInitialContext>) => MaybePromise<Response>;
+    /**
+     * WHATWG Fetch spec compliant `fetch` function that can be used for testing purposes.
+     */
+    fetch(request: Request, ctx: TServerContext): MaybePromise<Response>;
+    fetch(request: Request, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    fetch(urlStr: string, ctx: TServerContext): MaybePromise<Response>;
+    fetch(urlStr: string, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    fetch(urlStr: string, init: RequestInit, ctx: TServerContext): MaybePromise<Response>;
+    fetch(urlStr: string, init: RequestInit, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    fetch(url: URL, ctx: TServerContext): MaybePromise<Response>;
+    fetch(url: URL, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    fetch(url: URL, init: RequestInit, ctx: TServerContext): MaybePromise<Response>;
+    fetch(url: URL, init: RequestInit, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    /**
+     * This function takes Node's request object and returns a WHATWG Fetch spec compliant `Response` object.
+     *
+     * @deprecated Use `handleNodeRequestAndResponse` instead.
+     **/
+    handleNodeRequest(nodeRequest: NodeRequest, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+    /**
+     * This function takes Node's request and response objects and returns a WHATWG Fetch spec compliant `Response` object.
+     */
+    handleNodeRequestAndResponse(nodeRequest: NodeRequest, nodeResponseOrContainer: {
+        raw: NodeResponse;
+    } | NodeResponse, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+    /**
+     * A request listener function that can be used with any Node server variation.
+     */
+    requestListener: RequestListener;
+    handleUWS: UWSHandler;
+    handle(req: NodeRequest, res: NodeResponse, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<void>;
+    handle(requestLike: RequestLike, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+    handle(request: Request, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+    handle(request: Request, ...ctx: Partial<TServerContext>[]): MaybePromise<Response>;
+    handle(fetchEvent: FetchEvent & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext>[]): void;
+    handle(res: UWSResponse, req: UWSRequest, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<void>;
+    handle(container: {
+        request: Request;
+    } & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): MaybePromise<Response>;
+    disposableStack: AsyncDisposableStack;
+    dispose(): Promise<void> | void;
+    /**
+     * Register a promise that should be waited in the background for before the server process is exited.
+     *
+     * This also avoids unhandled promise rejections, which would otherwise cause the process to exit on some environment like Node.
+     * @param promise The promise to wait for
+     * @returns
+     */
+    waitUntil: WaitUntilFn;
+}
+export interface RequestLike {
+    url: string;
+    method: string;
+    headers: HeadersLike;
+    body?: AsyncIterable<Uint8Array> | null;
+}
+export interface HeadersLike extends Iterable<[string, string]> {
+    get(name: string): string | null | undefined;
+    set(name: string, value: string): void;
+    has(name: string): boolean;
+}
+export type ServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>> = TBaseObject & ServerAdapterObject<TServerContext>['handle'] & ServerAdapterObject<TServerContext>;
+export type ServerAdapterRequestHandler<TServerContext> = (request: Request, ctx: TServerContext & ServerAdapterInitialContext) => MaybePromise<Response>;
+export type ServerAdapterNodeContext = {
+    req: NodeRequest;
+    res: NodeResponse;
+};
+export type WaitUntilFn = (promise: Promise<void> | void) => void;
+export type FetchAPI = ReturnType<typeof import('@whatwg-node/fetch').createFetch>;
+export type ServerAdapterInitialContext = {
+    /**
+     * Register a promise that should be waited in the background for before the server process is exited.
+     *
+     * This also avoids unhandled promise rejections, which would otherwise cause the process to exit on some environment like Node.
+     * @param promise The promise to wait for
+     * @returns
+     */
+    waitUntil: WaitUntilFn;
+};

package/node_modules/@whatwg-node/server/typings/utils.d.cts

@@ -0,0 +1,42 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import type { Socket } from 'node:net';
+import type { Readable } from 'node:stream';
+import { createDeferredPromise, isPromise, MaybePromise } from '@whatwg-node/promise-helpers';
+import type { FetchAPI, FetchEvent, WaitUntilFn } from './types.cjs';
+export { isPromise, createDeferredPromise };
+export declare function isAsyncIterable(body: any): body is AsyncIterable<any>;
+export interface NodeRequest {
+    protocol?: string | undefined;
+    hostname?: string | undefined;
+    body?: any | undefined;
+    url?: string | undefined;
+    originalUrl?: string | undefined;
+    method?: string | undefined;
+    headers?: any | undefined;
+    req?: IncomingMessage | Http2ServerRequest | undefined;
+    raw?: IncomingMessage | Http2ServerRequest | undefined;
+    socket?: Socket | undefined;
+    query?: any | undefined;
+    once?(event: string, listener: (...args: any[]) => void): void;
+    aborted?: boolean | undefined;
+}
+export type NodeResponse = ServerResponse | Http2ServerResponse;
+export declare function normalizeNodeRequest(nodeRequest: NodeRequest, fetchAPI: FetchAPI, nodeResponse?: NodeResponse, __useCustomAbortCtrl?: boolean): Request;
+export declare function isReadable(stream: any): stream is Readable;
+export declare function isNodeRequest(request: any): request is NodeRequest;
+export declare function isServerResponse(stream: any): stream is NodeResponse;
+export declare function isReadableStream(stream: any): stream is ReadableStream;
+export declare function isFetchEvent(event: any): event is FetchEvent;
+export declare function sendNodeResponse(fetchResponse: Response, serverResponse: NodeResponse, nodeRequest: NodeRequest, __useSingleWriteHead: boolean): MaybePromise<void>;
+export declare function isRequestInit(val: unknown): val is RequestInit;
+export declare function completeAssign(...args: any[]): any;
+export { iterateAsyncVoid } from '@whatwg-node/promise-helpers';
+export declare function handleErrorFromRequestHandler(error: any, ResponseCtor: typeof Response): Response;
+export declare function isolateObject<TIsolatedObject extends object>(originalCtx: TIsolatedObject, waitUntilFn?: WaitUntilFn): TIsolatedObject;
+export declare function handleAbortSignalAndPromiseResponse(response$: MaybePromise<Response>, abortSignal: AbortSignal): MaybePromise<Response>;
+export declare const decompressedResponseMap: WeakMap<Response, Response>;
+export declare function getSupportedEncodings(fetchAPI: FetchAPI): CompressionFormat[];
+export declare function handleResponseDecompression(response: Response, fetchAPI: FetchAPI): Response;
+export declare function ensureDisposableStackRegisteredForTerminateEvents(disposableStack: AsyncDisposableStack): void;
+export declare function createCustomAbortControllerSignal(): AbortController;

package/node_modules/@whatwg-node/server/typings/utils.d.ts

@@ -0,0 +1,42 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import type { Socket } from 'node:net';
+import type { Readable } from 'node:stream';
+import { createDeferredPromise, isPromise, MaybePromise } from '@whatwg-node/promise-helpers';
+import type { FetchAPI, FetchEvent, WaitUntilFn } from './types.js';
+export { isPromise, createDeferredPromise };
+export declare function isAsyncIterable(body: any): body is AsyncIterable<any>;
+export interface NodeRequest {
+    protocol?: string | undefined;
+    hostname?: string | undefined;
+    body?: any | undefined;
+    url?: string | undefined;
+    originalUrl?: string | undefined;
+    method?: string | undefined;
+    headers?: any | undefined;
+    req?: IncomingMessage | Http2ServerRequest | undefined;
+    raw?: IncomingMessage | Http2ServerRequest | undefined;
+    socket?: Socket | undefined;
+    query?: any | undefined;
+    once?(event: string, listener: (...args: any[]) => void): void;
+    aborted?: boolean | undefined;
+}
+export type NodeResponse = ServerResponse | Http2ServerResponse;
+export declare function normalizeNodeRequest(nodeRequest: NodeRequest, fetchAPI: FetchAPI, nodeResponse?: NodeResponse, __useCustomAbortCtrl?: boolean): Request;
+export declare function isReadable(stream: any): stream is Readable;
+export declare function isNodeRequest(request: any): request is NodeRequest;
+export declare function isServerResponse(stream: any): stream is NodeResponse;
+export declare function isReadableStream(stream: any): stream is ReadableStream;
+export declare function isFetchEvent(event: any): event is FetchEvent;
+export declare function sendNodeResponse(fetchResponse: Response, serverResponse: NodeResponse, nodeRequest: NodeRequest, __useSingleWriteHead: boolean): MaybePromise<void>;
+export declare function isRequestInit(val: unknown): val is RequestInit;
+export declare function completeAssign(...args: any[]): any;
+export { iterateAsyncVoid } from '@whatwg-node/promise-helpers';
+export declare function handleErrorFromRequestHandler(error: any, ResponseCtor: typeof Response): Response;
+export declare function isolateObject<TIsolatedObject extends object>(originalCtx: TIsolatedObject, waitUntilFn?: WaitUntilFn): TIsolatedObject;
+export declare function handleAbortSignalAndPromiseResponse(response$: MaybePromise<Response>, abortSignal: AbortSignal): MaybePromise<Response>;
+export declare const decompressedResponseMap: WeakMap<Response, Response>;
+export declare function getSupportedEncodings(fetchAPI: FetchAPI): CompressionFormat[];
+export declare function handleResponseDecompression(response: Response, fetchAPI: FetchAPI): Response;
+export declare function ensureDisposableStackRegisteredForTerminateEvents(disposableStack: AsyncDisposableStack): void;
+export declare function createCustomAbortControllerSignal(): AbortController;

package/node_modules/@whatwg-node/server/typings/uwebsockets.d.cts

@@ -0,0 +1,32 @@
+import { fakePromise } from '@whatwg-node/promise-helpers';
+import type { FetchAPI } from './types.cjs';
+export interface UWSRequest {
+    getMethod(): string;
+    forEach(callback: (key: string, value: string) => void): void;
+    getUrl(): string;
+    getQuery(): string;
+    getHeader(key: string): string | undefined;
+    setYield(y: boolean): void;
+}
+export interface UWSResponse {
+    onData(callback: (chunk: ArrayBuffer, isLast: boolean) => void): void;
+    onAborted(callback: () => void): void;
+    writeStatus(status: string): void;
+    writeHeader(key: string, value: string): void;
+    end(body?: any): void;
+    close(): void;
+    write(body: any): boolean;
+    cork(callback: () => void): void;
+}
+export type UWSHandler = (res: UWSResponse, req: UWSRequest) => void | Promise<void>;
+export declare function isUWSResponse(res: any): res is UWSResponse;
+interface GetRequestFromUWSOpts {
+    req: UWSRequest;
+    res: UWSResponse;
+    fetchAPI: FetchAPI;
+    controller: AbortController;
+}
+export declare function getRequestFromUWSRequest({ req, res, fetchAPI, controller, }: GetRequestFromUWSOpts): Request;
+export declare function createWritableFromUWS(uwsResponse: UWSResponse, fetchAPI: FetchAPI): WritableStream<any>;
+export declare function sendResponseToUwsOpts(uwsResponse: UWSResponse, fetchResponse: Response, controller: AbortController, fetchAPI: FetchAPI): Promise<void> | undefined;
+export { fakePromise };

package/node_modules/@whatwg-node/server/typings/uwebsockets.d.ts

@@ -0,0 +1,32 @@
+import { fakePromise } from '@whatwg-node/promise-helpers';
+import type { FetchAPI } from './types.js';
+export interface UWSRequest {
+    getMethod(): string;
+    forEach(callback: (key: string, value: string) => void): void;
+    getUrl(): string;
+    getQuery(): string;
+    getHeader(key: string): string | undefined;
+    setYield(y: boolean): void;
+}
+export interface UWSResponse {
+    onData(callback: (chunk: ArrayBuffer, isLast: boolean) => void): void;
+    onAborted(callback: () => void): void;
+    writeStatus(status: string): void;
+    writeHeader(key: string, value: string): void;
+    end(body?: any): void;
+    close(): void;
+    write(body: any): boolean;
+    cork(callback: () => void): void;
+}
+export type UWSHandler = (res: UWSResponse, req: UWSRequest) => void | Promise<void>;
+export declare function isUWSResponse(res: any): res is UWSResponse;
+interface GetRequestFromUWSOpts {
+    req: UWSRequest;
+    res: UWSResponse;
+    fetchAPI: FetchAPI;
+    controller: AbortController;
+}
+export declare function getRequestFromUWSRequest({ req, res, fetchAPI, controller, }: GetRequestFromUWSOpts): Request;
+export declare function createWritableFromUWS(uwsResponse: UWSResponse, fetchAPI: FetchAPI): WritableStream<any>;
+export declare function sendResponseToUwsOpts(uwsResponse: UWSResponse, fetchResponse: Response, controller: AbortController, fetchAPI: FetchAPI): Promise<void> | undefined;
+export { fakePromise };

package/node_modules/tslib/CopyrightNotice.txt

@@ -0,0 +1,15 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+

package/node_modules/tslib/LICENSE.txt

@@ -0,0 +1,12 @@
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/node_modules/tslib/README.md

@@ -0,0 +1,164 @@
+# tslib
+
+This is a runtime library for [TypeScript](https://www.typescriptlang.org/) that contains all of the TypeScript helper functions.
+
+This library is primarily used by the `--importHelpers` flag in TypeScript.
+When using `--importHelpers`, a module that uses helper functions like `__extends` and `__assign` in the following emitted file:
+
+```ts
+var __assign = (this && this.__assign) || Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+        s = arguments[i];
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+    }
+    return t;
+};
+exports.x = {};
+exports.y = __assign({}, exports.x);
+
+```
+
+will instead be emitted as something like the following:
+
+```ts
+var tslib_1 = require("tslib");
+exports.x = {};
+exports.y = tslib_1.__assign({}, exports.x);
+```
+
+Because this can avoid duplicate declarations of things like `__extends`, `__assign`, etc., this means delivering users smaller files on average, as well as less runtime overhead.
+For optimized bundles with TypeScript, you should absolutely consider using `tslib` and `--importHelpers`.
+
+# Installing
+
+For the latest stable version, run:
+
+## npm
+
+```sh
+# TypeScript 3.9.2 or later
+npm install tslib
+
+# TypeScript 3.8.4 or earlier
+npm install tslib@^1
+
+# TypeScript 2.3.2 or earlier
+npm install tslib@1.6.1
+```
+
+## yarn
+
+```sh
+# TypeScript 3.9.2 or later
+yarn add tslib
+
+# TypeScript 3.8.4 or earlier
+yarn add tslib@^1
+
+# TypeScript 2.3.2 or earlier
+yarn add tslib@1.6.1
+```
+
+## bower
+
+```sh
+# TypeScript 3.9.2 or later
+bower install tslib
+
+# TypeScript 3.8.4 or earlier
+bower install tslib@^1
+
+# TypeScript 2.3.2 or earlier
+bower install tslib@1.6.1
+```
+
+## JSPM
+
+```sh
+# TypeScript 3.9.2 or later
+jspm install tslib
+
+# TypeScript 3.8.4 or earlier
+jspm install tslib@^1
+
+# TypeScript 2.3.2 or earlier
+jspm install tslib@1.6.1
+```
+
+# Usage
+
+Set the `importHelpers` compiler option on the command line:
+
+```
+tsc --importHelpers file.ts
+```
+
+or in your tsconfig.json:
+
+```json
+{
+    "compilerOptions": {
+        "importHelpers": true
+    }
+}
+```
+
+#### For bower and JSPM users
+
+You will need to add a `paths` mapping for `tslib`, e.g. For Bower users:
+
+```json
+{
+    "compilerOptions": {
+        "module": "amd",
+        "importHelpers": true,
+        "baseUrl": "./",
+        "paths": {
+            "tslib" : ["bower_components/tslib/tslib.d.ts"]
+        }
+    }
+}
+```
+
+For JSPM users:
+
+```json
+{
+    "compilerOptions": {
+        "module": "system",
+        "importHelpers": true,
+        "baseUrl": "./",
+        "paths": {
+            "tslib" : ["jspm_packages/npm/tslib@2.x.y/tslib.d.ts"]
+        }
+    }
+}
+```
+
+## Deployment
+
+- Choose your new version number
+- Set it in `package.json` and `bower.json`
+- Create a tag: `git tag [version]`
+- Push the tag: `git push --tags`
+- Create a [release in GitHub](https://github.com/microsoft/tslib/releases)
+- Run the [publish to npm](https://github.com/microsoft/tslib/actions?query=workflow%3A%22Publish+to+NPM%22) workflow
+
+Done.
+
+# Contribute
+
+There are many ways to [contribute](https://github.com/Microsoft/TypeScript/blob/master/CONTRIBUTING.md) to TypeScript.
+
+* [Submit bugs](https://github.com/Microsoft/TypeScript/issues) and help us verify fixes as they are checked in.
+* Review the [source code changes](https://github.com/Microsoft/TypeScript/pulls).
+* Engage with other TypeScript users and developers on [StackOverflow](http://stackoverflow.com/questions/tagged/typescript).
+* Join the [#typescript](http://twitter.com/#!/search/realtime/%23typescript) discussion on Twitter.
+* [Contribute bug fixes](https://github.com/Microsoft/TypeScript/blob/master/CONTRIBUTING.md).
+
+# Documentation
+
+* [Quick tutorial](http://www.typescriptlang.org/Tutorial)
+* [Programming handbook](http://www.typescriptlang.org/Handbook)
+* [Homepage](http://www.typescriptlang.org/)

package/node_modules/tslib/SECURITY.md

@@ -0,0 +1,41 @@
+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.7 BLOCK -->
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
+
+If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc). 
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
+
+<!-- END MICROSOFT SECURITY.MD BLOCK -->

package/node_modules/tslib/modules/index.d.ts

@@ -0,0 +1,38 @@
+// Note: named reexports are used instead of `export *` because
+// TypeScript itself doesn't resolve the `export *` when checking
+// if a particular helper exists.
+export {
+  __extends,
+  __assign,
+  __rest,
+  __decorate,
+  __param,
+  __esDecorate,
+  __runInitializers,
+  __propKey,
+  __setFunctionName,
+  __metadata,
+  __awaiter,
+  __generator,
+  __exportStar,
+  __values,
+  __read,
+  __spread,
+  __spreadArrays,
+  __spreadArray,
+  __await,
+  __asyncGenerator,
+  __asyncDelegator,
+  __asyncValues,
+  __makeTemplateObject,
+  __importStar,
+  __importDefault,
+  __classPrivateFieldGet,
+  __classPrivateFieldSet,
+  __classPrivateFieldIn,
+  __createBinding,
+  __addDisposableResource,
+  __disposeResources,
+  __rewriteRelativeImportExtension,
+} from '../tslib.js';
+export * as default from '../tslib.js';

package/node_modules/tslib/modules/index.js

@@ -0,0 +1,70 @@
+import tslib from '../tslib.js';
+const {
+    __extends,
+    __assign,
+    __rest,
+    __decorate,
+    __param,
+    __esDecorate,
+    __runInitializers,
+    __propKey,
+    __setFunctionName,
+    __metadata,
+    __awaiter,
+    __generator,
+    __exportStar,
+    __createBinding,
+    __values,
+    __read,
+    __spread,
+    __spreadArrays,
+    __spreadArray,
+    __await,
+    __asyncGenerator,
+    __asyncDelegator,
+    __asyncValues,
+    __makeTemplateObject,
+    __importStar,
+    __importDefault,
+    __classPrivateFieldGet,
+    __classPrivateFieldSet,
+    __classPrivateFieldIn,
+    __addDisposableResource,
+    __disposeResources,
+    __rewriteRelativeImportExtension,
+} = tslib;
+export {
+    __extends,
+    __assign,
+    __rest,
+    __decorate,
+    __param,
+    __esDecorate,
+    __runInitializers,
+    __propKey,
+    __setFunctionName,
+    __metadata,
+    __awaiter,
+    __generator,
+    __exportStar,
+    __createBinding,
+    __values,
+    __read,
+    __spread,
+    __spreadArrays,
+    __spreadArray,
+    __await,
+    __asyncGenerator,
+    __asyncDelegator,
+    __asyncValues,
+    __makeTemplateObject,
+    __importStar,
+    __importDefault,
+    __classPrivateFieldGet,
+    __classPrivateFieldSet,
+    __classPrivateFieldIn,
+    __addDisposableResource,
+    __disposeResources,
+    __rewriteRelativeImportExtension,
+};
+export default tslib;

package/node_modules/tslib/modules/package.json

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

package/node_modules/tslib/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "tslib",
+    "author": "Microsoft Corp.",
+    "homepage": "https://www.typescriptlang.org/",
+    "version": "2.8.1",
+    "license": "0BSD",
+    "description": "Runtime library for TypeScript helper functions",
+    "keywords": [
+        "TypeScript",
+        "Microsoft",
+        "compiler",
+        "language",
+        "javascript",
+        "tslib",
+        "runtime"
+    ],
+    "bugs": {
+        "url": "https://github.com/Microsoft/TypeScript/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Microsoft/tslib.git"
+    },
+    "main": "tslib.js",
+    "module": "tslib.es6.js",
+    "jsnext:main": "tslib.es6.js",
+    "typings": "tslib.d.ts",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "module": {
+                "types": "./modules/index.d.ts",
+                "default": "./tslib.es6.mjs"
+            },
+            "import": {
+                "node": "./modules/index.js",
+                "default": {
+                    "types": "./modules/index.d.ts",
+                    "default": "./tslib.es6.mjs"
+                }
+            },
+            "default": "./tslib.js"
+        },
+        "./*": "./*",
+        "./": "./"
+    }
+}