@intlayer/backend 7.1.3 → 7.1.5

package/dist/cjs/node_modules/pako/lib/zlib/trees.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"trees.cjs","names":[],"sources":["../../../../../../../../node_modules/pako/lib/zlib/trees.js"],"sourcesContent":["'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\n/* eslint-disable space-unary-ops */\n\nvar utils = require('../utils/common');\n\n/* Public constants ==========================================================*/\n/* ===========================================================================*/\n\n\n//var Z_FILTERED          = 1;\n//var Z_HUFFMAN_ONLY      = 2;\n//var Z_RLE               = 3;\nvar Z_FIXED               = 4;\n//var Z_DEFAULT_STRATEGY  = 0;\n\n/* Possible values of the data_type field (though see inflate()) */\nvar Z_BINARY              = 0;\nvar Z_TEXT                = 1;\n//var Z_ASCII             = 1; // = Z_TEXT\nvar Z_UNKNOWN             = 2;\n\n/*============================================================================*/\n\n\nfunction zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }\n\n// From zutil.h\n\nvar STORED_BLOCK = 0;\nvar STATIC_TREES = 1;\nvar DYN_TREES    = 2;\n/* The three kinds of block type */\n\nvar MIN_MATCH    = 3;\nvar MAX_MATCH    = 258;\n/* The minimum and maximum match lengths */\n\n// From deflate.h\n/* ===========================================================================\n * Internal compression state.\n */\n\nvar LENGTH_CODES  = 29;\n/* number of length codes, not counting the special END_BLOCK code */\n\nvar LITERALS      = 256;\n/* number of literal bytes 0..255 */\n\nvar L_CODES       = LITERALS + 1 + LENGTH_CODES;\n/* number of Literal or Length codes, including the END_BLOCK code */\n\nvar D_CODES       = 30;\n/* number of distance codes */\n\nvar BL_CODES      = 19;\n/* number of codes used to transfer the bit lengths */\n\nvar HEAP_SIZE     = 2 * L_CODES + 1;\n/* maximum heap size */\n\nvar MAX_BITS      = 15;\n/* All codes must not exceed MAX_BITS bits */\n\nvar Buf_size      = 16;\n/* size of bit buffer in bi_buf */\n\n\n/* ===========================================================================\n * Constants\n */\n\nvar MAX_BL_BITS = 7;\n/* Bit length codes must not exceed MAX_BL_BITS bits */\n\nvar END_BLOCK   = 256;\n/* end of block literal code */\n\nvar REP_3_6     = 16;\n/* repeat previous bit length 3-6 times (2 bits of repeat count) */\n\nvar REPZ_3_10   = 17;\n/* repeat a zero length 3-10 times  (3 bits of repeat count) */\n\nvar REPZ_11_138 = 18;\n/* repeat a zero length 11-138 times  (7 bits of repeat count) */\n\n/* eslint-disable comma-spacing,array-bracket-spacing */\nvar extra_lbits =   /* extra bits for each length code */\n  [0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0];\n\nvar extra_dbits =   /* extra bits for each distance code */\n  [0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13];\n\nvar extra_blbits =  /* extra bits for each bit length code */\n  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7];\n\nvar bl_order =\n  [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];\n/* eslint-enable comma-spacing,array-bracket-spacing */\n\n/* The lengths of the bit length codes are sent in order of decreasing\n * probability, to avoid transmitting the lengths for unused bit length codes.\n */\n\n/* ===========================================================================\n * Local data. These are initialized only once.\n */\n\n// We pre-fill arrays with 0 to avoid uninitialized gaps\n\nvar DIST_CODE_LEN = 512; /* see definition of array dist_code below */\n\n// !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1\nvar static_ltree  = new Array((L_CODES + 2) * 2);\nzero(static_ltree);\n/* The static literal tree. Since the bit lengths are imposed, there is no\n * need for the L_CODES extra codes used during heap construction. However\n * The codes 286 and 287 are needed to build a canonical tree (see _tr_init\n * below).\n */\n\nvar static_dtree  = new Array(D_CODES * 2);\nzero(static_dtree);\n/* The static distance tree. (Actually a trivial tree since all codes use\n * 5 bits.)\n */\n\nvar _dist_code    = new Array(DIST_CODE_LEN);\nzero(_dist_code);\n/* Distance codes. The first 256 values correspond to the distances\n * 3 .. 258, the last 256 values correspond to the top 8 bits of\n * the 15 bit distances.\n */\n\nvar _length_code  = new Array(MAX_MATCH - MIN_MATCH + 1);\nzero(_length_code);\n/* length code for each normalized match length (0 == MIN_MATCH) */\n\nvar base_length   = new Array(LENGTH_CODES);\nzero(base_length);\n/* First normalized length for each code (0 = MIN_MATCH) */\n\nvar base_dist     = new Array(D_CODES);\nzero(base_dist);\n/* First normalized distance for each code (0 = distance of 1) */\n\n\nfunction StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {\n\n  this.static_tree  = static_tree;  /* static tree or NULL */\n  this.extra_bits   = extra_bits;   /* extra bits for each code or NULL */\n  this.extra_base   = extra_base;   /* base index for extra_bits */\n  this.elems        = elems;        /* max number of elements in the tree */\n  this.max_length   = max_length;   /* max bit length for the codes */\n\n  // show if `static_tree` has data or dummy - needed for monomorphic objects\n  this.has_stree    = static_tree && static_tree.length;\n}\n\n\nvar static_l_desc;\nvar static_d_desc;\nvar static_bl_desc;\n\n\nfunction TreeDesc(dyn_tree, stat_desc) {\n  this.dyn_tree = dyn_tree;     /* the dynamic tree */\n  this.max_code = 0;            /* largest code with non zero frequency */\n  this.stat_desc = stat_desc;   /* the corresponding static tree */\n}\n\n\n\nfunction d_code(dist) {\n  return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];\n}\n\n\n/* ===========================================================================\n * Output a short LSB first on the stream.\n * IN assertion: there is enough room in pendingBuf.\n */\nfunction put_short(s, w) {\n//    put_byte(s, (uch)((w) & 0xff));\n//    put_byte(s, (uch)((ush)(w) >> 8));\n  s.pending_buf[s.pending++] = (w) & 0xff;\n  s.pending_buf[s.pending++] = (w >>> 8) & 0xff;\n}\n\n\n/* ===========================================================================\n * Send a value on a given number of bits.\n * IN assertion: length <= 16 and value fits in length bits.\n */\nfunction send_bits(s, value, length) {\n  if (s.bi_valid > (Buf_size - length)) {\n    s.bi_buf |= (value << s.bi_valid) & 0xffff;\n    put_short(s, s.bi_buf);\n    s.bi_buf = value >> (Buf_size - s.bi_valid);\n    s.bi_valid += length - Buf_size;\n  } else {\n    s.bi_buf |= (value << s.bi_valid) & 0xffff;\n    s.bi_valid += length;\n  }\n}\n\n\nfunction send_code(s, c, tree) {\n  send_bits(s, tree[c * 2]/*.Code*/, tree[c * 2 + 1]/*.Len*/);\n}\n\n\n/* ===========================================================================\n * Reverse the first len bits of a code, using straightforward code (a faster\n * method would use a table)\n * IN assertion: 1 <= len <= 15\n */\nfunction bi_reverse(code, len) {\n  var res = 0;\n  do {\n    res |= code & 1;\n    code >>>= 1;\n    res <<= 1;\n  } while (--len > 0);\n  return res >>> 1;\n}\n\n\n/* ===========================================================================\n * Flush the bit buffer, keeping at most 7 bits in it.\n */\nfunction bi_flush(s) {\n  if (s.bi_valid === 16) {\n    put_short(s, s.bi_buf);\n    s.bi_buf = 0;\n    s.bi_valid = 0;\n\n  } else if (s.bi_valid >= 8) {\n    s.pending_buf[s.pending++] = s.bi_buf & 0xff;\n    s.bi_buf >>= 8;\n    s.bi_valid -= 8;\n  }\n}\n\n\n/* ===========================================================================\n * Compute the optimal bit lengths for a tree and update the total bit length\n * for the current block.\n * IN assertion: the fields freq and dad are set, heap[heap_max] and\n *    above are the tree nodes sorted by increasing frequency.\n * OUT assertions: the field len is set to the optimal bit length, the\n *     array bl_count contains the frequencies for each bit length.\n *     The length opt_len is updated; static_len is also updated if stree is\n *     not null.\n */\nfunction gen_bitlen(s, desc)\n//    deflate_state *s;\n//    tree_desc *desc;    /* the tree descriptor */\n{\n  var tree            = desc.dyn_tree;\n  var max_code        = desc.max_code;\n  var stree           = desc.stat_desc.static_tree;\n  var has_stree       = desc.stat_desc.has_stree;\n  var extra           = desc.stat_desc.extra_bits;\n  var base            = desc.stat_desc.extra_base;\n  var max_length      = desc.stat_desc.max_length;\n  var h;              /* heap index */\n  var n, m;           /* iterate over the tree elements */\n  var bits;           /* bit length */\n  var xbits;          /* extra bits */\n  var f;              /* frequency */\n  var overflow = 0;   /* number of elements with bit length too large */\n\n  for (bits = 0; bits <= MAX_BITS; bits++) {\n    s.bl_count[bits] = 0;\n  }\n\n  /* In a first pass, compute the optimal bit lengths (which may\n   * overflow in the case of the bit length tree).\n   */\n  tree[s.heap[s.heap_max] * 2 + 1]/*.Len*/ = 0; /* root of the heap */\n\n  for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {\n    n = s.heap[h];\n    bits = tree[tree[n * 2 + 1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;\n    if (bits > max_length) {\n      bits = max_length;\n      overflow++;\n    }\n    tree[n * 2 + 1]/*.Len*/ = bits;\n    /* We overwrite tree[n].Dad which is no longer needed */\n\n    if (n > max_code) { continue; } /* not a leaf node */\n\n    s.bl_count[bits]++;\n    xbits = 0;\n    if (n >= base) {\n      xbits = extra[n - base];\n    }\n    f = tree[n * 2]/*.Freq*/;\n    s.opt_len += f * (bits + xbits);\n    if (has_stree) {\n      s.static_len += f * (stree[n * 2 + 1]/*.Len*/ + xbits);\n    }\n  }\n  if (overflow === 0) { return; }\n\n  // Trace((stderr,\"\\nbit length overflow\\n\"));\n  /* This happens for example on obj2 and pic of the Calgary corpus */\n\n  /* Find the first bit length which could increase: */\n  do {\n    bits = max_length - 1;\n    while (s.bl_count[bits] === 0) { bits--; }\n    s.bl_count[bits]--;      /* move one leaf down the tree */\n    s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */\n    s.bl_count[max_length]--;\n    /* The brother of the overflow item also moves one step up,\n     * but this does not affect bl_count[max_length]\n     */\n    overflow -= 2;\n  } while (overflow > 0);\n\n  /* Now recompute all bit lengths, scanning in increasing frequency.\n   * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all\n   * lengths instead of fixing only the wrong ones. This idea is taken\n   * from 'ar' written by Haruhiko Okumura.)\n   */\n  for (bits = max_length; bits !== 0; bits--) {\n    n = s.bl_count[bits];\n    while (n !== 0) {\n      m = s.heap[--h];\n      if (m > max_code) { continue; }\n      if (tree[m * 2 + 1]/*.Len*/ !== bits) {\n        // Trace((stderr,\"code %d bits %d->%d\\n\", m, tree[m].Len, bits));\n        s.opt_len += (bits - tree[m * 2 + 1]/*.Len*/) * tree[m * 2]/*.Freq*/;\n        tree[m * 2 + 1]/*.Len*/ = bits;\n      }\n      n--;\n    }\n  }\n}\n\n\n/* ===========================================================================\n * Generate the codes for a given tree and bit counts (which need not be\n * optimal).\n * IN assertion: the array bl_count contains the bit length statistics for\n * the given tree and the field len is set for all tree elements.\n * OUT assertion: the field code is set for all tree elements of non\n *     zero code length.\n */\nfunction gen_codes(tree, max_code, bl_count)\n//    ct_data *tree;             /* the tree to decorate */\n//    int max_code;              /* largest code with non zero frequency */\n//    ushf *bl_count;            /* number of codes at each bit length */\n{\n  var next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */\n  var code = 0;              /* running code value */\n  var bits;                  /* bit index */\n  var n;                     /* code index */\n\n  /* The distribution counts are first used to generate the code values\n   * without bit reversal.\n   */\n  for (bits = 1; bits <= MAX_BITS; bits++) {\n    next_code[bits] = code = (code + bl_count[bits - 1]) << 1;\n  }\n  /* Check that the bit counts in bl_count are consistent. The last code\n   * must be all ones.\n   */\n  //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,\n  //        \"inconsistent bit counts\");\n  //Tracev((stderr,\"\\ngen_codes: max_code %d \", max_code));\n\n  for (n = 0;  n <= max_code; n++) {\n    var len = tree[n * 2 + 1]/*.Len*/;\n    if (len === 0) { continue; }\n    /* Now reverse the bits */\n    tree[n * 2]/*.Code*/ = bi_reverse(next_code[len]++, len);\n\n    //Tracecv(tree != static_ltree, (stderr,\"\\nn %3d %c l %2d c %4x (%x) \",\n    //     n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));\n  }\n}\n\n\n/* ===========================================================================\n * Initialize the various 'constant' tables.\n */\nfunction tr_static_init() {\n  var n;        /* iterates over tree elements */\n  var bits;     /* bit counter */\n  var length;   /* length value */\n  var code;     /* code value */\n  var dist;     /* distance index */\n  var bl_count = new Array(MAX_BITS + 1);\n  /* number of codes at each bit length for an optimal tree */\n\n  // do check in _tr_init()\n  //if (static_init_done) return;\n\n  /* For some embedded targets, global variables are not initialized: */\n/*#ifdef NO_INIT_GLOBAL_POINTERS\n  static_l_desc.static_tree = static_ltree;\n  static_l_desc.extra_bits = extra_lbits;\n  static_d_desc.static_tree = static_dtree;\n  static_d_desc.extra_bits = extra_dbits;\n  static_bl_desc.extra_bits = extra_blbits;\n#endif*/\n\n  /* Initialize the mapping length (0..255) -> length code (0..28) */\n  length = 0;\n  for (code = 0; code < LENGTH_CODES - 1; code++) {\n    base_length[code] = length;\n    for (n = 0; n < (1 << extra_lbits[code]); n++) {\n      _length_code[length++] = code;\n    }\n  }\n  //Assert (length == 256, \"tr_static_init: length != 256\");\n  /* Note that the length 255 (match length 258) can be represented\n   * in two different ways: code 284 + 5 bits or code 285, so we\n   * overwrite length_code[255] to use the best encoding:\n   */\n  _length_code[length - 1] = code;\n\n  /* Initialize the mapping dist (0..32K) -> dist code (0..29) */\n  dist = 0;\n  for (code = 0; code < 16; code++) {\n    base_dist[code] = dist;\n    for (n = 0; n < (1 << extra_dbits[code]); n++) {\n      _dist_code[dist++] = code;\n    }\n  }\n  //Assert (dist == 256, \"tr_static_init: dist != 256\");\n  dist >>= 7; /* from now on, all distances are divided by 128 */\n  for (; code < D_CODES; code++) {\n    base_dist[code] = dist << 7;\n    for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {\n      _dist_code[256 + dist++] = code;\n    }\n  }\n  //Assert (dist == 256, \"tr_static_init: 256+dist != 512\");\n\n  /* Construct the codes of the static literal tree */\n  for (bits = 0; bits <= MAX_BITS; bits++) {\n    bl_count[bits] = 0;\n  }\n\n  n = 0;\n  while (n <= 143) {\n    static_ltree[n * 2 + 1]/*.Len*/ = 8;\n    n++;\n    bl_count[8]++;\n  }\n  while (n <= 255) {\n    static_ltree[n * 2 + 1]/*.Len*/ = 9;\n    n++;\n    bl_count[9]++;\n  }\n  while (n <= 279) {\n    static_ltree[n * 2 + 1]/*.Len*/ = 7;\n    n++;\n    bl_count[7]++;\n  }\n  while (n <= 287) {\n    static_ltree[n * 2 + 1]/*.Len*/ = 8;\n    n++;\n    bl_count[8]++;\n  }\n  /* Codes 286 and 287 do not exist, but we must include them in the\n   * tree construction to get a canonical Huffman tree (longest code\n   * all ones)\n   */\n  gen_codes(static_ltree, L_CODES + 1, bl_count);\n\n  /* The static distance tree is trivial: */\n  for (n = 0; n < D_CODES; n++) {\n    static_dtree[n * 2 + 1]/*.Len*/ = 5;\n    static_dtree[n * 2]/*.Code*/ = bi_reverse(n, 5);\n  }\n\n  // Now data ready and we can init static trees\n  static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);\n  static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS);\n  static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0,         BL_CODES, MAX_BL_BITS);\n\n  //static_init_done = true;\n}\n\n\n/* ===========================================================================\n * Initialize a new block.\n */\nfunction init_block(s) {\n  var n; /* iterates over tree elements */\n\n  /* Initialize the trees. */\n  for (n = 0; n < L_CODES;  n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; }\n  for (n = 0; n < D_CODES;  n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; }\n  for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; }\n\n  s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1;\n  s.opt_len = s.static_len = 0;\n  s.last_lit = s.matches = 0;\n}\n\n\n/* ===========================================================================\n * Flush the bit buffer and align the output on a byte boundary\n */\nfunction bi_windup(s)\n{\n  if (s.bi_valid > 8) {\n    put_short(s, s.bi_buf);\n  } else if (s.bi_valid > 0) {\n    //put_byte(s, (Byte)s->bi_buf);\n    s.pending_buf[s.pending++] = s.bi_buf;\n  }\n  s.bi_buf = 0;\n  s.bi_valid = 0;\n}\n\n/* ===========================================================================\n * Copy a stored block, storing first the length and its\n * one's complement if requested.\n */\nfunction copy_block(s, buf, len, header)\n//DeflateState *s;\n//charf    *buf;    /* the input data */\n//unsigned len;     /* its length */\n//int      header;  /* true if block header must be written */\n{\n  bi_windup(s);        /* align on byte boundary */\n\n  if (header) {\n    put_short(s, len);\n    put_short(s, ~len);\n  }\n//  while (len--) {\n//    put_byte(s, *buf++);\n//  }\n  utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);\n  s.pending += len;\n}\n\n/* ===========================================================================\n * Compares to subtrees, using the tree depth as tie breaker when\n * the subtrees have equal frequency. This minimizes the worst case length.\n */\nfunction smaller(tree, n, m, depth) {\n  var _n2 = n * 2;\n  var _m2 = m * 2;\n  return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ ||\n         (tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m]));\n}\n\n/* ===========================================================================\n * Restore the heap property by moving down the tree starting at node k,\n * exchanging a node with the smallest of its two sons if necessary, stopping\n * when the heap property is re-established (each father smaller than its\n * two sons).\n */\nfunction pqdownheap(s, tree, k)\n//    deflate_state *s;\n//    ct_data *tree;  /* the tree to restore */\n//    int k;               /* node to move down */\n{\n  var v = s.heap[k];\n  var j = k << 1;  /* left son of k */\n  while (j <= s.heap_len) {\n    /* Set j to the smallest of the two sons: */\n    if (j < s.heap_len &&\n      smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {\n      j++;\n    }\n    /* Exit if v is smaller than both sons */\n    if (smaller(tree, v, s.heap[j], s.depth)) { break; }\n\n    /* Exchange v with the smallest son */\n    s.heap[k] = s.heap[j];\n    k = j;\n\n    /* And continue down the tree, setting j to the left son of k */\n    j <<= 1;\n  }\n  s.heap[k] = v;\n}\n\n\n// inlined manually\n// var SMALLEST = 1;\n\n/* ===========================================================================\n * Send the block data compressed using the given Huffman trees\n */\nfunction compress_block(s, ltree, dtree)\n//    deflate_state *s;\n//    const ct_data *ltree; /* literal tree */\n//    const ct_data *dtree; /* distance tree */\n{\n  var dist;           /* distance of matched string */\n  var lc;             /* match length or unmatched char (if dist == 0) */\n  var lx = 0;         /* running index in l_buf */\n  var code;           /* the code to send */\n  var extra;          /* number of extra bits to send */\n\n  if (s.last_lit !== 0) {\n    do {\n      dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]);\n      lc = s.pending_buf[s.l_buf + lx];\n      lx++;\n\n      if (dist === 0) {\n        send_code(s, lc, ltree); /* send a literal byte */\n        //Tracecv(isgraph(lc), (stderr,\" '%c' \", lc));\n      } else {\n        /* Here, lc is the match length - MIN_MATCH */\n        code = _length_code[lc];\n        send_code(s, code + LITERALS + 1, ltree); /* send the length code */\n        extra = extra_lbits[code];\n        if (extra !== 0) {\n          lc -= base_length[code];\n          send_bits(s, lc, extra);       /* send the extra length bits */\n        }\n        dist--; /* dist is now the match distance - 1 */\n        code = d_code(dist);\n        //Assert (code < D_CODES, \"bad d_code\");\n\n        send_code(s, code, dtree);       /* send the distance code */\n        extra = extra_dbits[code];\n        if (extra !== 0) {\n          dist -= base_dist[code];\n          send_bits(s, dist, extra);   /* send the extra distance bits */\n        }\n      } /* literal or match pair ? */\n\n      /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */\n      //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,\n      //       \"pendingBuf overflow\");\n\n    } while (lx < s.last_lit);\n  }\n\n  send_code(s, END_BLOCK, ltree);\n}\n\n\n/* ===========================================================================\n * Construct one Huffman tree and assigns the code bit strings and lengths.\n * Update the total bit length for the current block.\n * IN assertion: the field freq is set for all tree elements.\n * OUT assertions: the fields len and code are set to the optimal bit length\n *     and corresponding code. The length opt_len is updated; static_len is\n *     also updated if stree is not null. The field max_code is set.\n */\nfunction build_tree(s, desc)\n//    deflate_state *s;\n//    tree_desc *desc; /* the tree descriptor */\n{\n  var tree     = desc.dyn_tree;\n  var stree    = desc.stat_desc.static_tree;\n  var has_stree = desc.stat_desc.has_stree;\n  var elems    = desc.stat_desc.elems;\n  var n, m;          /* iterate over heap elements */\n  var max_code = -1; /* largest code with non zero frequency */\n  var node;          /* new node being created */\n\n  /* Construct the initial heap, with least frequent element in\n   * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].\n   * heap[0] is not used.\n   */\n  s.heap_len = 0;\n  s.heap_max = HEAP_SIZE;\n\n  for (n = 0; n < elems; n++) {\n    if (tree[n * 2]/*.Freq*/ !== 0) {\n      s.heap[++s.heap_len] = max_code = n;\n      s.depth[n] = 0;\n\n    } else {\n      tree[n * 2 + 1]/*.Len*/ = 0;\n    }\n  }\n\n  /* The pkzip format requires that at least one distance code exists,\n   * and that at least one bit should be sent even if there is only one\n   * possible code. So to avoid special checks later on we force at least\n   * two codes of non zero frequency.\n   */\n  while (s.heap_len < 2) {\n    node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);\n    tree[node * 2]/*.Freq*/ = 1;\n    s.depth[node] = 0;\n    s.opt_len--;\n\n    if (has_stree) {\n      s.static_len -= stree[node * 2 + 1]/*.Len*/;\n    }\n    /* node is 0 or 1 so it does not have extra bits */\n  }\n  desc.max_code = max_code;\n\n  /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,\n   * establish sub-heaps of increasing lengths:\n   */\n  for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); }\n\n  /* Construct the Huffman tree by repeatedly combining the least two\n   * frequent nodes.\n   */\n  node = elems;              /* next internal node of the tree */\n  do {\n    //pqremove(s, tree, n);  /* n = node of least frequency */\n    /*** pqremove ***/\n    n = s.heap[1/*SMALLEST*/];\n    s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--];\n    pqdownheap(s, tree, 1/*SMALLEST*/);\n    /***/\n\n    m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */\n\n    s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */\n    s.heap[--s.heap_max] = m;\n\n    /* Create a new node father of n and m */\n    tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/;\n    s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;\n    tree[n * 2 + 1]/*.Dad*/ = tree[m * 2 + 1]/*.Dad*/ = node;\n\n    /* and insert the new node in the heap */\n    s.heap[1/*SMALLEST*/] = node++;\n    pqdownheap(s, tree, 1/*SMALLEST*/);\n\n  } while (s.heap_len >= 2);\n\n  s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/];\n\n  /* At this point, the fields freq and dad are set. We can now\n   * generate the bit lengths.\n   */\n  gen_bitlen(s, desc);\n\n  /* The field len is now set, we can generate the bit codes */\n  gen_codes(tree, max_code, s.bl_count);\n}\n\n\n/* ===========================================================================\n * Scan a literal or distance tree to determine the frequencies of the codes\n * in the bit length tree.\n */\nfunction scan_tree(s, tree, max_code)\n//    deflate_state *s;\n//    ct_data *tree;   /* the tree to be scanned */\n//    int max_code;    /* and its largest code of non zero frequency */\n{\n  var n;                     /* iterates over all tree elements */\n  var prevlen = -1;          /* last emitted length */\n  var curlen;                /* length of current code */\n\n  var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */\n\n  var count = 0;             /* repeat count of the current code */\n  var max_count = 7;         /* max repeat count */\n  var min_count = 4;         /* min repeat count */\n\n  if (nextlen === 0) {\n    max_count = 138;\n    min_count = 3;\n  }\n  tree[(max_code + 1) * 2 + 1]/*.Len*/ = 0xffff; /* guard */\n\n  for (n = 0; n <= max_code; n++) {\n    curlen = nextlen;\n    nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;\n\n    if (++count < max_count && curlen === nextlen) {\n      continue;\n\n    } else if (count < min_count) {\n      s.bl_tree[curlen * 2]/*.Freq*/ += count;\n\n    } else if (curlen !== 0) {\n\n      if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; }\n      s.bl_tree[REP_3_6 * 2]/*.Freq*/++;\n\n    } else if (count <= 10) {\n      s.bl_tree[REPZ_3_10 * 2]/*.Freq*/++;\n\n    } else {\n      s.bl_tree[REPZ_11_138 * 2]/*.Freq*/++;\n    }\n\n    count = 0;\n    prevlen = curlen;\n\n    if (nextlen === 0) {\n      max_count = 138;\n      min_count = 3;\n\n    } else if (curlen === nextlen) {\n      max_count = 6;\n      min_count = 3;\n\n    } else {\n      max_count = 7;\n      min_count = 4;\n    }\n  }\n}\n\n\n/* ===========================================================================\n * Send a literal or distance tree in compressed form, using the codes in\n * bl_tree.\n */\nfunction send_tree(s, tree, max_code)\n//    deflate_state *s;\n//    ct_data *tree; /* the tree to be scanned */\n//    int max_code;       /* and its largest code of non zero frequency */\n{\n  var n;                     /* iterates over all tree elements */\n  var prevlen = -1;          /* last emitted length */\n  var curlen;                /* length of current code */\n\n  var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */\n\n  var count = 0;             /* repeat count of the current code */\n  var max_count = 7;         /* max repeat count */\n  var min_count = 4;         /* min repeat count */\n\n  /* tree[max_code+1].Len = -1; */  /* guard already set */\n  if (nextlen === 0) {\n    max_count = 138;\n    min_count = 3;\n  }\n\n  for (n = 0; n <= max_code; n++) {\n    curlen = nextlen;\n    nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;\n\n    if (++count < max_count && curlen === nextlen) {\n      continue;\n\n    } else if (count < min_count) {\n      do { send_code(s, curlen, s.bl_tree); } while (--count !== 0);\n\n    } else if (curlen !== 0) {\n      if (curlen !== prevlen) {\n        send_code(s, curlen, s.bl_tree);\n        count--;\n      }\n      //Assert(count >= 3 && count <= 6, \" 3_6?\");\n      send_code(s, REP_3_6, s.bl_tree);\n      send_bits(s, count - 3, 2);\n\n    } else if (count <= 10) {\n      send_code(s, REPZ_3_10, s.bl_tree);\n      send_bits(s, count - 3, 3);\n\n    } else {\n      send_code(s, REPZ_11_138, s.bl_tree);\n      send_bits(s, count - 11, 7);\n    }\n\n    count = 0;\n    prevlen = curlen;\n    if (nextlen === 0) {\n      max_count = 138;\n      min_count = 3;\n\n    } else if (curlen === nextlen) {\n      max_count = 6;\n      min_count = 3;\n\n    } else {\n      max_count = 7;\n      min_count = 4;\n    }\n  }\n}\n\n\n/* ===========================================================================\n * Construct the Huffman tree for the bit lengths and return the index in\n * bl_order of the last bit length code to send.\n */\nfunction build_bl_tree(s) {\n  var max_blindex;  /* index of last bit length code of non zero freq */\n\n  /* Determine the bit length frequencies for literal and distance trees */\n  scan_tree(s, s.dyn_ltree, s.l_desc.max_code);\n  scan_tree(s, s.dyn_dtree, s.d_desc.max_code);\n\n  /* Build the bit length tree: */\n  build_tree(s, s.bl_desc);\n  /* opt_len now includes the length of the tree representations, except\n   * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.\n   */\n\n  /* Determine the number of bit length codes to send. The pkzip format\n   * requires that at least 4 bit length codes be sent. (appnote.txt says\n   * 3 but the actual value used is 4.)\n   */\n  for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {\n    if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/*.Len*/ !== 0) {\n      break;\n    }\n  }\n  /* Update opt_len to include the bit length tree and counts */\n  s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;\n  //Tracev((stderr, \"\\ndyn trees: dyn %ld, stat %ld\",\n  //        s->opt_len, s->static_len));\n\n  return max_blindex;\n}\n\n\n/* ===========================================================================\n * Send the header for a block using dynamic Huffman trees: the counts, the\n * lengths of the bit length codes, the literal tree and the distance tree.\n * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.\n */\nfunction send_all_trees(s, lcodes, dcodes, blcodes)\n//    deflate_state *s;\n//    int lcodes, dcodes, blcodes; /* number of codes for each tree */\n{\n  var rank;                    /* index in bl_order */\n\n  //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, \"not enough codes\");\n  //Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,\n  //        \"too many codes\");\n  //Tracev((stderr, \"\\nbl counts: \"));\n  send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */\n  send_bits(s, dcodes - 1,   5);\n  send_bits(s, blcodes - 4,  4); /* not -3 as stated in appnote.txt */\n  for (rank = 0; rank < blcodes; rank++) {\n    //Tracev((stderr, \"\\nbl code %2d \", bl_order[rank]));\n    send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]/*.Len*/, 3);\n  }\n  //Tracev((stderr, \"\\nbl tree: sent %ld\", s->bits_sent));\n\n  send_tree(s, s.dyn_ltree, lcodes - 1); /* literal tree */\n  //Tracev((stderr, \"\\nlit tree: sent %ld\", s->bits_sent));\n\n  send_tree(s, s.dyn_dtree, dcodes - 1); /* distance tree */\n  //Tracev((stderr, \"\\ndist tree: sent %ld\", s->bits_sent));\n}\n\n\n/* ===========================================================================\n * Check if the data type is TEXT or BINARY, using the following algorithm:\n * - TEXT if the two conditions below are satisfied:\n *    a) There are no non-portable control characters belonging to the\n *       \"black list\" (0..6, 14..25, 28..31).\n *    b) There is at least one printable character belonging to the\n *       \"white list\" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).\n * - BINARY otherwise.\n * - The following partially-portable control characters form a\n *   \"gray list\" that is ignored in this detection algorithm:\n *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).\n * IN assertion: the fields Freq of dyn_ltree are set.\n */\nfunction detect_data_type(s) {\n  /* black_mask is the bit mask of black-listed bytes\n   * set bits 0..6, 14..25, and 28..31\n   * 0xf3ffc07f = binary 11110011111111111100000001111111\n   */\n  var black_mask = 0xf3ffc07f;\n  var n;\n\n  /* Check for non-textual (\"black-listed\") bytes. */\n  for (n = 0; n <= 31; n++, black_mask >>>= 1) {\n    if ((black_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) {\n      return Z_BINARY;\n    }\n  }\n\n  /* Check for textual (\"white-listed\") bytes. */\n  if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 ||\n      s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) {\n    return Z_TEXT;\n  }\n  for (n = 32; n < LITERALS; n++) {\n    if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) {\n      return Z_TEXT;\n    }\n  }\n\n  /* There are no \"black-listed\" or \"white-listed\" bytes:\n   * this stream either is empty or has tolerated (\"gray-listed\") bytes only.\n   */\n  return Z_BINARY;\n}\n\n\nvar static_init_done = false;\n\n/* ===========================================================================\n * Initialize the tree data structures for a new zlib stream.\n */\nfunction _tr_init(s)\n{\n\n  if (!static_init_done) {\n    tr_static_init();\n    static_init_done = true;\n  }\n\n  s.l_desc  = new TreeDesc(s.dyn_ltree, static_l_desc);\n  s.d_desc  = new TreeDesc(s.dyn_dtree, static_d_desc);\n  s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);\n\n  s.bi_buf = 0;\n  s.bi_valid = 0;\n\n  /* Initialize the first block of the first file: */\n  init_block(s);\n}\n\n\n/* ===========================================================================\n * Send a stored block\n */\nfunction _tr_stored_block(s, buf, stored_len, last)\n//DeflateState *s;\n//charf *buf;       /* input block */\n//ulg stored_len;   /* length of input block */\n//int last;         /* one if this is the last block for a file */\n{\n  send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);    /* send block type */\n  copy_block(s, buf, stored_len, true); /* with header */\n}\n\n\n/* ===========================================================================\n * Send one empty static block to give enough lookahead for inflate.\n * This takes 10 bits, of which 7 may remain in the bit buffer.\n */\nfunction _tr_align(s) {\n  send_bits(s, STATIC_TREES << 1, 3);\n  send_code(s, END_BLOCK, static_ltree);\n  bi_flush(s);\n}\n\n\n/* ===========================================================================\n * Determine the best encoding for the current block: dynamic trees, static\n * trees or store, and output the encoded block to the zip file.\n */\nfunction _tr_flush_block(s, buf, stored_len, last)\n//DeflateState *s;\n//charf *buf;       /* input block, or NULL if too old */\n//ulg stored_len;   /* length of input block */\n//int last;         /* one if this is the last block for a file */\n{\n  var opt_lenb, static_lenb;  /* opt_len and static_len in bytes */\n  var max_blindex = 0;        /* index of last bit length code of non zero freq */\n\n  /* Build the Huffman trees unless a stored block is forced */\n  if (s.level > 0) {\n\n    /* Check if the file is binary or text */\n    if (s.strm.data_type === Z_UNKNOWN) {\n      s.strm.data_type = detect_data_type(s);\n    }\n\n    /* Construct the literal and distance trees */\n    build_tree(s, s.l_desc);\n    // Tracev((stderr, \"\\nlit data: dyn %ld, stat %ld\", s->opt_len,\n    //        s->static_len));\n\n    build_tree(s, s.d_desc);\n    // Tracev((stderr, \"\\ndist data: dyn %ld, stat %ld\", s->opt_len,\n    //        s->static_len));\n    /* At this point, opt_len and static_len are the total bit lengths of\n     * the compressed block data, excluding the tree representations.\n     */\n\n    /* Build the bit length tree for the above two trees, and get the index\n     * in bl_order of the last bit length code to send.\n     */\n    max_blindex = build_bl_tree(s);\n\n    /* Determine the best encoding. Compute the block lengths in bytes. */\n    opt_lenb = (s.opt_len + 3 + 7) >>> 3;\n    static_lenb = (s.static_len + 3 + 7) >>> 3;\n\n    // Tracev((stderr, \"\\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u \",\n    //        opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,\n    //        s->last_lit));\n\n    if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; }\n\n  } else {\n    // Assert(buf != (char*)0, \"lost buf\");\n    opt_lenb = static_lenb = stored_len + 5; /* force a stored block */\n  }\n\n  if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) {\n    /* 4: two words for the lengths */\n\n    /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.\n     * Otherwise we can't have processed more than WSIZE input bytes since\n     * the last block flush, because compression would have been\n     * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to\n     * transform a block into a stored block.\n     */\n    _tr_stored_block(s, buf, stored_len, last);\n\n  } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {\n\n    send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);\n    compress_block(s, static_ltree, static_dtree);\n\n  } else {\n    send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);\n    send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);\n    compress_block(s, s.dyn_ltree, s.dyn_dtree);\n  }\n  // Assert (s->compressed_len == s->bits_sent, \"bad compressed size\");\n  /* The above check is made mod 2^32, for files larger than 512 MB\n   * and uLong implemented on 32 bits.\n   */\n  init_block(s);\n\n  if (last) {\n    bi_windup(s);\n  }\n  // Tracev((stderr,\"\\ncomprlen %lu(%lu) \", s->compressed_len>>3,\n  //       s->compressed_len-7*last));\n}\n\n/* ===========================================================================\n * Save the match info and tally the frequency counts. Return true if\n * the current block must be flushed.\n */\nfunction _tr_tally(s, dist, lc)\n//    deflate_state *s;\n//    unsigned dist;  /* distance of matched string */\n//    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */\n{\n  //var out_length, in_length, dcode;\n\n  s.pending_buf[s.d_buf + s.last_lit * 2]     = (dist >>> 8) & 0xff;\n  s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;\n\n  s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;\n  s.last_lit++;\n\n  if (dist === 0) {\n    /* lc is the unmatched char */\n    s.dyn_ltree[lc * 2]/*.Freq*/++;\n  } else {\n    s.matches++;\n    /* Here, lc is the match length - MIN_MATCH */\n    dist--;             /* dist = match distance - 1 */\n    //Assert((ush)dist < (ush)MAX_DIST(s) &&\n    //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&\n    //       (ush)d_code(dist) < (ush)D_CODES,  \"_tr_tally: bad match\");\n\n    s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/*.Freq*/++;\n    s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++;\n  }\n\n// (!) This block is disabled in zlib defaults,\n// don't enable it for binary compatibility\n\n//#ifdef TRUNCATE_BLOCK\n//  /* Try to guess if it is profitable to stop the current block here */\n//  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {\n//    /* Compute an upper bound for the compressed length */\n//    out_length = s.last_lit*8;\n//    in_length = s.strstart - s.block_start;\n//\n//    for (dcode = 0; dcode < D_CODES; dcode++) {\n//      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);\n//    }\n//    out_length >>>= 3;\n//    //Tracev((stderr,\"\\nlast_lit %u, in %ld, out ~%ld(%ld%%) \",\n//    //       s->last_lit, in_length, out_length,\n//    //       100L - out_length*100L/in_length));\n//    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {\n//      return true;\n//    }\n//  }\n//#endif\n\n  return (s.last_lit === s.lit_bufsize - 1);\n  /* We avoid equality with lit_bufsize because of wraparound at 64K\n   * on 16 bit machines and because stored blocks are restricted to\n   * 64K-1 bytes.\n   */\n}\n\nexports._tr_init  = _tr_init;\nexports._tr_stored_block = _tr_stored_block;\nexports._tr_flush_block  = _tr_flush_block;\nexports._tr_tally = _tr_tally;\nexports._tr_align = _tr_align;\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/cjs/node_modules/pako/lib/zlib/zstream.cjs

@@ -1,29 +0,0 @@
-const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
-
-//#region ../../node_modules/pako/lib/zlib/zstream.js
-var require_zstream = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/pako/lib/zlib/zstream.js": ((exports, module) => {
-	function ZStream() {
-		this.input = null;
-		this.next_in = 0;
-		this.avail_in = 0;
-		this.total_in = 0;
-		this.output = null;
-		this.next_out = 0;
-		this.avail_out = 0;
-		this.total_out = 0;
-		this.msg = "";
-		this.state = null;
-		this.data_type = 2;
-		this.adler = 0;
-	}
-	module.exports = ZStream;
-}) });
-
-//#endregion
-Object.defineProperty(exports, 'default', {
-  enumerable: true,
-  get: function () {
-    return require_zstream();
-  }
-});
-//# sourceMappingURL=zstream.cjs.map

