alinea 1.7.0 → 2.0.0-preview.0

package/dist/chunks/chunk-AJJSW27C.js

@@ -1,728 +0,0 @@
-// node_modules/lib0/math.js
-var floor = Math.floor;
-var abs = Math.abs;
-var min = (a, b) => a < b ? a : b;
-var max = (a, b) => a > b ? a : b;
-var isNaN = Number.isNaN;
-var isNegativeZero = (n) => n !== 0 ? n < 0 : 1 / n < 0;
-
-// node_modules/lib0/binary.js
-var BIT1 = 1;
-var BIT2 = 2;
-var BIT3 = 4;
-var BIT4 = 8;
-var BIT6 = 32;
-var BIT7 = 64;
-var BIT8 = 128;
-var BIT18 = 1 << 17;
-var BIT19 = 1 << 18;
-var BIT20 = 1 << 19;
-var BIT21 = 1 << 20;
-var BIT22 = 1 << 21;
-var BIT23 = 1 << 22;
-var BIT24 = 1 << 23;
-var BIT25 = 1 << 24;
-var BIT26 = 1 << 25;
-var BIT27 = 1 << 26;
-var BIT28 = 1 << 27;
-var BIT29 = 1 << 28;
-var BIT30 = 1 << 29;
-var BIT31 = 1 << 30;
-var BIT32 = 1 << 31;
-var BITS5 = 31;
-var BITS6 = 63;
-var BITS7 = 127;
-var BITS17 = BIT18 - 1;
-var BITS18 = BIT19 - 1;
-var BITS19 = BIT20 - 1;
-var BITS20 = BIT21 - 1;
-var BITS21 = BIT22 - 1;
-var BITS22 = BIT23 - 1;
-var BITS23 = BIT24 - 1;
-var BITS24 = BIT25 - 1;
-var BITS25 = BIT26 - 1;
-var BITS26 = BIT27 - 1;
-var BITS27 = BIT28 - 1;
-var BITS28 = BIT29 - 1;
-var BITS29 = BIT30 - 1;
-var BITS30 = BIT31 - 1;
-var BITS31 = 2147483647;
-
-// node_modules/lib0/number.js
-var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
-var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
-var LOWEST_INT32 = 1 << 31;
-var isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
-var isNaN2 = Number.isNaN;
-var parseInt = Number.parseInt;
-
-// node_modules/lib0/set.js
-var create = () => /* @__PURE__ */ new Set();
-
-// node_modules/lib0/array.js
-var last = (arr) => arr[arr.length - 1];
-var appendTo = (dest, src) => {
-  for (let i = 0; i < src.length; i++) {
-    dest.push(src[i]);
-  }
-};
-var from = Array.from;
-var some = (arr, f) => {
-  for (let i = 0; i < arr.length; i++) {
-    if (f(arr[i], i, arr)) {
-      return true;
-    }
-  }
-  return false;
-};
-var unfold = (len, f) => {
-  const array = new Array(len);
-  for (let i = 0; i < len; i++) {
-    array[i] = f(i, array);
-  }
-  return array;
-};
-var isArray = Array.isArray;
-
-// node_modules/lib0/string.js
-var fromCharCode = String.fromCharCode;
-var fromCodePoint = String.fromCodePoint;
-var MAX_UTF16_CHARACTER = fromCharCode(65535);
-var toLowerCase = (s) => s.toLowerCase();
-var trimLeftRegex = /^\s*/g;
-var trimLeft = (s) => s.replace(trimLeftRegex, "");
-var fromCamelCaseRegex = /([A-Z])/g;
-var fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, (match) => `${separator}${toLowerCase(match)}`));
-var _encodeUtf8Polyfill = (str) => {
-  const encodedString = unescape(encodeURIComponent(str));
-  const len = encodedString.length;
-  const buf = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    buf[i] = /** @type {number} */
-    encodedString.codePointAt(i);
-  }
-  return buf;
-};
-var utf8TextEncoder = (
-  /** @type {TextEncoder} */
-  typeof TextEncoder !== "undefined" ? new TextEncoder() : null
-);
-var _encodeUtf8Native = (str) => utf8TextEncoder.encode(str);
-var encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
-var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
-  utf8TextDecoder = null;
-}
-var repeat = (source, n) => unfold(n, () => source).join("");
-
-// node_modules/lib0/encoding.js
-var Encoder = class {
-  constructor() {
-    this.cpos = 0;
-    this.cbuf = new Uint8Array(100);
-    this.bufs = [];
-  }
-};
-var createEncoder = () => new Encoder();
-var length = (encoder) => {
-  let len = encoder.cpos;
-  for (let i = 0; i < encoder.bufs.length; i++) {
-    len += encoder.bufs[i].length;
-  }
-  return len;
-};
-var 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;
-};
-var 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(max(bufferLen, len) * 2);
-    encoder.cpos = 0;
-  }
-};
-var 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;
-};
-var writeUint8 = write;
-var writeVarUint = (encoder, num) => {
-  while (num > BITS7) {
-    write(encoder, BIT8 | BITS7 & num);
-    num = floor(num / 128);
-  }
-  write(encoder, BITS7 & num);
-};
-var writeVarInt = (encoder, num) => {
-  const isNegative = isNegativeZero(num);
-  if (isNegative) {
-    num = -num;
-  }
-  write(encoder, (num > BITS6 ? BIT8 : 0) | (isNegative ? BIT7 : 0) | BITS6 & num);
-  num = floor(num / 64);
-  while (num > 0) {
-    write(encoder, (num > BITS7 ? BIT8 : 0) | BITS7 & num);
-    num = floor(num / 128);
-  }
-};
-var _strBuffer = new Uint8Array(3e4);
-var _maxStrBSize = _strBuffer.length / 3;
-var _writeVarStringNative = (encoder, str) => {
-  if (str.length < _maxStrBSize) {
-    const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
-    writeVarUint(encoder, written);
-    for (let i = 0; i < written; i++) {
-      write(encoder, _strBuffer[i]);
-    }
-  } else {
-    writeVarUint8Array(encoder, encodeUtf8(str));
-  }
-};
-var _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)
-    );
-  }
-};
-var writeVarString = utf8TextEncoder && /** @type {any} */
-utf8TextEncoder.encodeInto ? _writeVarStringNative : _writeVarStringPolyfill;
-var writeBinaryEncoder = (encoder, append) => writeUint8Array(encoder, toUint8Array(append));
-var writeUint8Array = (encoder, uint8Array) => {
-  const bufferLen = encoder.cbuf.length;
-  const cpos = encoder.cpos;
-  const leftCopyLen = 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(max(bufferLen * 2, rightCopyLen));
-    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
-    encoder.cpos = rightCopyLen;
-  }
-};
-var writeVarUint8Array = (encoder, uint8Array) => {
-  writeVarUint(encoder, uint8Array.byteLength);
-  writeUint8Array(encoder, uint8Array);
-};
-var writeOnDataView = (encoder, len) => {
-  verifyLen(encoder, len);
-  const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len);
-  encoder.cpos += len;
-  return dview;
-};
-var writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false);
-var writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false);
-var writeBigInt64 = (encoder, num) => (
-  /** @type {any} */
-  writeOnDataView(encoder, 8).setBigInt64(0, num, false)
-);
-var floatTestBed = new DataView(new ArrayBuffer(4));
-var isFloat32 = (num) => {
-  floatTestBed.setFloat32(0, num);
-  return floatTestBed.getFloat32(0) === num;
-};
-var writeAny = (encoder, data) => {
-  switch (typeof data) {
-    case "string":
-      write(encoder, 119);
-      writeVarString(encoder, data);
-      break;
-    case "number":
-      if (isInteger(data) && abs(data) <= 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 (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);
-  }
-};
-var RleEncoder = class 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;
-    }
-  }
-};
-var 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);
-    }
-  }
-};
-var UintOptRleEncoder = class {
-  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);
-  }
-};
-var 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);
-    }
-  }
-};
-var IntDiffOptRleEncoder = class {
-  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);
-  }
-};
-var StringEncoder = class {
-  constructor() {
-    this.sarr = [];
-    this.s = "";
-    this.lensE = new UintOptRleEncoder();
-  }
-  /**
-   * @param {string} string
-   */
-  write(string) {
-    this.s += string;
-    if (this.s.length > 19) {
-      this.sarr.push(this.s);
-      this.s = "";
-    }
-    this.lensE.write(string.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);
-  }
-};
-
-// node_modules/lib0/error.js
-var create2 = (s) => new Error(s);
-var methodUnimplemented = () => {
-  throw create2("Method unimplemented");
-};
-var unexpectedCase = () => {
-  throw create2("Unexpected case");
-};
-
-// node_modules/lib0/decoding.js
-var errorUnexpectedEndOfArray = create2("Unexpected end of array");
-var errorIntegerOutOfRange = create2("Integer out of Range");
-var Decoder = class {
-  /**
-   * @param {Uint8Array} uint8Array Binary data to decode
-   */
-  constructor(uint8Array) {
-    this.arr = uint8Array;
-    this.pos = 0;
-  }
-};
-var createDecoder = (uint8Array) => new Decoder(uint8Array);
-var hasContent = (decoder) => decoder.pos !== decoder.arr.length;
-var readUint8Array = (decoder, len) => {
-  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
-  decoder.pos += len;
-  return view;
-};
-var readVarUint8Array = (decoder) => readUint8Array(decoder, readVarUint(decoder));
-var readUint8 = (decoder) => decoder.arr[decoder.pos++];
-var readVarUint = (decoder) => {
-  let num = 0;
-  let mult = 1;
-  const len = decoder.arr.length;
-  while (decoder.pos < len) {
-    const r = decoder.arr[decoder.pos++];
-    num = num + (r & BITS7) * mult;
-    mult *= 128;
-    if (r < BIT8) {
-      return num;
-    }
-    if (num > MAX_SAFE_INTEGER) {
-      throw errorIntegerOutOfRange;
-    }
-  }
-  throw errorUnexpectedEndOfArray;
-};
-var readVarInt = (decoder) => {
-  let r = decoder.arr[decoder.pos++];
-  let num = r & BITS6;
-  let mult = 64;
-  const sign = (r & BIT7) > 0 ? -1 : 1;
-  if ((r & BIT8) === 0) {
-    return sign * num;
-  }
-  const len = decoder.arr.length;
-  while (decoder.pos < len) {
-    r = decoder.arr[decoder.pos++];
-    num = num + (r & BITS7) * mult;
-    mult *= 128;
-    if (r < BIT8) {
-      return sign * num;
-    }
-    if (num > MAX_SAFE_INTEGER) {
-      throw errorIntegerOutOfRange;
-    }
-  }
-  throw errorUnexpectedEndOfArray;
-};
-var _readVarStringPolyfill = (decoder) => {
-  let remainingLen = readVarUint(decoder);
-  if (remainingLen === 0) {
-    return "";
-  } else {
-    let encodedString = String.fromCodePoint(readUint8(decoder));
-    if (--remainingLen < 100) {
-      while (remainingLen--) {
-        encodedString += String.fromCodePoint(readUint8(decoder));
-      }
-    } else {
-      while (remainingLen > 0) {
-        const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
-        const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
-        decoder.pos += nextLen;
-        encodedString += String.fromCodePoint.apply(
-          null,
-          /** @type {any} */
-          bytes
-        );
-        remainingLen -= nextLen;
-      }
-    }
-    return decodeURIComponent(escape(encodedString));
-  }
-};
-var _readVarStringNative = (decoder) => (
-  /** @type any */
-  utf8TextDecoder.decode(readVarUint8Array(decoder))
-);
-var readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
-var readFromDataView = (decoder, len) => {
-  const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len);
-  decoder.pos += len;
-  return dv;
-};
-var readFloat32 = (decoder) => readFromDataView(decoder, 4).getFloat32(0, false);
-var readFloat64 = (decoder) => readFromDataView(decoder, 8).getFloat64(0, false);
-var readBigInt64 = (decoder) => (
-  /** @type {any} */
-  readFromDataView(decoder, 8).getBigInt64(0, false)
-);
-var readAnyLookupTable = [
-  (decoder) => void 0,
-  // CASE 127: undefined
-  (decoder) => null,
-  // CASE 126: null
-  readVarInt,
-  // CASE 125: integer
-  readFloat32,
-  // CASE 124: float32
-  readFloat64,
-  // CASE 123: float64
-  readBigInt64,
-  // CASE 122: bigint
-  (decoder) => false,
-  // CASE 121: boolean (false)
-  (decoder) => true,
-  // CASE 120: boolean (true)
-  readVarString,
-  // CASE 119: string
-  (decoder) => {
-    const len = readVarUint(decoder);
-    const obj = {};
-    for (let i = 0; i < len; i++) {
-      const key = readVarString(decoder);
-      obj[key] = readAny(decoder);
-    }
-    return obj;
-  },
-  (decoder) => {
-    const len = readVarUint(decoder);
-    const arr = [];
-    for (let i = 0; i < len; i++) {
-      arr.push(readAny(decoder));
-    }
-    return arr;
-  },
-  readVarUint8Array
-  // CASE 116: Uint8Array
-];
-var readAny = (decoder) => readAnyLookupTable[127 - readUint8(decoder)](decoder);
-var RleDecoder = class extends Decoder {
-  /**
-   * @param {Uint8Array} uint8Array
-   * @param {function(Decoder):T} reader
-   */
-  constructor(uint8Array, reader) {
-    super(uint8Array);
-    this.reader = reader;
-    this.s = null;
-    this.count = 0;
-  }
-  read() {
-    if (this.count === 0) {
-      this.s = this.reader(this);
-      if (hasContent(this)) {
-        this.count = readVarUint(this) + 1;
-      } else {
-        this.count = -1;
-      }
-    }
-    this.count--;
-    return (
-      /** @type {T} */
-      this.s
-    );
-  }
-};
-var UintOptRleDecoder = class extends Decoder {
-  /**
-   * @param {Uint8Array} uint8Array
-   */
-  constructor(uint8Array) {
-    super(uint8Array);
-    this.s = 0;
-    this.count = 0;
-  }
-  read() {
-    if (this.count === 0) {
-      this.s = readVarInt(this);
-      const isNegative = isNegativeZero(this.s);
-      this.count = 1;
-      if (isNegative) {
-        this.s = -this.s;
-        this.count = readVarUint(this) + 2;
-      }
-    }
-    this.count--;
-    return (
-      /** @type {number} */
-      this.s
-    );
-  }
-};
-var IntDiffOptRleDecoder = class extends Decoder {
-  /**
-   * @param {Uint8Array} uint8Array
-   */
-  constructor(uint8Array) {
-    super(uint8Array);
-    this.s = 0;
-    this.count = 0;
-    this.diff = 0;
-  }
-  /**
-   * @return {number}
-   */
-  read() {
-    if (this.count === 0) {
-      const diff = readVarInt(this);
-      const hasCount = diff & 1;
-      this.diff = floor(diff / 2);
-      this.count = 1;
-      if (hasCount) {
-        this.count = readVarUint(this) + 2;
-      }
-    }
-    this.s += this.diff;
-    this.count--;
-    return this.s;
-  }
-};
-var StringDecoder = class {
-  /**
-   * @param {Uint8Array} uint8Array
-   */
-  constructor(uint8Array) {
-    this.decoder = new UintOptRleDecoder(uint8Array);
-    this.str = readVarString(this.decoder);
-    this.spos = 0;
-  }
-  /**
-   * @return {string}
-   */
-  read() {
-    const end = this.spos + this.decoder.read();
-    const res = this.str.slice(this.spos, end);
-    this.spos = end;
-    return res;
-  }
-};
-
-export {
-  create,
-  last,
-  appendTo,
-  from,
-  some,
-  isArray,
-  floor,
-  abs,
-  min,
-  max,
-  BIT1,
-  BIT2,
-  BIT3,
-  BIT4,
-  BIT6,
-  BIT7,
-  BIT8,
-  BITS5,
-  fromCamelCase,
-  repeat,
-  createEncoder,
-  toUint8Array,
-  writeUint8,
-  writeVarUint,
-  writeVarInt,
-  writeVarString,
-  writeBinaryEncoder,
-  writeUint8Array,
-  writeVarUint8Array,
-  writeAny,
-  RleEncoder,
-  UintOptRleEncoder,
-  IntDiffOptRleEncoder,
-  StringEncoder,
-  create2,
-  methodUnimplemented,
-  unexpectedCase,
-  createDecoder,
-  hasContent,
-  readVarUint8Array,
-  readUint8,
-  readVarUint,
-  readVarInt,
-  readVarString,
-  readAny,
-  RleDecoder,
-  UintOptRleDecoder,
-  IntDiffOptRleDecoder,
-  StringDecoder
-};