@cdklabs/cdk-ssm-documents 0.0.73 → 0.0.75

package/node_modules/fflate/lib/index.d.ts

@@ -41,13 +41,13 @@ export interface InflateStreamOptions {
 /**
  * Options for decompressing DEFLATE data
  */
-export interface InflateOptions extends InflateStreamOptions {
+export interface InflateOptions<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends InflateStreamOptions {
     /**
      * The buffer into which to write the decompressed data. Saves memory if you know the decompressed size in advance.
      *
      * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit.
      */
-    out?: Uint8Array;
+    out?: Uint8Array<TArrayBuffer>;
 }
 /**
  * Options for decompressing a GZIP stream
@@ -57,13 +57,13 @@ export interface GunzipStreamOptions extends InflateStreamOptions {
 /**
  * Options for decompressing GZIP data
  */
-export interface GunzipOptions extends InflateStreamOptions {
+export interface GunzipOptions<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends InflateStreamOptions {
     /**
      * The buffer into which to write the decompressed data. GZIP already encodes the output size, so providing this doesn't save memory.
      *
      * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit.
      */
-    out?: Uint8Array;
+    out?: Uint8Array<TArrayBuffer>;
 }
 /**
  * Options for decompressing a Zlib stream
@@ -73,7 +73,7 @@ export interface UnzlibStreamOptions extends InflateStreamOptions {
 /**
  * Options for decompressing Zlib data
  */
-export interface UnzlibOptions extends InflateOptions {
+export interface UnzlibOptions<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends InflateOptions<TArrayBuffer> {
 }
 /**
  * Options for compressing data into a DEFLATE format
@@ -98,7 +98,7 @@ export interface DeflateOptions {
     /**
      * The memory level to use, ranging from 0-12. Increasing this increases speed and compression ratio at the cost of memory.
      *
-     * Note that this is exponential: while level 0 uses 4 kB, level 4 uses 64 kB, level 8 uses 1 MB, and level 12 uses 16 MB.
+     * Note that this is exponential: while level 0 uses 8 kB, level 4 uses 128 kB, level 8 uses 2 MB, and level 12 uses 32 MB.
      * It is recommended not to lower the value below 4, since that tends to hurt performance.
      * In addition, values above 8 tend to help very little on most data and can even hurt performance.
      *
@@ -142,20 +142,26 @@ export interface ZlibOptions extends DeflateOptions {
  * @param data The data output from the stream processor
  * @param final Whether this is the final block
  */
-export type FlateStreamHandler = (data: Uint8Array, final: boolean) => void;
+export type FlateStreamHandler = (data: Uint8Array<ArrayBuffer>, final: boolean) => void;
 /**
  * Handler for asynchronous data (de)compression streams
  * @param err Any error that occurred
  * @param data The data output from the stream processor
  * @param final Whether this is the final block
  */
-export type AsyncFlateStreamHandler = (err: FlateError | null, data: Uint8Array, final: boolean) => void;
+export type AsyncFlateStreamHandler = (err: FlateError | null, data: Uint8Array<ArrayBuffer>, final: boolean) => void;
+/**
+ * Handler for the asynchronous completion of (de)compression for a data chunk
+ * @param size The number of bytes that were processed. This is measured in terms of the input
+ * (i.e. compressed bytes for decompression, uncompressed bytes for compression.)
+ */
+export type AsyncFlateDrainHandler = (size: number) => void;
 /**
  * Callback for asynchronous (de)compression methods
  * @param err Any error that occurred
  * @param data The resulting data. Only present if `err` is null
  */
-export type FlateCallback = (err: FlateError | null, data: Uint8Array) => void;
+export type FlateCallback = (err: FlateError | null, data: Uint8Array<ArrayBuffer>) => void;
 interface AsyncOptions {
     /**
      * Whether or not to "consume" the source data. This will make the typed array/buffer you pass in
@@ -237,6 +243,15 @@ export declare class Deflate {
      * @param final Whether this is the last chunk
      */
     push(chunk: Uint8Array, final?: boolean): void;
+    /**
+     * Flushes buffered uncompressed data. Useful to immediately retrieve the
+     * deflated output for small inputs.
+     * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
+     *             extra bytes, but guarantees all pushed data is immediately
+     *             decompressible. A separate DEFLATE stream may be concatenated
+     *             with the current output after a sync flush.
+     */
+    flush(sync?: boolean): void;
 }
 /**
  * Asynchronous streaming DEFLATE compression
@@ -246,6 +261,14 @@ export declare class AsyncDeflate {
      * The handler to call whenever data is available
      */
     ondata: AsyncFlateStreamHandler;
+    /**
+     * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates)
+     */
+    ondrain?: AsyncFlateDrainHandler;
+    /**
+     * The number of uncompressed bytes buffered in the stream
+     */
+    queuedSize: number;
     /**
      * Creates an asynchronous DEFLATE stream
      * @param opts The compression options
@@ -263,6 +286,15 @@ export declare class AsyncDeflate {
      * @param final Whether this is the last chunk
      */
     push(chunk: Uint8Array, final?: boolean): void;
+    /**
+     * Flushes buffered uncompressed data. Useful to immediately retrieve the
+     * deflated output for small inputs.
+     * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
+     *             extra bytes, but guarantees all pushed data is immediately
+     *             decompressible. A separate DEFLATE stream may be concatenated
+     *             with the current output after a sync flush.
+     */
+    flush(sync?: boolean): void;
     /**
      * A method to terminate the stream's internal worker. Subsequent calls to
      * push() will silently fail.
@@ -289,7 +321,7 @@ export declare function deflate(data: Uint8Array, cb: FlateCallback): AsyncTermi
  * @param opts The compression options
  * @returns The deflated version of the data
  */
-export declare function deflateSync(data: Uint8Array, opts?: DeflateOptions): Uint8Array;
+export declare function deflateSync(data: Uint8Array, opts?: DeflateOptions): Uint8Array<ArrayBuffer>;
 /**
  * Streaming DEFLATE decompression
  */
@@ -330,6 +362,14 @@ export declare class AsyncInflate {
      * The handler to call whenever data is available
      */
     ondata: AsyncFlateStreamHandler;
+    /**
+     * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates)
+     */
+    ondrain?: AsyncFlateDrainHandler;
+    /**
+     * The number of compressed bytes buffered in the stream
+     */
+    queuedSize: number;
     /**
      * Creates an asynchronous DEFLATE decompression stream
      * @param opts The decompression options
@@ -368,13 +408,19 @@ export declare function inflate(data: Uint8Array, opts: AsyncInflateOptions, cb:
  * @returns A function that can be used to immediately terminate the decompression
  */
 export declare function inflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable;
+/**
+ * Expands DEFLATE data with no wrapper
+ * @param data The data to decompress
+ * @returns The decompressed version of the data
+ */
+export declare function inflateSync(data: Uint8Array): Uint8Array<ArrayBuffer>;
 /**
  * Expands DEFLATE data with no wrapper
  * @param data The data to decompress
  * @param opts The decompression options
  * @returns The decompressed version of the data
  */
-export declare function inflateSync(data: Uint8Array, opts?: InflateOptions): Uint8Array;
+export declare function inflateSync<TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(data: Uint8Array, opts?: InflateOptions<TArrayBuffer>): Uint8Array<TArrayBuffer>;
 /**
  * Streaming GZIP compression
  */
@@ -406,6 +452,14 @@ export declare class Gzip {
      */
     push(chunk: Uint8Array, final?: boolean): void;
     private p;
+    /**
+     * Flushes buffered uncompressed data. Useful to immediately retrieve the
+     * GZIPped output for small inputs.
+     * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
+     *             extra bytes, but guarantees all pushed data is immediately
+     *             decompressible.
+     */
+    flush(sync?: boolean): void;
 }
 /**
  * Asynchronous streaming GZIP compression
@@ -415,6 +469,14 @@ export declare class AsyncGzip {
      * The handler to call whenever data is available
      */
     ondata: AsyncFlateStreamHandler;
+    /**
+     * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates)
+     */
+    ondrain?: AsyncFlateDrainHandler;
+    /**
+     * The number of uncompressed bytes buffered in the stream
+     */
+    queuedSize: number;
     /**
      * Creates an asynchronous GZIP stream
      * @param opts The compression options
@@ -432,6 +494,14 @@ export declare class AsyncGzip {
      * @param final Whether this is the last chunk
      */
     push(chunk: Uint8Array, final?: boolean): void;
+    /**
+     * Flushes buffered uncompressed data. Useful to immediately retrieve the
+     * GZIPped output for small inputs.
+     * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
+     *             extra bytes, but guarantees all pushed data is immediately
+     *             decompressible.
+     */
+    flush(sync?: boolean): void;
     /**
      * A method to terminate the stream's internal worker. Subsequent calls to
      * push() will silently fail.
@@ -459,7 +529,7 @@ export declare function gzip(data: Uint8Array, cb: FlateCallback): AsyncTerminab
  * @param opts The compression options
  * @returns The gzipped version of the data
  */
-export declare function gzipSync(data: Uint8Array, opts?: GzipOptions): Uint8Array;
+export declare function gzipSync(data: Uint8Array, opts?: GzipOptions): Uint8Array<ArrayBuffer>;
 /**
  * Handler for new GZIP members in concatenated GZIP streams. Useful for building indices used to perform random-access reads on compressed files.
  * @param offset The offset of the new member relative to the start of the stream
@@ -508,6 +578,14 @@ export declare class AsyncGunzip {
      * The handler to call whenever data is available
      */
     ondata: AsyncFlateStreamHandler;
+    /**
+     * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates)
+     */
+    ondrain?: AsyncFlateDrainHandler;
+    /**
+     * The number of compressed bytes buffered in the stream
+     */
+    queuedSize: number;
     /**
      * The handler to call whenever a new GZIP member is found
      */
@@ -550,13 +628,19 @@ export declare function gunzip(data: Uint8Array, opts: AsyncGunzipOptions, cb: F
  * @returns A function that can be used to immediately terminate the decompression
  */
 export declare function gunzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable;
+/**
+ * Expands GZIP data
+ * @param data The data to decompress
+ * @returns The decompressed version of the data
+ */
+export declare function gunzipSync(data: Uint8Array): Uint8Array<ArrayBuffer>;
 /**
  * Expands GZIP data
  * @param data The data to decompress
  * @param opts The decompression options
  * @returns The decompressed version of the data
  */
-export declare function gunzipSync(data: Uint8Array, opts?: GunzipOptions): Uint8Array;
+export declare function gunzipSync<TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(data: Uint8Array, opts?: GunzipOptions<TArrayBuffer>): Uint8Array<TArrayBuffer>;
 /**
  * Streaming Zlib compression
  */
@@ -587,6 +671,14 @@ export declare class Zlib {
      */
     push(chunk: Uint8Array, final?: boolean): void;
     private p;
+    /**
+     * Flushes buffered uncompressed data. Useful to immediately retrieve the
+     * zlibbed output for small inputs.
+     * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
+     *             extra bytes, but guarantees all pushed data is immediately
+     *             decompressible.
+     */
+    flush(sync?: boolean): void;
 }
 /**
  * Asynchronous streaming Zlib compression
@@ -596,6 +688,14 @@ export declare class AsyncZlib {
      * The handler to call whenever data is available
      */
     ondata: AsyncFlateStreamHandler;
+    /**
+     * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates)
+     */
+    ondrain?: AsyncFlateDrainHandler;
+    /**
+     * The number of uncompressed bytes buffered in the stream
+     */
+    queuedSize: number;
     /**
      * Creates an asynchronous Zlib stream
      * @param opts The compression options
@@ -613,6 +713,14 @@ export declare class AsyncZlib {
      * @param final Whether this is the last chunk
      */
     push(chunk: Uint8Array, final?: boolean): void;
+    /**
+     * Flushes buffered uncompressed data. Useful to immediately retrieve the
+     * zlibbed output for small inputs.
+     * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
+     *             extra bytes, but guarantees all pushed data is immediately
+     *             decompressible.
+     */
+    flush(sync?: boolean): void;
     /**
      * A method to terminate the stream's internal worker. Subsequent calls to
      * push() will silently fail.
@@ -639,7 +747,7 @@ export declare function zlib(data: Uint8Array, cb: FlateCallback): AsyncTerminab
  * @param opts The compression options
  * @returns The zlib-compressed version of the data
  */
-export declare function zlibSync(data: Uint8Array, opts?: ZlibOptions): Uint8Array;
+export declare function zlibSync(data: Uint8Array, opts?: ZlibOptions): Uint8Array<ArrayBuffer>;
 /**
  * Streaming Zlib decompression
  */
@@ -676,6 +784,14 @@ export declare class AsyncUnzlib {
      * The handler to call whenever data is available
      */
     ondata: AsyncFlateStreamHandler;
+    /**
+     * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates)
+     */
+    ondrain?: AsyncFlateDrainHandler;
+    /**
+     * The number of compressed bytes buffered in the stream
+     */
+    queuedSize: number;
     /**
      * Creates an asynchronous Zlib decompression stream
      * @param opts The decompression options
@@ -714,13 +830,19 @@ export declare function unzlib(data: Uint8Array, opts: AsyncUnzlibOptions, cb: F
  * @returns A function that can be used to immediately terminate the decompression
  */
 export declare function unzlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable;
+/**
+ * Expands Zlib data
+ * @param data The data to decompress
+ * @returns The decompressed version of the data
+ */
+export declare function unzlibSync(data: Uint8Array): Uint8Array<ArrayBuffer>;
 /**
  * Expands Zlib data
  * @param data The data to decompress
  * @param opts The decompression options
  * @returns The decompressed version of the data
  */
-export declare function unzlibSync(data: Uint8Array, opts?: UnzlibOptions): Uint8Array;
+export declare function unzlibSync<TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(data: Uint8Array, opts?: UnzlibOptions<TArrayBuffer>): Uint8Array<TArrayBuffer>;
 export { gzip as compress, AsyncGzip as AsyncCompress };
 export { gzipSync as compressSync, Gzip as Compress };
 /**
@@ -748,6 +870,7 @@ export declare class Decompress {
      * @param cb The callback to call whenever data is decompressed
      */
     constructor(cb?: FlateStreamHandler);
+    private i;
     /**
      * Pushes a chunk to be decompressed
      * @param chunk The chunk to push
@@ -766,6 +889,14 @@ export declare class AsyncDecompress {
      * The handler to call whenever data is available
      */
     ondata: AsyncFlateStreamHandler;
+    /**
+     * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates)
+     */
+    ondrain?: AsyncFlateDrainHandler;
+    /**
+     * The number of compressed bytes buffered in the stream
+     */
+    queuedSize: number;
     /**
      * Creates an asynchronous decompression stream
      * @param opts The decompression options
@@ -777,6 +908,7 @@ export declare class AsyncDecompress {
      * @param cb The callback to call whenever data is decompressed
      */
     constructor(cb?: AsyncFlateStreamHandler);
+    private i;
     /**
      * Pushes a chunk to be decompressed
      * @param chunk The chunk to push
@@ -805,7 +937,7 @@ export declare function decompress(data: Uint8Array, cb: FlateCallback): AsyncTe
  * @param opts The decompression options
  * @returns The decompressed version of the data
  */
-export declare function decompressSync(data: Uint8Array, opts?: InflateOptions): Uint8Array;
+export declare function decompressSync(data: Uint8Array, opts?: InflateOptions): Uint8Array<ArrayBufferLike>;
 /**
  * Attributes for files added to a ZIP archive object
  */
@@ -907,7 +1039,7 @@ export interface AsyncZippable {
  * and the file is the value
  */
 export interface Unzipped {
-    [path: string]: Uint8Array;
+    [path: string]: Uint8Array<ArrayBuffer>;
 }
 /**
  * Handler for string generation streams
@@ -976,7 +1108,7 @@ export declare class EncodeUTF8 {
  *               not need to be true unless decoding a binary string.
  * @returns The string encoded in UTF-8/Latin-1 binary
  */
-export declare function strToU8(str: string, latin1?: boolean): Uint8Array;
+export declare function strToU8(str: string, latin1?: boolean): Uint8Array<ArrayBuffer>;
 /**
  * Converts a Uint8Array to a string
  * @param dat The data to decode to string
@@ -1077,7 +1209,7 @@ export declare class ZipPassThrough implements ZipInputFile {
      * @param chunk The chunk to process
      * @param final Whether this is the last chunk
      */
-    protected process(chunk: Uint8Array, final: boolean): void;
+    protected process(chunk: Uint8Array<ArrayBuffer>, final: boolean): void;
     /**
      * Pushes a chunk to be added. If you are subclassing this with a custom
      * compression algorithm, note that you must push data from the source
@@ -1110,7 +1242,7 @@ export declare class ZipDeflate implements ZipInputFile {
      * @param opts The compression options
      */
     constructor(filename: string, opts?: DeflateOptions);
-    process(chunk: Uint8Array, final: boolean): void;
+    private process;
     /**
      * Pushes a chunk to be deflated
      * @param chunk The chunk to push
@@ -1141,7 +1273,7 @@ export declare class AsyncZipDeflate implements ZipInputFile {
      * @param opts The compression options
      */
     constructor(filename: string, opts?: DeflateOptions);
-    process(chunk: Uint8Array, final: boolean): void;
+    private process;
     /**
      * Pushes a chunk to be deflated
      * @param chunk The chunk to push
@@ -1205,7 +1337,7 @@ export declare function zip(data: AsyncZippable, cb: FlateCallback): AsyncTermin
  * @param opts The main options, merged with per-file options
  * @returns The generated ZIP archive
  */
-export declare function zipSync(data: Zippable, opts?: ZipOptions): Uint8Array;
+export declare function zipSync(data: Zippable, opts?: ZipOptions): Uint8Array<ArrayBuffer>;
 /**
  * A decoder for files in ZIP streams
  */
@@ -1216,10 +1348,10 @@ export interface UnzipDecoder {
     ondata: AsyncFlateStreamHandler;
     /**
      * Pushes a chunk to be decompressed
-     * @param data The data in this chunk. Do not consume (detach) this data.
+     * @param chunk The data in this chunk. Do not consume (detach) this buffer.
      * @param final Whether this is the last chunk in the data stream
      */
-    push(data: Uint8Array, final: boolean): void;
+    push(chunk: Uint8Array, final: boolean): void;
     /**
      * A method to terminate any internal workers used by the stream. Subsequent
      * calls to push() should silently fail.
@@ -1321,7 +1453,7 @@ export interface UnzipFile {
 export declare class UnzipPassThrough implements UnzipDecoder {
     static compression: number;
     ondata: AsyncFlateStreamHandler;
-    push(data: Uint8Array, final: boolean): void;
+    push(chunk: Uint8Array, final: boolean): void;
 }
 /**
  * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for
@@ -1335,7 +1467,7 @@ export declare class UnzipInflate implements UnzipDecoder {
      * Creates a DEFLATE decompression that can be used in ZIP archives
      */
     constructor();
-    push(data: Uint8Array, final: boolean): void;
+    push(chunk: Uint8Array, final: boolean): void;
 }
 /**
  * Asynchronous streaming DEFLATE decompression for ZIP archives
@@ -1349,7 +1481,7 @@ export declare class AsyncUnzipInflate implements UnzipDecoder {
      * Creates a DEFLATE decompression that can be used in ZIP archives
      */
     constructor(_: string, sz?: number);
-    push(data: Uint8Array, final: boolean): void;
+    push(chunk: Uint8Array, final: boolean): void;
 }
 /**
  * A ZIP archive decompression stream that emits files as they are discovered
@@ -1370,7 +1502,7 @@ export declare class Unzip {
      * @param chunk The chunk to push
      * @param final Whether this is the last chunk
      */
-    push(chunk: Uint8Array, final?: boolean): any;
+    push(chunk: Uint8Array, final?: boolean): void;
     /**
      * Registers a decoder with the stream, allowing for files compressed with
      * the compression type provided to be expanded correctly

package/node_modules/fflate/lib/node-worker.cjs

@@ -1,10 +1,11 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+var _a;
 // Mediocre shim
 var Worker;
+var isMarkedAsUntransferable;
 var workerAdd = ";var __w=require('worker_threads');__w.parentPort.on('message',function(m){onmessage({data:m})}),postMessage=function(m,t){__w.parentPort.postMessage(m,t)},close=process.exit;self=global";
 try {
-    Worker = require('worker_threads').Worker;
+    (_a = require('worker_threads'), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable);
 }
 catch (e) {
 }
@@ -17,6 +18,8 @@ exports.default = Worker ? function (c, _, msg, transfer, cb) {
         if (c && !done)
             cb(new Error('exited with code ' + c), null);
     });
+    if (isMarkedAsUntransferable)
+        transfer = transfer.filter(function (t) { return !isMarkedAsUntransferable(t); });
     w.postMessage(msg, transfer);
     w.terminate = function () {
         done = true;