@aligent/cdk-prerender-proxy 0.2.7 → 2.0.1

package/lib/handlers/node_modules/@types/node/stream.d.ts

@@ -1,471 +0,0 @@
-declare module 'stream' {
-    import { EventEmitter, Abortable } from 'events';
-    import * as streamPromises from "stream/promises";
-
-    class internal extends EventEmitter {
-        pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
-    }
-
-    namespace internal {
-        class Stream extends internal {
-            constructor(opts?: ReadableOptions);
-        }
-
-        interface StreamOptions<T extends Stream> extends Abortable {
-            emitClose?: boolean;
-            highWaterMark?: number;
-            objectMode?: boolean;
-            construct?(this: T, callback: (error?: Error | null) => void): void;
-            destroy?(this: T, error: Error | null, callback: (error: Error | null) => void): void;
-            autoDestroy?: boolean;
-        }
-
-        interface ReadableOptions extends StreamOptions<Readable> {
-            encoding?: BufferEncoding;
-            read?(this: Readable, size: number): void;
-        }
-
-        class Readable extends Stream implements NodeJS.ReadableStream {
-            /**
-             * A utility method for creating Readable Streams out of iterators.
-             */
-            static from(iterable: Iterable<any> | AsyncIterable<any>, options?: ReadableOptions): Readable;
-
-            readable: boolean;
-            readonly readableEncoding: BufferEncoding | null;
-            readonly readableEnded: boolean;
-            readonly readableFlowing: boolean | null;
-            readonly readableHighWaterMark: number;
-            readonly readableLength: number;
-            readonly readableObjectMode: boolean;
-            destroyed: boolean;
-            constructor(opts?: ReadableOptions);
-            _construct?(callback: (error?: Error | null) => void): void;
-            _read(size: number): void;
-            read(size?: number): any;
-            setEncoding(encoding: BufferEncoding): this;
-            pause(): this;
-            resume(): this;
-            isPaused(): boolean;
-            unpipe(destination?: NodeJS.WritableStream): this;
-            unshift(chunk: any, encoding?: BufferEncoding): void;
-            wrap(oldStream: NodeJS.ReadableStream): this;
-            push(chunk: any, encoding?: BufferEncoding): boolean;
-            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
-            destroy(error?: Error): void;
-
-            /**
-             * Event emitter
-             * The defined events on documents including:
-             * 1. close
-             * 2. data
-             * 3. end
-             * 4. error
-             * 5. pause
-             * 6. readable
-             * 7. resume
-             */
-            addListener(event: "close", listener: () => void): this;
-            addListener(event: "data", listener: (chunk: any) => void): this;
-            addListener(event: "end", listener: () => void): this;
-            addListener(event: "error", listener: (err: Error) => void): this;
-            addListener(event: "pause", listener: () => void): this;
-            addListener(event: "readable", listener: () => void): this;
-            addListener(event: "resume", listener: () => void): this;
-            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-
-            emit(event: "close"): boolean;
-            emit(event: "data", chunk: any): boolean;
-            emit(event: "end"): boolean;
-            emit(event: "error", err: Error): boolean;
-            emit(event: "pause"): boolean;
-            emit(event: "readable"): boolean;
-            emit(event: "resume"): boolean;
-            emit(event: string | symbol, ...args: any[]): boolean;
-
-            on(event: "close", listener: () => void): this;
-            on(event: "data", listener: (chunk: any) => void): this;
-            on(event: "end", listener: () => void): this;
-            on(event: "error", listener: (err: Error) => void): this;
-            on(event: "pause", listener: () => void): this;
-            on(event: "readable", listener: () => void): this;
-            on(event: "resume", listener: () => void): this;
-            on(event: string | symbol, listener: (...args: any[]) => void): this;
-
-            once(event: "close", listener: () => void): this;
-            once(event: "data", listener: (chunk: any) => void): this;
-            once(event: "end", listener: () => void): this;
-            once(event: "error", listener: (err: Error) => void): this;
-            once(event: "pause", listener: () => void): this;
-            once(event: "readable", listener: () => void): this;
-            once(event: "resume", listener: () => void): this;
-            once(event: string | symbol, listener: (...args: any[]) => void): this;
-
-            prependListener(event: "close", listener: () => void): this;
-            prependListener(event: "data", listener: (chunk: any) => void): this;
-            prependListener(event: "end", listener: () => void): this;
-            prependListener(event: "error", listener: (err: Error) => void): this;
-            prependListener(event: "pause", listener: () => void): this;
-            prependListener(event: "readable", listener: () => void): this;
-            prependListener(event: "resume", listener: () => void): this;
-            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-
-            prependOnceListener(event: "close", listener: () => void): this;
-            prependOnceListener(event: "data", listener: (chunk: any) => void): this;
-            prependOnceListener(event: "end", listener: () => void): this;
-            prependOnceListener(event: "error", listener: (err: Error) => void): this;
-            prependOnceListener(event: "pause", listener: () => void): this;
-            prependOnceListener(event: "readable", listener: () => void): this;
-            prependOnceListener(event: "resume", listener: () => void): this;
-            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
-
-            removeListener(event: "close", listener: () => void): this;
-            removeListener(event: "data", listener: (chunk: any) => void): this;
-            removeListener(event: "end", listener: () => void): this;
-            removeListener(event: "error", listener: (err: Error) => void): this;
-            removeListener(event: "pause", listener: () => void): this;
-            removeListener(event: "readable", listener: () => void): this;
-            removeListener(event: "resume", listener: () => void): this;
-            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-
-            [Symbol.asyncIterator](): AsyncIterableIterator<any>;
-        }
-
-        interface WritableOptions extends StreamOptions<Writable> {
-            decodeStrings?: boolean;
-            defaultEncoding?: BufferEncoding;
-            write?(this: Writable, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-            writev?(this: Writable, chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
-            final?(this: Writable, callback: (error?: Error | null) => void): void;
-        }
-
-        class Writable extends Stream implements NodeJS.WritableStream {
-            readonly writable: boolean;
-            readonly writableEnded: boolean;
-            readonly writableFinished: boolean;
-            readonly writableHighWaterMark: number;
-            readonly writableLength: number;
-            readonly writableObjectMode: boolean;
-            readonly writableCorked: number;
-            destroyed: boolean;
-            constructor(opts?: WritableOptions);
-            _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-            _writev?(chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
-            _construct?(callback: (error?: Error | null) => void): void;
-            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
-            _final(callback: (error?: Error | null) => void): void;
-            write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean;
-            write(chunk: any, encoding: BufferEncoding, cb?: (error: Error | null | undefined) => void): boolean;
-            setDefaultEncoding(encoding: BufferEncoding): this;
-            end(cb?: () => void): void;
-            end(chunk: any, cb?: () => void): void;
-            end(chunk: any, encoding: BufferEncoding, cb?: () => void): void;
-            cork(): void;
-            uncork(): void;
-            destroy(error?: Error): void;
-
-            /**
-             * Event emitter
-             * The defined events on documents including:
-             * 1. close
-             * 2. drain
-             * 3. error
-             * 4. finish
-             * 5. pipe
-             * 6. unpipe
-             */
-            addListener(event: "close", listener: () => void): this;
-            addListener(event: "drain", listener: () => void): this;
-            addListener(event: "error", listener: (err: Error) => void): this;
-            addListener(event: "finish", listener: () => void): this;
-            addListener(event: "pipe", listener: (src: Readable) => void): this;
-            addListener(event: "unpipe", listener: (src: Readable) => void): this;
-            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-
-            emit(event: "close"): boolean;
-            emit(event: "drain"): boolean;
-            emit(event: "error", err: Error): boolean;
-            emit(event: "finish"): boolean;
-            emit(event: "pipe", src: Readable): boolean;
-            emit(event: "unpipe", src: Readable): boolean;
-            emit(event: string | symbol, ...args: any[]): boolean;
-
-            on(event: "close", listener: () => void): this;
-            on(event: "drain", listener: () => void): this;
-            on(event: "error", listener: (err: Error) => void): this;
-            on(event: "finish", listener: () => void): this;
-            on(event: "pipe", listener: (src: Readable) => void): this;
-            on(event: "unpipe", listener: (src: Readable) => void): this;
-            on(event: string | symbol, listener: (...args: any[]) => void): this;
-
-            once(event: "close", listener: () => void): this;
-            once(event: "drain", listener: () => void): this;
-            once(event: "error", listener: (err: Error) => void): this;
-            once(event: "finish", listener: () => void): this;
-            once(event: "pipe", listener: (src: Readable) => void): this;
-            once(event: "unpipe", listener: (src: Readable) => void): this;
-            once(event: string | symbol, listener: (...args: any[]) => void): this;
-
-            prependListener(event: "close", listener: () => void): this;
-            prependListener(event: "drain", listener: () => void): this;
-            prependListener(event: "error", listener: (err: Error) => void): this;
-            prependListener(event: "finish", listener: () => void): this;
-            prependListener(event: "pipe", listener: (src: Readable) => void): this;
-            prependListener(event: "unpipe", listener: (src: Readable) => void): this;
-            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-
-            prependOnceListener(event: "close", listener: () => void): this;
-            prependOnceListener(event: "drain", listener: () => void): this;
-            prependOnceListener(event: "error", listener: (err: Error) => void): this;
-            prependOnceListener(event: "finish", listener: () => void): this;
-            prependOnceListener(event: "pipe", listener: (src: Readable) => void): this;
-            prependOnceListener(event: "unpipe", listener: (src: Readable) => void): this;
-            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
-
-            removeListener(event: "close", listener: () => void): this;
-            removeListener(event: "drain", listener: () => void): this;
-            removeListener(event: "error", listener: (err: Error) => void): this;
-            removeListener(event: "finish", listener: () => void): this;
-            removeListener(event: "pipe", listener: (src: Readable) => void): this;
-            removeListener(event: "unpipe", listener: (src: Readable) => void): this;
-            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        }
-
-        interface DuplexOptions extends ReadableOptions, WritableOptions {
-            allowHalfOpen?: boolean;
-            readableObjectMode?: boolean;
-            writableObjectMode?: boolean;
-            readableHighWaterMark?: number;
-            writableHighWaterMark?: number;
-            writableCorked?: number;
-            construct?(this: Duplex, callback: (error?: Error | null) => void): void;
-            read?(this: Duplex, size: number): void;
-            write?(this: Duplex, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-            writev?(this: Duplex, chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
-            final?(this: Duplex, callback: (error?: Error | null) => void): void;
-            destroy?(this: Duplex, error: Error | null, callback: (error: Error | null) => void): void;
-        }
-
-        // Note: Duplex extends both Readable and Writable.
-        class Duplex extends Readable implements Writable {
-            readonly writable: boolean;
-            readonly writableEnded: boolean;
-            readonly writableFinished: boolean;
-            readonly writableHighWaterMark: number;
-            readonly writableLength: number;
-            readonly writableObjectMode: boolean;
-            readonly writableCorked: number;
-            constructor(opts?: DuplexOptions);
-            _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-            _writev?(chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
-            _destroy(error: Error | null, callback: (error: Error | null) => void): void;
-            _final(callback: (error?: Error | null) => void): void;
-            write(chunk: any, encoding?: BufferEncoding, cb?: (error: Error | null | undefined) => void): boolean;
-            write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean;
-            setDefaultEncoding(encoding: BufferEncoding): this;
-            end(cb?: () => void): void;
-            end(chunk: any, cb?: () => void): void;
-            end(chunk: any, encoding?: BufferEncoding, cb?: () => void): void;
-            cork(): void;
-            uncork(): void;
-        }
-
-        type TransformCallback = (error?: Error | null, data?: any) => void;
-
-        interface TransformOptions extends DuplexOptions {
-            construct?(this: Transform, callback: (error?: Error | null) => void): void;
-            read?(this: Transform, size: number): void;
-            write?(this: Transform, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-            writev?(this: Transform, chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
-            final?(this: Transform, callback: (error?: Error | null) => void): void;
-            destroy?(this: Transform, error: Error | null, callback: (error: Error | null) => void): void;
-            transform?(this: Transform, chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
-            flush?(this: Transform, callback: TransformCallback): void;
-        }
-
-        class Transform extends Duplex {
-            constructor(opts?: TransformOptions);
-            _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
-            _flush(callback: TransformCallback): void;
-        }
-
-        class PassThrough extends Transform { }
-
-        /**
-         * Attaches an AbortSignal to a readable or writeable stream. This lets code
-         * control stream destruction using an `AbortController`.
-         *
-         * Calling `abort` on the `AbortController` corresponding to the passed
-         * `AbortSignal` will behave the same way as calling `.destroy(new AbortError())`
-         * on the stream.
-         */
-        function addAbortSignal<T extends Stream>(signal: AbortSignal, stream: T): T;
-
-        interface FinishedOptions extends Abortable {
-            error?: boolean;
-            readable?: boolean;
-            writable?: boolean;
-        }
-        function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, options: FinishedOptions, callback: (err?: NodeJS.ErrnoException | null) => void): () => void;
-        function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, callback: (err?: NodeJS.ErrnoException | null) => void): () => void;
-        namespace finished {
-            function __promisify__(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, options?: FinishedOptions): Promise<void>;
-        }
-
-        type PipelineSourceFunction<T> = () => Iterable<T> | AsyncIterable<T>;
-        type PipelineSource<T> = Iterable<T> | AsyncIterable<T> | NodeJS.ReadableStream | PipelineSourceFunction<T>;
-        type PipelineTransform<S extends PipelineTransformSource<any>, U> =
-            NodeJS.ReadWriteStream |
-            ((source: S extends (...args: any[]) => Iterable<infer ST> | AsyncIterable<infer ST> ?
-                AsyncIterable<ST> : S) => AsyncIterable<U>);
-        type PipelineTransformSource<T> = PipelineSource<T> | PipelineTransform<any, T>;
-
-        type PipelineDestinationIterableFunction<T> = (source: AsyncIterable<T>) => AsyncIterable<any>;
-        type PipelineDestinationPromiseFunction<T, P> = (source: AsyncIterable<T>) => Promise<P>;
-
-        type PipelineDestination<S extends PipelineTransformSource<any>, P> =
-            S extends PipelineTransformSource<infer ST> ?
-                (NodeJS.WritableStream | PipelineDestinationIterableFunction<ST> | PipelineDestinationPromiseFunction<ST, P>) : never;
-        type PipelineCallback<S extends PipelineDestination<any, any>> =
-            S extends PipelineDestinationPromiseFunction<any, infer P> ? (err: NodeJS.ErrnoException | null, value: P) => void :
-                (err: NodeJS.ErrnoException | null) => void;
-        type PipelinePromise<S extends PipelineDestination<any, any>> =
-            S extends PipelineDestinationPromiseFunction<any, infer P> ? Promise<P> : Promise<void>;
-        interface PipelineOptions {
-            signal: AbortSignal;
-        }
-
-        function pipeline<A extends PipelineSource<any>,
-            B extends PipelineDestination<A, any>>(
-            source: A,
-            destination: B,
-            callback?: PipelineCallback<B>
-        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
-        function pipeline<A extends PipelineSource<any>,
-            T1 extends PipelineTransform<A, any>,
-            B extends PipelineDestination<T1, any>>(
-            source: A,
-            transform1: T1,
-            destination: B,
-            callback?: PipelineCallback<B>
-        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
-        function pipeline<A extends PipelineSource<any>,
-            T1 extends PipelineTransform<A, any>,
-            T2 extends PipelineTransform<T1, any>,
-            B extends PipelineDestination<T2, any>>(
-            source: A,
-            transform1: T1,
-            transform2: T2,
-            destination: B,
-            callback?: PipelineCallback<B>
-        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
-        function pipeline<A extends PipelineSource<any>,
-            T1 extends PipelineTransform<A, any>,
-            T2 extends PipelineTransform<T1, any>,
-            T3 extends PipelineTransform<T2, any>,
-            B extends PipelineDestination<T3, any>>(
-            source: A,
-            transform1: T1,
-            transform2: T2,
-            transform3: T3,
-            destination: B,
-            callback?: PipelineCallback<B>
-        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
-        function pipeline<A extends PipelineSource<any>,
-            T1 extends PipelineTransform<A, any>,
-            T2 extends PipelineTransform<T1, any>,
-            T3 extends PipelineTransform<T2, any>,
-            T4 extends PipelineTransform<T3, any>,
-            B extends PipelineDestination<T4, any>>(
-            source: A,
-            transform1: T1,
-            transform2: T2,
-            transform3: T3,
-            transform4: T4,
-            destination: B,
-            callback?: PipelineCallback<B>
-        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
-        function pipeline(
-            streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,
-            callback?: (err: NodeJS.ErrnoException | null) => void,
-        ): NodeJS.WritableStream;
-        function pipeline(
-            stream1: NodeJS.ReadableStream,
-            stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
-            ...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | ((err: NodeJS.ErrnoException | null) => void)>,
-        ): NodeJS.WritableStream;
-        namespace pipeline {
-            function __promisify__<A extends PipelineSource<any>,
-                B extends PipelineDestination<A, any>>(
-                source: A,
-                destination: B,
-                options?: PipelineOptions
-            ): PipelinePromise<B>;
-            function __promisify__<A extends PipelineSource<any>,
-                T1 extends PipelineTransform<A, any>,
-                B extends PipelineDestination<T1, any>>(
-                source: A,
-                transform1: T1,
-                destination: B,
-                options?: PipelineOptions,
-            ): PipelinePromise<B>;
-            function __promisify__<A extends PipelineSource<any>,
-                T1 extends PipelineTransform<A, any>,
-                T2 extends PipelineTransform<T1, any>,
-                B extends PipelineDestination<T2, any>>(
-                source: A,
-                transform1: T1,
-                transform2: T2,
-                destination: B,
-                options?: PipelineOptions
-            ): PipelinePromise<B>;
-            function __promisify__<A extends PipelineSource<any>,
-                T1 extends PipelineTransform<A, any>,
-                T2 extends PipelineTransform<T1, any>,
-                T3 extends PipelineTransform<T2, any>,
-                B extends PipelineDestination<T3, any>>(
-                source: A,
-                transform1: T1,
-                transform2: T2,
-                transform3: T3,
-                destination: B,
-                options?: PipelineOptions
-            ): PipelinePromise<B>;
-            function __promisify__<A extends PipelineSource<any>,
-                T1 extends PipelineTransform<A, any>,
-                T2 extends PipelineTransform<T1, any>,
-                T3 extends PipelineTransform<T2, any>,
-                T4 extends PipelineTransform<T3, any>,
-                B extends PipelineDestination<T4, any>>(
-                source: A,
-                transform1: T1,
-                transform2: T2,
-                transform3: T3,
-                transform4: T4,
-                destination: B,
-                options?: PipelineOptions
-            ): PipelinePromise<B>;
-
-            function __promisify__(
-                streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,
-                options?: PipelineOptions
-            ): Promise<void>;
-            function __promisify__(
-                stream1: NodeJS.ReadableStream,
-                stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
-                ...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | PipelineOptions>,
-            ): Promise<void>;
-        }
-
-        interface Pipe {
-            close(): void;
-            hasRef(): boolean;
-            ref(): void;
-            unref(): void;
-        }
-
-        const promises: typeof streamPromises;
-    }
-
-    export = internal;
-}

package/lib/handlers/node_modules/@types/node/string_decoder.d.ts

@@ -1,7 +0,0 @@
-declare module 'string_decoder' {
-    class StringDecoder {
-        constructor(encoding?: BufferEncoding);
-        write(buffer: Buffer): string;
-        end(buffer?: Buffer): string;
-    }
-}

package/lib/handlers/node_modules/@types/node/timers/promises.d.ts

@@ -1,21 +0,0 @@
-declare module 'timers/promises' {
-    import { TimerOptions } from 'timers';
-
-    /**
-     * Returns a promise that resolves after the specified delay in milliseconds.
-     * @param delay defaults to 1
-     */
-    function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;
-
-    /**
-     * Returns a promise that resolves in the next tick.
-     */
-    function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;
-
-    /**
-     *
-     * Returns an async iterator that generates values in an interval of delay ms.
-     * @param delay defaults to 1
-     */
-    function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;
-}

package/lib/handlers/node_modules/@types/node/timers.d.ts

@@ -1,27 +0,0 @@
-declare module 'timers' {
-    import { Abortable } from 'events';
-
-    interface TimerOptions extends Abortable {
-        /**
-         * Set to `false` to indicate that the scheduled `Timeout`
-         * should not require the Node.js event loop to remain active.
-         * @default true
-         */
-        ref?: boolean;
-    }
-
-    function setTimeout(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout;
-    namespace setTimeout {
-        function __promisify__(ms: number): Promise<void>;
-        function __promisify__<T>(ms: number, value: T, options?: TimerOptions): Promise<T>;
-    }
-    function clearTimeout(timeoutId: NodeJS.Timeout): void;
-    function setInterval(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout;
-    function clearInterval(intervalId: NodeJS.Timeout): void;
-    function setImmediate(callback: (...args: any[]) => void, ...args: any[]): NodeJS.Immediate;
-    namespace setImmediate {
-        function __promisify__(): Promise<void>;
-        function __promisify__<T>(value: T, options?: TimerOptions): Promise<T>;
-    }
-    function clearImmediate(immediateId: NodeJS.Immediate): void;
-}