@aligent/cdk-prerender-proxy 0.2.4 → 0.2.5-beta

package/lib/handlers/node_modules/@middy/core/index.cjs

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(module, "exports", {
+    enumerable: true,
+    get: ()=>_default
+});
+const _events = require("events");
+const defaultLambdaHandler = ()=>{};
+const defaultPlugin = {
+    timeoutEarlyInMillis: 5,
+    timeoutEarlyResponse: ()=>{
+        throw new Error('Timeout');
+    }
+};
+const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
+    if (typeof lambdaHandler !== 'function') {
+        plugin = lambdaHandler;
+        lambdaHandler = defaultLambdaHandler;
+    }
+    plugin = {
+        ...defaultPlugin,
+        ...plugin
+    };
+    plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0;
+    plugin.beforePrefetch?.();
+    const beforeMiddlewares = [];
+    const afterMiddlewares = [];
+    const onErrorMiddlewares = [];
+    const middy = (event = {}, context = {})=>{
+        plugin.requestStart?.();
+        const request = {
+            event,
+            context,
+            response: undefined,
+            error: undefined,
+            internal: plugin.internal ?? {}
+        };
+        return runRequest(request, [
+            ...beforeMiddlewares
+        ], lambdaHandler, [
+            ...afterMiddlewares
+        ], [
+            ...onErrorMiddlewares
+        ], plugin);
+    };
+    middy.use = (middlewares)=>{
+        if (!Array.isArray(middlewares)) {
+            middlewares = [
+                middlewares
+            ];
+        }
+        for (const middleware of middlewares){
+            const { before , after , onError  } = middleware;
+            if (!before && !after && !onError) {
+                throw new Error('Middleware must be an object containing at least one key among "before", "after", "onError"');
+            }
+            if (before) middy.before(before);
+            if (after) middy.after(after);
+            if (onError) middy.onError(onError);
+        }
+        return middy;
+    };
+    middy.before = (beforeMiddleware)=>{
+        beforeMiddlewares.push(beforeMiddleware);
+        return middy;
+    };
+    middy.after = (afterMiddleware)=>{
+        afterMiddlewares.unshift(afterMiddleware);
+        return middy;
+    };
+    middy.onError = (onErrorMiddleware)=>{
+        onErrorMiddlewares.unshift(onErrorMiddleware);
+        return middy;
+    };
+    middy.handler = (replaceLambdaHandler)=>{
+        lambdaHandler = replaceLambdaHandler;
+        return middy;
+    };
+    return middy;
+};
+const runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddlewares, onErrorMiddlewares, plugin)=>{
+    const timeoutEarly = plugin.timeoutEarly && request.context.getRemainingTimeInMillis;
+    try {
+        await runMiddlewares(request, beforeMiddlewares, plugin);
+        if (typeof request.response === 'undefined') {
+            plugin.beforeHandler?.();
+            const handlerAbort = new AbortController();
+            let timeoutAbort;
+            if (timeoutEarly) timeoutAbort = new AbortController();
+            request.response = await Promise.race([
+                lambdaHandler(request.event, request.context, {
+                    signal: handlerAbort.signal
+                }),
+                timeoutEarly ? setTimeoutPromise(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, {
+                    signal: timeoutAbort.signal
+                }).then(()=>{
+                    handlerAbort.abort();
+                    return plugin.timeoutEarlyResponse();
+                }) : Promise.race([])
+            ]);
+            if (timeoutEarly) timeoutAbort.abort();
+            plugin.afterHandler?.();
+            await runMiddlewares(request, afterMiddlewares, plugin);
+        }
+    } catch (e1) {
+        request.response = undefined;
+        request.error = e1;
+        try {
+            await runMiddlewares(request, onErrorMiddlewares, plugin);
+        } catch (e) {
+            e.originalError = request.error;
+            request.error = e;
+            throw request.error;
+        }
+        if (typeof request.response === 'undefined') throw request.error;
+    } finally{
+        await plugin.requestEnd?.(request);
+    }
+    return request.response;
+};
+const runMiddlewares = async (request, middlewares, plugin)=>{
+    for (const nextMiddleware of middlewares){
+        plugin.beforeMiddleware?.(nextMiddleware.name);
+        const res = await nextMiddleware(request);
+        plugin.afterMiddleware?.(nextMiddleware.name);
+        if (typeof res !== 'undefined') {
+            request.response = res;
+            return;
+        }
+    }
+};
+const polyfillAbortController = ()=>{
+    if (process.version < 'v15.0.0') {
+        class AbortSignal {
+            toString() {
+                return '[object AbortSignal]';
+            }
+            get [Symbol.toStringTag]() {
+                return 'AbortSignal';
+            }
+            removeEventListener(name, handler) {
+                this.eventEmitter.removeListener(name, handler);
+            }
+            addEventListener(name, handler) {
+                this.eventEmitter.on(name, handler);
+            }
+            dispatchEvent(type) {
+                const event = {
+                    type,
+                    target: this
+                };
+                const handlerName = `on${type}`;
+                if (typeof this[handlerName] === 'function') this[handlerName](event);
+                this.eventEmitter.emit(type, event);
+            }
+            constructor(){
+                this.eventEmitter = new _events.EventEmitter();
+                this.onabort = null;
+                this.aborted = false;
+            }
+        }
+        return class AbortController1 {
+            abort() {
+                if (this.signal.aborted) return;
+                this.signal.aborted = true;
+                this.signal.dispatchEvent('abort');
+            }
+            toString() {
+                return '[object AbortController]';
+            }
+            get [Symbol.toStringTag]() {
+                return 'AbortController';
+            }
+            constructor(){
+                this.signal = new AbortSignal();
+            }
+        };
+    } else {
+        return AbortController;
+    }
+};
+global.AbortController = polyfillAbortController();
+const polyfillSetTimeoutPromise = ()=>{
+    return (ms, { signal  })=>{
+        if (signal.aborted) {
+            return Promise.reject(new Error('Aborted', 'AbortError'));
+        }
+        return new Promise((resolve, reject)=>{
+            const abortHandler = ()=>{
+                clearTimeout(timeout);
+                reject(new Error('Aborted', 'AbortError'));
+            };
+            const timeout = setTimeout(()=>{
+                resolve();
+                signal.removeEventListener('abort', abortHandler);
+            }, ms);
+            signal.addEventListener('abort', abortHandler);
+        });
+    };
+};
+const setTimeoutPromise = polyfillSetTimeoutPromise();
+const _default = middy;
+
+
+//# sourceMappingURL=index.cjs.map

