rahad-media-downloader 1.0.2

package/.cache/typescript/5.3/node_modules/@types/jsdom/base.d.ts

@@ -0,0 +1,456 @@
+/// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
+/// <reference types="node" />
+
+import { EventEmitter } from "events";
+import { Token } from "parse5";
+import * as tough from "tough-cookie";
+import { Context } from "vm";
+
+// Needed to allow adding properties to `DOMWindow` that are only supported
+// in newer TypeScript versions:
+// eslint-disable-next-line @definitelytyped/no-declare-current-package
+declare module "jsdom" {
+    const toughCookie: typeof tough;
+    class CookieJar extends tough.CookieJar {}
+
+    interface AbortablePromise<T> extends Promise<T> {
+        abort(): void;
+    }
+
+    class JSDOM {
+        constructor(html?: string | Buffer | BinaryData, options?: ConstructorOptions);
+
+        static fromURL(url: string, options?: BaseOptions): Promise<JSDOM>;
+        static fromFile(url: string, options?: FileOptions): Promise<JSDOM>;
+        static fragment(html: string): DocumentFragment;
+
+        readonly window: DOMWindow;
+        readonly virtualConsole: VirtualConsole;
+        readonly cookieJar: CookieJar;
+
+        /**
+         * The serialize() method will return the HTML serialization of the document, including the doctype.
+         */
+        serialize(): string;
+
+        /**
+         * The nodeLocation() method will find where a DOM node is within the source document,
+         * returning the parse5 location info for the node.
+         *
+         * @throws {Error} If the JSDOM was not created with `includeNodeLocations`
+         */
+        nodeLocation(node: Node): Token.Location | null | undefined;
+
+        /**
+         * The built-in `vm` module of Node.js is what underpins JSDOM's script-running magic.
+         * Some advanced use cases, like pre-compiling a script and then running it multiple
+         * times, benefit from using the `vm` module directly with a jsdom-created `Window`.
+         *
+         * @throws {TypeError} If the `JSDOM` instance was created without `runScripts` set, or if you are using JSDOM in a web browser.
+         */
+        getInternalVMContext(): Context;
+
+        /**
+         * The reconfigure method allows changing the `window.top` and url from the outside.
+         */
+        reconfigure(settings: ReconfigureSettings): void;
+    }
+
+    class ResourceLoader {
+        fetch(url: string, options: FetchOptions): AbortablePromise<Buffer> | null;
+
+        constructor(obj?: ResourceLoaderConstructorOptions);
+    }
+
+    class VirtualConsole extends EventEmitter {
+        on<K extends keyof Console>(method: K, callback: Console[K]): this;
+        on(event: "jsdomError", callback: (e: Error) => void): this;
+
+        sendTo(console: Console, options?: VirtualConsoleSendToOptions): this;
+    }
+
+    type BinaryData = ArrayBufferLike | NodeJS.ArrayBufferView;
+    interface BaseOptions {
+        /**
+         * referrer just affects the value read from document.referrer.
+         * It defaults to no referrer (which reflects as the empty string).
+         */
+        referrer?: string | undefined;
+
+        /**
+         * userAgent affects the value read from navigator.userAgent, as well as the User-Agent header sent while fetching subresources.
+         *
+         * @default
+         * `Mozilla/5.0 (${process.platform}) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/${jsdomVersion}`
+         */
+        userAgent?: string | undefined;
+
+        /**
+         * `includeNodeLocations` preserves the location info produced by the HTML parser,
+         * allowing you to retrieve it with the nodeLocation() method (described below).
+         *
+         * It defaults to false to give the best performance,
+         * and cannot be used with an XML content type since our XML parser does not support location info.
+         *
+         * @default false
+         */
+        includeNodeLocations?: boolean | undefined;
+        runScripts?: "dangerously" | "outside-only" | undefined;
+        resources?: "usable" | ResourceLoader | undefined;
+        virtualConsole?: VirtualConsole | undefined;
+        cookieJar?: CookieJar | undefined;
+
+        /**
+         * jsdom does not have the capability to render visual content, and will act like a headless browser by default.
+         * It provides hints to web pages through APIs such as document.hidden that their content is not visible.
+         *
+         * When the `pretendToBeVisual` option is set to `true`, jsdom will pretend that it is rendering and displaying
+         * content.
+         *
+         * @default false
+         */
+        pretendToBeVisual?: boolean | undefined;
+        beforeParse?(window: DOMWindow): void;
+    }
+
+    interface FileOptions extends BaseOptions {
+        /**
+         * url sets the value returned by window.location, document.URL, and document.documentURI,
+         * and affects things like resolution of relative URLs within the document
+         * and the same-origin restrictions and referrer used while fetching subresources.
+         * It will default to a file URL corresponding to the given filename, instead of to "about:blank".
+         */
+        url?: string | undefined;
+
+        /**
+         * contentType affects the value read from document.contentType, and how the document is parsed: as HTML or as XML.
+         * Values that are not "text/html" or an XML mime type will throw. It will default to "application/xhtml+xml" if
+         * the given filename ends in .xhtml or .xml; otherwise it will continue to default to "text/html".
+         */
+        contentType?: string | undefined;
+    }
+
+    interface ConstructorOptions extends BaseOptions {
+        /**
+         * url sets the value returned by window.location, document.URL, and document.documentURI,
+         * and affects things like resolution of relative URLs within the document
+         * and the same-origin restrictions and referrer used while fetching subresources.
+         * It defaults to "about:blank".
+         */
+        url?: string | undefined;
+
+        /**
+         * contentType affects the value read from document.contentType, and how the document is parsed: as HTML or as XML.
+         * Values that are not "text/html" or an XML mime type will throw. It defaults to "text/html".
+         */
+        contentType?: SupportedContentTypes | undefined;
+
+        /**
+         * The maximum size in code units for the separate storage areas used by localStorage and sessionStorage.
+         * Attempts to store data larger than this limit will cause a DOMException to be thrown. By default, it is set
+         * to 5,000,000 code units per origin, as inspired by the HTML specification.
+         *
+         * @default 5_000_000
+         */
+        storageQuota?: number | undefined;
+    }
+
+    type SupportedContentTypes =
+        | "text/html"
+        | "application/xhtml+xml"
+        | "application/xml"
+        | "text/xml"
+        | "image/svg+xml";
+
+    interface VirtualConsoleSendToOptions {
+        omitJSDOMErrors: boolean;
+    }
+
+    interface ReconfigureSettings {
+        windowTop?: DOMWindow | undefined;
+        url?: string | undefined;
+    }
+
+    interface FetchOptions {
+        cookieJar?: CookieJar | undefined;
+        referrer?: string | undefined;
+        accept?: string | undefined;
+        element?: HTMLScriptElement | HTMLLinkElement | HTMLIFrameElement | HTMLImageElement | undefined;
+    }
+
+    interface ResourceLoaderConstructorOptions {
+        strictSSL?: boolean | undefined;
+        proxy?: string | undefined;
+        userAgent?: string | undefined;
+    }
+
+    interface DOMWindow extends Omit<Window, "top" | "self" | "window"> {
+        [key: string]: any;
+
+        /* node_modules/jsdom/browser/Window.js */
+        Window: typeof Window;
+        readonly top: DOMWindow;
+        readonly self: DOMWindow;
+        readonly window: DOMWindow;
+
+        /* ECMAScript Globals */
+        globalThis: DOMWindow;
+        readonly ["Infinity"]: number;
+        readonly ["NaN"]: number;
+        readonly undefined: undefined;
+
+        eval(script: string): unknown;
+        parseInt(s: string, radix?: number): number;
+        parseFloat(string: string): number;
+        isNaN(number: number): boolean;
+        isFinite(number: number): boolean;
+        decodeURI(encodedURI: string): string;
+        decodeURIComponent(encodedURIComponent: string): string;
+        encodeURI(uri: string): string;
+        encodeURIComponent(uriComponent: string | number | boolean): string;
+        escape(string: string): string;
+        unescape(string: string): string;
+
+        Array: typeof Array;
+        ArrayBuffer: typeof ArrayBuffer;
+        Atomics: typeof Atomics;
+        BigInt: typeof BigInt;
+        BigInt64Array: typeof BigInt64Array;
+        BigUint64Array: typeof BigUint64Array;
+        Boolean: typeof Boolean;
+        DataView: typeof DataView;
+        Date: typeof Date;
+        Error: typeof Error;
+        EvalError: typeof EvalError;
+        Float32Array: typeof Float32Array;
+        Float64Array: typeof Float64Array;
+        Function: typeof Function;
+        Int16Array: typeof Int16Array;
+        Int32Array: typeof Int32Array;
+        Int8Array: typeof Int8Array;
+        Intl: typeof Intl;
+        JSON: typeof JSON;
+        Map: typeof Map;
+        Math: typeof Math;
+        Number: typeof Number;
+        Object: typeof Object;
+        Promise: typeof Promise;
+        Proxy: typeof Proxy;
+        RangeError: typeof RangeError;
+        ReferenceError: typeof ReferenceError;
+        Reflect: typeof Reflect;
+        RegExp: typeof RegExp;
+        Set: typeof Set;
+        SharedArrayBuffer: typeof SharedArrayBuffer;
+        String: typeof String;
+        Symbol: typeof Symbol;
+        SyntaxError: typeof SyntaxError;
+        TypeError: typeof TypeError;
+        URIError: typeof URIError;
+        Uint16Array: typeof Uint16Array;
+        Uint32Array: typeof Uint32Array;
+        Uint8Array: typeof Uint8Array;
+        Uint8ClampedArray: typeof Uint8ClampedArray;
+        WeakMap: typeof WeakMap;
+        WeakSet: typeof WeakSet;
+        WebAssembly: typeof WebAssembly;
+
+        /* node_modules/jsdom/living/interfaces.js */
+        DOMException: typeof DOMException;
+
+        URL: typeof URL;
+        URLSearchParams: typeof URLSearchParams;
+
+        EventTarget: typeof EventTarget;
+
+        NamedNodeMap: typeof NamedNodeMap;
+        Node: typeof Node;
+        Attr: typeof Attr;
+        Element: typeof Element;
+        DocumentFragment: typeof DocumentFragment;
+        DOMImplementation: typeof DOMImplementation;
+        Document: typeof Document;
+        HTMLDocument: typeof HTMLDocument;
+        XMLDocument: typeof XMLDocument;
+        CharacterData: typeof CharacterData;
+        Text: typeof Text;
+        CDATASection: typeof CDATASection;
+        ProcessingInstruction: typeof ProcessingInstruction;
+        Comment: typeof Comment;
+        DocumentType: typeof DocumentType;
+        NodeList: typeof NodeList;
+        HTMLCollection: typeof HTMLCollection;
+        HTMLOptionsCollection: typeof HTMLOptionsCollection;
+        DOMStringMap: typeof DOMStringMap;
+        DOMTokenList: typeof DOMTokenList;
+
+        StyleSheetList: typeof StyleSheetList;
+
+        HTMLElement: typeof HTMLElement;
+        HTMLHeadElement: typeof HTMLHeadElement;
+        HTMLTitleElement: typeof HTMLTitleElement;
+        HTMLBaseElement: typeof HTMLBaseElement;
+        HTMLLinkElement: typeof HTMLLinkElement;
+        HTMLMetaElement: typeof HTMLMetaElement;
+        HTMLStyleElement: typeof HTMLStyleElement;
+        HTMLBodyElement: typeof HTMLBodyElement;
+        HTMLHeadingElement: typeof HTMLHeadingElement;
+        HTMLParagraphElement: typeof HTMLParagraphElement;
+        HTMLHRElement: typeof HTMLHRElement;
+        HTMLPreElement: typeof HTMLPreElement;
+        HTMLUListElement: typeof HTMLUListElement;
+        HTMLOListElement: typeof HTMLOListElement;
+        HTMLLIElement: typeof HTMLLIElement;
+        HTMLMenuElement: typeof HTMLMenuElement;
+        HTMLDListElement: typeof HTMLDListElement;
+        HTMLDivElement: typeof HTMLDivElement;
+        HTMLAnchorElement: typeof HTMLAnchorElement;
+        HTMLAreaElement: typeof HTMLAreaElement;
+        HTMLBRElement: typeof HTMLBRElement;
+        HTMLButtonElement: typeof HTMLButtonElement;
+        HTMLCanvasElement: typeof HTMLCanvasElement;
+        HTMLDataElement: typeof HTMLDataElement;
+        HTMLDataListElement: typeof HTMLDataListElement;
+        HTMLDetailsElement: typeof HTMLDetailsElement;
+        HTMLDialogElement: {
+            new(): HTMLDialogElement;
+            readonly prototype: HTMLDialogElement;
+        };
+        HTMLDirectoryElement: typeof HTMLDirectoryElement;
+        HTMLFieldSetElement: typeof HTMLFieldSetElement;
+        HTMLFontElement: typeof HTMLFontElement;
+        HTMLFormElement: typeof HTMLFormElement;
+        HTMLHtmlElement: typeof HTMLHtmlElement;
+        HTMLImageElement: typeof HTMLImageElement;
+        HTMLInputElement: typeof HTMLInputElement;
+        HTMLLabelElement: typeof HTMLLabelElement;
+        HTMLLegendElement: typeof HTMLLegendElement;
+        HTMLMapElement: typeof HTMLMapElement;
+        HTMLMarqueeElement: typeof HTMLMarqueeElement;
+        HTMLMediaElement: typeof HTMLMediaElement;
+        HTMLMeterElement: typeof HTMLMeterElement;
+        HTMLModElement: typeof HTMLModElement;
+        HTMLOptGroupElement: typeof HTMLOptGroupElement;
+        HTMLOptionElement: typeof HTMLOptionElement;
+        HTMLOutputElement: typeof HTMLOutputElement;
+        HTMLPictureElement: typeof HTMLPictureElement;
+        HTMLProgressElement: typeof HTMLProgressElement;
+        HTMLQuoteElement: typeof HTMLQuoteElement;
+        HTMLScriptElement: typeof HTMLScriptElement;
+        HTMLSelectElement: typeof HTMLSelectElement;
+        HTMLSlotElement: typeof HTMLSlotElement;
+        HTMLSourceElement: typeof HTMLSourceElement;
+        HTMLSpanElement: typeof HTMLSpanElement;
+        HTMLTableCaptionElement: typeof HTMLTableCaptionElement;
+        HTMLTableCellElement: typeof HTMLTableCellElement;
+        HTMLTableColElement: typeof HTMLTableColElement;
+        HTMLTableElement: typeof HTMLTableElement;
+        HTMLTimeElement: typeof HTMLTimeElement;
+        HTMLTableRowElement: typeof HTMLTableRowElement;
+        HTMLTableSectionElement: typeof HTMLTableSectionElement;
+        HTMLTemplateElement: typeof HTMLTemplateElement;
+        HTMLTextAreaElement: typeof HTMLTextAreaElement;
+        HTMLUnknownElement: typeof HTMLUnknownElement;
+        HTMLFrameElement: typeof HTMLFrameElement;
+        HTMLFrameSetElement: typeof HTMLFrameSetElement;
+        HTMLIFrameElement: typeof HTMLIFrameElement;
+        HTMLEmbedElement: typeof HTMLEmbedElement;
+        HTMLObjectElement: typeof HTMLObjectElement;
+        HTMLParamElement: typeof HTMLParamElement;
+        HTMLVideoElement: typeof HTMLVideoElement;
+        HTMLAudioElement: typeof HTMLAudioElement;
+        HTMLTrackElement: typeof HTMLTrackElement;
+
+        SVGElement: typeof SVGElement;
+        SVGGraphicsElement: typeof SVGGraphicsElement;
+        SVGSVGElement: typeof SVGSVGElement;
+        SVGTitleElement: typeof SVGTitleElement;
+        SVGAnimatedString: typeof SVGAnimatedString;
+        SVGNumber: typeof SVGNumber;
+        SVGStringList: typeof SVGStringList;
+
+        Event: typeof Event;
+        CloseEvent: typeof CloseEvent;
+        CustomEvent: typeof CustomEvent;
+        MessageEvent: typeof MessageEvent;
+        ErrorEvent: typeof ErrorEvent;
+        HashChangeEvent: typeof HashChangeEvent;
+        PopStateEvent: typeof PopStateEvent;
+        StorageEvent: typeof StorageEvent;
+        ProgressEvent: typeof ProgressEvent;
+        PageTransitionEvent: typeof PageTransitionEvent;
+
+        UIEvent: typeof UIEvent;
+        FocusEvent: typeof FocusEvent;
+        MouseEvent: typeof MouseEvent;
+        KeyboardEvent: typeof KeyboardEvent;
+        TouchEvent: typeof TouchEvent;
+        CompositionEvent: typeof CompositionEvent;
+        WheelEvent: typeof WheelEvent;
+
+        BarProp: typeof BarProp;
+        Location: typeof Location;
+        History: typeof History;
+        Screen: typeof Screen;
+        Performance: typeof Performance;
+        Navigator: typeof Navigator;
+
+        PluginArray: typeof PluginArray;
+        MimeTypeArray: typeof MimeTypeArray;
+        Plugin: typeof Plugin;
+        MimeType: typeof MimeType;
+
+        FileReader: typeof FileReader;
+        Blob: typeof Blob;
+        File: typeof File;
+        FileList: typeof FileList;
+        ValidityState: typeof ValidityState;
+
+        DOMParser: typeof DOMParser;
+        XMLSerializer: typeof XMLSerializer;
+
+        FormData: typeof FormData;
+        XMLHttpRequestEventTarget: typeof XMLHttpRequestEventTarget;
+        XMLHttpRequestUpload: typeof XMLHttpRequestUpload;
+        XMLHttpRequest: typeof XMLHttpRequest;
+        WebSocket: typeof WebSocket;
+
+        NodeFilter: typeof NodeFilter;
+        NodeIterator: typeof NodeIterator;
+        TreeWalker: typeof TreeWalker;
+
+        AbstractRange: typeof AbstractRange;
+        Range: typeof Range;
+        StaticRange: typeof StaticRange;
+        Selection: typeof Selection;
+
+        Storage: typeof Storage;
+
+        CustomElementRegistry: typeof CustomElementRegistry;
+        ShadowRoot: typeof ShadowRoot;
+
+        MutationObserver: typeof MutationObserver;
+        MutationRecord: typeof MutationRecord;
+
+        Headers: typeof Headers;
+        AbortController: typeof AbortController;
+        AbortSignal: typeof AbortSignal;
+
+        /* node_modules/jsdom/level2/style.js */
+        StyleSheet: typeof StyleSheet;
+        MediaList: typeof MediaList;
+        CSSStyleSheet: typeof CSSStyleSheet;
+        CSSRule: typeof CSSRule;
+        CSSStyleRule: typeof CSSStyleRule;
+        CSSMediaRule: typeof CSSMediaRule;
+        CSSImportRule: typeof CSSImportRule;
+        CSSStyleDeclaration: typeof CSSStyleDeclaration;
+
+        /* node_modules/jsdom/level3/xpath.js */
+        // XPathException: typeof XPathException;
+        XPathExpression: typeof XPathExpression;
+        XPathResult: typeof XPathResult;
+        XPathEvaluator: typeof XPathEvaluator;
+    }
+}

