@opentiny/fluent-editor 4.0.0-alpha.7 → 4.0.0-alpha.9

package/lib/node_modules/.pnpm/lib0@0.2.114/node_modules/lib0/encoding.cjs.js

@@ -1,484 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const math = require("./math.cjs.js");
-const number = require("./number.cjs.js");
-const binary = require("./binary.cjs.js");
-const string = require("./string.cjs.js");
-const array = require("./array.cjs.js");
-class Encoder {
-  constructor() {
-    this.cpos = 0;
-    this.cbuf = new Uint8Array(100);
-    this.bufs = [];
-  }
-}
-const createEncoder = () => new Encoder();
-const encode = (f) => {
-  const encoder = createEncoder();
-  f(encoder);
-  return toUint8Array(encoder);
-};
-const length = (encoder) => {
-  let len = encoder.cpos;
-  for (let i = 0; i < encoder.bufs.length; i++) {
-    len += encoder.bufs[i].length;
-  }
-  return len;
-};
-const hasContent = (encoder) => encoder.cpos > 0 || encoder.bufs.length > 0;
-const toUint8Array = (encoder) => {
-  const uint8arr = new Uint8Array(length(encoder));
-  let curPos = 0;
-  for (let i = 0; i < encoder.bufs.length; i++) {
-    const d = encoder.bufs[i];
-    uint8arr.set(d, curPos);
-    curPos += d.length;
-  }
-  uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
-  return uint8arr;
-};
-const verifyLen = (encoder, len) => {
-  const bufferLen = encoder.cbuf.length;
-  if (bufferLen - encoder.cpos < len) {
-    encoder.bufs.push(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos));
-    encoder.cbuf = new Uint8Array(math.max(bufferLen, len) * 2);
-    encoder.cpos = 0;
-  }
-};
-const write = (encoder, num) => {
-  const bufferLen = encoder.cbuf.length;
-  if (encoder.cpos === bufferLen) {
-    encoder.bufs.push(encoder.cbuf);
-    encoder.cbuf = new Uint8Array(bufferLen * 2);
-    encoder.cpos = 0;
-  }
-  encoder.cbuf[encoder.cpos++] = num;
-};
-const set = (encoder, pos, num) => {
-  let buffer = null;
-  for (let i = 0; i < encoder.bufs.length && buffer === null; i++) {
-    const b = encoder.bufs[i];
-    if (pos < b.length) {
-      buffer = b;
-    } else {
-      pos -= b.length;
-    }
-  }
-  if (buffer === null) {
-    buffer = encoder.cbuf;
-  }
-  buffer[pos] = num;
-};
-const writeUint8 = write;
-const setUint8 = set;
-const writeUint16 = (encoder, num) => {
-  write(encoder, num & binary.BITS8);
-  write(encoder, num >>> 8 & binary.BITS8);
-};
-const setUint16 = (encoder, pos, num) => {
-  set(encoder, pos, num & binary.BITS8);
-  set(encoder, pos + 1, num >>> 8 & binary.BITS8);
-};
-const writeUint32 = (encoder, num) => {
-  for (let i = 0; i < 4; i++) {
-    write(encoder, num & binary.BITS8);
-    num >>>= 8;
-  }
-};
-const writeUint32BigEndian = (encoder, num) => {
-  for (let i = 3; i >= 0; i--) {
-    write(encoder, num >>> 8 * i & binary.BITS8);
-  }
-};
-const setUint32 = (encoder, pos, num) => {
-  for (let i = 0; i < 4; i++) {
-    set(encoder, pos + i, num & binary.BITS8);
-    num >>>= 8;
-  }
-};
-const writeVarUint = (encoder, num) => {
-  while (num > binary.BITS7) {
-    write(encoder, binary.BIT8 | binary.BITS7 & num);
-    num = math.floor(num / 128);
-  }
-  write(encoder, binary.BITS7 & num);
-};
-const writeVarInt = (encoder, num) => {
-  const isNegative = math.isNegativeZero(num);
-  if (isNegative) {
-    num = -num;
-  }
-  write(encoder, (num > binary.BITS6 ? binary.BIT8 : 0) | (isNegative ? binary.BIT7 : 0) | binary.BITS6 & num);
-  num = math.floor(num / 64);
-  while (num > 0) {
-    write(encoder, (num > binary.BITS7 ? binary.BIT8 : 0) | binary.BITS7 & num);
-    num = math.floor(num / 128);
-  }
-};
-const _strBuffer = new Uint8Array(3e4);
-const _maxStrBSize = _strBuffer.length / 3;
-const _writeVarStringNative = (encoder, str) => {
-  if (str.length < _maxStrBSize) {
-    const written = string.utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
-    writeVarUint(encoder, written);
-    for (let i = 0; i < written; i++) {
-      write(encoder, _strBuffer[i]);
-    }
-  } else {
-    writeVarUint8Array(encoder, string.encodeUtf8(str));
-  }
-};
-const _writeVarStringPolyfill = (encoder, str) => {
-  const encodedString = unescape(encodeURIComponent(str));
-  const len = encodedString.length;
-  writeVarUint(encoder, len);
-  for (let i = 0; i < len; i++) {
-    write(
-      encoder,
-      /** @type {number} */
-      encodedString.codePointAt(i)
-    );
-  }
-};
-const writeVarString = string.utf8TextEncoder && /** @type {any} */
-string.utf8TextEncoder.encodeInto ? _writeVarStringNative : _writeVarStringPolyfill;
-const writeTerminatedString = (encoder, str) => writeTerminatedUint8Array(encoder, string.encodeUtf8(str));
-const writeTerminatedUint8Array = (encoder, buf) => {
-  for (let i = 0; i < buf.length; i++) {
-    const b = buf[i];
-    if (b === 0 || b === 1) {
-      write(encoder, 1);
-    }
-    write(encoder, buf[i]);
-  }
-  write(encoder, 0);
-};
-const writeBinaryEncoder = (encoder, append) => writeUint8Array(encoder, toUint8Array(append));
-const writeUint8Array = (encoder, uint8Array) => {
-  const bufferLen = encoder.cbuf.length;
-  const cpos = encoder.cpos;
-  const leftCopyLen = math.min(bufferLen - cpos, uint8Array.length);
-  const rightCopyLen = uint8Array.length - leftCopyLen;
-  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
-  encoder.cpos += leftCopyLen;
-  if (rightCopyLen > 0) {
-    encoder.bufs.push(encoder.cbuf);
-    encoder.cbuf = new Uint8Array(math.max(bufferLen * 2, rightCopyLen));
-    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
-    encoder.cpos = rightCopyLen;
-  }
-};
-const writeVarUint8Array = (encoder, uint8Array) => {
-  writeVarUint(encoder, uint8Array.byteLength);
-  writeUint8Array(encoder, uint8Array);
-};
-const writeOnDataView = (encoder, len) => {
-  verifyLen(encoder, len);
-  const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len);
-  encoder.cpos += len;
-  return dview;
-};
-const writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false);
-const writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false);
-const writeBigInt64 = (encoder, num) => (
-  /** @type {any} */
-  writeOnDataView(encoder, 8).setBigInt64(0, num, false)
-);
-const writeBigUint64 = (encoder, num) => (
-  /** @type {any} */
-  writeOnDataView(encoder, 8).setBigUint64(0, num, false)
-);
-const floatTestBed = new DataView(new ArrayBuffer(4));
-const isFloat32 = (num) => {
-  floatTestBed.setFloat32(0, num);
-  return floatTestBed.getFloat32(0) === num;
-};
-const writeAny = (encoder, data) => {
-  switch (typeof data) {
-    case "string":
-      write(encoder, 119);
-      writeVarString(encoder, data);
-      break;
-    case "number":
-      if (number.isInteger(data) && math.abs(data) <= binary.BITS31) {
-        write(encoder, 125);
-        writeVarInt(encoder, data);
-      } else if (isFloat32(data)) {
-        write(encoder, 124);
-        writeFloat32(encoder, data);
-      } else {
-        write(encoder, 123);
-        writeFloat64(encoder, data);
-      }
-      break;
-    case "bigint":
-      write(encoder, 122);
-      writeBigInt64(encoder, data);
-      break;
-    case "object":
-      if (data === null) {
-        write(encoder, 126);
-      } else if (array.isArray(data)) {
-        write(encoder, 117);
-        writeVarUint(encoder, data.length);
-        for (let i = 0; i < data.length; i++) {
-          writeAny(encoder, data[i]);
-        }
-      } else if (data instanceof Uint8Array) {
-        write(encoder, 116);
-        writeVarUint8Array(encoder, data);
-      } else {
-        write(encoder, 118);
-        const keys = Object.keys(data);
-        writeVarUint(encoder, keys.length);
-        for (let i = 0; i < keys.length; i++) {
-          const key = keys[i];
-          writeVarString(encoder, key);
-          writeAny(encoder, data[key]);
-        }
-      }
-      break;
-    case "boolean":
-      write(encoder, data ? 120 : 121);
-      break;
-    default:
-      write(encoder, 127);
-  }
-};
-class RleEncoder extends Encoder {
-  /**
-   * @param {function(Encoder, T):void} writer
-   */
-  constructor(writer) {
-    super();
-    this.w = writer;
-    this.s = null;
-    this.count = 0;
-  }
-  /**
-   * @param {T} v
-   */
-  write(v) {
-    if (this.s === v) {
-      this.count++;
-    } else {
-      if (this.count > 0) {
-        writeVarUint(this, this.count - 1);
-      }
-      this.count = 1;
-      this.w(this, v);
-      this.s = v;
-    }
-  }
-}
-class IntDiffEncoder extends Encoder {
-  /**
-   * @param {number} start
-   */
-  constructor(start) {
-    super();
-    this.s = start;
-  }
-  /**
-   * @param {number} v
-   */
-  write(v) {
-    writeVarInt(this, v - this.s);
-    this.s = v;
-  }
-}
-class RleIntDiffEncoder extends Encoder {
-  /**
-   * @param {number} start
-   */
-  constructor(start) {
-    super();
-    this.s = start;
-    this.count = 0;
-  }
-  /**
-   * @param {number} v
-   */
-  write(v) {
-    if (this.s === v && this.count > 0) {
-      this.count++;
-    } else {
-      if (this.count > 0) {
-        writeVarUint(this, this.count - 1);
-      }
-      this.count = 1;
-      writeVarInt(this, v - this.s);
-      this.s = v;
-    }
-  }
-}
-const flushUintOptRleEncoder = (encoder) => {
-  if (encoder.count > 0) {
-    writeVarInt(encoder.encoder, encoder.count === 1 ? encoder.s : -encoder.s);
-    if (encoder.count > 1) {
-      writeVarUint(encoder.encoder, encoder.count - 2);
-    }
-  }
-};
-class UintOptRleEncoder {
-  constructor() {
-    this.encoder = new Encoder();
-    this.s = 0;
-    this.count = 0;
-  }
-  /**
-   * @param {number} v
-   */
-  write(v) {
-    if (this.s === v) {
-      this.count++;
-    } else {
-      flushUintOptRleEncoder(this);
-      this.count = 1;
-      this.s = v;
-    }
-  }
-  /**
-   * Flush the encoded state and transform this to a Uint8Array.
-   *
-   * Note that this should only be called once.
-   */
-  toUint8Array() {
-    flushUintOptRleEncoder(this);
-    return toUint8Array(this.encoder);
-  }
-}
-class IncUintOptRleEncoder {
-  constructor() {
-    this.encoder = new Encoder();
-    this.s = 0;
-    this.count = 0;
-  }
-  /**
-   * @param {number} v
-   */
-  write(v) {
-    if (this.s + this.count === v) {
-      this.count++;
-    } else {
-      flushUintOptRleEncoder(this);
-      this.count = 1;
-      this.s = v;
-    }
-  }
-  /**
-   * Flush the encoded state and transform this to a Uint8Array.
-   *
-   * Note that this should only be called once.
-   */
-  toUint8Array() {
-    flushUintOptRleEncoder(this);
-    return toUint8Array(this.encoder);
-  }
-}
-const flushIntDiffOptRleEncoder = (encoder) => {
-  if (encoder.count > 0) {
-    const encodedDiff = encoder.diff * 2 + (encoder.count === 1 ? 0 : 1);
-    writeVarInt(encoder.encoder, encodedDiff);
-    if (encoder.count > 1) {
-      writeVarUint(encoder.encoder, encoder.count - 2);
-    }
-  }
-};
-class IntDiffOptRleEncoder {
-  constructor() {
-    this.encoder = new Encoder();
-    this.s = 0;
-    this.count = 0;
-    this.diff = 0;
-  }
-  /**
-   * @param {number} v
-   */
-  write(v) {
-    if (this.diff === v - this.s) {
-      this.s = v;
-      this.count++;
-    } else {
-      flushIntDiffOptRleEncoder(this);
-      this.count = 1;
-      this.diff = v - this.s;
-      this.s = v;
-    }
-  }
-  /**
-   * Flush the encoded state and transform this to a Uint8Array.
-   *
-   * Note that this should only be called once.
-   */
-  toUint8Array() {
-    flushIntDiffOptRleEncoder(this);
-    return toUint8Array(this.encoder);
-  }
-}
-class StringEncoder {
-  constructor() {
-    this.sarr = [];
-    this.s = "";
-    this.lensE = new UintOptRleEncoder();
-  }
-  /**
-   * @param {string} string
-   */
-  write(string2) {
-    this.s += string2;
-    if (this.s.length > 19) {
-      this.sarr.push(this.s);
-      this.s = "";
-    }
-    this.lensE.write(string2.length);
-  }
-  toUint8Array() {
-    const encoder = new Encoder();
-    this.sarr.push(this.s);
-    this.s = "";
-    writeVarString(encoder, this.sarr.join(""));
-    writeUint8Array(encoder, this.lensE.toUint8Array());
-    return toUint8Array(encoder);
-  }
-}
-exports.Encoder = Encoder;
-exports.IncUintOptRleEncoder = IncUintOptRleEncoder;
-exports.IntDiffEncoder = IntDiffEncoder;
-exports.IntDiffOptRleEncoder = IntDiffOptRleEncoder;
-exports.RleEncoder = RleEncoder;
-exports.RleIntDiffEncoder = RleIntDiffEncoder;
-exports.StringEncoder = StringEncoder;
-exports.UintOptRleEncoder = UintOptRleEncoder;
-exports._writeVarStringNative = _writeVarStringNative;
-exports._writeVarStringPolyfill = _writeVarStringPolyfill;
-exports.createEncoder = createEncoder;
-exports.encode = encode;
-exports.hasContent = hasContent;
-exports.length = length;
-exports.set = set;
-exports.setUint16 = setUint16;
-exports.setUint32 = setUint32;
-exports.setUint8 = setUint8;
-exports.toUint8Array = toUint8Array;
-exports.verifyLen = verifyLen;
-exports.write = write;
-exports.writeAny = writeAny;
-exports.writeBigInt64 = writeBigInt64;
-exports.writeBigUint64 = writeBigUint64;
-exports.writeBinaryEncoder = writeBinaryEncoder;
-exports.writeFloat32 = writeFloat32;
-exports.writeFloat64 = writeFloat64;
-exports.writeOnDataView = writeOnDataView;
-exports.writeTerminatedString = writeTerminatedString;
-exports.writeTerminatedUint8Array = writeTerminatedUint8Array;
-exports.writeUint16 = writeUint16;
-exports.writeUint32 = writeUint32;
-exports.writeUint32BigEndian = writeUint32BigEndian;
-exports.writeUint8 = writeUint8;
-exports.writeUint8Array = writeUint8Array;
-exports.writeVarInt = writeVarInt;
-exports.writeVarString = writeVarString;
-exports.writeVarUint = writeVarUint;
-exports.writeVarUint8Array = writeVarUint8Array;
-//# sourceMappingURL=encoding.cjs.js.map