package/lib/handlers/node_modules/@middy/core/index.d.ts

@@ -0,0 +1,91 @@
+import {
+  Callback as LambdaCallback,
+  Context as LambdaContext,
+  Handler as LambdaHandler
+} from 'aws-lambda'
+
+declare type PluginHook = () => void
+declare type PluginHookWithMiddlewareName = (middlewareName: string) => void
+declare type PluginHookPromise = (request: Request) => Promise<unknown> | unknown
+
+interface PluginObject {
+  internal?: any
+  beforePrefetch?: PluginHook
+  requestStart?: PluginHook
+  beforeMiddleware?: PluginHookWithMiddlewareName
+  afterMiddleware?: PluginHookWithMiddlewareName
+  beforeHandler?: PluginHook
+  timeoutEarlyInMillis?: number
+  timeoutEarlyResponse?: PluginHook
+  afterHandler?: PluginHook
+  requestEnd?: PluginHookPromise
+}
+
+interface Request<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> {
+  event: TEvent
+  context: TContext
+  response: TResult | null
+  error: TErr | null
+  internal: {
+    [key: string]: any
+  }
+}
+
+declare type MiddlewareFn<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> = (request: Request<TEvent, TResult, TErr, TContext>) => any
+
+export interface MiddlewareObj<TEvent = unknown, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> {
+  before?: MiddlewareFn<TEvent, TResult, TErr, TContext>
+  after?: MiddlewareFn<TEvent, TResult, TErr, TContext>
+  onError?: MiddlewareFn<TEvent, TResult, TErr, TContext>
+}
+
+// The AWS provided Handler type uses void | Promise<TResult> so we have no choice but to follow and suppress the linter warning
+// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+type MiddyInputHandler<TEvent, TResult, TContext extends LambdaContext = LambdaContext> = (event: TEvent, context: TContext, callback: LambdaCallback<TResult>) => void | Promise<TResult>
+type MiddyInputPromiseHandler<TEvent, TResult, TContext extends LambdaContext = LambdaContext> = (event: TEvent, context: TContext,) => Promise<TResult>
+
+export interface MiddyfiedHandler<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> extends MiddyInputHandler<TEvent, TResult, TContext>,
+  MiddyInputPromiseHandler<TEvent, TResult, TContext> {
+  use: UseFn<TEvent, TResult, TErr, TContext>
+  before: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
+  after: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
+  onError: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
+  handler: (handler: MiddlewareHandler<LambdaHandler<TEvent, TResult>, TContext>) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+}
+
+declare type AttachMiddlewareFn<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> =
+  (middleware: MiddlewareFn<TEvent, TResult, TErr, TContext>) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+
+declare type AttachMiddlewareObj<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> =
+  (middleware: MiddlewareObj<TEvent, TResult, TErr, TContext>) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+
+declare type UseFn<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> =
+  <TMiddleware extends MiddlewareObj<any, any, Error, any>>(middlewares: TMiddleware | TMiddleware[]) => TMiddleware extends MiddlewareObj<infer TMiddlewareEvent, any, Error, infer TMiddlewareContext>
+    ? MiddyfiedHandler<TMiddlewareEvent & TEvent, TResult, TErr, TMiddlewareContext & TContext> // always true
+    : never
+
+declare type MiddlewareHandler<THandler extends LambdaHandler<any, any>, TContext extends LambdaContext = LambdaContext> =
+  THandler extends LambdaHandler<infer TEvent, infer TResult> // always true
+    ? MiddyInputHandler<TEvent, TResult, TContext>
+    : never
+
+/**
+ * Middy factory function. Use it to wrap your existing handler to enable middlewares on it.
+ * @param handler your original AWS Lambda function
+ * @param plugin wraps around each middleware and handler to add custom lifecycle behaviours (e.g. to profile performance)
+ */
+declare function middy<TEvent = unknown, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> (handler?: MiddlewareHandler<LambdaHandler<TEvent, TResult>, TContext>, plugin?: PluginObject): MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+
+declare namespace middy {
+  export {
+    Request,
+    PluginHook,
+    PluginHookWithMiddlewareName,
+    PluginObject,
+    MiddlewareFn,
+    MiddlewareObj,
+    MiddyfiedHandler
+  }
+}
+
+export default middy