package/dist/cjs/node_modules/pako/lib/zlib/zstream.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"zstream.cjs","names":[],"sources":["../../../../../../../../node_modules/pako/lib/zlib/zstream.js"],"sourcesContent":["'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n//   claim that you wrote the original software. If you use this software\n//   in a product, an acknowledgment in the product documentation would be\n//   appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n//   misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nfunction ZStream() {\n  /* next input byte */\n  this.input = null; // JS specific, because we have no pointers\n  this.next_in = 0;\n  /* number of bytes available at input */\n  this.avail_in = 0;\n  /* total number of input bytes read so far */\n  this.total_in = 0;\n  /* next output byte should be put there */\n  this.output = null; // JS specific, because we have no pointers\n  this.next_out = 0;\n  /* remaining free space at output */\n  this.avail_out = 0;\n  /* total number of bytes output so far */\n  this.total_out = 0;\n  /* last error message, NULL if no error */\n  this.msg = ''/*Z_NULL*/;\n  /* not visible by applications */\n  this.state = null;\n  /* best guess about the data type: binary or text */\n  this.data_type = 2/*Z_UNKNOWN*/;\n  /* adler32 value of the uncompressed data */\n  this.adler = 0;\n}\n\nmodule.exports = ZStream;\n"],"x_google_ignoreList":[0],"mappings":";;;;CAqBA,SAAS,UAAU;AAEjB,OAAK,QAAQ;AACb,OAAK,UAAU;AAEf,OAAK,WAAW;AAEhB,OAAK,WAAW;AAEhB,OAAK,SAAS;AACd,OAAK,WAAW;AAEhB,OAAK,YAAY;AAEjB,OAAK,YAAY;AAEjB,OAAK,MAAM;AAEX,OAAK,QAAQ;AAEb,OAAK,YAAY;AAEjB,OAAK,QAAQ;;AAGf,QAAO,UAAU"}