package/lib/node_modules/.pnpm/lib0@0.2.114/node_modules/lib0/encoding.cjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoding.cjs.js","sources":["../../../../../../../../../node_modules/.pnpm/lib0@0.2.114/node_modules/lib0/encoding.js"],"sourcesContent":["/**\n * Efficient schema-less binary encoding with support for variable length encoding.\n *\n * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.\n *\n * Encodes numbers in little-endian order (least to most significant byte order)\n * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)\n * which is also used in Protocol Buffers.\n *\n * ```js\n * // encoding step\n * const encoder = encoding.createEncoder()\n * encoding.writeVarUint(encoder, 256)\n * encoding.writeVarString(encoder, 'Hello world!')\n * const buf = encoding.toUint8Array(encoder)\n * ```\n *\n * ```js\n * // decoding step\n * const decoder = decoding.createDecoder(buf)\n * decoding.readVarUint(decoder) // => 256\n * decoding.readVarString(decoder) // => 'Hello world!'\n * decoding.hasContent(decoder) // => false - all data is read\n * ```\n *\n * @module encoding\n */\n\nimport * as math from './math.js'\nimport * as number from './number.js'\nimport * as binary from './binary.js'\nimport * as string from './string.js'\nimport * as array from './array.js'\n\n/**\n * A BinaryEncoder handles the encoding to an Uint8Array.\n */\nexport class Encoder {\n  constructor () {\n    this.cpos = 0\n    this.cbuf = new Uint8Array(100)\n    /**\n     * @type {Array<Uint8Array>}\n     */\n    this.bufs = []\n  }\n}\n\n/**\n * @function\n * @return {Encoder}\n */\nexport const createEncoder = () => new Encoder()\n\n/**\n * @param {function(Encoder):void} f\n */\nexport const encode = (f) => {\n  const encoder = createEncoder()\n  f(encoder)\n  return toUint8Array(encoder)\n}\n\n/**\n * The current length of the encoded data.\n *\n * @function\n * @param {Encoder} encoder\n * @return {number}\n */\nexport const length = encoder => {\n  let len = encoder.cpos\n  for (let i = 0; i < encoder.bufs.length; i++) {\n    len += encoder.bufs[i].length\n  }\n  return len\n}\n\n/**\n * Check whether encoder is empty.\n *\n * @function\n * @param {Encoder} encoder\n * @return {boolean}\n */\nexport const hasContent = encoder => encoder.cpos > 0 || encoder.bufs.length > 0\n\n/**\n * Transform to Uint8Array.\n *\n * @function\n * @param {Encoder} encoder\n * @return {Uint8Array} The created ArrayBuffer.\n */\nexport const toUint8Array = encoder => {\n  const uint8arr = new Uint8Array(length(encoder))\n  let curPos = 0\n  for (let i = 0; i < encoder.bufs.length; i++) {\n    const d = encoder.bufs[i]\n    uint8arr.set(d, curPos)\n    curPos += d.length\n  }\n  uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos)\n  return uint8arr\n}\n\n/**\n * Verify that it is possible to write `len` bytes wtihout checking. If\n * necessary, a new Buffer with the required length is attached.\n *\n * @param {Encoder} encoder\n * @param {number} len\n */\nexport const verifyLen = (encoder, len) => {\n  const bufferLen = encoder.cbuf.length\n  if (bufferLen - encoder.cpos < len) {\n    encoder.bufs.push(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos))\n    encoder.cbuf = new Uint8Array(math.max(bufferLen, len) * 2)\n    encoder.cpos = 0\n  }\n}\n\n/**\n * Write one byte to the encoder.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The byte that is to be encoded.\n */\nexport const write = (encoder, num) => {\n  const bufferLen = encoder.cbuf.length\n  if (encoder.cpos === bufferLen) {\n    encoder.bufs.push(encoder.cbuf)\n    encoder.cbuf = new Uint8Array(bufferLen * 2)\n    encoder.cpos = 0\n  }\n  encoder.cbuf[encoder.cpos++] = num\n}\n\n/**\n * Write one byte at a specific position.\n * Position must already be written (i.e. encoder.length > pos)\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} pos Position to which to write data\n * @param {number} num Unsigned 8-bit integer\n */\nexport const set = (encoder, pos, num) => {\n  let buffer = null\n  // iterate all buffers and adjust position\n  for (let i = 0; i < encoder.bufs.length && buffer === null; i++) {\n    const b = encoder.bufs[i]\n    if (pos < b.length) {\n      buffer = b // found buffer\n    } else {\n      pos -= b.length\n    }\n  }\n  if (buffer === null) {\n    // use current buffer\n    buffer = encoder.cbuf\n  }\n  buffer[pos] = num\n}\n\n/**\n * Write one byte as an unsigned integer.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeUint8 = write\n\n/**\n * Write one byte as an unsigned Integer at a specific location.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} pos The location where the data will be written.\n * @param {number} num The number that is to be encoded.\n */\nexport const setUint8 = set\n\n/**\n * Write two bytes as an unsigned integer.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeUint16 = (encoder, num) => {\n  write(encoder, num & binary.BITS8)\n  write(encoder, (num >>> 8) & binary.BITS8)\n}\n/**\n * Write two bytes as an unsigned integer at a specific location.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} pos The location where the data will be written.\n * @param {number} num The number that is to be encoded.\n */\nexport const setUint16 = (encoder, pos, num) => {\n  set(encoder, pos, num & binary.BITS8)\n  set(encoder, pos + 1, (num >>> 8) & binary.BITS8)\n}\n\n/**\n * Write two bytes as an unsigned integer\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeUint32 = (encoder, num) => {\n  for (let i = 0; i < 4; i++) {\n    write(encoder, num & binary.BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write two bytes as an unsigned integer in big endian order.\n * (most significant byte first)\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeUint32BigEndian = (encoder, num) => {\n  for (let i = 3; i >= 0; i--) {\n    write(encoder, (num >>> (8 * i)) & binary.BITS8)\n  }\n}\n\n/**\n * Write two bytes as an unsigned integer at a specific location.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} pos The location where the data will be written.\n * @param {number} num The number that is to be encoded.\n */\nexport const setUint32 = (encoder, pos, num) => {\n  for (let i = 0; i < 4; i++) {\n    set(encoder, pos + i, num & binary.BITS8)\n    num >>>= 8\n  }\n}\n\n/**\n * Write a variable length unsigned integer. Max encodable integer is 2^53.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeVarUint = (encoder, num) => {\n  while (num > binary.BITS7) {\n    write(encoder, binary.BIT8 | (binary.BITS7 & num))\n    num = math.floor(num / 128) // shift >>> 7\n  }\n  write(encoder, binary.BITS7 & num)\n}\n\n/**\n * Write a variable length integer.\n *\n * We use the 7th bit instead for signaling that this is a negative number.\n *\n * @function\n * @param {Encoder} encoder\n * @param {number} num The number that is to be encoded.\n */\nexport const writeVarInt = (encoder, num) => {\n  const isNegative = math.isNegativeZero(num)\n  if (isNegative) {\n    num = -num\n  }\n  //             |- whether to continue reading         |- whether is negative     |- number\n  write(encoder, (num > binary.BITS6 ? binary.BIT8 : 0) | (isNegative ? binary.BIT7 : 0) | (binary.BITS6 & num))\n  num = math.floor(num / 64) // shift >>> 6\n  // We don't need to consider the case of num === 0 so we can use a different\n  // pattern here than above.\n  while (num > 0) {\n    write(encoder, (num > binary.BITS7 ? binary.BIT8 : 0) | (binary.BITS7 & num))\n    num = math.floor(num / 128) // shift >>> 7\n  }\n}\n\n/**\n * A cache to store strings temporarily\n */\nconst _strBuffer = new Uint8Array(30000)\nconst _maxStrBSize = _strBuffer.length / 3\n\n/**\n * Write a variable length string.\n *\n * @function\n * @param {Encoder} encoder\n * @param {String} str The string that is to be encoded.\n */\nexport const _writeVarStringNative = (encoder, str) => {\n  if (str.length < _maxStrBSize) {\n    // We can encode the string into the existing buffer\n    /* c8 ignore next */\n    const written = string.utf8TextEncoder.encodeInto(str, _strBuffer).written || 0\n    writeVarUint(encoder, written)\n    for (let i = 0; i < written; i++) {\n      write(encoder, _strBuffer[i])\n    }\n  } else {\n    writeVarUint8Array(encoder, string.encodeUtf8(str))\n  }\n}\n\n/**\n * Write a variable length string.\n *\n * @function\n * @param {Encoder} encoder\n * @param {String} str The string that is to be encoded.\n */\nexport const _writeVarStringPolyfill = (encoder, str) => {\n  const encodedString = unescape(encodeURIComponent(str))\n  const len = encodedString.length\n  writeVarUint(encoder, len)\n  for (let i = 0; i < len; i++) {\n    write(encoder, /** @type {number} */ (encodedString.codePointAt(i)))\n  }\n}\n\n/**\n * Write a variable length string.\n *\n * @function\n * @param {Encoder} encoder\n * @param {String} str The string that is to be encoded.\n */\n/* c8 ignore next */\nexport const writeVarString = (string.utf8TextEncoder && /** @type {any} */ (string.utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill\n\n/**\n * Write a string terminated by a special byte sequence. This is not very performant and is\n * generally discouraged. However, the resulting byte arrays are lexiographically ordered which\n * makes this a nice feature for databases.\n *\n * The string will be encoded using utf8 and then terminated and escaped using writeTerminatingUint8Array.\n *\n * @function\n * @param {Encoder} encoder\n * @param {String} str The string that is to be encoded.\n */\nexport const writeTerminatedString = (encoder, str) =>\n  writeTerminatedUint8Array(encoder, string.encodeUtf8(str))\n\n/**\n * Write a terminating Uint8Array. Note that this is not performant and is generally\n * discouraged. There are few situations when this is needed.\n *\n * We use 0x0 as a terminating character. 0x1 serves as an escape character for 0x0 and 0x1.\n *\n * Example: [0,1,2] is encoded to [1,0,1,1,2,0]. 0x0, and 0x1 needed to be escaped using 0x1. Then\n * the result is terminated using the 0x0 character.\n *\n * This is basically how many systems implement null terminated strings. However, we use an escape\n * character 0x1 to avoid issues and potenial attacks on our database (if this is used as a key\n * encoder for NoSql databases).\n *\n * @function\n * @param {Encoder} encoder\n * @param {Uint8Array} buf The string that is to be encoded.\n */\nexport const writeTerminatedUint8Array = (encoder, buf) => {\n  for (let i = 0; i < buf.length; i++) {\n    const b = buf[i]\n    if (b === 0 || b === 1) {\n      write(encoder, 1)\n    }\n    write(encoder, buf[i])\n  }\n  write(encoder, 0)\n}\n\n/**\n * Write the content of another Encoder.\n *\n * @TODO: can be improved!\n *        - Note: Should consider that when appending a lot of small Encoders, we should rather clone than referencing the old structure.\n *                Encoders start with a rather big initial buffer.\n *\n * @function\n * @param {Encoder} encoder The enUint8Arr\n * @param {Encoder} append The BinaryEncoder to be written.\n */\nexport const writeBinaryEncoder = (encoder, append) => writeUint8Array(encoder, toUint8Array(append))\n\n/**\n * Append fixed-length Uint8Array to the encoder.\n *\n * @function\n * @param {Encoder} encoder\n * @param {Uint8Array} uint8Array\n */\nexport const writeUint8Array = (encoder, uint8Array) => {\n  const bufferLen = encoder.cbuf.length\n  const cpos = encoder.cpos\n  const leftCopyLen = math.min(bufferLen - cpos, uint8Array.length)\n  const rightCopyLen = uint8Array.length - leftCopyLen\n  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos)\n  encoder.cpos += leftCopyLen\n  if (rightCopyLen > 0) {\n    // Still something to write, write right half..\n    // Append new buffer\n    encoder.bufs.push(encoder.cbuf)\n    // must have at least size of remaining buffer\n    encoder.cbuf = new Uint8Array(math.max(bufferLen * 2, rightCopyLen))\n    // copy array\n    encoder.cbuf.set(uint8Array.subarray(leftCopyLen))\n    encoder.cpos = rightCopyLen\n  }\n}\n\n/**\n * Append an Uint8Array to Encoder.\n *\n * @function\n * @param {Encoder} encoder\n * @param {Uint8Array} uint8Array\n */\nexport const writeVarUint8Array = (encoder, uint8Array) => {\n  writeVarUint(encoder, uint8Array.byteLength)\n  writeUint8Array(encoder, uint8Array)\n}\n\n/**\n * Create an DataView of the next `len` bytes. Use it to write data after\n * calling this function.\n *\n * ```js\n * // write float32 using DataView\n * const dv = writeOnDataView(encoder, 4)\n * dv.setFloat32(0, 1.1)\n * // read float32 using DataView\n * const dv = readFromDataView(encoder, 4)\n * dv.getFloat32(0) // => 1.100000023841858 (leaving it to the reader to find out why this is the correct result)\n * ```\n *\n * @param {Encoder} encoder\n * @param {number} len\n * @return {DataView}\n */\nexport const writeOnDataView = (encoder, len) => {\n  verifyLen(encoder, len)\n  const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len)\n  encoder.cpos += len\n  return dview\n}\n\n/**\n * @param {Encoder} encoder\n * @param {number} num\n */\nexport const writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false)\n\n/**\n * @param {Encoder} encoder\n * @param {number} num\n */\nexport const writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false)\n\n/**\n * @param {Encoder} encoder\n * @param {bigint} num\n */\nexport const writeBigInt64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigInt64(0, num, false)\n\n/**\n * @param {Encoder} encoder\n * @param {bigint} num\n */\nexport const writeBigUint64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigUint64(0, num, false)\n\nconst floatTestBed = new DataView(new ArrayBuffer(4))\n/**\n * Check if a number can be encoded as a 32 bit float.\n *\n * @param {number} num\n * @return {boolean}\n */\nconst isFloat32 = num => {\n  floatTestBed.setFloat32(0, num)\n  return floatTestBed.getFloat32(0) === num\n}\n\n/**\n * Encode data with efficient binary format.\n *\n * Differences to JSON:\n * • Transforms data to a binary format (not to a string)\n * • Encodes undefined, NaN, and ArrayBuffer (these can't be represented in JSON)\n * • Numbers are efficiently encoded either as a variable length integer, as a\n *   32 bit float, as a 64 bit float, or as a 64 bit bigint.\n *\n * Encoding table:\n *\n * | Data Type           | Prefix   | Encoding Method    | Comment |\n * | ------------------- | -------- | ------------------ | ------- |\n * | undefined           | 127      |                    | Functions, symbol, and everything that cannot be identified is encoded as undefined |\n * | null                | 126      |                    | |\n * | integer             | 125      | writeVarInt        | Only encodes 32 bit signed integers |\n * | float32             | 124      | writeFloat32       | |\n * | float64             | 123      | writeFloat64       | |\n * | bigint              | 122      | writeBigInt64      | |\n * | boolean (false)     | 121      |                    | True and false are different data types so we save the following byte |\n * | boolean (true)      | 120      |                    | - 0b01111000 so the last bit determines whether true or false |\n * | string              | 119      | writeVarString     | |\n * | object<string,any>  | 118      | custom             | Writes {length} then {length} key-value pairs |\n * | array<any>          | 117      | custom             | Writes {length} then {length} json values |\n * | Uint8Array          | 116      | writeVarUint8Array | We use Uint8Array for any kind of binary data |\n *\n * Reasons for the decreasing prefix:\n * We need the first bit for extendability (later we may want to encode the\n * prefix with writeVarUint). The remaining 7 bits are divided as follows:\n * [0-30]   the beginning of the data range is used for custom purposes\n *          (defined by the function that uses this library)\n * [31-127] the end of the data range is used for data encoding by\n *          lib0/encoding.js\n *\n * @param {Encoder} encoder\n * @param {undefined|null|number|bigint|boolean|string|Object<string,any>|Array<any>|Uint8Array} data\n */\nexport const writeAny = (encoder, data) => {\n  switch (typeof data) {\n    case 'string':\n      // TYPE 119: STRING\n      write(encoder, 119)\n      writeVarString(encoder, data)\n      break\n    case 'number':\n      if (number.isInteger(data) && math.abs(data) <= binary.BITS31) {\n        // TYPE 125: INTEGER\n        write(encoder, 125)\n        writeVarInt(encoder, data)\n      } else if (isFloat32(data)) {\n        // TYPE 124: FLOAT32\n        write(encoder, 124)\n        writeFloat32(encoder, data)\n      } else {\n        // TYPE 123: FLOAT64\n        write(encoder, 123)\n        writeFloat64(encoder, data)\n      }\n      break\n    case 'bigint':\n      // TYPE 122: BigInt\n      write(encoder, 122)\n      writeBigInt64(encoder, data)\n      break\n    case 'object':\n      if (data === null) {\n        // TYPE 126: null\n        write(encoder, 126)\n      } else if (array.isArray(data)) {\n        // TYPE 117: Array\n        write(encoder, 117)\n        writeVarUint(encoder, data.length)\n        for (let i = 0; i < data.length; i++) {\n          writeAny(encoder, data[i])\n        }\n      } else if (data instanceof Uint8Array) {\n        // TYPE 116: ArrayBuffer\n        write(encoder, 116)\n        writeVarUint8Array(encoder, data)\n      } else {\n        // TYPE 118: Object\n        write(encoder, 118)\n        const keys = Object.keys(data)\n        writeVarUint(encoder, keys.length)\n        for (let i = 0; i < keys.length; i++) {\n          const key = keys[i]\n          writeVarString(encoder, key)\n          writeAny(encoder, data[key])\n        }\n      }\n      break\n    case 'boolean':\n      // TYPE 120/121: boolean (true/false)\n      write(encoder, data ? 120 : 121)\n      break\n    default:\n      // TYPE 127: undefined\n      write(encoder, 127)\n  }\n}\n\n/**\n * Now come a few stateful encoder that have their own classes.\n */\n\n/**\n * Basic Run Length Encoder - a basic compression implementation.\n *\n * Encodes [1,1,1,7] to [1,3,7,1] (3 times 1, 1 time 7). This encoder might do more harm than good if there are a lot of values that are not repeated.\n *\n * It was originally used for image compression. Cool .. article http://csbruce.com/cbm/transactor/pdfs/trans_v7_i06.pdf\n *\n * @note T must not be null!\n *\n * @template T\n */\nexport class RleEncoder extends Encoder {\n  /**\n   * @param {function(Encoder, T):void} writer\n   */\n  constructor (writer) {\n    super()\n    /**\n     * The writer\n     */\n    this.w = writer\n    /**\n     * Current state\n     * @type {T|null}\n     */\n    this.s = null\n    this.count = 0\n  }\n\n  /**\n   * @param {T} v\n   */\n  write (v) {\n    if (this.s === v) {\n      this.count++\n    } else {\n      if (this.count > 0) {\n        // flush counter, unless this is the first value (count = 0)\n        writeVarUint(this, this.count - 1) // since count is always > 0, we can decrement by one. non-standard encoding ftw\n      }\n      this.count = 1\n      // write first value\n      this.w(this, v)\n      this.s = v\n    }\n  }\n}\n\n/**\n * Basic diff decoder using variable length encoding.\n *\n * Encodes the values [3, 1100, 1101, 1050, 0] to [3, 1097, 1, -51, -1050] using writeVarInt.\n */\nexport class IntDiffEncoder extends Encoder {\n  /**\n   * @param {number} start\n   */\n  constructor (start) {\n    super()\n    /**\n     * Current state\n     * @type {number}\n     */\n    this.s = start\n  }\n\n  /**\n   * @param {number} v\n   */\n  write (v) {\n    writeVarInt(this, v - this.s)\n    this.s = v\n  }\n}\n\n/**\n * A combination of IntDiffEncoder and RleEncoder.\n *\n * Basically first writes the IntDiffEncoder and then counts duplicate diffs using RleEncoding.\n *\n * Encodes the values [1,1,1,2,3,4,5,6] as [1,1,0,2,1,5] (RLE([1,0,0,1,1,1,1,1]) ⇒ RleIntDiff[1,1,0,2,1,5])\n */\nexport class RleIntDiffEncoder extends Encoder {\n  /**\n   * @param {number} start\n   */\n  constructor (start) {\n    super()\n    /**\n     * Current state\n     * @type {number}\n     */\n    this.s = start\n    this.count = 0\n  }\n\n  /**\n   * @param {number} v\n   */\n  write (v) {\n    if (this.s === v && this.count > 0) {\n      this.count++\n    } else {\n      if (this.count > 0) {\n        // flush counter, unless this is the first value (count = 0)\n        writeVarUint(this, this.count - 1) // since count is always > 0, we can decrement by one. non-standard encoding ftw\n      }\n      this.count = 1\n      // write first value\n      writeVarInt(this, v - this.s)\n      this.s = v\n    }\n  }\n}\n\n/**\n * @param {UintOptRleEncoder} encoder\n */\nconst flushUintOptRleEncoder = encoder => {\n  if (encoder.count > 0) {\n    // flush counter, unless this is the first value (count = 0)\n    // case 1: just a single value. set sign to positive\n    // case 2: write several values. set sign to negative to indicate that there is a length coming\n    writeVarInt(encoder.encoder, encoder.count === 1 ? encoder.s : -encoder.s)\n    if (encoder.count > 1) {\n      writeVarUint(encoder.encoder, encoder.count - 2) // since count is always > 1, we can decrement by one. non-standard encoding ftw\n    }\n  }\n}\n\n/**\n * Optimized Rle encoder that does not suffer from the mentioned problem of the basic Rle encoder.\n *\n * Internally uses VarInt encoder to write unsigned integers. If the input occurs multiple times, we write\n * write it as a negative number. The UintOptRleDecoder then understands that it needs to read a count.\n *\n * Encodes [1,2,3,3,3] as [1,2,-3,3] (once 1, once 2, three times 3)\n */\nexport class UintOptRleEncoder {\n  constructor () {\n    this.encoder = new Encoder()\n    /**\n     * @type {number}\n     */\n    this.s = 0\n    this.count = 0\n  }\n\n  /**\n   * @param {number} v\n   */\n  write (v) {\n    if (this.s === v) {\n      this.count++\n    } else {\n      flushUintOptRleEncoder(this)\n      this.count = 1\n      this.s = v\n    }\n  }\n\n  /**\n   * Flush the encoded state and transform this to a Uint8Array.\n   *\n   * Note that this should only be called once.\n   */\n  toUint8Array () {\n    flushUintOptRleEncoder(this)\n    return toUint8Array(this.encoder)\n  }\n}\n\n/**\n * Increasing Uint Optimized RLE Encoder\n *\n * The RLE encoder counts the number of same occurences of the same value.\n * The IncUintOptRle encoder counts if the value increases.\n * I.e. 7, 8, 9, 10 will be encoded as [-7, 4]. 1, 3, 5 will be encoded\n * as [1, 3, 5].\n */\nexport class IncUintOptRleEncoder {\n  constructor () {\n    this.encoder = new Encoder()\n    /**\n     * @type {number}\n     */\n    this.s = 0\n    this.count = 0\n  }\n\n  /**\n   * @param {number} v\n   */\n  write (v) {\n    if (this.s + this.count === v) {\n      this.count++\n    } else {\n      flushUintOptRleEncoder(this)\n      this.count = 1\n      this.s = v\n    }\n  }\n\n  /**\n   * Flush the encoded state and transform this to a Uint8Array.\n   *\n   * Note that this should only be called once.\n   */\n  toUint8Array () {\n    flushUintOptRleEncoder(this)\n    return toUint8Array(this.encoder)\n  }\n}\n\n/**\n * @param {IntDiffOptRleEncoder} encoder\n */\nconst flushIntDiffOptRleEncoder = encoder => {\n  if (encoder.count > 0) {\n    //          31 bit making up the diff | wether to write the counter\n    // const encodedDiff = encoder.diff << 1 | (encoder.count === 1 ? 0 : 1)\n    const encodedDiff = encoder.diff * 2 + (encoder.count === 1 ? 0 : 1)\n    // flush counter, unless this is the first value (count = 0)\n    // case 1: just a single value. set first bit to positive\n    // case 2: write several values. set first bit to negative to indicate that there is a length coming\n    writeVarInt(encoder.encoder, encodedDiff)\n    if (encoder.count > 1) {\n      writeVarUint(encoder.encoder, encoder.count - 2) // since count is always > 1, we can decrement by one. non-standard encoding ftw\n    }\n  }\n}\n\n/**\n * A combination of the IntDiffEncoder and the UintOptRleEncoder.\n *\n * The count approach is similar to the UintDiffOptRleEncoder, but instead of using the negative bitflag, it encodes\n * in the LSB whether a count is to be read. Therefore this Encoder only supports 31 bit integers!\n *\n * Encodes [1, 2, 3, 2] as [3, 1, 6, -1] (more specifically [(1 << 1) | 1, (3 << 0) | 0, -1])\n *\n * Internally uses variable length encoding. Contrary to normal UintVar encoding, the first byte contains:\n * * 1 bit that denotes whether the next value is a count (LSB)\n * * 1 bit that denotes whether this value is negative (MSB - 1)\n * * 1 bit that denotes whether to continue reading the variable length integer (MSB)\n *\n * Therefore, only five bits remain to encode diff ranges.\n *\n * Use this Encoder only when appropriate. In most cases, this is probably a bad idea.\n */\nexport class IntDiffOptRleEncoder {\n  constructor () {\n    this.encoder = new Encoder()\n    /**\n     * @type {number}\n     */\n    this.s = 0\n    this.count = 0\n    this.diff = 0\n  }\n\n  /**\n   * @param {number} v\n   */\n  write (v) {\n    if (this.diff === v - this.s) {\n      this.s = v\n      this.count++\n    } else {\n      flushIntDiffOptRleEncoder(this)\n      this.count = 1\n      this.diff = v - this.s\n      this.s = v\n    }\n  }\n\n  /**\n   * Flush the encoded state and transform this to a Uint8Array.\n   *\n   * Note that this should only be called once.\n   */\n  toUint8Array () {\n    flushIntDiffOptRleEncoder(this)\n    return toUint8Array(this.encoder)\n  }\n}\n\n/**\n * Optimized String Encoder.\n *\n * Encoding many small strings in a simple Encoder is not very efficient. The function call to decode a string takes some time and creates references that must be eventually deleted.\n * In practice, when decoding several million small strings, the GC will kick in more and more often to collect orphaned string objects (or maybe there is another reason?).\n *\n * This string encoder solves the above problem. All strings are concatenated and written as a single string using a single encoding call.\n *\n * The lengths are encoded using a UintOptRleEncoder.\n */\nexport class StringEncoder {\n  constructor () {\n    /**\n     * @type {Array<string>}\n     */\n    this.sarr = []\n    this.s = ''\n    this.lensE = new UintOptRleEncoder()\n  }\n\n  /**\n   * @param {string} string\n   */\n  write (string) {\n    this.s += string\n    if (this.s.length > 19) {\n      this.sarr.push(this.s)\n      this.s = ''\n    }\n    this.lensE.write(string.length)\n  }\n\n  toUint8Array () {\n    const encoder = new Encoder()\n    this.sarr.push(this.s)\n    this.s = ''\n    writeVarString(encoder, this.sarr.join(''))\n    writeUint8Array(encoder, this.lensE.toUint8Array())\n    return toUint8Array(encoder)\n  }\n}\n"],"names":["math.max","binary.BITS8","binary.BITS7","binary.BIT8","math.floor","math.isNegativeZero","binary.BITS6","binary.BIT7","string.utf8TextEncoder","string.encodeUtf8","math.min","number.isInteger","math.abs","binary.BITS31","array.isArray","string"],"mappings":";;;;;;;AAqCO,MAAM,QAAQ;AAAA,EACnB,cAAe;AACb,SAAK,OAAO;AACZ,SAAK,OAAO,IAAI,WAAW,GAAG;AAI9B,SAAK,OAAO,CAAA;AAAA,EAChB;AACA;AAMY,MAAC,gBAAgB,MAAM,IAAI,QAAO;AAKlC,MAAC,SAAS,CAAC,MAAM;AAC3B,QAAM,UAAU,cAAa;AAC7B,IAAE,OAAO;AACT,SAAO,aAAa,OAAO;AAC7B;AASY,MAAC,SAAS,aAAW;AAC/B,MAAI,MAAM,QAAQ;AAClB,WAAS,IAAI,GAAG,IAAI,QAAQ,KAAK,QAAQ,KAAK;AAC5C,WAAO,QAAQ,KAAK,CAAC,EAAE;AAAA,EAC3B;AACE,SAAO;AACT;AASY,MAAC,aAAa,aAAW,QAAQ,OAAO,KAAK,QAAQ,KAAK,SAAS;AASnE,MAAC,eAAe,aAAW;AACrC,QAAM,WAAW,IAAI,WAAW,OAAO,OAAO,CAAC;AAC/C,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,QAAQ,KAAK,QAAQ,KAAK;AAC5C,UAAM,IAAI,QAAQ,KAAK,CAAC;AACxB,aAAS,IAAI,GAAG,MAAM;AACtB,cAAU,EAAE;AAAA,EAChB;AACE,WAAS,IAAI,IAAI,WAAW,QAAQ,KAAK,QAAQ,GAAG,QAAQ,IAAI,GAAG,MAAM;AACzE,SAAO;AACT;AASY,MAAC,YAAY,CAAC,SAAS,QAAQ;AACzC,QAAM,YAAY,QAAQ,KAAK;AAC/B,MAAI,YAAY,QAAQ,OAAO,KAAK;AAClC,YAAQ,KAAK,KAAK,IAAI,WAAW,QAAQ,KAAK,QAAQ,GAAG,QAAQ,IAAI,CAAC;AACtE,YAAQ,OAAO,IAAI,WAAWA,KAAQ,IAAC,WAAW,GAAG,IAAI,CAAC;AAC1D,YAAQ,OAAO;AAAA,EACnB;AACA;AASY,MAAC,QAAQ,CAAC,SAAS,QAAQ;AACrC,QAAM,YAAY,QAAQ,KAAK;AAC/B,MAAI,QAAQ,SAAS,WAAW;AAC9B,YAAQ,KAAK,KAAK,QAAQ,IAAI;AAC9B,YAAQ,OAAO,IAAI,WAAW,YAAY,CAAC;AAC3C,YAAQ,OAAO;AAAA,EACnB;AACE,UAAQ,KAAK,QAAQ,MAAM,IAAI;AACjC;AAWY,MAAC,MAAM,CAAC,SAAS,KAAK,QAAQ;AACxC,MAAI,SAAS;AAEb,WAAS,IAAI,GAAG,IAAI,QAAQ,KAAK,UAAU,WAAW,MAAM,KAAK;AAC/D,UAAM,IAAI,QAAQ,KAAK,CAAC;AACxB,QAAI,MAAM,EAAE,QAAQ;AAClB,eAAS;AAAA,IACf,OAAW;AACL,aAAO,EAAE;AAAA,IACf;AAAA,EACA;AACE,MAAI,WAAW,MAAM;AAEnB,aAAS,QAAQ;AAAA,EACrB;AACE,SAAO,GAAG,IAAI;AAChB;AASY,MAAC,aAAa;AAUd,MAAC,WAAW;AASZ,MAAC,cAAc,CAAC,SAAS,QAAQ;AAC3C,QAAM,SAAS,MAAMC,OAAY,KAAA;AACjC,QAAM,SAAU,QAAQ,IAAKA,OAAY,KAAA;AAC3C;AASY,MAAC,YAAY,CAAC,SAAS,KAAK,QAAQ;AAC9C,MAAI,SAAS,KAAK,MAAMA,OAAY,KAAA;AACpC,MAAI,SAAS,MAAM,GAAI,QAAQ,IAAKA,OAAY,KAAA;AAClD;AASY,MAAC,cAAc,CAAC,SAAS,QAAQ;AAC3C,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,UAAM,SAAS,MAAMA,OAAY,KAAA;AACjC,aAAS;AAAA,EACb;AACA;AAUY,MAAC,uBAAuB,CAAC,SAAS,QAAQ;AACpD,WAAS,IAAI,GAAG,KAAK,GAAG,KAAK;AAC3B,UAAM,SAAU,QAAS,IAAI,IAAMA,OAAY,KAAA;AAAA,EACnD;AACA;AAUY,MAAC,YAAY,CAAC,SAAS,KAAK,QAAQ;AAC9C,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,QAAI,SAAS,MAAM,GAAG,MAAMA,OAAY,KAAA;AACxC,aAAS;AAAA,EACb;AACA;AASY,MAAC,eAAe,CAAC,SAAS,QAAQ;AAC5C,SAAO,MAAMC,OAAAA,OAAc;AACzB,UAAM,SAASC,cAAeD,OAAAA,QAAe,GAAI;AACjD,UAAME,KAAAA,MAAW,MAAM,GAAG;AAAA,EAC9B;AACE,QAAM,SAASF,OAAAA,QAAe,GAAG;AACnC;AAWY,MAAC,cAAc,CAAC,SAAS,QAAQ;AAC3C,QAAM,aAAaG,KAAAA,eAAoB,GAAG;AAC1C,MAAI,YAAY;AACd,UAAM,CAAC;AAAA,EACX;AAEE,QAAM,UAAU,MAAMC,OAAY,QAAGH,OAAW,OAAG,MAAM,aAAaI,OAAAA,OAAc,KAAMD,OAAAA,QAAe,GAAI;AAC7G,QAAMF,KAAAA,MAAW,MAAM,EAAE;AAGzB,SAAO,MAAM,GAAG;AACd,UAAM,UAAU,MAAMF,OAAAA,QAAeC,OAAAA,OAAc,KAAMD,OAAY,QAAG,GAAI;AAC5E,UAAME,KAAAA,MAAW,MAAM,GAAG;AAAA,EAC9B;AACA;AAKA,MAAM,aAAa,IAAI,WAAW,GAAK;AACvC,MAAM,eAAe,WAAW,SAAS;AAS7B,MAAC,wBAAwB,CAAC,SAAS,QAAQ;AACrD,MAAI,IAAI,SAAS,cAAc;AAG7B,UAAM,UAAUI,OAAAA,gBAAuB,WAAW,KAAK,UAAU,EAAE,WAAW;AAC9E,iBAAa,SAAS,OAAO;AAC7B,aAAS,IAAI,GAAG,IAAI,SAAS,KAAK;AAChC,YAAM,SAAS,WAAW,CAAC,CAAC;AAAA,IAClC;AAAA,EACA,OAAS;AACL,uBAAmB,SAASC,OAAiB,WAAC,GAAG,CAAC;AAAA,EACtD;AACA;AASY,MAAC,0BAA0B,CAAC,SAAS,QAAQ;AACvD,QAAM,gBAAgB,SAAS,mBAAmB,GAAG,CAAC;AACtD,QAAM,MAAM,cAAc;AAC1B,eAAa,SAAS,GAAG;AACzB,WAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B;AAAA,MAAM;AAAA;AAAA,MAAgC,cAAc,YAAY,CAAC;AAAA,IAAC;AAAA,EACtE;AACA;AAUY,MAAC,iBAAkBD,OAAsB;AAAwBA,OAAAA,gBAAwB,aAAc,wBAAwB;AAa/H,MAAC,wBAAwB,CAAC,SAAS,QAC7C,0BAA0B,SAASC,OAAiB,WAAC,GAAG,CAAC;AAmB/C,MAAC,4BAA4B,CAAC,SAAS,QAAQ;AACzD,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,UAAM,IAAI,IAAI,CAAC;AACf,QAAI,MAAM,KAAK,MAAM,GAAG;AACtB,YAAM,SAAS,CAAC;AAAA,IACtB;AACI,UAAM,SAAS,IAAI,CAAC,CAAC;AAAA,EACzB;AACE,QAAM,SAAS,CAAC;AAClB;AAaY,MAAC,qBAAqB,CAAC,SAAS,WAAW,gBAAgB,SAAS,aAAa,MAAM,CAAC;AASxF,MAAC,kBAAkB,CAAC,SAAS,eAAe;AACtD,QAAM,YAAY,QAAQ,KAAK;AAC/B,QAAM,OAAO,QAAQ;AACrB,QAAM,cAAcC,KAAQ,IAAC,YAAY,MAAM,WAAW,MAAM;AAChE,QAAM,eAAe,WAAW,SAAS;AACzC,UAAQ,KAAK,IAAI,WAAW,SAAS,GAAG,WAAW,GAAG,IAAI;AAC1D,UAAQ,QAAQ;AAChB,MAAI,eAAe,GAAG;AAGpB,YAAQ,KAAK,KAAK,QAAQ,IAAI;AAE9B,YAAQ,OAAO,IAAI,WAAWV,KAAQ,IAAC,YAAY,GAAG,YAAY,CAAC;AAEnE,YAAQ,KAAK,IAAI,WAAW,SAAS,WAAW,CAAC;AACjD,YAAQ,OAAO;AAAA,EACnB;AACA;AASY,MAAC,qBAAqB,CAAC,SAAS,eAAe;AACzD,eAAa,SAAS,WAAW,UAAU;AAC3C,kBAAgB,SAAS,UAAU;AACrC;AAmBY,MAAC,kBAAkB,CAAC,SAAS,QAAQ;AAC/C,YAAU,SAAS,GAAG;AACtB,QAAM,QAAQ,IAAI,SAAS,QAAQ,KAAK,QAAQ,QAAQ,MAAM,GAAG;AACjE,UAAQ,QAAQ;AAChB,SAAO;AACT;AAMY,MAAC,eAAe,CAAC,SAAS,QAAQ,gBAAgB,SAAS,CAAC,EAAE,WAAW,GAAG,KAAK,KAAK;AAMtF,MAAC,eAAe,CAAC,SAAS,QAAQ,gBAAgB,SAAS,CAAC,EAAE,WAAW,GAAG,KAAK,KAAK;AAMtF,MAAC,gBAAgB,CAAC,SAAS;AAAA;AAAA,EAA4B,gBAAgB,SAAS,CAAC,EAAG,YAAY,GAAG,KAAK,KAAK;AAAA;AAM7G,MAAC,iBAAiB,CAAC,SAAS;AAAA;AAAA,EAA4B,gBAAgB,SAAS,CAAC,EAAG,aAAa,GAAG,KAAK,KAAK;AAAA;AAE3H,MAAM,eAAe,IAAI,SAAS,IAAI,YAAY,CAAC,CAAC;AAOpD,MAAM,YAAY,SAAO;AACvB,eAAa,WAAW,GAAG,GAAG;AAC9B,SAAO,aAAa,WAAW,CAAC,MAAM;AACxC;AAuCY,MAAC,WAAW,CAAC,SAAS,SAAS;AACzC,UAAQ,OAAO,MAAI;AAAA,IACjB,KAAK;AAEH,YAAM,SAAS,GAAG;AAClB,qBAAe,SAAS,IAAI;AAC5B;AAAA,IACF,KAAK;AACH,UAAIW,OAAAA,UAAiB,IAAI,KAAKC,KAAQ,IAAC,IAAI,KAAKC,OAAAA,QAAe;AAE7D,cAAM,SAAS,GAAG;AAClB,oBAAY,SAAS,IAAI;AAAA,MACjC,WAAiB,UAAU,IAAI,GAAG;AAE1B,cAAM,SAAS,GAAG;AAClB,qBAAa,SAAS,IAAI;AAAA,MAClC,OAAa;AAEL,cAAM,SAAS,GAAG;AAClB,qBAAa,SAAS,IAAI;AAAA,MAClC;AACM;AAAA,IACF,KAAK;AAEH,YAAM,SAAS,GAAG;AAClB,oBAAc,SAAS,IAAI;AAC3B;AAAA,IACF,KAAK;AACH,UAAI,SAAS,MAAM;AAEjB,cAAM,SAAS,GAAG;AAAA,MAC1B,WAAiBC,MAAAA,QAAc,IAAI,GAAG;AAE9B,cAAM,SAAS,GAAG;AAClB,qBAAa,SAAS,KAAK,MAAM;AACjC,iBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,mBAAS,SAAS,KAAK,CAAC,CAAC;AAAA,QACnC;AAAA,MACA,WAAiB,gBAAgB,YAAY;AAErC,cAAM,SAAS,GAAG;AAClB,2BAAmB,SAAS,IAAI;AAAA,MACxC,OAAa;AAEL,cAAM,SAAS,GAAG;AAClB,cAAM,OAAO,OAAO,KAAK,IAAI;AAC7B,qBAAa,SAAS,KAAK,MAAM;AACjC,iBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,gBAAM,MAAM,KAAK,CAAC;AAClB,yBAAe,SAAS,GAAG;AAC3B,mBAAS,SAAS,KAAK,GAAG,CAAC;AAAA,QACrC;AAAA,MACA;AACM;AAAA,IACF,KAAK;AAEH,YAAM,SAAS,OAAO,MAAM,GAAG;AAC/B;AAAA,IACF;AAEE,YAAM,SAAS,GAAG;AAAA,EACxB;AACA;AAiBO,MAAM,mBAAmB,QAAQ;AAAA;AAAA;AAAA;AAAA,EAItC,YAAa,QAAQ;AACnB,UAAK;AAIL,SAAK,IAAI;AAKT,SAAK,IAAI;AACT,SAAK,QAAQ;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA,EAKE,MAAO,GAAG;AACR,QAAI,KAAK,MAAM,GAAG;AAChB,WAAK;AAAA,IACX,OAAW;AACL,UAAI,KAAK,QAAQ,GAAG;AAElB,qBAAa,MAAM,KAAK,QAAQ,CAAC;AAAA,MACzC;AACM,WAAK,QAAQ;AAEb,WAAK,EAAE,MAAM,CAAC;AACd,WAAK,IAAI;AAAA,IACf;AAAA,EACA;AACA;AAOO,MAAM,uBAAuB,QAAQ;AAAA;AAAA;AAAA;AAAA,EAI1C,YAAa,OAAO;AAClB,UAAK;AAKL,SAAK,IAAI;AAAA,EACb;AAAA;AAAA;AAAA;AAAA,EAKE,MAAO,GAAG;AACR,gBAAY,MAAM,IAAI,KAAK,CAAC;AAC5B,SAAK,IAAI;AAAA,EACb;AACA;AASO,MAAM,0BAA0B,QAAQ;AAAA;AAAA;AAAA;AAAA,EAI7C,YAAa,OAAO;AAClB,UAAK;AAKL,SAAK,IAAI;AACT,SAAK,QAAQ;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA,EAKE,MAAO,GAAG;AACR,QAAI,KAAK,MAAM,KAAK,KAAK,QAAQ,GAAG;AAClC,WAAK;AAAA,IACX,OAAW;AACL,UAAI,KAAK,QAAQ,GAAG;AAElB,qBAAa,MAAM,KAAK,QAAQ,CAAC;AAAA,MACzC;AACM,WAAK,QAAQ;AAEb,kBAAY,MAAM,IAAI,KAAK,CAAC;AAC5B,WAAK,IAAI;AAAA,IACf;AAAA,EACA;AACA;AAKA,MAAM,yBAAyB,aAAW;AACxC,MAAI,QAAQ,QAAQ,GAAG;AAIrB,gBAAY,QAAQ,SAAS,QAAQ,UAAU,IAAI,QAAQ,IAAI,CAAC,QAAQ,CAAC;AACzE,QAAI,QAAQ,QAAQ,GAAG;AACrB,mBAAa,QAAQ,SAAS,QAAQ,QAAQ,CAAC;AAAA,IACrD;AAAA,EACA;AACA;AAUO,MAAM,kBAAkB;AAAA,EAC7B,cAAe;AACb,SAAK,UAAU,IAAI,QAAO;AAI1B,SAAK,IAAI;AACT,SAAK,QAAQ;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA,EAKE,MAAO,GAAG;AACR,QAAI,KAAK,MAAM,GAAG;AAChB,WAAK;AAAA,IACX,OAAW;AACL,6BAAuB,IAAI;AAC3B,WAAK,QAAQ;AACb,WAAK,IAAI;AAAA,IACf;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOE,eAAgB;AACd,2BAAuB,IAAI;AAC3B,WAAO,aAAa,KAAK,OAAO;AAAA,EACpC;AACA;AAUO,MAAM,qBAAqB;AAAA,EAChC,cAAe;AACb,SAAK,UAAU,IAAI,QAAO;AAI1B,SAAK,IAAI;AACT,SAAK,QAAQ;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA,EAKE,MAAO,GAAG;AACR,QAAI,KAAK,IAAI,KAAK,UAAU,GAAG;AAC7B,WAAK;AAAA,IACX,OAAW;AACL,6BAAuB,IAAI;AAC3B,WAAK,QAAQ;AACb,WAAK,IAAI;AAAA,IACf;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOE,eAAgB;AACd,2BAAuB,IAAI;AAC3B,WAAO,aAAa,KAAK,OAAO;AAAA,EACpC;AACA;AAKA,MAAM,4BAA4B,aAAW;AAC3C,MAAI,QAAQ,QAAQ,GAAG;AAGrB,UAAM,cAAc,QAAQ,OAAO,KAAK,QAAQ,UAAU,IAAI,IAAI;AAIlE,gBAAY,QAAQ,SAAS,WAAW;AACxC,QAAI,QAAQ,QAAQ,GAAG;AACrB,mBAAa,QAAQ,SAAS,QAAQ,QAAQ,CAAC;AAAA,IACrD;AAAA,EACA;AACA;AAmBO,MAAM,qBAAqB;AAAA,EAChC,cAAe;AACb,SAAK,UAAU,IAAI,QAAO;AAI1B,SAAK,IAAI;AACT,SAAK,QAAQ;AACb,SAAK,OAAO;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAKE,MAAO,GAAG;AACR,QAAI,KAAK,SAAS,IAAI,KAAK,GAAG;AAC5B,WAAK,IAAI;AACT,WAAK;AAAA,IACX,OAAW;AACL,gCAA0B,IAAI;AAC9B,WAAK,QAAQ;AACb,WAAK,OAAO,IAAI,KAAK;AACrB,WAAK,IAAI;AAAA,IACf;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOE,eAAgB;AACd,8BAA0B,IAAI;AAC9B,WAAO,aAAa,KAAK,OAAO;AAAA,EACpC;AACA;AAYO,MAAM,cAAc;AAAA,EACzB,cAAe;AAIb,SAAK,OAAO,CAAA;AACZ,SAAK,IAAI;AACT,SAAK,QAAQ,IAAI,kBAAiB;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA,EAKE,MAAOC,SAAQ;AACb,SAAK,KAAKA;AACV,QAAI,KAAK,EAAE,SAAS,IAAI;AACtB,WAAK,KAAK,KAAK,KAAK,CAAC;AACrB,WAAK,IAAI;AAAA,IACf;AACI,SAAK,MAAM,MAAMA,QAAO,MAAM;AAAA,EAClC;AAAA,EAEE,eAAgB;AACd,UAAM,UAAU,IAAI,QAAO;AAC3B,SAAK,KAAK,KAAK,KAAK,CAAC;AACrB,SAAK,IAAI;AACT,mBAAe,SAAS,KAAK,KAAK,KAAK,EAAE,CAAC;AAC1C,oBAAgB,SAAS,KAAK,MAAM,aAAc,CAAA;AAClD,WAAO,aAAa,OAAO;AAAA,EAC/B;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/.pnpm/lib0@0.2.114/node_modules/lib0/environment.cjs.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const map = require("./map.cjs.js");
-const string = require("./string.cjs.js");
-const conditions = require("./conditions.cjs.js");
-const storage = require("./storage.cjs.js");
-const _function = require("./function.cjs.js");
-var define_process_env_default = {};
-const isNode = typeof process !== "undefined" && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== "undefined" ? process : 0) === "[object process]";
-const isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && !isNode;
-const isMac = typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
-let params;
-const args = [];
-const computeParams = () => {
-  if (params === void 0) {
-    if (isNode) {
-      params = map.create();
-      const pargs = process.argv;
-      let currParamName = null;
-      for (let i = 0; i < pargs.length; i++) {
-        const parg = pargs[i];
-        if (parg[0] === "-") {
-          if (currParamName !== null) {
-            params.set(currParamName, "");
-          }
-          currParamName = parg;
-        } else {
-          if (currParamName !== null) {
-            params.set(currParamName, parg);
-            currParamName = null;
-          } else {
-            args.push(parg);
-          }
-        }
-      }
-      if (currParamName !== null) {
-        params.set(currParamName, "");
-      }
-    } else if (typeof location === "object") {
-      params = map.create();
-      (location.search || "?").slice(1).split("&").forEach((kv) => {
-        if (kv.length !== 0) {
-          const [key, value] = kv.split("=");
-          params.set(`--${string.fromCamelCase(key, "-")}`, value);
-          params.set(`-${string.fromCamelCase(key, "-")}`, value);
-        }
-      });
-    } else {
-      params = map.create();
-    }
-  }
-  return params;
-};
-const hasParam = (name) => computeParams().has(name);
-const getParam = (name, defaultVal) => computeParams().get(name) || defaultVal;
-const getVariable = (name) => isNode ? conditions.undefinedToNull(define_process_env_default[name.toUpperCase().replaceAll("-", "_")]) : conditions.undefinedToNull(storage.varStorage.getItem(name));
-const getConf = (name) => computeParams().get("--" + name) || getVariable(name);
-const ensureConf = (name) => {
-  const c = getConf(name);
-  if (c == null) throw new Error(`Expected configuration "${name.toUpperCase().replaceAll("-", "_")}"`);
-  return c;
-};
-const hasConf = (name) => hasParam("--" + name) || getVariable(name) !== null;
-const production = hasConf("production");
-const forceColor = isNode && _function.isOneOf(define_process_env_default.FORCE_COLOR, ["true", "1", "2"]);
-const supportsColor = forceColor || !hasParam("--no-colors") && // @todo deprecate --no-colors
-!hasConf("no-color") && (!isNode || process.stdout.isTTY) && (!isNode || hasParam("--color") || getVariable("COLORTERM") !== null || (getVariable("TERM") || "").includes("color"));
-exports.ensureConf = ensureConf;
-exports.getConf = getConf;
-exports.getParam = getParam;
-exports.getVariable = getVariable;
-exports.hasConf = hasConf;
-exports.hasParam = hasParam;
-exports.isBrowser = isBrowser;
-exports.isMac = isMac;
-exports.isNode = isNode;
-exports.production = production;
-exports.supportsColor = supportsColor;
-//# sourceMappingURL=environment.cjs.js.map