package/.cache/typescript/5.3/node_modules/@types/jsdom/index.d.ts

@@ -0,0 +1,18 @@
+/// <reference path="base.d.ts"/>
+
+// eslint-disable-next-line @definitelytyped/no-declare-current-package
+declare module "jsdom" {
+    interface DOMWindow {
+        FinalizationRegistry: FinalizationRegistryConstructor;
+        WeakRef: WeakRefConstructor;
+        InputEvent: typeof InputEvent;
+        External: typeof External;
+    }
+}
+
+// Necessary to avoid breaking dependents because of the dependency
+// on the `ESNext.WeakRef` lib:
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface FinalizationRegistryConstructor {}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface WeakRefConstructor {}

package/.cache/typescript/5.3/node_modules/@types/jsdom/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@types/jsdom",
+    "version": "21.1.6",
+    "description": "TypeScript definitions for jsdom",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/jsdom",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Leonard Thieu",
+            "githubUsername": "leonard-thieu",
+            "url": "https://github.com/leonard-thieu"
+        },
+        {
+            "name": "Johan Palmfjord",
+            "githubUsername": "palmfjord",
+            "url": "https://github.com/palmfjord"
+        },
+        {
+            "name": "ExE Boss",
+            "githubUsername": "ExE-Boss",
+            "url": "https://github.com/ExE-Boss"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./index.d.ts"
+        },
+        "./package.json": "./package.json"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/jsdom"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/node": "*",
+        "@types/tough-cookie": "*",
+        "parse5": "^7.0.0"
+    },
+    "typesPublisherContentHash": "367c61c03f27a6233d260f9ad45a105daa2a6430fc0cd81549c4edbef166c9fc",
+    "typeScriptVersion": "4.5"
+}

package/.cache/typescript/5.3/node_modules/@types/node/LICENSE

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

package/.cache/typescript/5.3/node_modules/@types/node/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/node`
+
+# Summary
+This package contains type definitions for node (https://nodejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
+
+### Additional Details
+ * Last updated: Thu, 07 Dec 2023 07:07:09 GMT
+ * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
+
+# Credits
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Victor Perin](https://github.com/victorperin), [Yongsheng Zhang](https://github.com/ZYSzys), [NodeJS Contributors](https://github.com/NodeJS), [Linus Unnebäck](https://github.com/LinusU), [wafuwafu13](https://github.com/wafuwafu13), [Matteo Collina](https://github.com/mcollina), and [Dmitry Semigradsky](https://github.com/Semigradsky).

package/.cache/typescript/5.3/node_modules/@types/node/assert/strict.d.ts

@@ -0,0 +1,8 @@
+declare module "assert/strict" {
+    import { strict } from "node:assert";
+    export = strict;
+}
+declare module "node:assert/strict" {
+    import { strict } from "node:assert";
+    export = strict;
+}