package/dist/cjs/node_modules/safer-buffer/safer.cjs

@@ -1,52 +0,0 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-
-//#region ../../node_modules/safer-buffer/safer.js
-var require_safer = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/safer-buffer/safer.js": ((exports, module) => {
-	var buffer = require("buffer");
-	var Buffer = buffer.Buffer;
-	var safer = {};
-	var key;
-	for (key in buffer) {
-		if (!buffer.hasOwnProperty(key)) continue;
-		if (key === "SlowBuffer" || key === "Buffer") continue;
-		safer[key] = buffer[key];
-	}
-	var Safer = safer.Buffer = {};
-	for (key in Buffer) {
-		if (!Buffer.hasOwnProperty(key)) continue;
-		if (key === "allocUnsafe" || key === "allocUnsafeSlow") continue;
-		Safer[key] = Buffer[key];
-	}
-	safer.Buffer.prototype = Buffer.prototype;
-	if (!Safer.from || Safer.from === Uint8Array.from) Safer.from = function(value, encodingOrOffset, length) {
-		if (typeof value === "number") throw new TypeError("The \"value\" argument must not be of type number. Received type " + typeof value);
-		if (value && typeof value.length === "undefined") throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
-		return Buffer(value, encodingOrOffset, length);
-	};
-	if (!Safer.alloc) Safer.alloc = function(size, fill, encoding) {
-		if (typeof size !== "number") throw new TypeError("The \"size\" argument must be of type number. Received type " + typeof size);
-		if (size < 0 || size >= 2 * (1 << 30)) throw new RangeError("The value \"" + size + "\" is invalid for option \"size\"");
-		var buf = Buffer(size);
-		if (!fill || fill.length === 0) buf.fill(0);
-		else if (typeof encoding === "string") buf.fill(fill, encoding);
-		else buf.fill(fill);
-		return buf;
-	};
-	if (!safer.kStringMaxLength) try {
-		safer.kStringMaxLength = process.binding("buffer").kStringMaxLength;
-	} catch (e) {}
-	if (!safer.constants) {
-		safer.constants = { MAX_LENGTH: safer.kMaxLength };
-		if (safer.kStringMaxLength) safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
-	}
-	module.exports = safer;
-}) });
-
-//#endregion
-Object.defineProperty(exports, 'default', {
-  enumerable: true,
-  get: function () {
-    return require_safer();
-  }
-});
-//# sourceMappingURL=safer.cjs.map

