@aixa-transformation/pptx-viewer 2.0.2

package/dist/chunk-Y6FQDUJU.js

@@ -0,0 +1,1160 @@
+'use strict';
+
+var Y = require('yjs');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Y__namespace = /*#__PURE__*/_interopNamespace(Y);
+
+// ../../node_modules/lib0/map.js
+var create = () => /* @__PURE__ */ new Map();
+var setIfUndefined = (map3, key, createT) => {
+  let set = map3.get(key);
+  if (set === void 0) {
+    map3.set(key, set = createT());
+  }
+  return set;
+};
+var map = (m, f) => {
+  const res = [];
+  for (const [key, value] of m) {
+    res.push(f(value, key));
+  }
+  return res;
+};
+
+// ../../node_modules/lib0/set.js
+var create2 = () => /* @__PURE__ */ new Set();
+
+// ../../node_modules/lib0/array.js
+var from = Array.from;
+var every = (arr, f) => {
+  for (let i = 0; i < arr.length; i++) {
+    if (!f(arr[i], i, arr)) {
+      return false;
+    }
+  }
+  return true;
+};
+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/observable.js
+var ObservableV2 = class {
+  constructor() {
+    this._observers = create();
+  }
+  /**
+   * @template {keyof EVENTS & string} NAME
+   * @param {NAME} name
+   * @param {EVENTS[NAME]} f
+   */
+  on(name, f) {
+    setIfUndefined(
+      this._observers,
+      /** @type {string} */
+      name,
+      create2
+    ).add(f);
+    return f;
+  }
+  /**
+   * @template {keyof EVENTS & string} NAME
+   * @param {NAME} name
+   * @param {EVENTS[NAME]} f
+   */
+  once(name, f) {
+    const _f = (...args2) => {
+      this.off(
+        name,
+        /** @type {any} */
+        _f
+      );
+      f(...args2);
+    };
+    this.on(
+      name,
+      /** @type {any} */
+      _f
+    );
+  }
+  /**
+   * @template {keyof EVENTS & string} NAME
+   * @param {NAME} name
+   * @param {EVENTS[NAME]} f
+   */
+  off(name, f) {
+    const observers = this._observers.get(name);
+    if (observers !== void 0) {
+      observers.delete(f);
+      if (observers.size === 0) {
+        this._observers.delete(name);
+      }
+    }
+  }
+  /**
+   * Emit a named event. All registered event listeners that listen to the
+   * specified name will receive the event.
+   *
+   * @todo This should catch exceptions
+   *
+   * @template {keyof EVENTS & string} NAME
+   * @param {NAME} name The event name.
+   * @param {Parameters<EVENTS[NAME]>} args The arguments that are applied to the event listener.
+   */
+  emit(name, args2) {
+    return from((this._observers.get(name) || create()).values()).forEach((f) => f(...args2));
+  }
+  destroy() {
+    this._observers = create();
+  }
+};
+var Observable = class {
+  constructor() {
+    this._observers = create();
+  }
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  on(name, f) {
+    setIfUndefined(this._observers, name, create2).add(f);
+  }
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  once(name, f) {
+    const _f = (...args2) => {
+      this.off(name, _f);
+      f(...args2);
+    };
+    this.on(name, _f);
+  }
+  /**
+   * @param {N} name
+   * @param {function} f
+   */
+  off(name, f) {
+    const observers = this._observers.get(name);
+    if (observers !== void 0) {
+      observers.delete(f);
+      if (observers.size === 0) {
+        this._observers.delete(name);
+      }
+    }
+  }
+  /**
+   * Emit a named event. All registered event listeners that listen to the
+   * specified name will receive the event.
+   *
+   * @todo This should catch exceptions
+   *
+   * @param {N} name The event name.
+   * @param {Array<any>} args The arguments that are applied to the event listener.
+   */
+  emit(name, args2) {
+    return from((this._observers.get(name) || create()).values()).forEach((f) => f(...args2));
+  }
+  destroy() {
+    this._observers = create();
+  }
+};
+
+// ../../node_modules/lib0/math.js
+var floor = Math.floor;
+var abs = Math.abs;
+var log10 = Math.log10;
+var min = (a, b) => a < b ? a : b;
+var max = (a, b) => a > b ? a : b;
+var pow = Math.pow;
+var isNegativeZero = (n) => n !== 0 ? n < 0 : 1 / n < 0;
+
+// ../../node_modules/lib0/time.js
+var getUnixTime = Date.now;
+
+// ../../node_modules/lib0/error.js
+var create3 = (s) => new Error(s);
+var methodUnimplemented = () => {
+  throw create3("Method unimplemented");
+};
+var unexpectedCase = () => {
+  throw create3("Unexpected case");
+};
+
+// ../../node_modules/lib0/binary.js
+var BIT7 = 64;
+var BIT8 = 128;
+var BITS6 = 63;
+var BITS7 = 127;
+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 isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
+
+// ../../node_modules/lib0/string.js
+var fromCharCode = String.fromCharCode;
+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 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 keys2 = Object.keys(data);
+        writeVarUint(encoder, keys2.length);
+        for (let i = 0; i < keys2.length; i++) {
+          const key = keys2[i];
+          writeVarString(encoder, key);
+          writeAny(encoder, data[key]);
+        }
+      }
+      break;
+    case "boolean":
+      write(encoder, data ? 120 : 121);
+      break;
+    default:
+      write(encoder, 127);
+  }
+};
+
+// ../../node_modules/lib0/decoding.js
+var errorUnexpectedEndOfArray = create3("Unexpected end of array");
+var errorIntegerOutOfRange = create3("Integer out of Range");
+var Decoder = class {
+  /**
+   * @param {Uint8Array<Buf>} uint8Array Binary data to decode
+   */
+  constructor(uint8Array) {
+    this.arr = uint8Array;
+    this.pos = 0;
+  }
+};
+var createDecoder = (uint8Array) => new Decoder(uint8Array);
+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);
+
+// ../../node_modules/lib0/conditions.js
+var undefinedToNull = (v) => v === void 0 ? null : v;
+
+// ../../node_modules/lib0/storage.js
+var VarStoragePolyfill = class {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  /**
+   * @param {string} key
+   * @param {any} newValue
+   */
+  setItem(key, newValue) {
+    this.map.set(key, newValue);
+  }
+  /**
+   * @param {string} key
+   */
+  getItem(key) {
+    return this.map.get(key);
+  }
+};
+var _localStorage = new VarStoragePolyfill();
+var usePolyfill = true;
+try {
+  if (typeof localStorage !== "undefined" && localStorage) {
+    _localStorage = localStorage;
+    usePolyfill = false;
+  }
+} catch (e) {
+}
+var varStorage = _localStorage;
+var onChange = (eventHandler) => usePolyfill || addEventListener(
+  "storage",
+  /** @type {any} */
+  eventHandler
+);
+var offChange = (eventHandler) => usePolyfill || removeEventListener(
+  "storage",
+  /** @type {any} */
+  eventHandler
+);
+
+// ../../node_modules/lib0/trait/equality.js
+var EqualityTraitSymbol = /* @__PURE__ */ Symbol("Equality");
+var equals = (a, b) => a === b || !!a?.[EqualityTraitSymbol]?.(b) || false;
+
+// ../../node_modules/lib0/object.js
+var isObject = (o) => typeof o === "object";
+var keys = Object.keys;
+var map2 = (obj, f) => {
+  const results = [];
+  for (const key in obj) {
+    results.push(f(obj[key], key));
+  }
+  return results;
+};
+var size = (obj) => keys(obj).length;
+var every2 = (obj, f) => {
+  for (const key in obj) {
+    if (!f(obj[key], key)) {
+      return false;
+    }
+  }
+  return true;
+};
+var hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+// ../../node_modules/lib0/function.js
+var nop = () => {
+};
+var equalityDeep = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a == null || b == null || a.constructor !== b.constructor && (a.constructor || Object) !== (b.constructor || Object)) {
+    return false;
+  }
+  if (a[EqualityTraitSymbol] != null) {
+    return a[EqualityTraitSymbol](b);
+  }
+  switch (a.constructor) {
+    case ArrayBuffer:
+      a = new Uint8Array(a);
+      b = new Uint8Array(b);
+    // eslint-disable-next-line no-fallthrough
+    case Uint8Array: {
+      if (a.byteLength !== b.byteLength) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+          return false;
+        }
+      }
+      break;
+    }
+    case Set: {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const value of a) {
+        if (!b.has(value)) {
+          return false;
+        }
+      }
+      break;
+    }
+    case Map: {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const key of a.keys()) {
+        if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
+          return false;
+        }
+      }
+      break;
+    }
+    case void 0:
+    case Object:
+      if (size(a) !== size(b)) {
+        return false;
+      }
+      for (const key in a) {
+        if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
+          return false;
+        }
+      }
+      break;
+    case Array:
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!equalityDeep(a[i], b[i])) {
+          return false;
+        }
+      }
+      break;
+    default:
+      return false;
+  }
+  return true;
+};
+var isOneOf = (value, options) => options.includes(value);
+
+// ../../node_modules/lib0/environment.js
+var isNode = typeof process !== "undefined" && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== "undefined" ? process : 0) === "[object process]";
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && !isNode;
+var params;
+var computeParams = () => {
+  if (params === void 0) {
+    if (isNode) {
+      params = 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;
+          }
+        }
+      }
+      if (currParamName !== null) {
+        params.set(currParamName, "");
+      }
+    } else if (typeof location === "object") {
+      params = create();
+      (location.search || "?").slice(1).split("&").forEach((kv) => {
+        if (kv.length !== 0) {
+          const [key, value] = kv.split("=");
+          params.set(`--${fromCamelCase(key, "-")}`, value);
+          params.set(`-${fromCamelCase(key, "-")}`, value);
+        }
+      });
+    } else {
+      params = create();
+    }
+  }
+  return params;
+};
+var hasParam = (name) => computeParams().has(name);
+var getVariable = (name) => isNode ? undefinedToNull(process.env[name.toUpperCase().replaceAll("-", "_")]) : undefinedToNull(varStorage.getItem(name));
+var hasConf = (name) => hasParam("--" + name) || getVariable(name) !== null;
+var production = hasConf("production");
+var forceColor = isNode && isOneOf(process.env.FORCE_COLOR, ["true", "1", "2"]);
+var 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"));
+
+// ../../node_modules/lib0/buffer.js
+var createUint8ArrayFromLen = (len) => new Uint8Array(len);
+var createUint8ArrayViewFromArrayBuffer = (buffer, byteOffset, length2) => new Uint8Array(buffer, byteOffset, length2);
+var createUint8ArrayFromArrayBuffer = (buffer) => new Uint8Array(buffer);
+var toBase64Browser = (bytes) => {
+  let s = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    s += fromCharCode(bytes[i]);
+  }
+  return btoa(s);
+};
+var toBase64Node = (bytes) => Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+var fromBase64Browser = (s) => {
+  const a = atob(s);
+  const bytes = createUint8ArrayFromLen(a.length);
+  for (let i = 0; i < a.length; i++) {
+    bytes[i] = a.charCodeAt(i);
+  }
+  return bytes;
+};
+var fromBase64Node = (s) => {
+  const buf = Buffer.from(s, "base64");
+  return createUint8ArrayViewFromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength);
+};
+var toBase64 = isBrowser ? toBase64Browser : toBase64Node;
+var fromBase64 = isBrowser ? fromBase64Browser : fromBase64Node;
+
+// ../../node_modules/lib0/broadcastchannel.js
+var channels = /* @__PURE__ */ new Map();
+var LocalStoragePolyfill = class {
+  /**
+   * @param {string} room
+   */
+  constructor(room) {
+    this.room = room;
+    this.onmessage = null;
+    this._onChange = (e) => e.key === room && this.onmessage !== null && this.onmessage({ data: fromBase64(e.newValue || "") });
+    onChange(this._onChange);
+  }
+  /**
+   * @param {ArrayBuffer} buf
+   */
+  postMessage(buf) {
+    varStorage.setItem(this.room, toBase64(createUint8ArrayFromArrayBuffer(buf)));
+  }
+  close() {
+    offChange(this._onChange);
+  }
+};
+var BC = typeof BroadcastChannel === "undefined" ? LocalStoragePolyfill : BroadcastChannel;
+var getChannel = (room) => setIfUndefined(channels, room, () => {
+  const subs = create2();
+  const bc = new BC(room);
+  bc.onmessage = (e) => subs.forEach((sub) => sub(e.data, "broadcastchannel"));
+  return {
+    bc,
+    subs
+  };
+});
+var subscribe = (room, f) => {
+  getChannel(room).subs.add(f);
+  return f;
+};
+var unsubscribe = (room, f) => {
+  const channel = getChannel(room);
+  const unsubscribed = channel.subs.delete(f);
+  if (unsubscribed && channel.subs.size === 0) {
+    channel.bc.close();
+    channels.delete(room);
+  }
+  return unsubscribed;
+};
+var publish = (room, data, origin = null) => {
+  const c = getChannel(room);
+  c.bc.postMessage(data);
+  c.subs.forEach((sub) => sub(data, origin));
+};
+var messageYjsSyncStep1 = 0;
+var messageYjsSyncStep2 = 1;
+var messageYjsUpdate = 2;
+var writeSyncStep1 = (encoder, doc) => {
+  writeVarUint(encoder, messageYjsSyncStep1);
+  const sv = Y__namespace.encodeStateVector(doc);
+  writeVarUint8Array(encoder, sv);
+};
+var writeSyncStep2 = (encoder, doc, encodedStateVector) => {
+  writeVarUint(encoder, messageYjsSyncStep2);
+  writeVarUint8Array(encoder, Y__namespace.encodeStateAsUpdate(doc, encodedStateVector));
+};
+var readSyncStep1 = (decoder, encoder, doc) => writeSyncStep2(encoder, doc, readVarUint8Array(decoder));
+var readSyncStep2 = (decoder, doc, transactionOrigin, errorHandler) => {
+  try {
+    Y__namespace.applyUpdate(doc, readVarUint8Array(decoder), transactionOrigin);
+  } catch (error) {
+    if (errorHandler != null) errorHandler(
+      /** @type {Error} */
+      error
+    );
+    console.error("Caught error while handling a Yjs update", error);
+  }
+};
+var writeUpdate = (encoder, update) => {
+  writeVarUint(encoder, messageYjsUpdate);
+  writeVarUint8Array(encoder, update);
+};
+var readUpdate = readSyncStep2;
+var readSyncMessage = (decoder, encoder, doc, transactionOrigin, errorHandler) => {
+  const messageType = readVarUint(decoder);
+  switch (messageType) {
+    case messageYjsSyncStep1:
+      readSyncStep1(decoder, encoder, doc);
+      break;
+    case messageYjsSyncStep2:
+      readSyncStep2(decoder, doc, transactionOrigin, errorHandler);
+      break;
+    case messageYjsUpdate:
+      readUpdate(decoder, doc, transactionOrigin, errorHandler);
+      break;
+    default:
+      throw new Error("Unknown message type");
+  }
+  return messageType;
+};
+var outdatedTimeout = 3e4;
+var Awareness = class extends Observable {
+  /**
+   * @param {Y.Doc} doc
+   */
+  constructor(doc) {
+    super();
+    this.doc = doc;
+    this.clientID = doc.clientID;
+    this.states = /* @__PURE__ */ new Map();
+    this.meta = /* @__PURE__ */ new Map();
+    this._checkInterval = /** @type {any} */
+    setInterval(() => {
+      const now = getUnixTime();
+      if (this.getLocalState() !== null && outdatedTimeout / 2 <= now - /** @type {{lastUpdated:number}} */
+      this.meta.get(this.clientID).lastUpdated) {
+        this.setLocalState(this.getLocalState());
+      }
+      const remove = [];
+      this.meta.forEach((meta, clientid) => {
+        if (clientid !== this.clientID && outdatedTimeout <= now - meta.lastUpdated && this.states.has(clientid)) {
+          remove.push(clientid);
+        }
+      });
+      if (remove.length > 0) {
+        removeAwarenessStates(this, remove, "timeout");
+      }
+    }, floor(outdatedTimeout / 10));
+    doc.on("destroy", () => {
+      this.destroy();
+    });
+    this.setLocalState({});
+  }
+  destroy() {
+    this.emit("destroy", [this]);
+    this.setLocalState(null);
+    super.destroy();
+    clearInterval(this._checkInterval);
+  }
+  /**
+   * @return {Object<string,any>|null}
+   */
+  getLocalState() {
+    return this.states.get(this.clientID) || null;
+  }
+  /**
+   * @param {Object<string,any>|null} state
+   */
+  setLocalState(state) {
+    const clientID = this.clientID;
+    const currLocalMeta = this.meta.get(clientID);
+    const clock = currLocalMeta === void 0 ? 0 : currLocalMeta.clock + 1;
+    const prevState = this.states.get(clientID);
+    if (state === null) {
+      this.states.delete(clientID);
+    } else {
+      this.states.set(clientID, state);
+    }
+    this.meta.set(clientID, {
+      clock,
+      lastUpdated: getUnixTime()
+    });
+    const added = [];
+    const updated = [];
+    const filteredUpdated = [];
+    const removed = [];
+    if (state === null) {
+      removed.push(clientID);
+    } else if (prevState == null) {
+      if (state != null) {
+        added.push(clientID);
+      }
+    } else {
+      updated.push(clientID);
+      if (!equalityDeep(prevState, state)) {
+        filteredUpdated.push(clientID);
+      }
+    }
+    if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
+      this.emit("change", [{ added, updated: filteredUpdated, removed }, "local"]);
+    }
+    this.emit("update", [{ added, updated, removed }, "local"]);
+  }
+  /**
+   * @param {string} field
+   * @param {any} value
+   */
+  setLocalStateField(field, value) {
+    const state = this.getLocalState();
+    if (state !== null) {
+      this.setLocalState({
+        ...state,
+        [field]: value
+      });
+    }
+  }
+  /**
+   * @return {Map<number,Object<string,any>>}
+   */
+  getStates() {
+    return this.states;
+  }
+};
+var removeAwarenessStates = (awareness, clients, origin) => {
+  const removed = [];
+  for (let i = 0; i < clients.length; i++) {
+    const clientID = clients[i];
+    if (awareness.states.has(clientID)) {
+      awareness.states.delete(clientID);
+      if (clientID === awareness.clientID) {
+        const curMeta = (
+          /** @type {MetaClientState} */
+          awareness.meta.get(clientID)
+        );
+        awareness.meta.set(clientID, {
+          clock: curMeta.clock + 1,
+          lastUpdated: getUnixTime()
+        });
+      }
+      removed.push(clientID);
+    }
+  }
+  if (removed.length > 0) {
+    awareness.emit("change", [{ added: [], updated: [], removed }, origin]);
+    awareness.emit("update", [{ added: [], updated: [], removed }, origin]);
+  }
+};
+var encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => {
+  const len = clients.length;
+  const encoder = createEncoder();
+  writeVarUint(encoder, len);
+  for (let i = 0; i < len; i++) {
+    const clientID = clients[i];
+    const state = states.get(clientID) || null;
+    const clock = (
+      /** @type {MetaClientState} */
+      awareness.meta.get(clientID).clock
+    );
+    writeVarUint(encoder, clientID);
+    writeVarUint(encoder, clock);
+    writeVarString(encoder, JSON.stringify(state));
+  }
+  return toUint8Array(encoder);
+};
+var applyAwarenessUpdate = (awareness, update, origin) => {
+  const decoder = createDecoder(update);
+  const timestamp = getUnixTime();
+  const added = [];
+  const updated = [];
+  const filteredUpdated = [];
+  const removed = [];
+  const len = readVarUint(decoder);
+  for (let i = 0; i < len; i++) {
+    const clientID = readVarUint(decoder);
+    let clock = readVarUint(decoder);
+    const state = JSON.parse(readVarString(decoder));
+    const clientMeta = awareness.meta.get(clientID);
+    const prevState = awareness.states.get(clientID);
+    const currClock = clientMeta === void 0 ? 0 : clientMeta.clock;
+    if (currClock < clock || currClock === clock && state === null && awareness.states.has(clientID)) {
+      if (state === null) {
+        if (clientID === awareness.clientID && awareness.getLocalState() != null) {
+          clock++;
+        } else {
+          awareness.states.delete(clientID);
+        }
+      } else {
+        awareness.states.set(clientID, state);
+      }
+      awareness.meta.set(clientID, {
+        clock,
+        lastUpdated: timestamp
+      });
+      if (clientMeta === void 0 && state !== null) {
+        added.push(clientID);
+      } else if (clientMeta !== void 0 && state === null) {
+        removed.push(clientID);
+      } else if (state !== null) {
+        if (!equalityDeep(state, prevState)) {
+          filteredUpdated.push(clientID);
+        }
+        updated.push(clientID);
+      }
+    }
+  }
+  if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
+    awareness.emit("change", [{
+      added,
+      updated: filteredUpdated,
+      removed
+    }, origin]);
+  }
+  if (added.length > 0 || updated.length > 0 || removed.length > 0) {
+    awareness.emit("update", [{
+      added,
+      updated,
+      removed
+    }, origin]);
+  }
+};
+
+exports.Awareness = Awareness;
+exports.EqualityTraitSymbol = EqualityTraitSymbol;
+exports.MAX_SAFE_INTEGER = MAX_SAFE_INTEGER;
+exports.MIN_SAFE_INTEGER = MIN_SAFE_INTEGER;
+exports.Observable = Observable;
+exports.ObservableV2 = ObservableV2;
+exports.applyAwarenessUpdate = applyAwarenessUpdate;
+exports.create = create;
+exports.create2 = create2;
+exports.create3 = create3;
+exports.createDecoder = createDecoder;
+exports.createEncoder = createEncoder;
+exports.encodeAwarenessUpdate = encodeAwarenessUpdate;
+exports.encodeUtf8 = encodeUtf8;
+exports.equalityDeep = equalityDeep;
+exports.equals = equals;
+exports.every = every;
+exports.every2 = every2;
+exports.floor = floor;
+exports.fromBase64 = fromBase64;
+exports.fromCharCode = fromCharCode;
+exports.getUnixTime = getUnixTime;
+exports.getVariable = getVariable;
+exports.hasProperty = hasProperty;
+exports.isArray = isArray;
+exports.isNode = isNode;
+exports.isObject = isObject;
+exports.length = length;
+exports.log10 = log10;
+exports.map = map;
+exports.map2 = map2;
+exports.messageYjsSyncStep1 = messageYjsSyncStep1;
+exports.messageYjsSyncStep2 = messageYjsSyncStep2;
+exports.methodUnimplemented = methodUnimplemented;
+exports.min = min;
+exports.nop = nop;
+exports.pow = pow;
+exports.production = production;
+exports.publish = publish;
+exports.readAny = readAny;
+exports.readSyncMessage = readSyncMessage;
+exports.readUint8 = readUint8;
+exports.readVarString = readVarString;
+exports.readVarUint = readVarUint;
+exports.readVarUint8Array = readVarUint8Array;
+exports.removeAwarenessStates = removeAwarenessStates;
+exports.repeat = repeat;
+exports.setIfUndefined = setIfUndefined;
+exports.some = some;
+exports.subscribe = subscribe;
+exports.supportsColor = supportsColor;
+exports.toBase64 = toBase64;
+exports.toUint8Array = toUint8Array;
+exports.unexpectedCase = unexpectedCase;
+exports.unsubscribe = unsubscribe;
+exports.writeAny = writeAny;
+exports.writeSyncStep1 = writeSyncStep1;
+exports.writeSyncStep2 = writeSyncStep2;
+exports.writeUint8 = writeUint8;
+exports.writeUpdate = writeUpdate;
+exports.writeVarString = writeVarString;
+exports.writeVarUint = writeVarUint;
+exports.writeVarUint8Array = writeVarUint8Array;