package/lib/node_modules/.pnpm/lib0@0.2.114/node_modules/lib0/environment.cjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"environment.cjs.js","sources":["../../../../../../../../../node_modules/.pnpm/lib0@0.2.114/node_modules/lib0/environment.js"],"sourcesContent":["/**\n * Isomorphic module to work access the environment (query params, env variables).\n *\n * @module environment\n */\n\nimport * as map from './map.js'\nimport * as string from './string.js'\nimport * as conditions from './conditions.js'\nimport * as storage from './storage.js'\nimport * as f from './function.js'\n\n/* c8 ignore next 2 */\n// @ts-ignore\nexport const isNode = typeof process !== 'undefined' && process.release && /node|io\\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n\n/* c8 ignore next */\nexport const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && !isNode\n/* c8 ignore next 3 */\nexport const isMac = typeof navigator !== 'undefined'\n  ? /Mac/.test(navigator.platform)\n  : false\n\n/**\n * @type {Map<string,string>}\n */\nlet params\nconst args = []\n\n/* c8 ignore start */\nconst computeParams = () => {\n  if (params === undefined) {\n    if (isNode) {\n      params = map.create()\n      const pargs = process.argv\n      let currParamName = null\n      for (let i = 0; i < pargs.length; i++) {\n        const parg = pargs[i]\n        if (parg[0] === '-') {\n          if (currParamName !== null) {\n            params.set(currParamName, '')\n          }\n          currParamName = parg\n        } else {\n          if (currParamName !== null) {\n            params.set(currParamName, parg)\n            currParamName = null\n          } else {\n            args.push(parg)\n          }\n        }\n      }\n      if (currParamName !== null) {\n        params.set(currParamName, '')\n      }\n      // in ReactNative for example this would not be true (unless connected to the Remote Debugger)\n    } else if (typeof location === 'object') {\n      params = map.create(); // eslint-disable-next-line no-undef\n      (location.search || '?').slice(1).split('&').forEach((kv) => {\n        if (kv.length !== 0) {\n          const [key, value] = kv.split('=')\n          params.set(`--${string.fromCamelCase(key, '-')}`, value)\n          params.set(`-${string.fromCamelCase(key, '-')}`, value)\n        }\n      })\n    } else {\n      params = map.create()\n    }\n  }\n  return params\n}\n/* c8 ignore stop */\n\n/**\n * @param {string} name\n * @return {boolean}\n */\n/* c8 ignore next */\nexport const hasParam = (name) => computeParams().has(name)\n\n/**\n * @param {string} name\n * @param {string} defaultVal\n * @return {string}\n */\n/* c8 ignore next 2 */\nexport const getParam = (name, defaultVal) =>\n  computeParams().get(name) || defaultVal\n\n/**\n * @param {string} name\n * @return {string|null}\n */\n/* c8 ignore next 4 */\nexport const getVariable = (name) =>\n  isNode\n    ? conditions.undefinedToNull(process.env[name.toUpperCase().replaceAll('-', '_')])\n    : conditions.undefinedToNull(storage.varStorage.getItem(name))\n\n/**\n * @param {string} name\n * @return {string|null}\n */\n/* c8 ignore next 2 */\nexport const getConf = (name) =>\n  computeParams().get('--' + name) || getVariable(name)\n\n/**\n * @param {string} name\n * @return {string}\n */\n/* c8 ignore next 5 */\nexport const ensureConf = (name) => {\n  const c = getConf(name)\n  if (c == null) throw new Error(`Expected configuration \"${name.toUpperCase().replaceAll('-', '_')}\"`)\n  return c\n}\n\n/**\n * @param {string} name\n * @return {boolean}\n */\n/* c8 ignore next 2 */\nexport const hasConf = (name) =>\n  hasParam('--' + name) || getVariable(name) !== null\n\n/* c8 ignore next */\nexport const production = hasConf('production')\n\n/* c8 ignore next 2 */\nconst forceColor = isNode &&\n  f.isOneOf(process.env.FORCE_COLOR, ['true', '1', '2'])\n\n/* c8 ignore start */\n/**\n * Color is enabled by default if the terminal supports it.\n *\n * Explicitly enable color using `--color` parameter\n * Disable color using `--no-color` parameter or using `NO_COLOR=1` environment variable.\n * `FORCE_COLOR=1` enables color and takes precedence over all.\n */\nexport const supportsColor = forceColor || (\n  !hasParam('--no-colors') && // @todo deprecate --no-colors\n  !hasConf('no-color') &&\n  (!isNode || process.stdout.isTTY) && (\n    !isNode ||\n    hasParam('--color') ||\n    getVariable('COLORTERM') !== null ||\n    (getVariable('TERM') || '').includes('color')\n  )\n)\n/* c8 ignore stop */\n"],"names":["map.create","string.fromCamelCase","conditions.undefinedToNull","storage.varStorage","f.isOneOf"],"mappings":";;;;;;;;AAca,MAAA,SAAS,OAAO,YAAY,eAAe,QAAQ,WAAW,cAAc,KAAK,QAAQ,QAAQ,IAAI,KAAK,OAAO,UAAU,SAAS,KAAK,OAAO,YAAY,cAAc,UAAU,CAAC,MAAM;AAGjM,MAAM,YAAY,OAAO,WAAW,eAAe,OAAO,aAAa,eAAe,CAAC;AAEjF,MAAA,QAAQ,OAAO,cAAc,cACtC,MAAM,KAAK,UAAU,QAAQ,IAC7B;AAKJ,IAAI;AACJ,MAAM,OAAO,CAAC;AAGd,MAAM,gBAAgB,MAAM;AAC1B,MAAI,WAAW,QAAW;AACxB,QAAI,QAAQ;AACV,eAASA,IAAAA,OAAW;AACpB,YAAM,QAAQ,QAAQ;AACtB,UAAI,gBAAgB;AACpB,eAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AAC/B,cAAA,OAAO,MAAM,CAAC;AAChB,YAAA,KAAK,CAAC,MAAM,KAAK;AACnB,cAAI,kBAAkB,MAAM;AACnB,mBAAA,IAAI,eAAe,EAAE;AAAA,UAAA;AAEd,0BAAA;AAAA,QAAA,OACX;AACL,cAAI,kBAAkB,MAAM;AACnB,mBAAA,IAAI,eAAe,IAAI;AACd,4BAAA;AAAA,UAAA,OACX;AACL,iBAAK,KAAK,IAAI;AAAA,UAAA;AAAA,QAChB;AAAA,MACF;AAEF,UAAI,kBAAkB,MAAM;AACnB,eAAA,IAAI,eAAe,EAAE;AAAA,MAAA;AAAA,IAC9B,WAES,OAAO,aAAa,UAAU;AACvC,eAASA,IAAAA,OAAW;AACnB,OAAA,SAAS,UAAU,KAAK,MAAM,CAAC,EAAE,MAAM,GAAG,EAAE,QAAQ,CAAC,OAAO;AACvD,YAAA,GAAG,WAAW,GAAG;AACnB,gBAAM,CAAC,KAAK,KAAK,IAAI,GAAG,MAAM,GAAG;AAC1B,iBAAA,IAAI,KAAKC,OAAAA,cAAqB,KAAK,GAAG,CAAC,IAAI,KAAK;AAChD,iBAAA,IAAI,IAAIA,OAAAA,cAAqB,KAAK,GAAG,CAAC,IAAI,KAAK;AAAA,QAAA;AAAA,MACxD,CACD;AAAA,IAAA,OACI;AACL,eAASD,IAAAA,OAAW;AAAA,IAAA;AAAA,EACtB;AAEK,SAAA;AACT;AAQO,MAAM,WAAW,CAAC,SAAS,cAAc,EAAE,IAAI,IAAI;AAQ7C,MAAA,WAAW,CAAC,MAAM,eAC7B,gBAAgB,IAAI,IAAI,KAAK;AAOlB,MAAA,cAAc,CAAC,SAC1B,SACIE,WAA2B,gBAAA,2BAAY,KAAK,YAAc,EAAA,WAAW,KAAK,GAAG,CAAC,CAAC,IAC/EA,2BAA2BC,QAAQ,WAAW,QAAQ,IAAI,CAAC;AAOpD,MAAA,UAAU,CAAC,SACtB,cAAc,EAAE,IAAI,OAAO,IAAI,KAAK,YAAY,IAAI;AAOzC,MAAA,aAAa,CAAC,SAAS;AAC5B,QAAA,IAAI,QAAQ,IAAI;AACtB,MAAI,KAAK,KAAY,OAAA,IAAI,MAAM,2BAA2B,KAAK,YAAA,EAAc,WAAW,KAAK,GAAG,CAAC,GAAG;AAC7F,SAAA;AACT;AAOa,MAAA,UAAU,CAAC,SACtB,SAAS,OAAO,IAAI,KAAK,YAAY,IAAI,MAAM;AAGpC,MAAA,aAAa,QAAQ,YAAY;AAG9C,MAAM,aAAa,UACjBC,UAAAA,QAAU,2BAAY,aAAa,CAAC,QAAQ,KAAK,GAAG,CAAC;AAUhD,MAAM,gBAAgB,cAC3B,CAAC,SAAS,aAAa;AACvB,CAAC,QAAQ,UAAU,MAClB,CAAC,UAAU,QAAQ,OAAO,WACzB,CAAC,UACD,SAAS,SAAS,KAClB,YAAY,WAAW,MAAM,SAC5B,YAAY,MAAM,KAAK,IAAI,SAAS,OAAO;;;;;;;;;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/.pnpm/lib0@0.2.114/node_modules/lib0/error.cjs.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const create = (s) => new Error(s);
-const methodUnimplemented = () => {
-  throw create("Method unimplemented");
-};
-const unexpectedCase = () => {
-  throw create("Unexpected case");
-};
-exports.create = create;
-exports.methodUnimplemented = methodUnimplemented;
-exports.unexpectedCase = unexpectedCase;
-//# sourceMappingURL=error.cjs.js.map