package/dist/cjs/node_modules/safer-buffer/safer.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"safer.cjs","names":[],"sources":["../../../../../../node_modules/safer-buffer/safer.js"],"sourcesContent":["/* eslint-disable node/no-deprecated-api */\n\n'use strict'\n\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\nvar safer = {}\n\nvar key\n\nfor (key in buffer) {\n  if (!buffer.hasOwnProperty(key)) continue\n  if (key === 'SlowBuffer' || key === 'Buffer') continue\n  safer[key] = buffer[key]\n}\n\nvar Safer = safer.Buffer = {}\nfor (key in Buffer) {\n  if (!Buffer.hasOwnProperty(key)) continue\n  if (key === 'allocUnsafe' || key === 'allocUnsafeSlow') continue\n  Safer[key] = Buffer[key]\n}\n\nsafer.Buffer.prototype = Buffer.prototype\n\nif (!Safer.from || Safer.from === Uint8Array.from) {\n  Safer.from = function (value, encodingOrOffset, length) {\n    if (typeof value === 'number') {\n      throw new TypeError('The \"value\" argument must not be of type number. Received type ' + typeof value)\n    }\n    if (value && typeof value.length === 'undefined') {\n      throw new TypeError('The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ' + typeof value)\n    }\n    return Buffer(value, encodingOrOffset, length)\n  }\n}\n\nif (!Safer.alloc) {\n  Safer.alloc = function (size, fill, encoding) {\n    if (typeof size !== 'number') {\n      throw new TypeError('The \"size\" argument must be of type number. Received type ' + typeof size)\n    }\n    if (size < 0 || size >= 2 * (1 << 30)) {\n      throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n    }\n    var buf = Buffer(size)\n    if (!fill || fill.length === 0) {\n      buf.fill(0)\n    } else if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n    return buf\n  }\n}\n\nif (!safer.kStringMaxLength) {\n  try {\n    safer.kStringMaxLength = process.binding('buffer').kStringMaxLength\n  } catch (e) {\n    // we can't determine kStringMaxLength in environments where process.binding\n    // is unsupported, so let's not set it\n  }\n}\n\nif (!safer.constants) {\n  safer.constants = {\n    MAX_LENGTH: safer.kMaxLength\n  }\n  if (safer.kStringMaxLength) {\n    safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength\n  }\n}\n\nmodule.exports = safer\n"],"x_google_ignoreList":[0],"mappings":";;;;CAIA,IAAI,SAAS,QAAQ,SAAS;CAC9B,IAAI,SAAS,OAAO;CAEpB,IAAI,QAAQ,EAAE;CAEd,IAAI;AAEJ,MAAK,OAAO,QAAQ;AAClB,MAAI,CAAC,OAAO,eAAe,IAAI,CAAE;AACjC,MAAI,QAAQ,gBAAgB,QAAQ,SAAU;AAC9C,QAAM,OAAO,OAAO;;CAGtB,IAAI,QAAQ,MAAM,SAAS,EAAE;AAC7B,MAAK,OAAO,QAAQ;AAClB,MAAI,CAAC,OAAO,eAAe,IAAI,CAAE;AACjC,MAAI,QAAQ,iBAAiB,QAAQ,kBAAmB;AACxD,QAAM,OAAO,OAAO;;AAGtB,OAAM,OAAO,YAAY,OAAO;AAEhC,KAAI,CAAC,MAAM,QAAQ,MAAM,SAAS,WAAW,KAC3C,OAAM,OAAO,SAAU,OAAO,kBAAkB,QAAQ;AACtD,MAAI,OAAO,UAAU,SACnB,OAAM,IAAI,UAAU,sEAAoE,OAAO,MAAM;AAEvG,MAAI,SAAS,OAAO,MAAM,WAAW,YACnC,OAAM,IAAI,UAAU,oHAAoH,OAAO,MAAM;AAEvJ,SAAO,OAAO,OAAO,kBAAkB,OAAO;;AAIlD,KAAI,CAAC,MAAM,MACT,OAAM,QAAQ,SAAU,MAAM,MAAM,UAAU;AAC5C,MAAI,OAAO,SAAS,SAClB,OAAM,IAAI,UAAU,iEAA+D,OAAO,KAAK;AAEjG,MAAI,OAAO,KAAK,QAAQ,KAAK,KAAK,IAChC,OAAM,IAAI,WAAW,iBAAgB,OAAO,oCAAiC;EAE/E,IAAI,MAAM,OAAO,KAAK;AACtB,MAAI,CAAC,QAAQ,KAAK,WAAW,EAC3B,KAAI,KAAK,EAAE;WACF,OAAO,aAAa,SAC7B,KAAI,KAAK,MAAM,SAAS;MAExB,KAAI,KAAK,KAAK;AAEhB,SAAO;;AAIX,KAAI,CAAC,MAAM,iBACT,KAAI;AACF,QAAM,mBAAmB,QAAQ,QAAQ,SAAS,CAAC;UAC5C,GAAG;AAMd,KAAI,CAAC,MAAM,WAAW;AACpB,QAAM,YAAY,EAChB,YAAY,MAAM,YACnB;AACD,MAAI,MAAM,iBACR,OAAM,UAAU,oBAAoB,MAAM;;AAI9C,QAAO,UAAU"}