package/lib/handlers/node_modules/@middy/core/index.js

@@ -0,0 +1,199 @@
+import { EventEmitter } from 'events';
+const defaultLambdaHandler = ()=>{};
+const defaultPlugin = {
+    timeoutEarlyInMillis: 5,
+    timeoutEarlyResponse: ()=>{
+        throw new Error('Timeout');
+    }
+};
+const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
+    if (typeof lambdaHandler !== 'function') {
+        plugin = lambdaHandler;
+        lambdaHandler = defaultLambdaHandler;
+    }
+    plugin = {
+        ...defaultPlugin,
+        ...plugin
+    };
+    plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0;
+    plugin.beforePrefetch?.();
+    const beforeMiddlewares = [];
+    const afterMiddlewares = [];
+    const onErrorMiddlewares = [];
+    const middy = (event = {}, context = {})=>{
+        plugin.requestStart?.();
+        const request = {
+            event,
+            context,
+            response: undefined,
+            error: undefined,
+            internal: plugin.internal ?? {}
+        };
+        return runRequest(request, [
+            ...beforeMiddlewares
+        ], lambdaHandler, [
+            ...afterMiddlewares
+        ], [
+            ...onErrorMiddlewares
+        ], plugin);
+    };
+    middy.use = (middlewares)=>{
+        if (!Array.isArray(middlewares)) {
+            middlewares = [
+                middlewares
+            ];
+        }
+        for (const middleware of middlewares){
+            const { before , after , onError  } = middleware;
+            if (!before && !after && !onError) {
+                throw new Error('Middleware must be an object containing at least one key among "before", "after", "onError"');
+            }
+            if (before) middy.before(before);
+            if (after) middy.after(after);
+            if (onError) middy.onError(onError);
+        }
+        return middy;
+    };
+    middy.before = (beforeMiddleware)=>{
+        beforeMiddlewares.push(beforeMiddleware);
+        return middy;
+    };
+    middy.after = (afterMiddleware)=>{
+        afterMiddlewares.unshift(afterMiddleware);
+        return middy;
+    };
+    middy.onError = (onErrorMiddleware)=>{
+        onErrorMiddlewares.unshift(onErrorMiddleware);
+        return middy;
+    };
+    middy.handler = (replaceLambdaHandler)=>{
+        lambdaHandler = replaceLambdaHandler;
+        return middy;
+    };
+    return middy;
+};
+const runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddlewares, onErrorMiddlewares, plugin)=>{
+    const timeoutEarly = plugin.timeoutEarly && request.context.getRemainingTimeInMillis;
+    try {
+        await runMiddlewares(request, beforeMiddlewares, plugin);
+        if (typeof request.response === 'undefined') {
+            plugin.beforeHandler?.();
+            const handlerAbort = new AbortController();
+            let timeoutAbort;
+            if (timeoutEarly) timeoutAbort = new AbortController();
+            request.response = await Promise.race([
+                lambdaHandler(request.event, request.context, {
+                    signal: handlerAbort.signal
+                }),
+                timeoutEarly ? setTimeoutPromise(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, {
+                    signal: timeoutAbort.signal
+                }).then(()=>{
+                    handlerAbort.abort();
+                    return plugin.timeoutEarlyResponse();
+                }) : Promise.race([])
+            ]);
+            if (timeoutEarly) timeoutAbort.abort();
+            plugin.afterHandler?.();
+            await runMiddlewares(request, afterMiddlewares, plugin);
+        }
+    } catch (e1) {
+        request.response = undefined;
+        request.error = e1;
+        try {
+            await runMiddlewares(request, onErrorMiddlewares, plugin);
+        } catch (e) {
+            e.originalError = request.error;
+            request.error = e;
+            throw request.error;
+        }
+        if (typeof request.response === 'undefined') throw request.error;
+    } finally{
+        await plugin.requestEnd?.(request);
+    }
+    return request.response;
+};
+const runMiddlewares = async (request, middlewares, plugin)=>{
+    for (const nextMiddleware of middlewares){
+        plugin.beforeMiddleware?.(nextMiddleware.name);
+        const res = await nextMiddleware(request);
+        plugin.afterMiddleware?.(nextMiddleware.name);
+        if (typeof res !== 'undefined') {
+            request.response = res;
+            return;
+        }
+    }
+};
+const polyfillAbortController = ()=>{
+    if (process.version < 'v15.0.0') {
+        class AbortSignal {
+            toString() {
+                return '[object AbortSignal]';
+            }
+            get [Symbol.toStringTag]() {
+                return 'AbortSignal';
+            }
+            removeEventListener(name, handler) {
+                this.eventEmitter.removeListener(name, handler);
+            }
+            addEventListener(name, handler) {
+                this.eventEmitter.on(name, handler);
+            }
+            dispatchEvent(type) {
+                const event = {
+                    type,
+                    target: this
+                };
+                const handlerName = `on${type}`;
+                if (typeof this[handlerName] === 'function') this[handlerName](event);
+                this.eventEmitter.emit(type, event);
+            }
+            constructor(){
+                this.eventEmitter = new EventEmitter();
+                this.onabort = null;
+                this.aborted = false;
+            }
+        }
+        return class AbortController1 {
+            abort() {
+                if (this.signal.aborted) return;
+                this.signal.aborted = true;
+                this.signal.dispatchEvent('abort');
+            }
+            toString() {
+                return '[object AbortController]';
+            }
+            get [Symbol.toStringTag]() {
+                return 'AbortController';
+            }
+            constructor(){
+                this.signal = new AbortSignal();
+            }
+        };
+    } else {
+        return AbortController;
+    }
+};
+global.AbortController = polyfillAbortController();
+const polyfillSetTimeoutPromise = ()=>{
+    return (ms, { signal  })=>{
+        if (signal.aborted) {
+            return Promise.reject(new Error('Aborted', 'AbortError'));
+        }
+        return new Promise((resolve, reject)=>{
+            const abortHandler = ()=>{
+                clearTimeout(timeout);
+                reject(new Error('Aborted', 'AbortError'));
+            };
+            const timeout = setTimeout(()=>{
+                resolve();
+                signal.removeEventListener('abort', abortHandler);
+            }, ms);
+            signal.addEventListener('abort', abortHandler);
+        });
+    };
+};
+const setTimeoutPromise = polyfillSetTimeoutPromise();
+export default middy;
+
+
+//# sourceMappingURL=index.js.map

