@jigging/jig 0.1.0-alpha.15 → 0.1.0-alpha.19

package/libexec/authoring/node_modules/minizlib/dist/commonjs/index.js

@@ -0,0 +1,416 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZstdDecompress = exports.ZstdCompress = exports.BrotliDecompress = exports.BrotliCompress = exports.Unzip = exports.InflateRaw = exports.DeflateRaw = exports.Gunzip = exports.Gzip = exports.Inflate = exports.Deflate = exports.Zlib = exports.ZlibError = exports.constants = void 0;
+const assert_1 = __importDefault(require("assert"));
+const buffer_1 = require("buffer");
+const minipass_1 = require("minipass");
+const realZlib = __importStar(require("zlib"));
+const constants_js_1 = require("./constants.js");
+var constants_js_2 = require("./constants.js");
+Object.defineProperty(exports, "constants", { enumerable: true, get: function () { return constants_js_2.constants; } });
+const OriginalBufferConcat = buffer_1.Buffer.concat;
+const desc = Object.getOwnPropertyDescriptor(buffer_1.Buffer, 'concat');
+const noop = (args) => args;
+const passthroughBufferConcat = desc?.writable === true || desc?.set !== undefined
+    ? (makeNoOp) => {
+        buffer_1.Buffer.concat = makeNoOp ? noop : OriginalBufferConcat;
+    }
+    : (_) => { };
+const _superWrite = Symbol('_superWrite');
+class ZlibError extends Error {
+    code;
+    errno;
+    constructor(err, origin) {
+        super('zlib: ' + err.message, { cause: err });
+        this.code = err.code;
+        this.errno = err.errno;
+        /* c8 ignore next */
+        if (!this.code)
+            this.code = 'ZLIB_ERROR';
+        this.message = 'zlib: ' + err.message;
+        Error.captureStackTrace(this, origin ?? this.constructor);
+    }
+    get name() {
+        return 'ZlibError';
+    }
+}
+exports.ZlibError = ZlibError;
+// the Zlib class they all inherit from
+// This thing manages the queue of requests, and returns
+// true or false if there is anything in the queue when
+// you call the .write() method.
+const _flushFlag = Symbol('flushFlag');
+class ZlibBase extends minipass_1.Minipass {
+    #sawError = false;
+    #ended = false;
+    #flushFlag;
+    #finishFlushFlag;
+    #fullFlushFlag;
+    #handle;
+    #onError;
+    get sawError() {
+        return this.#sawError;
+    }
+    get handle() {
+        return this.#handle;
+    }
+    /* c8 ignore start */
+    get flushFlag() {
+        return this.#flushFlag;
+    }
+    /* c8 ignore stop */
+    constructor(opts, mode) {
+        if (!opts || typeof opts !== 'object')
+            throw new TypeError('invalid options for ZlibBase constructor');
+        //@ts-ignore
+        super(opts);
+        /* c8 ignore start */
+        this.#flushFlag = opts.flush ?? 0;
+        this.#finishFlushFlag = opts.finishFlush ?? 0;
+        this.#fullFlushFlag = opts.fullFlushFlag ?? 0;
+        /* c8 ignore stop */
+        //@ts-ignore
+        if (typeof realZlib[mode] !== 'function') {
+            throw new TypeError('Compression method not supported: ' + mode);
+        }
+        // this will throw if any options are invalid for the class selected
+        try {
+            // @types/node doesn't know that it exports the classes, but they're there
+            //@ts-ignore
+            this.#handle = new realZlib[mode](opts);
+        }
+        catch (er) {
+            // make sure that all errors get decorated properly
+            throw new ZlibError(er, this.constructor);
+        }
+        this.#onError = err => {
+            // no sense raising multiple errors, since we abort on the first one.
+            if (this.#sawError)
+                return;
+            this.#sawError = true;
+            // there is no way to cleanly recover.
+            // continuing only obscures problems.
+            this.close();
+            this.emit('error', err);
+        };
+        this.#handle?.on('error', er => this.#onError(new ZlibError(er)));
+        this.once('end', () => this.close);
+    }
+    close() {
+        if (this.#handle) {
+            this.#handle.close();
+            this.#handle = undefined;
+            this.emit('close');
+        }
+    }
+    reset() {
+        if (!this.#sawError) {
+            (0, assert_1.default)(this.#handle, 'zlib binding closed');
+            //@ts-ignore
+            return this.#handle.reset?.();
+        }
+    }
+    flush(flushFlag) {
+        if (this.ended)
+            return;
+        if (typeof flushFlag !== 'number')
+            flushFlag = this.#fullFlushFlag;
+        this.write(Object.assign(buffer_1.Buffer.alloc(0), { [_flushFlag]: flushFlag }));
+    }
+    end(chunk, encoding, cb) {
+        /* c8 ignore start */
+        if (typeof chunk === 'function') {
+            cb = chunk;
+            encoding = undefined;
+            chunk = undefined;
+        }
+        if (typeof encoding === 'function') {
+            cb = encoding;
+            encoding = undefined;
+        }
+        /* c8 ignore stop */
+        if (chunk) {
+            if (encoding)
+                this.write(chunk, encoding);
+            else
+                this.write(chunk);
+        }
+        this.flush(this.#finishFlushFlag);
+        this.#ended = true;
+        return super.end(cb);
+    }
+    get ended() {
+        return this.#ended;
+    }
+    // overridden in the gzip classes to do portable writes
+    [_superWrite](data) {
+        return super.write(data);
+    }
+    write(chunk, encoding, cb) {
+        // process the chunk using the sync process
+        // then super.write() all the outputted chunks
+        if (typeof encoding === 'function')
+            (cb = encoding), (encoding = 'utf8');
+        if (typeof chunk === 'string')
+            chunk = buffer_1.Buffer.from(chunk, encoding);
+        if (this.#sawError)
+            return;
+        (0, assert_1.default)(this.#handle, 'zlib binding closed');
+        // _processChunk tries to .close() the native handle after it's done, so we
+        // intercept that by temporarily making it a no-op.
+        // diving into the node:zlib internals a bit here
+        const nativeHandle = this.#handle
+            ._handle;
+        const originalNativeClose = nativeHandle.close;
+        nativeHandle.close = () => { };
+        const originalClose = this.#handle.close;
+        this.#handle.close = () => { };
+        // It also calls `Buffer.concat()` at the end, which may be convenient
+        // for some, but which we are not interested in as it slows us down.
+        passthroughBufferConcat(true);
+        let result = undefined;
+        try {
+            const flushFlag = typeof chunk[_flushFlag] === 'number'
+                ? chunk[_flushFlag]
+                : this.#flushFlag;
+            result = this.#handle._processChunk(chunk, flushFlag);
+            // if we don't throw, reset it back how it was
+            passthroughBufferConcat(false);
+        }
+        catch (err) {
+            // or if we do, put Buffer.concat() back before we emit error
+            // Error events call into user code, which may call Buffer.concat()
+            passthroughBufferConcat(false);
+            this.#onError(new ZlibError(err, this.write));
+        }
+        finally {
+            if (this.#handle) {
+                // Core zlib resets `_handle` to null after attempting to close the
+                // native handle. Our no-op handler prevented actual closure, but we
+                // need to restore the `._handle` property.
+                ;
+                this.#handle._handle =
+                    nativeHandle;
+                nativeHandle.close = originalNativeClose;
+                this.#handle.close = originalClose;
+                // `_processChunk()` adds an 'error' listener. If we don't remove it
+                // after each call, these handlers start piling up.
+                this.#handle.removeAllListeners('error');
+                // make sure OUR error listener is still attached tho
+            }
+        }
+        if (this.#handle)
+            this.#handle.on('error', er => this.#onError(new ZlibError(er, this.write)));
+        let writeReturn;
+        if (result) {
+            if (Array.isArray(result) && result.length > 0) {
+                const r = result[0];
+                // The first buffer is always `handle._outBuffer`, which would be
+                // re-used for later invocations; so, we always have to copy that one.
+                writeReturn = this[_superWrite](buffer_1.Buffer.from(r));
+                for (let i = 1; i < result.length; i++) {
+                    writeReturn = this[_superWrite](result[i]);
+                }
+            }
+            else {
+                // either a single Buffer or an empty array
+                writeReturn = this[_superWrite](buffer_1.Buffer.from(result));
+            }
+        }
+        if (cb)
+            cb();
+        return writeReturn;
+    }
+}
+class Zlib extends ZlibBase {
+    #level;
+    #strategy;
+    constructor(opts, mode) {
+        opts = opts || {};
+        opts.flush = opts.flush || constants_js_1.constants.Z_NO_FLUSH;
+        opts.finishFlush = opts.finishFlush || constants_js_1.constants.Z_FINISH;
+        opts.fullFlushFlag = constants_js_1.constants.Z_FULL_FLUSH;
+        super(opts, mode);
+        this.#level = opts.level;
+        this.#strategy = opts.strategy;
+    }
+    params(level, strategy) {
+        if (this.sawError)
+            return;
+        if (!this.handle)
+            throw new Error('cannot switch params when binding is closed');
+        // no way to test this without also not supporting params at all
+        /* c8 ignore start */
+        if (!this.handle.params)
+            throw new Error('not supported in this implementation');
+        /* c8 ignore stop */
+        if (this.#level !== level || this.#strategy !== strategy) {
+            this.flush(constants_js_1.constants.Z_SYNC_FLUSH);
+            (0, assert_1.default)(this.handle, 'zlib binding closed');
+            // .params() calls .flush(), but the latter is always async in the
+            // core zlib. We override .flush() temporarily to intercept that and
+            // flush synchronously.
+            const origFlush = this.handle.flush;
+            this.handle.flush = (flushFlag, cb) => {
+                /* c8 ignore start */
+                if (typeof flushFlag === 'function') {
+                    cb = flushFlag;
+                    flushFlag = this.flushFlag;
+                }
+                /* c8 ignore stop */
+                this.flush(flushFlag);
+                cb?.();
+            };
+            try {
+                ;
+                this.handle.params(level, strategy);
+            }
+            finally {
+                this.handle.flush = origFlush;
+            }
+            /* c8 ignore start */
+            if (this.handle) {
+                this.#level = level;
+                this.#strategy = strategy;
+            }
+            /* c8 ignore stop */
+        }
+    }
+}
+exports.Zlib = Zlib;
+// minimal 2-byte header
+class Deflate extends Zlib {
+    constructor(opts) {
+        super(opts, 'Deflate');
+    }
+}
+exports.Deflate = Deflate;
+class Inflate extends Zlib {
+    constructor(opts) {
+        super(opts, 'Inflate');
+    }
+}
+exports.Inflate = Inflate;
+class Gzip extends Zlib {
+    #portable;
+    constructor(opts) {
+        super(opts, 'Gzip');
+        this.#portable = opts && !!opts.portable;
+    }
+    [_superWrite](data) {
+        if (!this.#portable)
+            return super[_superWrite](data);
+        // we'll always get the header emitted in one first chunk
+        // overwrite the OS indicator byte with 0xFF
+        this.#portable = false;
+        data[9] = 255;
+        return super[_superWrite](data);
+    }
+}
+exports.Gzip = Gzip;
+class Gunzip extends Zlib {
+    constructor(opts) {
+        super(opts, 'Gunzip');
+    }
+}
+exports.Gunzip = Gunzip;
+// raw - no header
+class DeflateRaw extends Zlib {
+    constructor(opts) {
+        super(opts, 'DeflateRaw');
+    }
+}
+exports.DeflateRaw = DeflateRaw;
+class InflateRaw extends Zlib {
+    constructor(opts) {
+        super(opts, 'InflateRaw');
+    }
+}
+exports.InflateRaw = InflateRaw;
+// auto-detect header.
+class Unzip extends Zlib {
+    constructor(opts) {
+        super(opts, 'Unzip');
+    }
+}
+exports.Unzip = Unzip;
+class Brotli extends ZlibBase {
+    constructor(opts, mode) {
+        opts = opts || {};
+        opts.flush = opts.flush || constants_js_1.constants.BROTLI_OPERATION_PROCESS;
+        opts.finishFlush =
+            opts.finishFlush || constants_js_1.constants.BROTLI_OPERATION_FINISH;
+        opts.fullFlushFlag = constants_js_1.constants.BROTLI_OPERATION_FLUSH;
+        super(opts, mode);
+    }
+}
+class BrotliCompress extends Brotli {
+    constructor(opts) {
+        super(opts, 'BrotliCompress');
+    }
+}
+exports.BrotliCompress = BrotliCompress;
+class BrotliDecompress extends Brotli {
+    constructor(opts) {
+        super(opts, 'BrotliDecompress');
+    }
+}
+exports.BrotliDecompress = BrotliDecompress;
+class Zstd extends ZlibBase {
+    constructor(opts, mode) {
+        opts = opts || {};
+        opts.flush = opts.flush || constants_js_1.constants.ZSTD_e_continue;
+        opts.finishFlush = opts.finishFlush || constants_js_1.constants.ZSTD_e_end;
+        opts.fullFlushFlag = constants_js_1.constants.ZSTD_e_flush;
+        super(opts, mode);
+    }
+}
+class ZstdCompress extends Zstd {
+    constructor(opts) {
+        super(opts, 'ZstdCompress');
+    }
+}
+exports.ZstdCompress = ZstdCompress;
+class ZstdDecompress extends Zstd {
+    constructor(opts) {
+        super(opts, 'ZstdDecompress');
+    }
+}
+exports.ZstdDecompress = ZstdDecompress;
+//# sourceMappingURL=index.js.map

package/libexec/authoring/node_modules/minizlib/dist/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert'\nimport { Buffer } from 'buffer'\nimport { Minipass } from 'minipass'\nimport * as realZlib from 'zlib'\nimport { constants } from './constants.js'\nexport { constants } from './constants.js'\n\nconst OriginalBufferConcat = Buffer.concat\nconst desc = Object.getOwnPropertyDescriptor(Buffer, 'concat')\nconst noop = (args: Buffer[]) => args as unknown as Buffer\nconst passthroughBufferConcat =\n  desc?.writable === true || desc?.set !== undefined\n    ? (makeNoOp: boolean) => {\n        Buffer.concat = makeNoOp ? noop : OriginalBufferConcat\n      }\n    : (_: boolean) => {}\n\nconst _superWrite = Symbol('_superWrite')\n\nexport class ZlibError extends Error {\n  code?: string\n  errno?: number\n  constructor(err: NodeJS.ErrnoException | Error, origin?: Function) {\n    super('zlib: ' + err.message, { cause: err })\n    this.code = (err as NodeJS.ErrnoException).code\n    this.errno = (err as NodeJS.ErrnoException).errno\n    /* c8 ignore next */\n    if (!this.code) this.code = 'ZLIB_ERROR'\n\n    this.message = 'zlib: ' + err.message\n    Error.captureStackTrace(this, origin ?? this.constructor)\n  }\n\n  get name() {\n    return 'ZlibError'\n  }\n}\n\n// the Zlib class they all inherit from\n// This thing manages the queue of requests, and returns\n// true or false if there is anything in the queue when\n// you call the .write() method.\nconst _flushFlag = Symbol('flushFlag')\n\nexport type ChunkWithFlushFlag = Minipass.ContiguousData & {\n  [_flushFlag]?: number\n}\n\nexport type ZlibBaseOptions = Minipass.Options<Minipass.ContiguousData> & {\n  flush?: number\n  finishFlush?: number\n  fullFlushFlag?: number\n}\n\nexport type ZlibHandle =\n  | realZlib.Gzip\n  | realZlib.Gunzip\n  | realZlib.Deflate\n  | realZlib.Inflate\n  | realZlib.DeflateRaw\n  | realZlib.InflateRaw\n  | realZlib.BrotliCompress\n  | realZlib.BrotliDecompress\n  | realZlib.ZstdCompress\n  | realZlib.ZstdDecompress\nexport type ZlibMode =\n  | 'Gzip'\n  | 'Gunzip'\n  | 'Deflate'\n  | 'Inflate'\n  | 'DeflateRaw'\n  | 'InflateRaw'\n  | 'Unzip'\nexport type BrotliMode = 'BrotliCompress' | 'BrotliDecompress'\nexport type ZstdMode = 'ZstdCompress' | 'ZstdDecompress'\n\nabstract class ZlibBase extends Minipass<Buffer, ChunkWithFlushFlag> {\n  #sawError: boolean = false\n  #ended: boolean = false\n  #flushFlag: number\n  #finishFlushFlag: number\n  #fullFlushFlag: number\n  #handle?: ZlibHandle\n  #onError: (err: ZlibError) => any\n\n  get sawError() {\n    return this.#sawError\n  }\n  get handle() {\n    return this.#handle\n  }\n  /* c8 ignore start */\n  get flushFlag() {\n    return this.#flushFlag\n  }\n  /* c8 ignore stop */\n\n  constructor(opts: ZlibBaseOptions, mode: ZlibMode | BrotliMode | ZstdMode) {\n    if (!opts || typeof opts !== 'object')\n      throw new TypeError('invalid options for ZlibBase constructor')\n\n    //@ts-ignore\n    super(opts)\n\n    /* c8 ignore start */\n    this.#flushFlag = opts.flush ?? 0\n    this.#finishFlushFlag = opts.finishFlush ?? 0\n    this.#fullFlushFlag = opts.fullFlushFlag ?? 0\n    /* c8 ignore stop */\n\n    //@ts-ignore\n    if (typeof realZlib[mode] !== 'function') {\n      throw new TypeError('Compression method not supported: ' + mode)\n    }\n\n    // this will throw if any options are invalid for the class selected\n    try {\n      // @types/node doesn't know that it exports the classes, but they're there\n      //@ts-ignore\n      this.#handle = new realZlib[mode](opts)\n    } catch (er) {\n      // make sure that all errors get decorated properly\n      throw new ZlibError(er as NodeJS.ErrnoException, this.constructor)\n    }\n\n    this.#onError = err => {\n      // no sense raising multiple errors, since we abort on the first one.\n      if (this.#sawError) return\n\n      this.#sawError = true\n\n      // there is no way to cleanly recover.\n      // continuing only obscures problems.\n      this.close()\n      this.emit('error', err)\n    }\n\n    this.#handle?.on('error', er => this.#onError(new ZlibError(er)))\n    this.once('end', () => this.close)\n  }\n\n  close() {\n    if (this.#handle) {\n      this.#handle.close()\n      this.#handle = undefined\n      this.emit('close')\n    }\n  }\n\n  reset() {\n    if (!this.#sawError) {\n      assert(this.#handle, 'zlib binding closed')\n      //@ts-ignore\n      return this.#handle.reset?.()\n    }\n  }\n\n  flush(flushFlag?: number) {\n    if (this.ended) return\n\n    if (typeof flushFlag !== 'number') flushFlag = this.#fullFlushFlag\n\n    this.write(Object.assign(Buffer.alloc(0), { [_flushFlag]: flushFlag }))\n  }\n\n  end(cb?: () => void): this\n  end(chunk: ChunkWithFlushFlag, cb?: () => void): this\n  end(\n    chunk: ChunkWithFlushFlag,\n    encoding?: Minipass.Encoding,\n    cb?: () => void,\n  ): this\n  end(\n    chunk?: ChunkWithFlushFlag | (() => void),\n    encoding?: Minipass.Encoding | (() => void),\n    cb?: () => void,\n  ) {\n    /* c8 ignore start */\n    if (typeof chunk === 'function') {\n      cb = chunk\n      encoding = undefined\n      chunk = undefined\n    }\n    if (typeof encoding === 'function') {\n      cb = encoding\n      encoding = undefined\n    }\n    /* c8 ignore stop */\n    if (chunk) {\n      if (encoding) this.write(chunk, encoding)\n      else this.write(chunk)\n    }\n    this.flush(this.#finishFlushFlag)\n    this.#ended = true\n    return super.end(cb)\n  }\n\n  get ended() {\n    return this.#ended\n  }\n\n  // overridden in the gzip classes to do portable writes\n  [_superWrite](data: Buffer & { [_flushFlag]?: number }) {\n    return super.write(data)\n  }\n\n  write(chunk: ChunkWithFlushFlag, cb?: () => void): boolean\n  write(\n    chunk: ChunkWithFlushFlag,\n    encoding?: Minipass.Encoding,\n    cb?: () => void,\n  ): boolean\n  write(\n    chunk: ChunkWithFlushFlag,\n    encoding?: Minipass.Encoding | (() => void),\n    cb?: () => void,\n  ) {\n    // process the chunk using the sync process\n    // then super.write() all the outputted chunks\n    if (typeof encoding === 'function')\n      (cb = encoding), (encoding = 'utf8')\n\n    if (typeof chunk === 'string')\n      chunk = Buffer.from(chunk as string, encoding as BufferEncoding)\n\n    if (this.#sawError) return\n    assert(this.#handle, 'zlib binding closed')\n\n    // _processChunk tries to .close() the native handle after it's done, so we\n    // intercept that by temporarily making it a no-op.\n    // diving into the node:zlib internals a bit here\n    const nativeHandle = (this.#handle as unknown as { _handle: any })\n      ._handle\n    const originalNativeClose = nativeHandle.close\n    nativeHandle.close = () => {}\n    const originalClose = this.#handle.close\n    this.#handle.close = () => {}\n    // It also calls `Buffer.concat()` at the end, which may be convenient\n    // for some, but which we are not interested in as it slows us down.\n    passthroughBufferConcat(true)\n    let result: undefined | Buffer | Buffer[] = undefined\n    try {\n      const flushFlag =\n        typeof chunk[_flushFlag] === 'number'\n          ? chunk[_flushFlag]\n          : this.#flushFlag\n      result = (\n        this.#handle as unknown as {\n          _processChunk: (chunk: Buffer, flushFlag: number) => Buffer[]\n        }\n      )._processChunk(chunk as Buffer, flushFlag)\n      // if we don't throw, reset it back how it was\n      passthroughBufferConcat(false)\n    } catch (err) {\n      // or if we do, put Buffer.concat() back before we emit error\n      // Error events call into user code, which may call Buffer.concat()\n      passthroughBufferConcat(false)\n      this.#onError(new ZlibError(err as NodeJS.ErrnoException, this.write))\n    } finally {\n      if (this.#handle) {\n        // Core zlib resets `_handle` to null after attempting to close the\n        // native handle. Our no-op handler prevented actual closure, but we\n        // need to restore the `._handle` property.\n        ;(this.#handle as unknown as { _handle: any })._handle =\n          nativeHandle\n        nativeHandle.close = originalNativeClose\n        this.#handle.close = originalClose\n        // `_processChunk()` adds an 'error' listener. If we don't remove it\n        // after each call, these handlers start piling up.\n        this.#handle.removeAllListeners('error')\n        // make sure OUR error listener is still attached tho\n      }\n    }\n\n    if (this.#handle)\n      this.#handle.on('error', er => this.#onError(new ZlibError(er, this.write)))\n\n    let writeReturn\n    if (result) {\n      if (Array.isArray(result) && result.length > 0) {\n        const r = result[0]\n        // The first buffer is always `handle._outBuffer`, which would be\n        // re-used for later invocations; so, we always have to copy that one.\n        writeReturn = this[_superWrite](Buffer.from(r as Buffer))\n        for (let i = 1; i < result.length; i++) {\n          writeReturn = this[_superWrite](result[i] as Buffer)\n        }\n      } else {\n        // either a single Buffer or an empty array\n        writeReturn = this[_superWrite](Buffer.from(result as Buffer | []))\n      }\n    }\n\n    if (cb) cb()\n    return writeReturn\n  }\n}\n\nexport type ZlibOptions = ZlibBaseOptions & {\n  level?: number\n  strategy?: number\n}\n\nexport class Zlib extends ZlibBase {\n  #level?: number\n  #strategy?: number\n\n  constructor(opts: ZlibOptions, mode: ZlibMode) {\n    opts = opts || {}\n\n    opts.flush = opts.flush || constants.Z_NO_FLUSH\n    opts.finishFlush = opts.finishFlush || constants.Z_FINISH\n    opts.fullFlushFlag = constants.Z_FULL_FLUSH\n    super(opts, mode)\n\n    this.#level = opts.level\n    this.#strategy = opts.strategy\n  }\n\n  params(level: number, strategy: number) {\n    if (this.sawError) return\n\n    if (!this.handle)\n      throw new Error('cannot switch params when binding is closed')\n\n    // no way to test this without also not supporting params at all\n    /* c8 ignore start */\n    if (!(this.handle as { params?: any }).params)\n      throw new Error('not supported in this implementation')\n    /* c8 ignore stop */\n\n    if (this.#level !== level || this.#strategy !== strategy) {\n      this.flush(constants.Z_SYNC_FLUSH)\n      assert(this.handle, 'zlib binding closed')\n      // .params() calls .flush(), but the latter is always async in the\n      // core zlib. We override .flush() temporarily to intercept that and\n      // flush synchronously.\n      const origFlush = this.handle.flush\n      this.handle.flush = (\n        flushFlag?: (() => void) | number,\n        cb?: () => void,\n      ) => {\n        /* c8 ignore start */\n        if (typeof flushFlag === 'function') {\n          cb = flushFlag\n          flushFlag = this.flushFlag\n        }\n        /* c8 ignore stop */\n        this.flush(flushFlag)\n        cb?.()\n      }\n      try {\n        ;(\n          this.handle as unknown as {\n            params: (level?: number, strategy?: number) => void\n          }\n        ).params(level, strategy)\n      } finally {\n        this.handle.flush = origFlush\n      }\n      /* c8 ignore start */\n      if (this.handle) {\n        this.#level = level\n        this.#strategy = strategy\n      }\n      /* c8 ignore stop */\n    }\n  }\n}\n\n// minimal 2-byte header\nexport class Deflate extends Zlib {\n  constructor(opts: ZlibOptions) {\n    super(opts, 'Deflate')\n  }\n}\n\nexport class Inflate extends Zlib {\n  constructor(opts: ZlibOptions) {\n    super(opts, 'Inflate')\n  }\n}\n\n// gzip - bigger header, same deflate compression\nexport type GzipOptions = ZlibOptions & { portable?: boolean }\nexport class Gzip extends Zlib {\n  #portable: boolean\n  constructor(opts: GzipOptions) {\n    super(opts, 'Gzip')\n    this.#portable = opts && !!opts.portable\n  }\n\n  [_superWrite](data: Buffer & { [_flushFlag]?: number }) {\n    if (!this.#portable) return super[_superWrite](data)\n\n    // we'll always get the header emitted in one first chunk\n    // overwrite the OS indicator byte with 0xFF\n    this.#portable = false\n    data[9] = 255\n    return super[_superWrite](data)\n  }\n}\n\nexport class Gunzip extends Zlib {\n  constructor(opts: ZlibOptions) {\n    super(opts, 'Gunzip')\n  }\n}\n\n// raw - no header\nexport class DeflateRaw extends Zlib {\n  constructor(opts: ZlibOptions) {\n    super(opts, 'DeflateRaw')\n  }\n}\n\nexport class InflateRaw extends Zlib {\n  constructor(opts: ZlibOptions) {\n    super(opts, 'InflateRaw')\n  }\n}\n\n// auto-detect header.\nexport class Unzip extends Zlib {\n  constructor(opts: ZlibOptions) {\n    super(opts, 'Unzip')\n  }\n}\n\nclass Brotli extends ZlibBase {\n  constructor(opts: ZlibOptions, mode: BrotliMode) {\n    opts = opts || {}\n\n    opts.flush = opts.flush || constants.BROTLI_OPERATION_PROCESS\n    opts.finishFlush =\n      opts.finishFlush || constants.BROTLI_OPERATION_FINISH\n    opts.fullFlushFlag = constants.BROTLI_OPERATION_FLUSH\n    super(opts, mode)\n  }\n}\n\nexport class BrotliCompress extends Brotli {\n  constructor(opts: ZlibOptions) {\n    super(opts, 'BrotliCompress')\n  }\n}\n\nexport class BrotliDecompress extends Brotli {\n  constructor(opts: ZlibOptions) {\n    super(opts, 'BrotliDecompress')\n  }\n}\n\nclass Zstd extends ZlibBase {\n  constructor(opts: ZlibOptions, mode: ZstdMode) {\n    opts = opts || {}\n\n    opts.flush = opts.flush || constants.ZSTD_e_continue\n    opts.finishFlush = opts.finishFlush || constants.ZSTD_e_end\n    opts.fullFlushFlag = constants.ZSTD_e_flush\n    super(opts, mode)\n  }\n}\n\nexport class ZstdCompress extends Zstd {\n  constructor(opts: ZlibOptions) {\n    super(opts, 'ZstdCompress')\n  }\n}\n\nexport class ZstdDecompress extends Zstd {\n  constructor(opts: ZlibOptions) {\n    super(opts, 'ZstdDecompress')\n  }\n}\n"]}

package/libexec/authoring/node_modules/minizlib/dist/commonjs/package.json

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

package/libexec/authoring/node_modules/minizlib/dist/esm/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const constants: any;
+//# sourceMappingURL=constants.d.ts.map

package/libexec/authoring/node_modules/minizlib/dist/esm/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,SAAS,KAiHrB,CAAA"}

package/libexec/authoring/node_modules/minizlib/dist/esm/constants.js

@@ -0,0 +1,117 @@
+// Update with any zlib constants that are added or changed in the future.
+// Node v6 didn't export this, so we just hard code the version and rely
+// on all the other hard-coded values from zlib v4736.  When node v6
+// support drops, we can just export the realZlibConstants object.
+import realZlib from 'zlib';
+/* c8 ignore start */
+const realZlibConstants = realZlib.constants || { ZLIB_VERNUM: 4736 };
+/* c8 ignore stop */
+export const constants = Object.freeze(Object.assign(Object.create(null), {
+    Z_NO_FLUSH: 0,
+    Z_PARTIAL_FLUSH: 1,
+    Z_SYNC_FLUSH: 2,
+    Z_FULL_FLUSH: 3,
+    Z_FINISH: 4,
+    Z_BLOCK: 5,
+    Z_OK: 0,
+    Z_STREAM_END: 1,
+    Z_NEED_DICT: 2,
+    Z_ERRNO: -1,
+    Z_STREAM_ERROR: -2,
+    Z_DATA_ERROR: -3,
+    Z_MEM_ERROR: -4,
+    Z_BUF_ERROR: -5,
+    Z_VERSION_ERROR: -6,
+    Z_NO_COMPRESSION: 0,
+    Z_BEST_SPEED: 1,
+    Z_BEST_COMPRESSION: 9,
+    Z_DEFAULT_COMPRESSION: -1,
+    Z_FILTERED: 1,
+    Z_HUFFMAN_ONLY: 2,
+    Z_RLE: 3,
+    Z_FIXED: 4,
+    Z_DEFAULT_STRATEGY: 0,
+    DEFLATE: 1,
+    INFLATE: 2,
+    GZIP: 3,
+    GUNZIP: 4,
+    DEFLATERAW: 5,
+    INFLATERAW: 6,
+    UNZIP: 7,
+    BROTLI_DECODE: 8,
+    BROTLI_ENCODE: 9,
+    Z_MIN_WINDOWBITS: 8,
+    Z_MAX_WINDOWBITS: 15,
+    Z_DEFAULT_WINDOWBITS: 15,
+    Z_MIN_CHUNK: 64,
+    Z_MAX_CHUNK: Infinity,
+    Z_DEFAULT_CHUNK: 16384,
+    Z_MIN_MEMLEVEL: 1,
+    Z_MAX_MEMLEVEL: 9,
+    Z_DEFAULT_MEMLEVEL: 8,
+    Z_MIN_LEVEL: -1,
+    Z_MAX_LEVEL: 9,
+    Z_DEFAULT_LEVEL: -1,
+    BROTLI_OPERATION_PROCESS: 0,
+    BROTLI_OPERATION_FLUSH: 1,
+    BROTLI_OPERATION_FINISH: 2,
+    BROTLI_OPERATION_EMIT_METADATA: 3,
+    BROTLI_MODE_GENERIC: 0,
+    BROTLI_MODE_TEXT: 1,
+    BROTLI_MODE_FONT: 2,
+    BROTLI_DEFAULT_MODE: 0,
+    BROTLI_MIN_QUALITY: 0,
+    BROTLI_MAX_QUALITY: 11,
+    BROTLI_DEFAULT_QUALITY: 11,
+    BROTLI_MIN_WINDOW_BITS: 10,
+    BROTLI_MAX_WINDOW_BITS: 24,
+    BROTLI_LARGE_MAX_WINDOW_BITS: 30,
+    BROTLI_DEFAULT_WINDOW: 22,
+    BROTLI_MIN_INPUT_BLOCK_BITS: 16,
+    BROTLI_MAX_INPUT_BLOCK_BITS: 24,
+    BROTLI_PARAM_MODE: 0,
+    BROTLI_PARAM_QUALITY: 1,
+    BROTLI_PARAM_LGWIN: 2,
+    BROTLI_PARAM_LGBLOCK: 3,
+    BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,
+    BROTLI_PARAM_SIZE_HINT: 5,
+    BROTLI_PARAM_LARGE_WINDOW: 6,
+    BROTLI_PARAM_NPOSTFIX: 7,
+    BROTLI_PARAM_NDIRECT: 8,
+    BROTLI_DECODER_RESULT_ERROR: 0,
+    BROTLI_DECODER_RESULT_SUCCESS: 1,
+    BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,
+    BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,
+    BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,
+    BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,
+    BROTLI_DECODER_NO_ERROR: 0,
+    BROTLI_DECODER_SUCCESS: 1,
+    BROTLI_DECODER_NEEDS_MORE_INPUT: 2,
+    BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,
+    BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,
+    BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,
+    BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,
+    BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,
+    BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,
+    BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,
+    BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,
+    BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,
+    BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,
+    BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,
+    BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,
+    BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,
+    BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,
+    BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,
+    BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,
+    BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,
+    BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,
+    BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,
+    BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,
+    BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,
+    BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,
+    BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,
+    BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,
+    BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,
+    BROTLI_DECODER_ERROR_UNREACHABLE: -31,
+}, realZlibConstants));
+//# sourceMappingURL=constants.js.map

package/libexec/authoring/node_modules/minizlib/dist/esm/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"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","sourcesContent":["// Update with any zlib constants that are added or changed in the future.\n// Node v6 didn't export this, so we just hard code the version and rely\n// on all the other hard-coded values from zlib v4736.  When node v6\n// support drops, we can just export the realZlibConstants object.\nimport realZlib from 'zlib'\n/* c8 ignore start */\nconst realZlibConstants = realZlib.constants || { ZLIB_VERNUM: 4736 }\n/* c8 ignore stop */\n\nexport const constants = Object.freeze(\n  Object.assign(\n    Object.create(null),\n    {\n      Z_NO_FLUSH: 0,\n      Z_PARTIAL_FLUSH: 1,\n      Z_SYNC_FLUSH: 2,\n      Z_FULL_FLUSH: 3,\n      Z_FINISH: 4,\n      Z_BLOCK: 5,\n      Z_OK: 0,\n      Z_STREAM_END: 1,\n      Z_NEED_DICT: 2,\n      Z_ERRNO: -1,\n      Z_STREAM_ERROR: -2,\n      Z_DATA_ERROR: -3,\n      Z_MEM_ERROR: -4,\n      Z_BUF_ERROR: -5,\n      Z_VERSION_ERROR: -6,\n      Z_NO_COMPRESSION: 0,\n      Z_BEST_SPEED: 1,\n      Z_BEST_COMPRESSION: 9,\n      Z_DEFAULT_COMPRESSION: -1,\n      Z_FILTERED: 1,\n      Z_HUFFMAN_ONLY: 2,\n      Z_RLE: 3,\n      Z_FIXED: 4,\n      Z_DEFAULT_STRATEGY: 0,\n      DEFLATE: 1,\n      INFLATE: 2,\n      GZIP: 3,\n      GUNZIP: 4,\n      DEFLATERAW: 5,\n      INFLATERAW: 6,\n      UNZIP: 7,\n      BROTLI_DECODE: 8,\n      BROTLI_ENCODE: 9,\n      Z_MIN_WINDOWBITS: 8,\n      Z_MAX_WINDOWBITS: 15,\n      Z_DEFAULT_WINDOWBITS: 15,\n      Z_MIN_CHUNK: 64,\n      Z_MAX_CHUNK: Infinity,\n      Z_DEFAULT_CHUNK: 16384,\n      Z_MIN_MEMLEVEL: 1,\n      Z_MAX_MEMLEVEL: 9,\n      Z_DEFAULT_MEMLEVEL: 8,\n      Z_MIN_LEVEL: -1,\n      Z_MAX_LEVEL: 9,\n      Z_DEFAULT_LEVEL: -1,\n      BROTLI_OPERATION_PROCESS: 0,\n      BROTLI_OPERATION_FLUSH: 1,\n      BROTLI_OPERATION_FINISH: 2,\n      BROTLI_OPERATION_EMIT_METADATA: 3,\n      BROTLI_MODE_GENERIC: 0,\n      BROTLI_MODE_TEXT: 1,\n      BROTLI_MODE_FONT: 2,\n      BROTLI_DEFAULT_MODE: 0,\n      BROTLI_MIN_QUALITY: 0,\n      BROTLI_MAX_QUALITY: 11,\n      BROTLI_DEFAULT_QUALITY: 11,\n      BROTLI_MIN_WINDOW_BITS: 10,\n      BROTLI_MAX_WINDOW_BITS: 24,\n      BROTLI_LARGE_MAX_WINDOW_BITS: 30,\n      BROTLI_DEFAULT_WINDOW: 22,\n      BROTLI_MIN_INPUT_BLOCK_BITS: 16,\n      BROTLI_MAX_INPUT_BLOCK_BITS: 24,\n      BROTLI_PARAM_MODE: 0,\n      BROTLI_PARAM_QUALITY: 1,\n      BROTLI_PARAM_LGWIN: 2,\n      BROTLI_PARAM_LGBLOCK: 3,\n      BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,\n      BROTLI_PARAM_SIZE_HINT: 5,\n      BROTLI_PARAM_LARGE_WINDOW: 6,\n      BROTLI_PARAM_NPOSTFIX: 7,\n      BROTLI_PARAM_NDIRECT: 8,\n      BROTLI_DECODER_RESULT_ERROR: 0,\n      BROTLI_DECODER_RESULT_SUCCESS: 1,\n      BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,\n      BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,\n      BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,\n      BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,\n      BROTLI_DECODER_NO_ERROR: 0,\n      BROTLI_DECODER_SUCCESS: 1,\n      BROTLI_DECODER_NEEDS_MORE_INPUT: 2,\n      BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,\n      BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,\n      BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,\n      BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,\n      BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,\n      BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,\n      BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,\n      BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,\n      BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,\n      BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,\n      BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,\n      BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,\n      BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,\n      BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,\n      BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,\n      BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,\n      BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,\n      BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,\n      BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,\n      BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,\n      BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,\n      BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,\n      BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,\n      BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,\n      BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,\n      BROTLI_DECODER_ERROR_UNREACHABLE: -31,\n    },\n    realZlibConstants,\n  ),\n)\n"]}