package/dist/cjs/node_modules/samlify/build/index.cjs

@@ -1,120 +0,0 @@
-const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
-const require_utility$1 = require('./src/utility.cjs');
-const require_urn$1 = require('./src/urn.cjs');
-const require_api$1 = require('./src/api.cjs');
-const require_extractor$1 = require('./src/extractor.cjs');
-const require_libsaml$1 = require('./src/libsaml.cjs');
-const require_metadata_idp$1 = require('./src/metadata-idp.cjs');
-const require_metadata_sp$1 = require('./src/metadata-sp.cjs');
-const require_entity_idp$1 = require('./src/entity-idp.cjs');
-const require_entity_sp$1 = require('./src/entity-sp.cjs');
-
-//#region ../../node_modules/samlify/build/index.js
-var require_build = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/samlify/build/index.js": ((exports) => {
-	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
-		if (k2 === void 0) 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 === void 0) k2 = k;
-		o[k2] = m[k];
-	}));
-	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
-		Object.defineProperty(o, "default", {
-			enumerable: true,
-			value: v
-		});
-	}) : function(o, v) {
-		o["default"] = v;
-	});
-	var __importStar = exports && exports.__importStar || function(mod) {
-		if (mod && mod.__esModule) return mod;
-		var result = {};
-		if (mod != null) {
-			for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-		}
-		__setModuleDefault(result, mod);
-		return result;
-	};
-	var __importDefault = exports && exports.__importDefault || function(mod) {
-		return mod && mod.__esModule ? mod : { "default": mod };
-	};
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.setDOMParserOptions = exports.setSchemaValidator = exports.ServiceProviderInstance = exports.ServiceProvider = exports.IdentityProviderInstance = exports.IdentityProvider = exports.Extractor = exports.Constants = exports.SamlLib = exports.Utility = exports.SPMetadata = exports.IdPMetadata = void 0;
-	var entity_idp_1 = __importStar(require_entity_idp$1.default);
-	exports.IdentityProvider = entity_idp_1.default;
-	Object.defineProperty(exports, "IdentityProviderInstance", {
-		enumerable: true,
-		get: function() {
-			return entity_idp_1.IdentityProvider;
-		}
-	});
-	var entity_sp_1 = __importStar(require_entity_sp$1.default);
-	exports.ServiceProvider = entity_sp_1.default;
-	Object.defineProperty(exports, "ServiceProviderInstance", {
-		enumerable: true,
-		get: function() {
-			return entity_sp_1.ServiceProvider;
-		}
-	});
-	var metadata_idp_1 = require_metadata_idp$1.default;
-	Object.defineProperty(exports, "IdPMetadata", {
-		enumerable: true,
-		get: function() {
-			return __importDefault(metadata_idp_1).default;
-		}
-	});
-	var metadata_sp_1 = require_metadata_sp$1.default;
-	Object.defineProperty(exports, "SPMetadata", {
-		enumerable: true,
-		get: function() {
-			return __importDefault(metadata_sp_1).default;
-		}
-	});
-	var utility_1 = require_utility$1.default;
-	Object.defineProperty(exports, "Utility", {
-		enumerable: true,
-		get: function() {
-			return __importDefault(utility_1).default;
-		}
-	});
-	var libsaml_1 = require_libsaml$1.default;
-	Object.defineProperty(exports, "SamlLib", {
-		enumerable: true,
-		get: function() {
-			return __importDefault(libsaml_1).default;
-		}
-	});
-	var Constants = __importStar(require_urn$1.default);
-	exports.Constants = Constants;
-	var Extractor = __importStar(require_extractor$1.default);
-	exports.Extractor = Extractor;
-	var api_1 = require_api$1.default;
-	Object.defineProperty(exports, "setSchemaValidator", {
-		enumerable: true,
-		get: function() {
-			return api_1.setSchemaValidator;
-		}
-	});
-	Object.defineProperty(exports, "setDOMParserOptions", {
-		enumerable: true,
-		get: function() {
-			return api_1.setDOMParserOptions;
-		}
-	});
-}) });
-
-//#endregion
-Object.defineProperty(exports, 'default', {
-  enumerable: true,
-  get: function () {
-    return require_build();
-  }
-});
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/node_modules/samlify/build/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../../../../../../node_modules/samlify/build/index.js"],"sourcesContent":["\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setDOMParserOptions = exports.setSchemaValidator = exports.ServiceProviderInstance = exports.ServiceProvider = exports.IdentityProviderInstance = exports.IdentityProvider = exports.Extractor = exports.Constants = exports.SamlLib = exports.Utility = exports.SPMetadata = exports.IdPMetadata = void 0;\n// version <= 1.25\nvar entity_idp_1 = __importStar(require(\"./src/entity-idp\"));\nexports.IdentityProvider = entity_idp_1.default;\nObject.defineProperty(exports, \"IdentityProviderInstance\", { enumerable: true, get: function () { return entity_idp_1.IdentityProvider; } });\nvar entity_sp_1 = __importStar(require(\"./src/entity-sp\"));\nexports.ServiceProvider = entity_sp_1.default;\nObject.defineProperty(exports, \"ServiceProviderInstance\", { enumerable: true, get: function () { return entity_sp_1.ServiceProvider; } });\nvar metadata_idp_1 = require(\"./src/metadata-idp\");\nObject.defineProperty(exports, \"IdPMetadata\", { enumerable: true, get: function () { return __importDefault(metadata_idp_1).default; } });\nvar metadata_sp_1 = require(\"./src/metadata-sp\");\nObject.defineProperty(exports, \"SPMetadata\", { enumerable: true, get: function () { return __importDefault(metadata_sp_1).default; } });\nvar utility_1 = require(\"./src/utility\");\nObject.defineProperty(exports, \"Utility\", { enumerable: true, get: function () { return __importDefault(utility_1).default; } });\nvar libsaml_1 = require(\"./src/libsaml\");\nObject.defineProperty(exports, \"SamlLib\", { enumerable: true, get: function () { return __importDefault(libsaml_1).default; } });\n// roadmap\n// new name convention in version >= 3.0\nvar Constants = __importStar(require(\"./src/urn\"));\nexports.Constants = Constants;\nvar Extractor = __importStar(require(\"./src/extractor\"));\nexports.Extractor = Extractor;\n// exposed methods for customizing samlify\nvar api_1 = require(\"./src/api\");\nObject.defineProperty(exports, \"setSchemaValidator\", { enumerable: true, get: function () { return api_1.setSchemaValidator; } });\nObject.defineProperty(exports, \"setDOMParserOptions\", { enumerable: true, get: function () { return api_1.setDOMParserOptions; } });\n//# sourceMappingURL=index.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;CACA,IAAI,qCAAgC,oBAAqB,OAAO,UAAU,SAAS,GAAG,GAAG,GAAG,IAAI;AAC5F,MAAI,OAAO,OAAW,MAAK;EAC3B,IAAI,OAAO,OAAO,yBAAyB,GAAG,EAAE;AAChD,MAAI,CAAC,SAAS,SAAS,OAAO,CAAC,EAAE,aAAa,KAAK,YAAY,KAAK,cAClE,QAAO;GAAE,YAAY;GAAM,KAAK,WAAW;AAAE,WAAO,EAAE;;GAAO;AAE/D,SAAO,eAAe,GAAG,IAAI,KAAK;OAChC,SAAS,GAAG,GAAG,GAAG,IAAI;AACxB,MAAI,OAAO,OAAW,MAAK;AAC3B,IAAE,MAAM,EAAE;;CAEd,IAAI,wCAAmC,uBAAwB,OAAO,UAAU,SAAS,GAAG,GAAG;AAC3F,SAAO,eAAe,GAAG,WAAW;GAAE,YAAY;GAAM,OAAO;GAAG,CAAC;MAClE,SAAS,GAAG,GAAG;AAChB,IAAE,aAAa;;CAEnB,IAAI,kCAA6B,gBAAiB,SAAU,KAAK;AAC7D,MAAI,OAAO,IAAI,WAAY,QAAO;EAClC,IAAI,SAAS,EAAE;AACf,MAAI,OAAO,MAAM;QAAK,IAAI,KAAK,IAAK,KAAI,MAAM,aAAa,OAAO,UAAU,eAAe,KAAK,KAAK,EAAE,CAAE,iBAAgB,QAAQ,KAAK,EAAE;;AACxI,qBAAmB,QAAQ,IAAI;AAC/B,SAAO;;CAEX,IAAI,qCAAgC,mBAAoB,SAAU,KAAK;AACnE,SAAQ,OAAO,IAAI,aAAc,MAAM,EAAE,WAAW,KAAK;;AAE7D,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,sBAAsB,QAAQ,qBAAqB,QAAQ,0BAA0B,QAAQ,kBAAkB,QAAQ,2BAA2B,QAAQ,mBAAmB,QAAQ,YAAY,QAAQ,YAAY,QAAQ,UAAU,QAAQ,UAAU,QAAQ,aAAa,QAAQ,cAAc,KAAK;CAEjT,IAAI,eAAe,0CAAyC;AAC5D,SAAQ,mBAAmB,aAAa;AACxC,QAAO,eAAe,SAAS,4BAA4B;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,aAAa;;EAAqB,CAAC;CAC5I,IAAI,cAAc,yCAAwC;AAC1D,SAAQ,kBAAkB,YAAY;AACtC,QAAO,eAAe,SAAS,2BAA2B;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,YAAY;;EAAoB,CAAC;CACzI,IAAI;AACJ,QAAO,eAAe,SAAS,eAAe;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,gBAAgB,eAAe,CAAC;;EAAY,CAAC;CACzI,IAAI;AACJ,QAAO,eAAe,SAAS,cAAc;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,gBAAgB,cAAc,CAAC;;EAAY,CAAC;CACvI,IAAI;AACJ,QAAO,eAAe,SAAS,WAAW;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,gBAAgB,UAAU,CAAC;;EAAY,CAAC;CAChI,IAAI;AACJ,QAAO,eAAe,SAAS,WAAW;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,gBAAgB,UAAU,CAAC;;EAAY,CAAC;CAGhI,IAAI,YAAY,mCAAkC;AAClD,SAAQ,YAAY;CACpB,IAAI,YAAY,yCAAwC;AACxD,SAAQ,YAAY;CAEpB,IAAI;AACJ,QAAO,eAAe,SAAS,sBAAsB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,MAAM;;EAAuB,CAAC;AACjI,QAAO,eAAe,SAAS,uBAAuB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,MAAM;;EAAwB,CAAC"}