package/lib/handlers/node_modules/@middy/core/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@middy/core",
+  "version": "3.6.2",
+  "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
+  "type": "module",
+  "engines": {
+    "node": ">=14"
+  },
+  "engineStrict": true,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./index.cjs"
+      }
+    }
+  },
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.cjs",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "test": "npm run test:unit",
+    "test:unit": "ava",
+    "test:benchmark": "node __benchmarks__/index.js"
+  },
+  "license": "MIT",
+  "keywords": [
+    "Lambda",
+    "Middleware",
+    "Serverless",
+    "Framework",
+    "AWS",
+    "AWS Lambda"
+  ],
+  "author": {
+    "name": "Middy contributors",
+    "url": "https://github.com/middyjs/middy/graphs/contributors"
+  },
+  "repository": {
+    "type": "git",
+    "url": "github:middyjs/middy",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/middyjs/middy/issues"
+  },
+  "homepage": "https://middy.js.org",
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.76",
+    "@types/node": "^18.0.0"
+  },
+  "gitHead": "4c5d64c72dd4bfde0d3b828a0082c99f688c759c"
+}

package/lib/handlers/node_modules/@types/node/README.md

@@ -2,15 +2,15 @@
 > `npm install --save @types/node`
 
 # Summary
-This package contains type definitions for Node.js (http://nodejs.org/).
+This package contains type definitions for Node.js (https://nodejs.org/).
 
 # Details
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Fri, 18 Jun 2021 21:01:11 GMT
+ * Last updated: Mon, 26 Dec 2022 17:32:37 GMT
  * Dependencies: none
- * Global values: `AbortController`, `AbortSignal`, `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
+ * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`, `structuredClone`
 
 # Credits
-These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [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), [Hoàng Văn Khải](https://github.com/KSXGitHub), [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), [Simon Schick](https://github.com/SimonSchick), [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), [Minh Son Nguyen](https://github.com/nguymin4), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Surasak Chaisurin](https://github.com/Ryan-Willpower), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Jason Kwok](https://github.com/JasonHK), [Victor Perin](https://github.com/victorperin), and [Yongsheng Zhang](https://github.com/ZYSzys).
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [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), [Simon Schick](https://github.com/SimonSchick), [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/lib/handlers/node_modules/@types/node/assert/strict.d.ts

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