@intlayer/backend 7.0.9-canary.0 → 7.0.9-canary.3

package/dist/esm/node_modules/pako/lib/deflate.mjs

@@ -0,0 +1,308 @@
+import { __commonJS } from "../../../_virtual/rolldown_runtime.mjs";
+import { require_common } from "./utils/common.mjs";
+import { require_messages } from "./zlib/messages.mjs";
+import { require_deflate as require_deflate$1 } from "./zlib/deflate.mjs";
+import { require_strings } from "./utils/strings.mjs";
+import { require_zstream } from "./zlib/zstream.mjs";
+
+//#region ../../node_modules/pako/lib/deflate.js
+var require_deflate = /* @__PURE__ */ __commonJS({ "../../node_modules/pako/lib/deflate.js": ((exports) => {
+	var zlib_deflate = require_deflate$1();
+	var utils = require_common();
+	var strings = require_strings();
+	var msg = require_messages();
+	var ZStream = require_zstream();
+	var toString = Object.prototype.toString;
+	var Z_NO_FLUSH = 0;
+	var Z_FINISH = 4;
+	var Z_OK = 0;
+	var Z_STREAM_END = 1;
+	var Z_SYNC_FLUSH = 2;
+	var Z_DEFAULT_COMPRESSION = -1;
+	var Z_DEFAULT_STRATEGY = 0;
+	var Z_DEFLATED = 8;
+	/**
+	* class Deflate
+	*
+	* Generic JS-style wrapper for zlib calls. If you don't need
+	* streaming behaviour - use more simple functions: [[deflate]],
+	* [[deflateRaw]] and [[gzip]].
+	**/
+	/**
+	* Deflate.result -> Uint8Array|Array
+	*
+	* Compressed result, generated by default [[Deflate#onData]]
+	* and [[Deflate#onEnd]] handlers. Filled after you push last chunk
+	* (call [[Deflate#push]] with `Z_FINISH` / `true` param)  or if you
+	* push a chunk with explicit flush (call [[Deflate#push]] with
+	* `Z_SYNC_FLUSH` param).
+	**/
+	/**
+	* Deflate.err -> Number
+	*
+	* Error code after deflate finished. 0 (Z_OK) on success.
+	* You will not need it in real life, because deflate errors
+	* are possible only on wrong options or bad `onData` / `onEnd`
+	* custom handlers.
+	**/
+	/**
+	* Deflate.msg -> String
+	*
+	* Error message, if [[Deflate.err]] != 0
+	**/
+	/**
+	* new Deflate(options)
+	* - options (Object): zlib deflate options.
+	*
+	* Creates new deflator instance with specified params. Throws exception
+	* on bad params. Supported options:
+	*
+	* - `level`
+	* - `windowBits`
+	* - `memLevel`
+	* - `strategy`
+	* - `dictionary`
+	*
+	* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
+	* for more information on these.
+	*
+	* Additional options, for internal needs:
+	*
+	* - `chunkSize` - size of generated data chunks (16K by default)
+	* - `raw` (Boolean) - do raw deflate
+	* - `gzip` (Boolean) - create gzip wrapper
+	* - `to` (String) - if equal to 'string', then result will be "binary string"
+	*    (each char code [0..255])
+	* - `header` (Object) - custom header for gzip
+	*   - `text` (Boolean) - true if compressed data believed to be text
+	*   - `time` (Number) - modification time, unix timestamp
+	*   - `os` (Number) - operation system code
+	*   - `extra` (Array) - array of bytes with extra data (max 65536)
+	*   - `name` (String) - file name (binary string)
+	*   - `comment` (String) - comment (binary string)
+	*   - `hcrc` (Boolean) - true if header crc should be added
+	*
+	* ##### Example:
+	*
+	* ```javascript
+	* var pako = require('pako')
+	*   , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
+	*   , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
+	*
+	* var deflate = new pako.Deflate({ level: 3});
+	*
+	* deflate.push(chunk1, false);
+	* deflate.push(chunk2, true);  // true -> last chunk
+	*
+	* if (deflate.err) { throw new Error(deflate.err); }
+	*
+	* console.log(deflate.result);
+	* ```
+	**/
+	function Deflate(options) {
+		if (!(this instanceof Deflate)) return new Deflate(options);
+		this.options = utils.assign({
+			level: Z_DEFAULT_COMPRESSION,
+			method: Z_DEFLATED,
+			chunkSize: 16384,
+			windowBits: 15,
+			memLevel: 8,
+			strategy: Z_DEFAULT_STRATEGY,
+			to: ""
+		}, options || {});
+		var opt = this.options;
+		if (opt.raw && opt.windowBits > 0) opt.windowBits = -opt.windowBits;
+		else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) opt.windowBits += 16;
+		this.err = 0;
+		this.msg = "";
+		this.ended = false;
+		this.chunks = [];
+		this.strm = new ZStream();
+		this.strm.avail_out = 0;
+		var status = zlib_deflate.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy);
+		if (status !== Z_OK) throw new Error(msg[status]);
+		if (opt.header) zlib_deflate.deflateSetHeader(this.strm, opt.header);
+		if (opt.dictionary) {
+			var dict;
+			if (typeof opt.dictionary === "string") dict = strings.string2buf(opt.dictionary);
+			else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") dict = new Uint8Array(opt.dictionary);
+			else dict = opt.dictionary;
+			status = zlib_deflate.deflateSetDictionary(this.strm, dict);
+			if (status !== Z_OK) throw new Error(msg[status]);
+			this._dict_set = true;
+		}
+	}
+	/**
+	* Deflate#push(data[, mode]) -> Boolean
+	* - data (Uint8Array|Array|ArrayBuffer|String): input data. Strings will be
+	*   converted to utf8 byte sequence.
+	* - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
+	*   See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.
+	*
+	* Sends input data to deflate pipe, generating [[Deflate#onData]] calls with
+	* new compressed chunks. Returns `true` on success. The last data block must have
+	* mode Z_FINISH (or `true`). That will flush internal pending buffers and call
+	* [[Deflate#onEnd]]. For interim explicit flushes (without ending the stream) you
+	* can use mode Z_SYNC_FLUSH, keeping the compression context.
+	*
+	* On fail call [[Deflate#onEnd]] with error code and return false.
+	*
+	* We strongly recommend to use `Uint8Array` on input for best speed (output
+	* array format is detected automatically). Also, don't skip last param and always
+	* use the same type in your code (boolean or number). That will improve JS speed.
+	*
+	* For regular `Array`-s make sure all elements are [0..255].
+	*
+	* ##### Example
+	*
+	* ```javascript
+	* push(chunk, false); // push one of data chunks
+	* ...
+	* push(chunk, true);  // push last chunk
+	* ```
+	**/
+	Deflate.prototype.push = function(data, mode) {
+		var strm = this.strm;
+		var chunkSize = this.options.chunkSize;
+		var status, _mode;
+		if (this.ended) return false;
+		_mode = mode === ~~mode ? mode : mode === true ? Z_FINISH : Z_NO_FLUSH;
+		if (typeof data === "string") strm.input = strings.string2buf(data);
+		else if (toString.call(data) === "[object ArrayBuffer]") strm.input = new Uint8Array(data);
+		else strm.input = data;
+		strm.next_in = 0;
+		strm.avail_in = strm.input.length;
+		do {
+			if (strm.avail_out === 0) {
+				strm.output = new utils.Buf8(chunkSize);
+				strm.next_out = 0;
+				strm.avail_out = chunkSize;
+			}
+			status = zlib_deflate.deflate(strm, _mode);
+			if (status !== Z_STREAM_END && status !== Z_OK) {
+				this.onEnd(status);
+				this.ended = true;
+				return false;
+			}
+			if (strm.avail_out === 0 || strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH)) if (this.options.to === "string") this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out)));
+			else this.onData(utils.shrinkBuf(strm.output, strm.next_out));
+		} while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END);
+		if (_mode === Z_FINISH) {
+			status = zlib_deflate.deflateEnd(this.strm);
+			this.onEnd(status);
+			this.ended = true;
+			return status === Z_OK;
+		}
+		if (_mode === Z_SYNC_FLUSH) {
+			this.onEnd(Z_OK);
+			strm.avail_out = 0;
+			return true;
+		}
+		return true;
+	};
+	/**
+	* Deflate#onData(chunk) -> Void
+	* - chunk (Uint8Array|Array|String): output data. Type of array depends
+	*   on js engine support. When string output requested, each chunk
+	*   will be string.
+	*
+	* By default, stores data blocks in `chunks[]` property and glue
+	* those in `onEnd`. Override this handler, if you need another behaviour.
+	**/
+	Deflate.prototype.onData = function(chunk) {
+		this.chunks.push(chunk);
+	};
+	/**
+	* Deflate#onEnd(status) -> Void
+	* - status (Number): deflate status. 0 (Z_OK) on success,
+	*   other if not.
+	*
+	* Called once after you tell deflate that the input stream is
+	* complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)
+	* or if an error happened. By default - join collected chunks,
+	* free memory and fill `results` / `err` properties.
+	**/
+	Deflate.prototype.onEnd = function(status) {
+		if (status === Z_OK) if (this.options.to === "string") this.result = this.chunks.join("");
+		else this.result = utils.flattenChunks(this.chunks);
+		this.chunks = [];
+		this.err = status;
+		this.msg = this.strm.msg;
+	};
+	/**
+	* deflate(data[, options]) -> Uint8Array|Array|String
+	* - data (Uint8Array|Array|String): input data to compress.
+	* - options (Object): zlib deflate options.
+	*
+	* Compress `data` with deflate algorithm and `options`.
+	*
+	* Supported options are:
+	*
+	* - level
+	* - windowBits
+	* - memLevel
+	* - strategy
+	* - dictionary
+	*
+	* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
+	* for more information on these.
+	*
+	* Sugar (options):
+	*
+	* - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
+	*   negative windowBits implicitly.
+	* - `to` (String) - if equal to 'string', then result will be "binary string"
+	*    (each char code [0..255])
+	*
+	* ##### Example:
+	*
+	* ```javascript
+	* var pako = require('pako')
+	*   , data = Uint8Array([1,2,3,4,5,6,7,8,9]);
+	*
+	* console.log(pako.deflate(data));
+	* ```
+	**/
+	function deflate(input, options) {
+		var deflator = new Deflate(options);
+		deflator.push(input, true);
+		if (deflator.err) throw deflator.msg || msg[deflator.err];
+		return deflator.result;
+	}
+	/**
+	* deflateRaw(data[, options]) -> Uint8Array|Array|String
+	* - data (Uint8Array|Array|String): input data to compress.
+	* - options (Object): zlib deflate options.
+	*
+	* The same as [[deflate]], but creates raw data, without wrapper
+	* (header and adler32 crc).
+	**/
+	function deflateRaw(input, options) {
+		options = options || {};
+		options.raw = true;
+		return deflate(input, options);
+	}
+	/**
+	* gzip(data[, options]) -> Uint8Array|Array|String
+	* - data (Uint8Array|Array|String): input data to compress.
+	* - options (Object): zlib deflate options.
+	*
+	* The same as [[deflate]], but create gzip wrapper instead of
+	* deflate one.
+	**/
+	function gzip(input, options) {
+		options = options || {};
+		options.gzip = true;
+		return deflate(input, options);
+	}
+	exports.Deflate = Deflate;
+	exports.deflate = deflate;
+	exports.deflateRaw = deflateRaw;
+	exports.gzip = gzip;
+}) });
+
+//#endregion
+export default require_deflate();
+
+export { require_deflate };
+//# sourceMappingURL=deflate.mjs.map