package/dist/cjs/node_modules/samlify/build/src/api.cjs

@@ -1,36 +0,0 @@
-const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
-const require_index = require('../../../@xmldom/xmldom/lib/index.cjs');
-
-//#region ../../node_modules/samlify/build/src/api.js
-var require_api = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/samlify/build/src/api.js": ((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.setDOMParserOptions = exports.setSchemaValidator = exports.getContext = void 0;
-	var xmldom_1 = require_index.default;
-	var context = {
-		validate: void 0,
-		dom: new xmldom_1.DOMParser()
-	};
-	function getContext() {
-		return context;
-	}
-	exports.getContext = getContext;
-	function setSchemaValidator(params) {
-		if (typeof params.validate !== "function") throw new Error("validate must be a callback function having one argument as xml input");
-		context.validate = params.validate;
-	}
-	exports.setSchemaValidator = setSchemaValidator;
-	function setDOMParserOptions(options) {
-		if (options === void 0) options = {};
-		context.dom = new xmldom_1.DOMParser(options);
-	}
-	exports.setDOMParserOptions = setDOMParserOptions;
-}) });
-
-//#endregion
-Object.defineProperty(exports, 'default', {
-  enumerable: true,
-  get: function () {
-    return require_api();
-  }
-});
-//# sourceMappingURL=api.cjs.map

package/dist/cjs/node_modules/samlify/build/src/api.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"api.cjs","names":[],"sources":["../../../../../../../../node_modules/samlify/build/src/api.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setDOMParserOptions = exports.setSchemaValidator = exports.getContext = void 0;\nvar xmldom_1 = require(\"@xmldom/xmldom\");\nvar context = {\n    validate: undefined,\n    dom: new xmldom_1.DOMParser()\n};\nfunction getContext() {\n    return context;\n}\nexports.getContext = getContext;\nfunction setSchemaValidator(params) {\n    if (typeof params.validate !== 'function') {\n        throw new Error('validate must be a callback function having one argument as xml input');\n    }\n    // assign the validate function to the context\n    context.validate = params.validate;\n}\nexports.setSchemaValidator = setSchemaValidator;\nfunction setDOMParserOptions(options) {\n    if (options === void 0) { options = {}; }\n    context.dom = new xmldom_1.DOMParser(options);\n}\nexports.setDOMParserOptions = setDOMParserOptions;\n//# sourceMappingURL=api.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,sBAAsB,QAAQ,qBAAqB,QAAQ,aAAa,KAAK;CACrF,IAAI;CACJ,IAAI,UAAU;EACV,UAAU;EACV,KAAK,IAAI,SAAS,WAAW;EAChC;CACD,SAAS,aAAa;AAClB,SAAO;;AAEX,SAAQ,aAAa;CACrB,SAAS,mBAAmB,QAAQ;AAChC,MAAI,OAAO,OAAO,aAAa,WAC3B,OAAM,IAAI,MAAM,wEAAwE;AAG5F,UAAQ,WAAW,OAAO;;AAE9B,SAAQ,qBAAqB;CAC7B,SAAS,oBAAoB,SAAS;AAClC,MAAI,YAAY,KAAK,EAAK,WAAU,EAAE;AACtC,UAAQ,MAAM,IAAI,SAAS,UAAU,QAAQ;;AAEjD,SAAQ,sBAAsB"}