package/dist/esm/node_modules/pako/lib/deflate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deflate.mjs","names":[],"sources":["../../../../../../../node_modules/pako/lib/deflate.js"],"sourcesContent":["'use strict';\n\n\nvar zlib_deflate = require('./zlib/deflate');\nvar utils        = require('./utils/common');\nvar strings      = require('./utils/strings');\nvar msg          = require('./zlib/messages');\nvar ZStream      = require('./zlib/zstream');\n\nvar toString = Object.prototype.toString;\n\n/* Public constants ==========================================================*/\n/* ===========================================================================*/\n\nvar Z_NO_FLUSH      = 0;\nvar Z_FINISH        = 4;\n\nvar Z_OK            = 0;\nvar Z_STREAM_END    = 1;\nvar Z_SYNC_FLUSH    = 2;\n\nvar Z_DEFAULT_COMPRESSION = -1;\n\nvar Z_DEFAULT_STRATEGY    = 0;\n\nvar Z_DEFLATED  = 8;\n\n/* ===========================================================================*/\n\n\n/**\n * class Deflate\n *\n * Generic JS-style wrapper for zlib calls. If you don't need\n * streaming behaviour - use more simple functions: [[deflate]],\n * [[deflateRaw]] and [[gzip]].\n **/\n\n/* internal\n * Deflate.chunks -> Array\n *\n * Chunks of output data, if [[Deflate#onData]] not overridden.\n **/\n\n/**\n * Deflate.result -> Uint8Array|Array\n *\n * Compressed result, generated by default [[Deflate#onData]]\n * and [[Deflate#onEnd]] handlers. Filled after you push last chunk\n * (call [[Deflate#push]] with `Z_FINISH` / `true` param)  or if you\n * push a chunk with explicit flush (call [[Deflate#push]] with\n * `Z_SYNC_FLUSH` param).\n **/\n\n/**\n * Deflate.err -> Number\n *\n * Error code after deflate finished. 0 (Z_OK) on success.\n * You will not need it in real life, because deflate errors\n * are possible only on wrong options or bad `onData` / `onEnd`\n * custom handlers.\n **/\n\n/**\n * Deflate.msg -> String\n *\n * Error message, if [[Deflate.err]] != 0\n **/\n\n\n/**\n * new Deflate(options)\n * - options (Object): zlib deflate options.\n *\n * Creates new deflator instance with specified params. Throws exception\n * on bad params. Supported options:\n *\n * - `level`\n * - `windowBits`\n * - `memLevel`\n * - `strategy`\n * - `dictionary`\n *\n * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information on these.\n *\n * Additional options, for internal needs:\n *\n * - `chunkSize` - size of generated data chunks (16K by default)\n * - `raw` (Boolean) - do raw deflate\n * - `gzip` (Boolean) - create gzip wrapper\n * - `to` (String) - if equal to 'string', then result will be \"binary string\"\n *    (each char code [0..255])\n * - `header` (Object) - custom header for gzip\n *   - `text` (Boolean) - true if compressed data believed to be text\n *   - `time` (Number) - modification time, unix timestamp\n *   - `os` (Number) - operation system code\n *   - `extra` (Array) - array of bytes with extra data (max 65536)\n *   - `name` (String) - file name (binary string)\n *   - `comment` (String) - comment (binary string)\n *   - `hcrc` (Boolean) - true if header crc should be added\n *\n * ##### Example:\n *\n * ```javascript\n * var pako = require('pako')\n *   , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])\n *   , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);\n *\n * var deflate = new pako.Deflate({ level: 3});\n *\n * deflate.push(chunk1, false);\n * deflate.push(chunk2, true);  // true -> last chunk\n *\n * if (deflate.err) { throw new Error(deflate.err); }\n *\n * console.log(deflate.result);\n * ```\n **/\nfunction Deflate(options) {\n  if (!(this instanceof Deflate)) return new Deflate(options);\n\n  this.options = utils.assign({\n    level: Z_DEFAULT_COMPRESSION,\n    method: Z_DEFLATED,\n    chunkSize: 16384,\n    windowBits: 15,\n    memLevel: 8,\n    strategy: Z_DEFAULT_STRATEGY,\n    to: ''\n  }, options || {});\n\n  var opt = this.options;\n\n  if (opt.raw && (opt.windowBits > 0)) {\n    opt.windowBits = -opt.windowBits;\n  }\n\n  else if (opt.gzip && (opt.windowBits > 0) && (opt.windowBits < 16)) {\n    opt.windowBits += 16;\n  }\n\n  this.err    = 0;      // error code, if happens (0 = Z_OK)\n  this.msg    = '';     // error message\n  this.ended  = false;  // used to avoid multiple onEnd() calls\n  this.chunks = [];     // chunks of compressed data\n\n  this.strm = new ZStream();\n  this.strm.avail_out = 0;\n\n  var status = zlib_deflate.deflateInit2(\n    this.strm,\n    opt.level,\n    opt.method,\n    opt.windowBits,\n    opt.memLevel,\n    opt.strategy\n  );\n\n  if (status !== Z_OK) {\n    throw new Error(msg[status]);\n  }\n\n  if (opt.header) {\n    zlib_deflate.deflateSetHeader(this.strm, opt.header);\n  }\n\n  if (opt.dictionary) {\n    var dict;\n    // Convert data if needed\n    if (typeof opt.dictionary === 'string') {\n      // If we need to compress text, change encoding to utf8.\n      dict = strings.string2buf(opt.dictionary);\n    } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {\n      dict = new Uint8Array(opt.dictionary);\n    } else {\n      dict = opt.dictionary;\n    }\n\n    status = zlib_deflate.deflateSetDictionary(this.strm, dict);\n\n    if (status !== Z_OK) {\n      throw new Error(msg[status]);\n    }\n\n    this._dict_set = true;\n  }\n}\n\n/**\n * Deflate#push(data[, mode]) -> Boolean\n * - data (Uint8Array|Array|ArrayBuffer|String): input data. Strings will be\n *   converted to utf8 byte sequence.\n * - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.\n *   See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.\n *\n * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with\n * new compressed chunks. Returns `true` on success. The last data block must have\n * mode Z_FINISH (or `true`). That will flush internal pending buffers and call\n * [[Deflate#onEnd]]. For interim explicit flushes (without ending the stream) you\n * can use mode Z_SYNC_FLUSH, keeping the compression context.\n *\n * On fail call [[Deflate#onEnd]] with error code and return false.\n *\n * We strongly recommend to use `Uint8Array` on input for best speed (output\n * array format is detected automatically). Also, don't skip last param and always\n * use the same type in your code (boolean or number). That will improve JS speed.\n *\n * For regular `Array`-s make sure all elements are [0..255].\n *\n * ##### Example\n *\n * ```javascript\n * push(chunk, false); // push one of data chunks\n * ...\n * push(chunk, true);  // push last chunk\n * ```\n **/\nDeflate.prototype.push = function (data, mode) {\n  var strm = this.strm;\n  var chunkSize = this.options.chunkSize;\n  var status, _mode;\n\n  if (this.ended) { return false; }\n\n  _mode = (mode === ~~mode) ? mode : ((mode === true) ? Z_FINISH : Z_NO_FLUSH);\n\n  // Convert data if needed\n  if (typeof data === 'string') {\n    // If we need to compress text, change encoding to utf8.\n    strm.input = strings.string2buf(data);\n  } else if (toString.call(data) === '[object ArrayBuffer]') {\n    strm.input = new Uint8Array(data);\n  } else {\n    strm.input = data;\n  }\n\n  strm.next_in = 0;\n  strm.avail_in = strm.input.length;\n\n  do {\n    if (strm.avail_out === 0) {\n      strm.output = new utils.Buf8(chunkSize);\n      strm.next_out = 0;\n      strm.avail_out = chunkSize;\n    }\n    status = zlib_deflate.deflate(strm, _mode);    /* no bad return value */\n\n    if (status !== Z_STREAM_END && status !== Z_OK) {\n      this.onEnd(status);\n      this.ended = true;\n      return false;\n    }\n    if (strm.avail_out === 0 || (strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH))) {\n      if (this.options.to === 'string') {\n        this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out)));\n      } else {\n        this.onData(utils.shrinkBuf(strm.output, strm.next_out));\n      }\n    }\n  } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END);\n\n  // Finalize on the last chunk.\n  if (_mode === Z_FINISH) {\n    status = zlib_deflate.deflateEnd(this.strm);\n    this.onEnd(status);\n    this.ended = true;\n    return status === Z_OK;\n  }\n\n  // callback interim results if Z_SYNC_FLUSH.\n  if (_mode === Z_SYNC_FLUSH) {\n    this.onEnd(Z_OK);\n    strm.avail_out = 0;\n    return true;\n  }\n\n  return true;\n};\n\n\n/**\n * Deflate#onData(chunk) -> Void\n * - chunk (Uint8Array|Array|String): output data. Type of array depends\n *   on js engine support. When string output requested, each chunk\n *   will be string.\n *\n * By default, stores data blocks in `chunks[]` property and glue\n * those in `onEnd`. Override this handler, if you need another behaviour.\n **/\nDeflate.prototype.onData = function (chunk) {\n  this.chunks.push(chunk);\n};\n\n\n/**\n * Deflate#onEnd(status) -> Void\n * - status (Number): deflate status. 0 (Z_OK) on success,\n *   other if not.\n *\n * Called once after you tell deflate that the input stream is\n * complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)\n * or if an error happened. By default - join collected chunks,\n * free memory and fill `results` / `err` properties.\n **/\nDeflate.prototype.onEnd = function (status) {\n  // On success - join\n  if (status === Z_OK) {\n    if (this.options.to === 'string') {\n      this.result = this.chunks.join('');\n    } else {\n      this.result = utils.flattenChunks(this.chunks);\n    }\n  }\n  this.chunks = [];\n  this.err = status;\n  this.msg = this.strm.msg;\n};\n\n\n/**\n * deflate(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to compress.\n * - options (Object): zlib deflate options.\n *\n * Compress `data` with deflate algorithm and `options`.\n *\n * Supported options are:\n *\n * - level\n * - windowBits\n * - memLevel\n * - strategy\n * - dictionary\n *\n * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information on these.\n *\n * Sugar (options):\n *\n * - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify\n *   negative windowBits implicitly.\n * - `to` (String) - if equal to 'string', then result will be \"binary string\"\n *    (each char code [0..255])\n *\n * ##### Example:\n *\n * ```javascript\n * var pako = require('pako')\n *   , data = Uint8Array([1,2,3,4,5,6,7,8,9]);\n *\n * console.log(pako.deflate(data));\n * ```\n **/\nfunction deflate(input, options) {\n  var deflator = new Deflate(options);\n\n  deflator.push(input, true);\n\n  // That will never happens, if you don't cheat with options :)\n  if (deflator.err) { throw deflator.msg || msg[deflator.err]; }\n\n  return deflator.result;\n}\n\n\n/**\n * deflateRaw(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to compress.\n * - options (Object): zlib deflate options.\n *\n * The same as [[deflate]], but creates raw data, without wrapper\n * (header and adler32 crc).\n **/\nfunction deflateRaw(input, options) {\n  options = options || {};\n  options.raw = true;\n  return deflate(input, options);\n}\n\n\n/**\n * gzip(data[, options]) -> Uint8Array|Array|String\n * - data (Uint8Array|Array|String): input data to compress.\n * - options (Object): zlib deflate options.\n *\n * The same as [[deflate]], but create gzip wrapper instead of\n * deflate one.\n **/\nfunction gzip(input, options) {\n  options = options || {};\n  options.gzip = true;\n  return deflate(input, options);\n}\n\n\nexports.Deflate = Deflate;\nexports.deflate = deflate;\nexports.deflateRaw = deflateRaw;\nexports.gzip = gzip;\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/esm/node_modules/pako/lib/inflate.mjs

@@ -0,0 +1,314 @@
+import { __commonJS } from "../../../_virtual/rolldown_runtime.mjs";
+import { require_common } from "./utils/common.mjs";
+import { require_messages } from "./zlib/messages.mjs";
+import { require_strings } from "./utils/strings.mjs";
+import { require_zstream } from "./zlib/zstream.mjs";
+import { require_inflate as require_inflate$1 } from "./zlib/inflate.mjs";
+import { require_constants } from "./zlib/constants.mjs";
+import { require_gzheader } from "./zlib/gzheader.mjs";
+
+//#region ../../node_modules/pako/lib/inflate.js
+var require_inflate = /* @__PURE__ */ __commonJS({ "../../node_modules/pako/lib/inflate.js": ((exports) => {
+	var zlib_inflate = require_inflate$1();
+	var utils = require_common();
+	var strings = require_strings();
+	var c = require_constants();
+	var msg = require_messages();
+	var ZStream = require_zstream();
+	var GZheader = require_gzheader();
+	var toString = Object.prototype.toString;
+	/**
+	* class Inflate
+	*
+	* Generic JS-style wrapper for zlib calls. If you don't need
+	* streaming behaviour - use more simple functions: [[inflate]]
+	* and [[inflateRaw]].
+	**/
+	/**
+	* Inflate.result -> Uint8Array|Array|String
+	*
+	* Uncompressed result, generated by default [[Inflate#onData]]
+	* and [[Inflate#onEnd]] handlers. Filled after you push last chunk
+	* (call [[Inflate#push]] with `Z_FINISH` / `true` param) or if you
+	* push a chunk with explicit flush (call [[Inflate#push]] with
+	* `Z_SYNC_FLUSH` param).
+	**/
+	/**
+	* Inflate.err -> Number
+	*
+	* Error code after inflate finished. 0 (Z_OK) on success.
+	* Should be checked if broken data possible.
+	**/
+	/**
+	* Inflate.msg -> String
+	*
+	* Error message, if [[Inflate.err]] != 0
+	**/
+	/**
+	* new Inflate(options)
+	* - options (Object): zlib inflate options.
+	*
+	* Creates new inflator instance with specified params. Throws exception
+	* on bad params. Supported options:
+	*
+	* - `windowBits`
+	* - `dictionary`
+	*
+	* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
+	* for more information on these.
+	*
+	* Additional options, for internal needs:
+	*
+	* - `chunkSize` - size of generated data chunks (16K by default)
+	* - `raw` (Boolean) - do raw inflate
+	* - `to` (String) - if equal to 'string', then result will be converted
+	*   from utf8 to utf16 (javascript) string. When string output requested,
+	*   chunk length can differ from `chunkSize`, depending on content.
+	*
+	* By default, when no options set, autodetect deflate/gzip data format via
+	* wrapper header.
+	*
+	* ##### Example:
+	*
+	* ```javascript
+	* var pako = require('pako')
+	*   , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
+	*   , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
+	*
+	* var inflate = new pako.Inflate({ level: 3});
+	*
+	* inflate.push(chunk1, false);
+	* inflate.push(chunk2, true);  // true -> last chunk
+	*
+	* if (inflate.err) { throw new Error(inflate.err); }
+	*
+	* console.log(inflate.result);
+	* ```
+	**/
+	function Inflate(options) {
+		if (!(this instanceof Inflate)) return new Inflate(options);
+		this.options = utils.assign({
+			chunkSize: 16384,
+			windowBits: 0,
+			to: ""
+		}, options || {});
+		var opt = this.options;
+		if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) {
+			opt.windowBits = -opt.windowBits;
+			if (opt.windowBits === 0) opt.windowBits = -15;
+		}
+		if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) opt.windowBits += 32;
+		if (opt.windowBits > 15 && opt.windowBits < 48) {
+			if ((opt.windowBits & 15) === 0) opt.windowBits |= 15;
+		}
+		this.err = 0;
+		this.msg = "";
+		this.ended = false;
+		this.chunks = [];
+		this.strm = new ZStream();
+		this.strm.avail_out = 0;
+		var status = zlib_inflate.inflateInit2(this.strm, opt.windowBits);
+		if (status !== c.Z_OK) throw new Error(msg[status]);
+		this.header = new GZheader();
+		zlib_inflate.inflateGetHeader(this.strm, this.header);
+		if (opt.dictionary) {
+			if (typeof opt.dictionary === "string") opt.dictionary = strings.string2buf(opt.dictionary);
+			else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") opt.dictionary = new Uint8Array(opt.dictionary);
+			if (opt.raw) {
+				status = zlib_inflate.inflateSetDictionary(this.strm, opt.dictionary);
+				if (status !== c.Z_OK) throw new Error(msg[status]);
+			}
+		}
+	}
+	/**
+	* Inflate#push(data[, mode]) -> Boolean
+	* - data (Uint8Array|Array|ArrayBuffer|String): input data
+	* - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
+	*   See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.
+	*
+	* Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
+	* new output chunks. Returns `true` on success. The last data block must have
+	* mode Z_FINISH (or `true`). That will flush internal pending buffers and call
+	* [[Inflate#onEnd]]. For interim explicit flushes (without ending the stream) you
+	* can use mode Z_SYNC_FLUSH, keeping the decompression context.
+	*
+	* On fail call [[Inflate#onEnd]] with error code and return false.
+	*
+	* We strongly recommend to use `Uint8Array` on input for best speed (output
+	* format is detected automatically). Also, don't skip last param and always
+	* use the same type in your code (boolean or number). That will improve JS speed.
+	*
+	* For regular `Array`-s make sure all elements are [0..255].
+	*
+	* ##### Example
+	*
+	* ```javascript
+	* push(chunk, false); // push one of data chunks
+	* ...
+	* push(chunk, true);  // push last chunk
+	* ```
+	**/
+	Inflate.prototype.push = function(data, mode) {
+		var strm = this.strm;
+		var chunkSize = this.options.chunkSize;
+		var dictionary = this.options.dictionary;
+		var status, _mode;
+		var next_out_utf8, tail, utf8str;
+		var allowBufError = false;
+		if (this.ended) return false;
+		_mode = mode === ~~mode ? mode : mode === true ? c.Z_FINISH : c.Z_NO_FLUSH;
+		if (typeof data === "string") strm.input = strings.binstring2buf(data);
+		else if (toString.call(data) === "[object ArrayBuffer]") strm.input = new Uint8Array(data);
+		else strm.input = data;
+		strm.next_in = 0;
+		strm.avail_in = strm.input.length;
+		do {
+			if (strm.avail_out === 0) {
+				strm.output = new utils.Buf8(chunkSize);
+				strm.next_out = 0;
+				strm.avail_out = chunkSize;
+			}
+			status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH);
+			if (status === c.Z_NEED_DICT && dictionary) status = zlib_inflate.inflateSetDictionary(this.strm, dictionary);
+			if (status === c.Z_BUF_ERROR && allowBufError === true) {
+				status = c.Z_OK;
+				allowBufError = false;
+			}
+			if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
+				this.onEnd(status);
+				this.ended = true;
+				return false;
+			}
+			if (strm.next_out) {
+				if (strm.avail_out === 0 || status === c.Z_STREAM_END || strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH)) if (this.options.to === "string") {
+					next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
+					tail = strm.next_out - next_out_utf8;
+					utf8str = strings.buf2string(strm.output, next_out_utf8);
+					strm.next_out = tail;
+					strm.avail_out = chunkSize - tail;
+					if (tail) utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0);
+					this.onData(utf8str);
+				} else this.onData(utils.shrinkBuf(strm.output, strm.next_out));
+			}
+			if (strm.avail_in === 0 && strm.avail_out === 0) allowBufError = true;
+		} while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END);
+		if (status === c.Z_STREAM_END) _mode = c.Z_FINISH;
+		if (_mode === c.Z_FINISH) {
+			status = zlib_inflate.inflateEnd(this.strm);
+			this.onEnd(status);
+			this.ended = true;
+			return status === c.Z_OK;
+		}
+		if (_mode === c.Z_SYNC_FLUSH) {
+			this.onEnd(c.Z_OK);
+			strm.avail_out = 0;
+			return true;
+		}
+		return true;
+	};
+	/**
+	* Inflate#onData(chunk) -> Void
+	* - chunk (Uint8Array|Array|String): output data. Type of array depends
+	*   on js engine support. When string output requested, each chunk
+	*   will be string.
+	*
+	* By default, stores data blocks in `chunks[]` property and glue
+	* those in `onEnd`. Override this handler, if you need another behaviour.
+	**/
+	Inflate.prototype.onData = function(chunk) {
+		this.chunks.push(chunk);
+	};
+	/**
+	* Inflate#onEnd(status) -> Void
+	* - status (Number): inflate status. 0 (Z_OK) on success,
+	*   other if not.
+	*
+	* Called either after you tell inflate that the input stream is
+	* complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)
+	* or if an error happened. By default - join collected chunks,
+	* free memory and fill `results` / `err` properties.
+	**/
+	Inflate.prototype.onEnd = function(status) {
+		if (status === c.Z_OK) if (this.options.to === "string") this.result = this.chunks.join("");
+		else this.result = utils.flattenChunks(this.chunks);
+		this.chunks = [];
+		this.err = status;
+		this.msg = this.strm.msg;
+	};
+	/**
+	* inflate(data[, options]) -> Uint8Array|Array|String
+	* - data (Uint8Array|Array|String): input data to decompress.
+	* - options (Object): zlib inflate options.
+	*
+	* Decompress `data` with inflate/ungzip and `options`. Autodetect
+	* format via wrapper header by default. That's why we don't provide
+	* separate `ungzip` method.
+	*
+	* Supported options are:
+	*
+	* - windowBits
+	*
+	* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
+	* for more information.
+	*
+	* Sugar (options):
+	*
+	* - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
+	*   negative windowBits implicitly.
+	* - `to` (String) - if equal to 'string', then result will be converted
+	*   from utf8 to utf16 (javascript) string. When string output requested,
+	*   chunk length can differ from `chunkSize`, depending on content.
+	*
+	*
+	* ##### Example:
+	*
+	* ```javascript
+	* var pako = require('pako')
+	*   , input = pako.deflate([1,2,3,4,5,6,7,8,9])
+	*   , output;
+	*
+	* try {
+	*   output = pako.inflate(input);
+	* } catch (err)
+	*   console.log(err);
+	* }
+	* ```
+	**/
+	function inflate(input, options) {
+		var inflator = new Inflate(options);
+		inflator.push(input, true);
+		if (inflator.err) throw inflator.msg || msg[inflator.err];
+		return inflator.result;
+	}
+	/**
+	* inflateRaw(data[, options]) -> Uint8Array|Array|String
+	* - data (Uint8Array|Array|String): input data to decompress.
+	* - options (Object): zlib inflate options.
+	*
+	* The same as [[inflate]], but creates raw data, without wrapper
+	* (header and adler32 crc).
+	**/
+	function inflateRaw(input, options) {
+		options = options || {};
+		options.raw = true;
+		return inflate(input, options);
+	}
+	/**
+	* ungzip(data[, options]) -> Uint8Array|Array|String
+	* - data (Uint8Array|Array|String): input data to decompress.
+	* - options (Object): zlib inflate options.
+	*
+	* Just shortcut to [[inflate]], because it autodetects format
+	* by header.content. Done for convenience.
+	**/
+	exports.Inflate = Inflate;
+	exports.inflate = inflate;
+	exports.inflateRaw = inflateRaw;
+	exports.ungzip = inflate;
+}) });
+
+//#endregion
+export default require_inflate();
+
+export { require_inflate };
+//# sourceMappingURL=inflate.mjs.map