@scalar/use-codemirror 0.8.2 → 0.8.3

package/dist/index.js

@@ -4,2920 +4,8 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
+import * as Y from "yjs";
 import { ref, watch, onBeforeUnmount, toValue, computed, defineComponent, toRef, openBlock, createElementBlock } from "vue";
-const create$4 = () => /* @__PURE__ */ new Map();
-const copy = (m) => {
-  const r2 = create$4();
-  m.forEach((v, k) => {
-    r2.set(k, v);
-  });
-  return r2;
-};
-const setIfUndefined = (map2, key, createT) => {
-  let set = map2.get(key);
-  if (set === void 0) {
-    map2.set(key, set = createT());
-  }
-  return set;
-};
-const map = (m, f) => {
-  const res = [];
-  for (const [key, value] of m) {
-    res.push(f(value, key));
-  }
-  return res;
-};
-const any = (m, f) => {
-  for (const [key, value] of m) {
-    if (f(value, key)) {
-      return true;
-    }
-  }
-  return false;
-};
-const create$3 = () => /* @__PURE__ */ new Set();
-const appendTo = (dest, src) => {
-  for (let i = 0; i < src.length; i++) {
-    dest.push(src[i]);
-  }
-};
-const from$1 = Array.from;
-const some = (arr, f) => {
-  for (let i = 0; i < arr.length; i++) {
-    if (f(arr[i], i, arr)) {
-      return true;
-    }
-  }
-  return false;
-};
-const isArray = Array.isArray;
-class Observable {
-  constructor() {
-    this._observers = create$4();
-  }
-  /**
-   * @param {N} name
-   * @param {function} f
-   */
-  on(name2, f) {
-    setIfUndefined(this._observers, name2, create$3).add(f);
-  }
-  /**
-   * @param {N} name
-   * @param {function} f
-   */
-  once(name2, f) {
-    const _f2 = (...args) => {
-      this.off(name2, _f2);
-      f(...args);
-    };
-    this.on(name2, _f2);
-  }
-  /**
-   * @param {N} name
-   * @param {function} f
-   */
-  off(name2, f) {
-    const observers2 = this._observers.get(name2);
-    if (observers2 !== void 0) {
-      observers2.delete(f);
-      if (observers2.size === 0) {
-        this._observers.delete(name2);
-      }
-    }
-  }
-  /**
-   * 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(name2, args) {
-    return from$1((this._observers.get(name2) || create$4()).values()).forEach((f) => f(...args));
-  }
-  destroy() {
-    this._observers = create$4();
-  }
-}
-const floor = Math.floor;
-const abs = Math.abs;
-const min = (a, b) => a < b ? a : b;
-const max = (a, b) => a > b ? a : b;
-const isNegativeZero = (n) => n !== 0 ? n < 0 : 1 / n < 0;
-const BIT1 = 1;
-const BIT2 = 2;
-const BIT3 = 4;
-const BIT4 = 8;
-const BIT6 = 32;
-const BIT7 = 64;
-const BIT8 = 128;
-const BITS5 = 31;
-const BITS6 = 63;
-const BITS7 = 127;
-const BITS31 = 2147483647;
-const isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
-const toLowerCase = (s) => s.toLowerCase();
-const trimLeftRegex = /^\s*/g;
-const trimLeft = (s) => s.replace(trimLeftRegex, "");
-const fromCamelCaseRegex = /([A-Z])/g;
-const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, (match2) => `${separator}${toLowerCase(match2)}`));
-const _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;
-};
-const utf8TextEncoder = (
-  /** @type {TextEncoder} */
-  typeof TextEncoder !== "undefined" ? new TextEncoder() : null
-);
-const _encodeUtf8Native = (str) => utf8TextEncoder.encode(str);
-const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
-let utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
-  utf8TextDecoder = null;
-}
-class Encoder {
-  constructor() {
-    this.cpos = 0;
-    this.cbuf = new Uint8Array(100);
-    this.bufs = [];
-  }
-}
-const createEncoder = () => new 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 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(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 writeUint8 = write;
-const writeVarUint = (encoder, num) => {
-  while (num > BITS7) {
-    write(encoder, BIT8 | BITS7 & num);
-    num = floor(num / 128);
-  }
-  write(encoder, BITS7 & num);
-};
-const 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);
-  }
-};
-const _strBuffer = new Uint8Array(3e4);
-const _maxStrBSize = _strBuffer.length / 3;
-const _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));
-  }
-};
-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 = utf8TextEncoder && /** @type {any} */
-utf8TextEncoder.encodeInto ? _writeVarStringNative : _writeVarStringPolyfill;
-const 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;
-  }
-};
-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 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 (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);
-  }
-};
-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;
-    }
-  }
-}
-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);
-  }
-}
-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);
-  }
-}
-const create$2 = (s) => new Error(s);
-const methodUnimplemented = () => {
-  throw create$2("Method unimplemented");
-};
-const unexpectedCase = () => {
-  throw create$2("Unexpected case");
-};
-const getRandomValues = crypto.getRandomValues.bind(crypto);
-const uint32 = () => getRandomValues(new Uint32Array(1))[0];
-const getUnixTime = Date.now;
-const undefinedToNull = (v) => v === void 0 ? null : v;
-class VarStoragePolyfill {
-  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);
-  }
-}
-let _localStorage = new VarStoragePolyfill();
-let usePolyfill = true;
-try {
-  if (typeof localStorage !== "undefined" && localStorage) {
-    _localStorage = localStorage;
-    usePolyfill = false;
-  }
-} catch (e) {
-}
-const varStorage = _localStorage;
-const callAll = (fs, args, i = 0) => {
-  try {
-    for (; i < fs.length; i++) {
-      fs[i](...args);
-    }
-  } finally {
-    if (i < fs.length) {
-      callAll(fs, args, i + 1);
-    }
-  }
-};
-const isOneOf = (value, options) => options.includes(value);
-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]";
-let params;
-const computeParams = () => {
-  if (params === void 0) {
-    if (isNode) {
-      params = create$4();
-      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$4();
-      (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$4();
-    }
-  }
-  return params;
-};
-const hasParam = (name2) => computeParams().has(name2);
-const getVariable = (name2) => isNode ? undefinedToNull(process.env[name2.toUpperCase()]) : undefinedToNull(varStorage.getItem(name2));
-const hasConf = (name2) => hasParam("--" + name2) || getVariable(name2) !== null;
-hasConf("production");
-const forceColor = isNode && isOneOf(process.env.FORCE_COLOR, ["true", "1", "2"]);
-const supportsColor = !hasParam("no-colors") && (!isNode || process.stdout.isTTY || forceColor) && (!isNode || hasParam("color") || forceColor || getVariable("COLORTERM") !== null || (getVariable("TERM") || "").includes("color"));
-class Pair {
-  /**
-   * @param {L} left
-   * @param {R} right
-   */
-  constructor(left, right) {
-    this.left = left;
-    this.right = right;
-  }
-}
-const create$1 = (left, right) => new Pair(left, right);
-const forEach = (arr, f) => arr.forEach((p) => f(p.left, p.right));
-const doc$1 = (
-  /** @type {Document} */
-  typeof document !== "undefined" ? document : {}
-);
-const createElement = (name2) => doc$1.createElement(name2);
-const createDocumentFragment = () => doc$1.createDocumentFragment();
-const createTextNode = (text2) => doc$1.createTextNode(text2);
-typeof DOMParser !== "undefined" ? new DOMParser() : null;
-const setAttributes = (el, attrs) => {
-  forEach(attrs, (key, value) => {
-    if (value === false) {
-      el.removeAttribute(key);
-    } else if (value === true) {
-      el.setAttribute(key, "");
-    } else {
-      el.setAttribute(key, value);
-    }
-  });
-  return el;
-};
-const fragment = (children) => {
-  const fragment2 = createDocumentFragment();
-  for (let i = 0; i < children.length; i++) {
-    appendChild(fragment2, children[i]);
-  }
-  return fragment2;
-};
-const append = (parent, nodes) => {
-  appendChild(parent, fragment(nodes));
-  return parent;
-};
-const element = (name2, attrs = [], children = []) => append(setAttributes(createElement(name2), attrs), children);
-const text = createTextNode;
-const mapToStyleString = (m) => map(m, (value, key) => `${key}:${value};`).join("");
-const appendChild = (parent, child) => parent.appendChild(child);
-doc$1.ELEMENT_NODE;
-doc$1.TEXT_NODE;
-doc$1.CDATA_SECTION_NODE;
-doc$1.COMMENT_NODE;
-doc$1.DOCUMENT_NODE;
-doc$1.DOCUMENT_TYPE_NODE;
-doc$1.DOCUMENT_FRAGMENT_NODE;
-const create = Symbol;
-const BOLD = create();
-const UNBOLD = create();
-const BLUE = create();
-const GREY = create();
-const GREEN = create();
-const RED = create();
-const PURPLE = create();
-const ORANGE = create();
-const UNCOLOR = create();
-const computeNoColorLoggingArgs = (args) => {
-  const logArgs = [];
-  let i = 0;
-  for (; i < args.length; i++) {
-    const arg = args[i];
-    if (arg.constructor === String || arg.constructor === Number)
-      ;
-    else if (arg.constructor === Object) {
-      logArgs.push(JSON.stringify(arg));
-    }
-  }
-  return logArgs;
-};
-const _browserStyleMap = {
-  [BOLD]: create$1("font-weight", "bold"),
-  [UNBOLD]: create$1("font-weight", "normal"),
-  [BLUE]: create$1("color", "blue"),
-  [GREEN]: create$1("color", "green"),
-  [GREY]: create$1("color", "grey"),
-  [RED]: create$1("color", "red"),
-  [PURPLE]: create$1("color", "purple"),
-  [ORANGE]: create$1("color", "orange"),
-  // not well supported in chrome when debugging node with inspector - TODO: deprecate
-  [UNCOLOR]: create$1("color", "black")
-};
-const computeBrowserLoggingArgs = (args) => {
-  const strBuilder = [];
-  const styles = [];
-  const currentStyle = create$4();
-  let logArgs = [];
-  let i = 0;
-  for (; i < args.length; i++) {
-    const arg = args[i];
-    const style = _browserStyleMap[arg];
-    if (style !== void 0) {
-      currentStyle.set(style.left, style.right);
-    } else {
-      if (arg.constructor === String || arg.constructor === Number) {
-        const style2 = mapToStyleString(currentStyle);
-        if (i > 0 || style2.length > 0) {
-          strBuilder.push("%c" + arg);
-          styles.push(style2);
-        } else {
-          strBuilder.push(arg);
-        }
-      } else {
-        break;
-      }
-    }
-  }
-  if (i > 0) {
-    logArgs = styles;
-    logArgs.unshift(strBuilder.join(""));
-  }
-  for (; i < args.length; i++) {
-    const arg = args[i];
-    if (!(arg instanceof Symbol)) {
-      logArgs.push(arg);
-    }
-  }
-  return logArgs;
-};
-const computeLoggingArgs = supportsColor ? computeBrowserLoggingArgs : computeNoColorLoggingArgs;
-const print$1 = (...args) => {
-  console.log(...computeLoggingArgs(args));
-  vconsoles.forEach((vc) => vc.print(args));
-};
-const warn = (...args) => {
-  console.warn(...computeLoggingArgs(args));
-  args.unshift(ORANGE);
-  vconsoles.forEach((vc) => vc.print(args));
-};
-const vconsoles = create$3();
-class DeleteItem {
-  /**
-   * @param {number} clock
-   * @param {number} len
-   */
-  constructor(clock, len) {
-    this.clock = clock;
-    this.len = len;
-  }
-}
-class DeleteSet {
-  constructor() {
-    this.clients = /* @__PURE__ */ new Map();
-  }
-}
-const iterateDeletedStructs = (transaction, ds, f) => ds.clients.forEach((deletes, clientid) => {
-  const structs = (
-    /** @type {Array<GC|Item>} */
-    transaction.doc.store.clients.get(clientid)
-  );
-  for (let i = 0; i < deletes.length; i++) {
-    const del = deletes[i];
-    iterateStructs(transaction, structs, del.clock, del.len, f);
-  }
-});
-const findIndexDS = (dis, clock) => {
-  let left = 0;
-  let right = dis.length - 1;
-  while (left <= right) {
-    const midindex = floor((left + right) / 2);
-    const mid = dis[midindex];
-    const midclock = mid.clock;
-    if (midclock <= clock) {
-      if (clock < midclock + mid.len) {
-        return midindex;
-      }
-      left = midindex + 1;
-    } else {
-      right = midindex - 1;
-    }
-  }
-  return null;
-};
-const isDeleted = (ds, id2) => {
-  const dis = ds.clients.get(id2.client);
-  return dis !== void 0 && findIndexDS(dis, id2.clock) !== null;
-};
-const sortAndMergeDeleteSet = (ds) => {
-  ds.clients.forEach((dels) => {
-    dels.sort((a, b) => a.clock - b.clock);
-    let i, j;
-    for (i = 1, j = 1; i < dels.length; i++) {
-      const left = dels[j - 1];
-      const right = dels[i];
-      if (left.clock + left.len >= right.clock) {
-        left.len = max(left.len, right.clock + right.len - left.clock);
-      } else {
-        if (j < i) {
-          dels[j] = right;
-        }
-        j++;
-      }
-    }
-    dels.length = j;
-  });
-};
-const mergeDeleteSets = (dss) => {
-  const merged = new DeleteSet();
-  for (let dssI = 0; dssI < dss.length; dssI++) {
-    dss[dssI].clients.forEach((delsLeft, client) => {
-      if (!merged.clients.has(client)) {
-        const dels = delsLeft.slice();
-        for (let i = dssI + 1; i < dss.length; i++) {
-          appendTo(dels, dss[i].clients.get(client) || []);
-        }
-        merged.clients.set(client, dels);
-      }
-    });
-  }
-  sortAndMergeDeleteSet(merged);
-  return merged;
-};
-const addToDeleteSet = (ds, client, clock, length2) => {
-  setIfUndefined(ds.clients, client, () => (
-    /** @type {Array<DeleteItem>} */
-    []
-  )).push(new DeleteItem(clock, length2));
-};
-const writeDeleteSet = (encoder, ds) => {
-  writeVarUint(encoder.restEncoder, ds.clients.size);
-  from$1(ds.clients.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, dsitems]) => {
-    encoder.resetDsCurVal();
-    writeVarUint(encoder.restEncoder, client);
-    const len = dsitems.length;
-    writeVarUint(encoder.restEncoder, len);
-    for (let i = 0; i < len; i++) {
-      const item = dsitems[i];
-      encoder.writeDsClock(item.clock);
-      encoder.writeDsLen(item.len);
-    }
-  });
-};
-const generateNewClientId = uint32;
-class DSEncoderV1 {
-  constructor() {
-    this.restEncoder = createEncoder();
-  }
-  toUint8Array() {
-    return toUint8Array(this.restEncoder);
-  }
-  resetDsCurVal() {
-  }
-  /**
-   * @param {number} clock
-   */
-  writeDsClock(clock) {
-    writeVarUint(this.restEncoder, clock);
-  }
-  /**
-   * @param {number} len
-   */
-  writeDsLen(len) {
-    writeVarUint(this.restEncoder, len);
-  }
-}
-class UpdateEncoderV1 extends DSEncoderV1 {
-  /**
-   * @param {ID} id
-   */
-  writeLeftID(id2) {
-    writeVarUint(this.restEncoder, id2.client);
-    writeVarUint(this.restEncoder, id2.clock);
-  }
-  /**
-   * @param {ID} id
-   */
-  writeRightID(id2) {
-    writeVarUint(this.restEncoder, id2.client);
-    writeVarUint(this.restEncoder, id2.clock);
-  }
-  /**
-   * Use writeClient and writeClock instead of writeID if possible.
-   * @param {number} client
-   */
-  writeClient(client) {
-    writeVarUint(this.restEncoder, client);
-  }
-  /**
-   * @param {number} info An unsigned 8-bit integer
-   */
-  writeInfo(info) {
-    writeUint8(this.restEncoder, info);
-  }
-  /**
-   * @param {string} s
-   */
-  writeString(s) {
-    writeVarString(this.restEncoder, s);
-  }
-  /**
-   * @param {boolean} isYKey
-   */
-  writeParentInfo(isYKey) {
-    writeVarUint(this.restEncoder, isYKey ? 1 : 0);
-  }
-  /**
-   * @param {number} info An unsigned 8-bit integer
-   */
-  writeTypeRef(info) {
-    writeVarUint(this.restEncoder, info);
-  }
-  /**
-   * Write len of a struct - well suited for Opt RLE encoder.
-   *
-   * @param {number} len
-   */
-  writeLen(len) {
-    writeVarUint(this.restEncoder, len);
-  }
-  /**
-   * @param {any} any
-   */
-  writeAny(any2) {
-    writeAny(this.restEncoder, any2);
-  }
-  /**
-   * @param {Uint8Array} buf
-   */
-  writeBuf(buf) {
-    writeVarUint8Array(this.restEncoder, buf);
-  }
-  /**
-   * @param {any} embed
-   */
-  writeJSON(embed) {
-    writeVarString(this.restEncoder, JSON.stringify(embed));
-  }
-  /**
-   * @param {string} key
-   */
-  writeKey(key) {
-    writeVarString(this.restEncoder, key);
-  }
-}
-class DSEncoderV2 {
-  constructor() {
-    this.restEncoder = createEncoder();
-    this.dsCurrVal = 0;
-  }
-  toUint8Array() {
-    return toUint8Array(this.restEncoder);
-  }
-  resetDsCurVal() {
-    this.dsCurrVal = 0;
-  }
-  /**
-   * @param {number} clock
-   */
-  writeDsClock(clock) {
-    const diff = clock - this.dsCurrVal;
-    this.dsCurrVal = clock;
-    writeVarUint(this.restEncoder, diff);
-  }
-  /**
-   * @param {number} len
-   */
-  writeDsLen(len) {
-    if (len === 0) {
-      unexpectedCase();
-    }
-    writeVarUint(this.restEncoder, len - 1);
-    this.dsCurrVal += len;
-  }
-}
-class UpdateEncoderV2 extends DSEncoderV2 {
-  constructor() {
-    super();
-    this.keyMap = /* @__PURE__ */ new Map();
-    this.keyClock = 0;
-    this.keyClockEncoder = new IntDiffOptRleEncoder();
-    this.clientEncoder = new UintOptRleEncoder();
-    this.leftClockEncoder = new IntDiffOptRleEncoder();
-    this.rightClockEncoder = new IntDiffOptRleEncoder();
-    this.infoEncoder = new RleEncoder(writeUint8);
-    this.stringEncoder = new StringEncoder();
-    this.parentInfoEncoder = new RleEncoder(writeUint8);
-    this.typeRefEncoder = new UintOptRleEncoder();
-    this.lenEncoder = new UintOptRleEncoder();
-  }
-  toUint8Array() {
-    const encoder = createEncoder();
-    writeVarUint(encoder, 0);
-    writeVarUint8Array(encoder, this.keyClockEncoder.toUint8Array());
-    writeVarUint8Array(encoder, this.clientEncoder.toUint8Array());
-    writeVarUint8Array(encoder, this.leftClockEncoder.toUint8Array());
-    writeVarUint8Array(encoder, this.rightClockEncoder.toUint8Array());
-    writeVarUint8Array(encoder, toUint8Array(this.infoEncoder));
-    writeVarUint8Array(encoder, this.stringEncoder.toUint8Array());
-    writeVarUint8Array(encoder, toUint8Array(this.parentInfoEncoder));
-    writeVarUint8Array(encoder, this.typeRefEncoder.toUint8Array());
-    writeVarUint8Array(encoder, this.lenEncoder.toUint8Array());
-    writeUint8Array(encoder, toUint8Array(this.restEncoder));
-    return toUint8Array(encoder);
-  }
-  /**
-   * @param {ID} id
-   */
-  writeLeftID(id2) {
-    this.clientEncoder.write(id2.client);
-    this.leftClockEncoder.write(id2.clock);
-  }
-  /**
-   * @param {ID} id
-   */
-  writeRightID(id2) {
-    this.clientEncoder.write(id2.client);
-    this.rightClockEncoder.write(id2.clock);
-  }
-  /**
-   * @param {number} client
-   */
-  writeClient(client) {
-    this.clientEncoder.write(client);
-  }
-  /**
-   * @param {number} info An unsigned 8-bit integer
-   */
-  writeInfo(info) {
-    this.infoEncoder.write(info);
-  }
-  /**
-   * @param {string} s
-   */
-  writeString(s) {
-    this.stringEncoder.write(s);
-  }
-  /**
-   * @param {boolean} isYKey
-   */
-  writeParentInfo(isYKey) {
-    this.parentInfoEncoder.write(isYKey ? 1 : 0);
-  }
-  /**
-   * @param {number} info An unsigned 8-bit integer
-   */
-  writeTypeRef(info) {
-    this.typeRefEncoder.write(info);
-  }
-  /**
-   * Write len of a struct - well suited for Opt RLE encoder.
-   *
-   * @param {number} len
-   */
-  writeLen(len) {
-    this.lenEncoder.write(len);
-  }
-  /**
-   * @param {any} any
-   */
-  writeAny(any2) {
-    writeAny(this.restEncoder, any2);
-  }
-  /**
-   * @param {Uint8Array} buf
-   */
-  writeBuf(buf) {
-    writeVarUint8Array(this.restEncoder, buf);
-  }
-  /**
-   * This is mainly here for legacy purposes.
-   *
-   * Initial we incoded objects using JSON. Now we use the much faster lib0/any-encoder. This method mainly exists for legacy purposes for the v1 encoder.
-   *
-   * @param {any} embed
-   */
-  writeJSON(embed) {
-    writeAny(this.restEncoder, embed);
-  }
-  /**
-   * Property keys are often reused. For example, in y-prosemirror the key `bold` might
-   * occur very often. For a 3d application, the key `position` might occur very often.
-   *
-   * We cache these keys in a Map and refer to them via a unique number.
-   *
-   * @param {string} key
-   */
-  writeKey(key) {
-    const clock = this.keyMap.get(key);
-    if (clock === void 0) {
-      this.keyClockEncoder.write(this.keyClock++);
-      this.stringEncoder.write(key);
-    } else {
-      this.keyClockEncoder.write(clock);
-    }
-  }
-}
-const writeStructs = (encoder, structs, client, clock) => {
-  clock = max(clock, structs[0].id.clock);
-  const startNewStructs = findIndexSS(structs, clock);
-  writeVarUint(encoder.restEncoder, structs.length - startNewStructs);
-  encoder.writeClient(client);
-  writeVarUint(encoder.restEncoder, clock);
-  const firstStruct = structs[startNewStructs];
-  firstStruct.write(encoder, clock - firstStruct.id.clock);
-  for (let i = startNewStructs + 1; i < structs.length; i++) {
-    structs[i].write(encoder, 0);
-  }
-};
-const writeClientsStructs = (encoder, store, _sm) => {
-  const sm = /* @__PURE__ */ new Map();
-  _sm.forEach((clock, client) => {
-    if (getState(store, client) > clock) {
-      sm.set(client, clock);
-    }
-  });
-  getStateVector(store).forEach((_clock, client) => {
-    if (!_sm.has(client)) {
-      sm.set(client, 0);
-    }
-  });
-  writeVarUint(encoder.restEncoder, sm.size);
-  from$1(sm.entries()).sort((a, b) => b[0] - a[0]).forEach(([client, clock]) => {
-    writeStructs(
-      encoder,
-      /** @type {Array<GC|Item>} */
-      store.clients.get(client),
-      client,
-      clock
-    );
-  });
-};
-const writeStructsFromTransaction = (encoder, transaction) => writeClientsStructs(encoder, transaction.doc.store, transaction.beforeState);
-const callEventHandlerListeners = (eventHandler, arg0, arg1) => callAll(eventHandler.l, [arg0, arg1]);
-class ID {
-  /**
-   * @param {number} client client id
-   * @param {number} clock unique per client id, continuous number
-   */
-  constructor(client, clock) {
-    this.client = client;
-    this.clock = clock;
-  }
-}
-const compareIDs = (a, b) => a === b || a !== null && b !== null && a.client === b.client && a.clock === b.clock;
-const createID = (client, clock) => new ID(client, clock);
-const findRootTypeKey = (type) => {
-  for (const [key, value] of type.doc.share.entries()) {
-    if (value === type) {
-      return key;
-    }
-  }
-  throw unexpectedCase();
-};
-const isParentOf = (parent, child) => {
-  while (child !== null) {
-    if (child.parent === parent) {
-      return true;
-    }
-    child = /** @type {AbstractType<any>} */
-    child.parent._item;
-  }
-  return false;
-};
-class RelativePosition {
-  /**
-   * @param {ID|null} type
-   * @param {string|null} tname
-   * @param {ID|null} item
-   * @param {number} assoc
-   */
-  constructor(type, tname, item, assoc = 0) {
-    this.type = type;
-    this.tname = tname;
-    this.item = item;
-    this.assoc = assoc;
-  }
-}
-const relativePositionToJSON = (rpos) => {
-  const json2 = {};
-  if (rpos.type) {
-    json2.type = rpos.type;
-  }
-  if (rpos.tname) {
-    json2.tname = rpos.tname;
-  }
-  if (rpos.item) {
-    json2.item = rpos.item;
-  }
-  if (rpos.assoc != null) {
-    json2.assoc = rpos.assoc;
-  }
-  return json2;
-};
-const createRelativePositionFromJSON = (json2) => new RelativePosition(json2.type == null ? null : createID(json2.type.client, json2.type.clock), json2.tname || null, json2.item == null ? null : createID(json2.item.client, json2.item.clock), json2.assoc == null ? 0 : json2.assoc);
-class AbsolutePosition {
-  /**
-   * @param {AbstractType<any>} type
-   * @param {number} index
-   * @param {number} [assoc]
-   */
-  constructor(type, index, assoc = 0) {
-    this.type = type;
-    this.index = index;
-    this.assoc = assoc;
-  }
-}
-const createAbsolutePosition = (type, index, assoc = 0) => new AbsolutePosition(type, index, assoc);
-const createRelativePosition = (type, item, assoc) => {
-  let typeid = null;
-  let tname = null;
-  if (type._item === null) {
-    tname = findRootTypeKey(type);
-  } else {
-    typeid = createID(type._item.id.client, type._item.id.clock);
-  }
-  return new RelativePosition(typeid, tname, item, assoc);
-};
-const createRelativePositionFromTypeIndex = (type, index, assoc = 0) => {
-  let t2 = type._start;
-  if (assoc < 0) {
-    if (index === 0) {
-      return createRelativePosition(type, null, assoc);
-    }
-    index--;
-  }
-  while (t2 !== null) {
-    if (!t2.deleted && t2.countable) {
-      if (t2.length > index) {
-        return createRelativePosition(type, createID(t2.id.client, t2.id.clock + index), assoc);
-      }
-      index -= t2.length;
-    }
-    if (t2.right === null && assoc < 0) {
-      return createRelativePosition(type, t2.lastId, assoc);
-    }
-    t2 = t2.right;
-  }
-  return createRelativePosition(type, null, assoc);
-};
-const createAbsolutePositionFromRelativePosition = (rpos, doc2) => {
-  const store = doc2.store;
-  const rightID = rpos.item;
-  const typeID = rpos.type;
-  const tname = rpos.tname;
-  const assoc = rpos.assoc;
-  let type = null;
-  let index = 0;
-  if (rightID !== null) {
-    if (getState(store, rightID.client) <= rightID.clock) {
-      return null;
-    }
-    const res = followRedone(store, rightID);
-    const right = res.item;
-    if (!(right instanceof Item)) {
-      return null;
-    }
-    type = /** @type {AbstractType<any>} */
-    right.parent;
-    if (type._item === null || !type._item.deleted) {
-      index = right.deleted || !right.countable ? 0 : res.diff + (assoc >= 0 ? 0 : 1);
-      let n = right.left;
-      while (n !== null) {
-        if (!n.deleted && n.countable) {
-          index += n.length;
-        }
-        n = n.left;
-      }
-    }
-  } else {
-    if (tname !== null) {
-      type = doc2.get(tname);
-    } else if (typeID !== null) {
-      if (getState(store, typeID.client) <= typeID.clock) {
-        return null;
-      }
-      const { item } = followRedone(store, typeID);
-      if (item instanceof Item && item.content instanceof ContentType) {
-        type = item.content.type;
-      } else {
-        return null;
-      }
-    } else {
-      throw unexpectedCase();
-    }
-    if (assoc >= 0) {
-      index = type._length;
-    } else {
-      index = 0;
-    }
-  }
-  return createAbsolutePosition(type, index, rpos.assoc);
-};
-const compareRelativePositions = (a, b) => a === b || a !== null && b !== null && a.tname === b.tname && compareIDs(a.item, b.item) && compareIDs(a.type, b.type) && a.assoc === b.assoc;
-const getStateVector = (store) => {
-  const sm = /* @__PURE__ */ new Map();
-  store.clients.forEach((structs, client) => {
-    const struct = structs[structs.length - 1];
-    sm.set(client, struct.id.clock + struct.length);
-  });
-  return sm;
-};
-const getState = (store, client) => {
-  const structs = store.clients.get(client);
-  if (structs === void 0) {
-    return 0;
-  }
-  const lastStruct = structs[structs.length - 1];
-  return lastStruct.id.clock + lastStruct.length;
-};
-const addStruct = (store, struct) => {
-  let structs = store.clients.get(struct.id.client);
-  if (structs === void 0) {
-    structs = [];
-    store.clients.set(struct.id.client, structs);
-  } else {
-    const lastStruct = structs[structs.length - 1];
-    if (lastStruct.id.clock + lastStruct.length !== struct.id.clock) {
-      throw unexpectedCase();
-    }
-  }
-  structs.push(struct);
-};
-const findIndexSS = (structs, clock) => {
-  let left = 0;
-  let right = structs.length - 1;
-  let mid = structs[right];
-  let midclock = mid.id.clock;
-  if (midclock === clock) {
-    return right;
-  }
-  let midindex = floor(clock / (midclock + mid.length - 1) * right);
-  while (left <= right) {
-    mid = structs[midindex];
-    midclock = mid.id.clock;
-    if (midclock <= clock) {
-      if (clock < midclock + mid.length) {
-        return midindex;
-      }
-      left = midindex + 1;
-    } else {
-      right = midindex - 1;
-    }
-    midindex = floor((left + right) / 2);
-  }
-  throw unexpectedCase();
-};
-const find$1 = (store, id2) => {
-  const structs = store.clients.get(id2.client);
-  return structs[findIndexSS(structs, id2.clock)];
-};
-const getItem = (
-  /** @type {function(StructStore,ID):Item} */
-  find$1
-);
-const findIndexCleanStart = (transaction, structs, clock) => {
-  const index = findIndexSS(structs, clock);
-  const struct = structs[index];
-  if (struct.id.clock < clock && struct instanceof Item) {
-    structs.splice(index + 1, 0, splitItem(transaction, struct, clock - struct.id.clock));
-    return index + 1;
-  }
-  return index;
-};
-const getItemCleanStart = (transaction, id2) => {
-  const structs = (
-    /** @type {Array<Item>} */
-    transaction.doc.store.clients.get(id2.client)
-  );
-  return structs[findIndexCleanStart(transaction, structs, id2.clock)];
-};
-const getItemCleanEnd = (transaction, store, id2) => {
-  const structs = store.clients.get(id2.client);
-  const index = findIndexSS(structs, id2.clock);
-  const struct = structs[index];
-  if (id2.clock !== struct.id.clock + struct.length - 1 && struct.constructor !== GC) {
-    structs.splice(index + 1, 0, splitItem(transaction, struct, id2.clock - struct.id.clock + 1));
-  }
-  return struct;
-};
-const replaceStruct = (store, struct, newStruct) => {
-  const structs = (
-    /** @type {Array<GC|Item>} */
-    store.clients.get(struct.id.client)
-  );
-  structs[findIndexSS(structs, struct.id.clock)] = newStruct;
-};
-const iterateStructs = (transaction, structs, clockStart, len, f) => {
-  if (len === 0) {
-    return;
-  }
-  const clockEnd = clockStart + len;
-  let index = findIndexCleanStart(transaction, structs, clockStart);
-  let struct;
-  do {
-    struct = structs[index++];
-    if (clockEnd < struct.id.clock + struct.length) {
-      findIndexCleanStart(transaction, structs, clockEnd);
-    }
-    f(struct);
-  } while (index < structs.length && structs[index].id.clock < clockEnd);
-};
-let Transaction$1 = class Transaction {
-  /**
-   * @param {Doc} doc
-   * @param {any} origin
-   * @param {boolean} local
-   */
-  constructor(doc2, origin, local) {
-    this.doc = doc2;
-    this.deleteSet = new DeleteSet();
-    this.beforeState = getStateVector(doc2.store);
-    this.afterState = /* @__PURE__ */ new Map();
-    this.changed = /* @__PURE__ */ new Map();
-    this.changedParentTypes = /* @__PURE__ */ new Map();
-    this._mergeStructs = [];
-    this.origin = origin;
-    this.meta = /* @__PURE__ */ new Map();
-    this.local = local;
-    this.subdocsAdded = /* @__PURE__ */ new Set();
-    this.subdocsRemoved = /* @__PURE__ */ new Set();
-    this.subdocsLoaded = /* @__PURE__ */ new Set();
-    this._needFormattingCleanup = false;
-  }
-};
-const writeUpdateMessageFromTransaction = (encoder, transaction) => {
-  if (transaction.deleteSet.clients.size === 0 && !any(transaction.afterState, (clock, client) => transaction.beforeState.get(client) !== clock)) {
-    return false;
-  }
-  sortAndMergeDeleteSet(transaction.deleteSet);
-  writeStructsFromTransaction(encoder, transaction);
-  writeDeleteSet(encoder, transaction.deleteSet);
-  return true;
-};
-const addChangedTypeToTransaction = (transaction, type, parentSub) => {
-  const item = type._item;
-  if (item === null || item.id.clock < (transaction.beforeState.get(item.id.client) || 0) && !item.deleted) {
-    setIfUndefined(transaction.changed, type, create$3).add(parentSub);
-  }
-};
-const tryToMergeWithLefts = (structs, pos) => {
-  let right = structs[pos];
-  let left = structs[pos - 1];
-  let i = pos;
-  for (; i > 0; right = left, left = structs[--i - 1]) {
-    if (left.deleted === right.deleted && left.constructor === right.constructor) {
-      if (left.mergeWith(right)) {
-        if (right instanceof Item && right.parentSub !== null && /** @type {AbstractType<any>} */
-        right.parent._map.get(right.parentSub) === right) {
-          right.parent._map.set(
-            right.parentSub,
-            /** @type {Item} */
-            left
-          );
-        }
-        continue;
-      }
-    }
-    break;
-  }
-  const merged = pos - i;
-  if (merged) {
-    structs.splice(pos + 1 - merged, merged);
-  }
-  return merged;
-};
-const tryGcDeleteSet = (ds, store, gcFilter) => {
-  for (const [client, deleteItems] of ds.clients.entries()) {
-    const structs = (
-      /** @type {Array<GC|Item>} */
-      store.clients.get(client)
-    );
-    for (let di = deleteItems.length - 1; di >= 0; di--) {
-      const deleteItem = deleteItems[di];
-      const endDeleteItemClock = deleteItem.clock + deleteItem.len;
-      for (let si = findIndexSS(structs, deleteItem.clock), struct = structs[si]; si < structs.length && struct.id.clock < endDeleteItemClock; struct = structs[++si]) {
-        const struct2 = structs[si];
-        if (deleteItem.clock + deleteItem.len <= struct2.id.clock) {
-          break;
-        }
-        if (struct2 instanceof Item && struct2.deleted && !struct2.keep && gcFilter(struct2)) {
-          struct2.gc(store, false);
-        }
-      }
-    }
-  }
-};
-const tryMergeDeleteSet = (ds, store) => {
-  ds.clients.forEach((deleteItems, client) => {
-    const structs = (
-      /** @type {Array<GC|Item>} */
-      store.clients.get(client)
-    );
-    for (let di = deleteItems.length - 1; di >= 0; di--) {
-      const deleteItem = deleteItems[di];
-      const mostRightIndexToCheck = min(structs.length - 1, 1 + findIndexSS(structs, deleteItem.clock + deleteItem.len - 1));
-      for (let si = mostRightIndexToCheck, struct = structs[si]; si > 0 && struct.id.clock >= deleteItem.clock; struct = structs[si]) {
-        si -= 1 + tryToMergeWithLefts(structs, si);
-      }
-    }
-  });
-};
-const cleanupTransactions = (transactionCleanups, i) => {
-  if (i < transactionCleanups.length) {
-    const transaction = transactionCleanups[i];
-    const doc2 = transaction.doc;
-    const store = doc2.store;
-    const ds = transaction.deleteSet;
-    const mergeStructs = transaction._mergeStructs;
-    try {
-      sortAndMergeDeleteSet(ds);
-      transaction.afterState = getStateVector(transaction.doc.store);
-      doc2.emit("beforeObserverCalls", [transaction, doc2]);
-      const fs = [];
-      transaction.changed.forEach(
-        (subs, itemtype) => fs.push(() => {
-          if (itemtype._item === null || !itemtype._item.deleted) {
-            itemtype._callObserver(transaction, subs);
-          }
-        })
-      );
-      fs.push(() => {
-        transaction.changedParentTypes.forEach((events, type) => {
-          if (type._dEH.l.length > 0 && (type._item === null || !type._item.deleted)) {
-            events = events.filter(
-              (event) => event.target._item === null || !event.target._item.deleted
-            );
-            events.forEach((event) => {
-              event.currentTarget = type;
-              event._path = null;
-            });
-            events.sort((event1, event2) => event1.path.length - event2.path.length);
-            callEventHandlerListeners(type._dEH, events, transaction);
-          }
-        });
-      });
-      fs.push(() => doc2.emit("afterTransaction", [transaction, doc2]));
-      callAll(fs, []);
-      if (transaction._needFormattingCleanup) {
-        cleanupYTextAfterTransaction(transaction);
-      }
-    } finally {
-      if (doc2.gc) {
-        tryGcDeleteSet(ds, store, doc2.gcFilter);
-      }
-      tryMergeDeleteSet(ds, store);
-      transaction.afterState.forEach((clock, client) => {
-        const beforeClock = transaction.beforeState.get(client) || 0;
-        if (beforeClock !== clock) {
-          const structs = (
-            /** @type {Array<GC|Item>} */
-            store.clients.get(client)
-          );
-          const firstChangePos = max(findIndexSS(structs, beforeClock), 1);
-          for (let i2 = structs.length - 1; i2 >= firstChangePos; ) {
-            i2 -= 1 + tryToMergeWithLefts(structs, i2);
-          }
-        }
-      });
-      for (let i2 = mergeStructs.length - 1; i2 >= 0; i2--) {
-        const { client, clock } = mergeStructs[i2].id;
-        const structs = (
-          /** @type {Array<GC|Item>} */
-          store.clients.get(client)
-        );
-        const replacedStructPos = findIndexSS(structs, clock);
-        if (replacedStructPos + 1 < structs.length) {
-          if (tryToMergeWithLefts(structs, replacedStructPos + 1) > 1) {
-            continue;
-          }
-        }
-        if (replacedStructPos > 0) {
-          tryToMergeWithLefts(structs, replacedStructPos);
-        }
-      }
-      if (!transaction.local && transaction.afterState.get(doc2.clientID) !== transaction.beforeState.get(doc2.clientID)) {
-        print$1(ORANGE, BOLD, "[yjs] ", UNBOLD, RED, "Changed the client-id because another client seems to be using it.");
-        doc2.clientID = generateNewClientId();
-      }
-      doc2.emit("afterTransactionCleanup", [transaction, doc2]);
-      if (doc2._observers.has("update")) {
-        const encoder = new UpdateEncoderV1();
-        const hasContent = writeUpdateMessageFromTransaction(encoder, transaction);
-        if (hasContent) {
-          doc2.emit("update", [encoder.toUint8Array(), transaction.origin, doc2, transaction]);
-        }
-      }
-      if (doc2._observers.has("updateV2")) {
-        const encoder = new UpdateEncoderV2();
-        const hasContent = writeUpdateMessageFromTransaction(encoder, transaction);
-        if (hasContent) {
-          doc2.emit("updateV2", [encoder.toUint8Array(), transaction.origin, doc2, transaction]);
-        }
-      }
-      const { subdocsAdded, subdocsLoaded, subdocsRemoved } = transaction;
-      if (subdocsAdded.size > 0 || subdocsRemoved.size > 0 || subdocsLoaded.size > 0) {
-        subdocsAdded.forEach((subdoc) => {
-          subdoc.clientID = doc2.clientID;
-          if (subdoc.collectionid == null) {
-            subdoc.collectionid = doc2.collectionid;
-          }
-          doc2.subdocs.add(subdoc);
-        });
-        subdocsRemoved.forEach((subdoc) => doc2.subdocs.delete(subdoc));
-        doc2.emit("subdocs", [{ loaded: subdocsLoaded, added: subdocsAdded, removed: subdocsRemoved }, doc2, transaction]);
-        subdocsRemoved.forEach((subdoc) => subdoc.destroy());
-      }
-      if (transactionCleanups.length <= i + 1) {
-        doc2._transactionCleanups = [];
-        doc2.emit("afterAllTransactions", [doc2, transactionCleanups]);
-      } else {
-        cleanupTransactions(transactionCleanups, i + 1);
-      }
-    }
-  }
-};
-const transact = (doc2, f, origin = null, local = true) => {
-  const transactionCleanups = doc2._transactionCleanups;
-  let initialCall = false;
-  let result = null;
-  if (doc2._transaction === null) {
-    initialCall = true;
-    doc2._transaction = new Transaction$1(doc2, origin, local);
-    transactionCleanups.push(doc2._transaction);
-    if (transactionCleanups.length === 1) {
-      doc2.emit("beforeAllTransactions", [doc2]);
-    }
-    doc2.emit("beforeTransaction", [doc2._transaction, doc2]);
-  }
-  try {
-    result = f(doc2._transaction);
-  } finally {
-    if (initialCall) {
-      const finishCleanup = doc2._transaction === transactionCleanups[0];
-      doc2._transaction = null;
-      if (finishCleanup) {
-        cleanupTransactions(transactionCleanups, 0);
-      }
-    }
-  }
-  return result;
-};
-class StackItem {
-  /**
-   * @param {DeleteSet} deletions
-   * @param {DeleteSet} insertions
-   */
-  constructor(deletions, insertions) {
-    this.insertions = insertions;
-    this.deletions = deletions;
-    this.meta = /* @__PURE__ */ new Map();
-  }
-}
-const clearUndoManagerStackItem = (tr, um, stackItem) => {
-  iterateDeletedStructs(tr, stackItem.deletions, (item) => {
-    if (item instanceof Item && um.scope.some((type) => isParentOf(type, item))) {
-      keepItem(item, false);
-    }
-  });
-};
-const popStackItem = (undoManager, stack, eventType) => {
-  let result = null;
-  let _tr = null;
-  const doc2 = undoManager.doc;
-  const scope = undoManager.scope;
-  transact(doc2, (transaction) => {
-    while (stack.length > 0 && result === null) {
-      const store = doc2.store;
-      const stackItem = (
-        /** @type {StackItem} */
-        stack.pop()
-      );
-      const itemsToRedo = /* @__PURE__ */ new Set();
-      const itemsToDelete = [];
-      let performedChange = false;
-      iterateDeletedStructs(transaction, stackItem.insertions, (struct) => {
-        if (struct instanceof Item) {
-          if (struct.redone !== null) {
-            let { item, diff } = followRedone(store, struct.id);
-            if (diff > 0) {
-              item = getItemCleanStart(transaction, createID(item.id.client, item.id.clock + diff));
-            }
-            struct = item;
-          }
-          if (!struct.deleted && scope.some((type) => isParentOf(
-            type,
-            /** @type {Item} */
-            struct
-          ))) {
-            itemsToDelete.push(struct);
-          }
-        }
-      });
-      iterateDeletedStructs(transaction, stackItem.deletions, (struct) => {
-        if (struct instanceof Item && scope.some((type) => isParentOf(type, struct)) && // Never redo structs in stackItem.insertions because they were created and deleted in the same capture interval.
-        !isDeleted(stackItem.insertions, struct.id)) {
-          itemsToRedo.add(struct);
-        }
-      });
-      itemsToRedo.forEach((struct) => {
-        performedChange = redoItem(transaction, struct, itemsToRedo, stackItem.insertions, undoManager.ignoreRemoteMapChanges, undoManager) !== null || performedChange;
-      });
-      for (let i = itemsToDelete.length - 1; i >= 0; i--) {
-        const item = itemsToDelete[i];
-        if (undoManager.deleteFilter(item)) {
-          item.delete(transaction);
-          performedChange = true;
-        }
-      }
-      result = performedChange ? stackItem : null;
-    }
-    transaction.changed.forEach((subProps, type) => {
-      if (subProps.has(null) && type._searchMarker) {
-        type._searchMarker.length = 0;
-      }
-    });
-    _tr = transaction;
-  }, undoManager);
-  if (result != null) {
-    const changedParentTypes = _tr.changedParentTypes;
-    undoManager.emit("stack-item-popped", [{ stackItem: result, type: eventType, changedParentTypes }, undoManager]);
-  }
-  return result;
-};
-class UndoManager extends Observable {
-  /**
-   * @param {AbstractType<any>|Array<AbstractType<any>>} typeScope Accepts either a single type, or an array of types
-   * @param {UndoManagerOptions} options
-   */
-  constructor(typeScope, {
-    captureTimeout = 500,
-    captureTransaction = (_tr) => true,
-    deleteFilter = () => true,
-    trackedOrigins = /* @__PURE__ */ new Set([null]),
-    ignoreRemoteMapChanges = false,
-    doc: doc2 = (
-      /** @type {Doc} */
-      isArray(typeScope) ? typeScope[0].doc : typeScope.doc
-    )
-  } = {}) {
-    super();
-    this.scope = [];
-    this.doc = doc2;
-    this.addToScope(typeScope);
-    this.deleteFilter = deleteFilter;
-    trackedOrigins.add(this);
-    this.trackedOrigins = trackedOrigins;
-    this.captureTransaction = captureTransaction;
-    this.undoStack = [];
-    this.redoStack = [];
-    this.undoing = false;
-    this.redoing = false;
-    this.lastChange = 0;
-    this.ignoreRemoteMapChanges = ignoreRemoteMapChanges;
-    this.captureTimeout = captureTimeout;
-    this.afterTransactionHandler = (transaction) => {
-      if (!this.captureTransaction(transaction) || !this.scope.some((type) => transaction.changedParentTypes.has(type)) || !this.trackedOrigins.has(transaction.origin) && (!transaction.origin || !this.trackedOrigins.has(transaction.origin.constructor))) {
-        return;
-      }
-      const undoing = this.undoing;
-      const redoing = this.redoing;
-      const stack = undoing ? this.redoStack : this.undoStack;
-      if (undoing) {
-        this.stopCapturing();
-      } else if (!redoing) {
-        this.clear(false, true);
-      }
-      const insertions = new DeleteSet();
-      transaction.afterState.forEach((endClock, client) => {
-        const startClock = transaction.beforeState.get(client) || 0;
-        const len = endClock - startClock;
-        if (len > 0) {
-          addToDeleteSet(insertions, client, startClock, len);
-        }
-      });
-      const now = getUnixTime();
-      let didAdd = false;
-      if (this.lastChange > 0 && now - this.lastChange < this.captureTimeout && stack.length > 0 && !undoing && !redoing) {
-        const lastOp = stack[stack.length - 1];
-        lastOp.deletions = mergeDeleteSets([lastOp.deletions, transaction.deleteSet]);
-        lastOp.insertions = mergeDeleteSets([lastOp.insertions, insertions]);
-      } else {
-        stack.push(new StackItem(transaction.deleteSet, insertions));
-        didAdd = true;
-      }
-      if (!undoing && !redoing) {
-        this.lastChange = now;
-      }
-      iterateDeletedStructs(
-        transaction,
-        transaction.deleteSet,
-        /** @param {Item|GC} item */
-        (item) => {
-          if (item instanceof Item && this.scope.some((type) => isParentOf(type, item))) {
-            keepItem(item, true);
-          }
-        }
-      );
-      const changeEvent = [{ stackItem: stack[stack.length - 1], origin: transaction.origin, type: undoing ? "redo" : "undo", changedParentTypes: transaction.changedParentTypes }, this];
-      if (didAdd) {
-        this.emit("stack-item-added", changeEvent);
-      } else {
-        this.emit("stack-item-updated", changeEvent);
-      }
-    };
-    this.doc.on("afterTransaction", this.afterTransactionHandler);
-    this.doc.on("destroy", () => {
-      this.destroy();
-    });
-  }
-  /**
-   * @param {Array<AbstractType<any>> | AbstractType<any>} ytypes
-   */
-  addToScope(ytypes) {
-    ytypes = isArray(ytypes) ? ytypes : [ytypes];
-    ytypes.forEach((ytype) => {
-      if (this.scope.every((yt) => yt !== ytype)) {
-        if (ytype.doc !== this.doc)
-          warn("[yjs#509] Not same Y.Doc");
-        this.scope.push(ytype);
-      }
-    });
-  }
-  /**
-   * @param {any} origin
-   */
-  addTrackedOrigin(origin) {
-    this.trackedOrigins.add(origin);
-  }
-  /**
-   * @param {any} origin
-   */
-  removeTrackedOrigin(origin) {
-    this.trackedOrigins.delete(origin);
-  }
-  clear(clearUndoStack = true, clearRedoStack = true) {
-    if (clearUndoStack && this.canUndo() || clearRedoStack && this.canRedo()) {
-      this.doc.transact((tr) => {
-        if (clearUndoStack) {
-          this.undoStack.forEach((item) => clearUndoManagerStackItem(tr, this, item));
-          this.undoStack = [];
-        }
-        if (clearRedoStack) {
-          this.redoStack.forEach((item) => clearUndoManagerStackItem(tr, this, item));
-          this.redoStack = [];
-        }
-        this.emit("stack-cleared", [{ undoStackCleared: clearUndoStack, redoStackCleared: clearRedoStack }]);
-      });
-    }
-  }
-  /**
-   * UndoManager merges Undo-StackItem if they are created within time-gap
-   * smaller than `options.captureTimeout`. Call `um.stopCapturing()` so that the next
-   * StackItem won't be merged.
-   *
-   *
-   * @example
-   *     // without stopCapturing
-   *     ytext.insert(0, 'a')
-   *     ytext.insert(1, 'b')
-   *     um.undo()
-   *     ytext.toString() // => '' (note that 'ab' was removed)
-   *     // with stopCapturing
-   *     ytext.insert(0, 'a')
-   *     um.stopCapturing()
-   *     ytext.insert(0, 'b')
-   *     um.undo()
-   *     ytext.toString() // => 'a' (note that only 'b' was removed)
-   *
-   */
-  stopCapturing() {
-    this.lastChange = 0;
-  }
-  /**
-   * Undo last changes on type.
-   *
-   * @return {StackItem?} Returns StackItem if a change was applied
-   */
-  undo() {
-    this.undoing = true;
-    let res;
-    try {
-      res = popStackItem(this, this.undoStack, "undo");
-    } finally {
-      this.undoing = false;
-    }
-    return res;
-  }
-  /**
-   * Redo last undo operation.
-   *
-   * @return {StackItem?} Returns StackItem if a change was applied
-   */
-  redo() {
-    this.redoing = true;
-    let res;
-    try {
-      res = popStackItem(this, this.redoStack, "redo");
-    } finally {
-      this.redoing = false;
-    }
-    return res;
-  }
-  /**
-   * Are undo steps available?
-   *
-   * @return {boolean} `true` if undo is possible
-   */
-  canUndo() {
-    return this.undoStack.length > 0;
-  }
-  /**
-   * Are redo steps available?
-   *
-   * @return {boolean} `true` if redo is possible
-   */
-  canRedo() {
-    return this.redoStack.length > 0;
-  }
-  destroy() {
-    this.trackedOrigins.delete(this);
-    this.doc.off("afterTransaction", this.afterTransactionHandler);
-    super.destroy();
-  }
-}
-const updateCurrentAttributes = (currentAttributes, format) => {
-  const { key, value } = format;
-  if (value === null) {
-    currentAttributes.delete(key);
-  } else {
-    currentAttributes.set(key, value);
-  }
-};
-const cleanupFormattingGap = (transaction, start2, curr, startAttributes, currAttributes) => {
-  let end = start2;
-  const endFormats = create$4();
-  while (end && (!end.countable || end.deleted)) {
-    if (!end.deleted && end.content.constructor === ContentFormat) {
-      const cf = (
-        /** @type {ContentFormat} */
-        end.content
-      );
-      endFormats.set(cf.key, cf);
-    }
-    end = end.right;
-  }
-  let cleanups = 0;
-  let reachedCurr = false;
-  while (start2 !== end) {
-    if (curr === start2) {
-      reachedCurr = true;
-    }
-    if (!start2.deleted) {
-      const content2 = start2.content;
-      switch (content2.constructor) {
-        case ContentFormat: {
-          const { key, value } = (
-            /** @type {ContentFormat} */
-            content2
-          );
-          const startAttrValue = startAttributes.get(key) || null;
-          if (endFormats.get(key) !== content2 || startAttrValue === value) {
-            start2.delete(transaction);
-            cleanups++;
-            if (!reachedCurr && (currAttributes.get(key) || null) === value && startAttrValue !== value) {
-              if (startAttrValue === null) {
-                currAttributes.delete(key);
-              } else {
-                currAttributes.set(key, startAttrValue);
-              }
-            }
-          }
-          if (!reachedCurr && !start2.deleted) {
-            updateCurrentAttributes(
-              currAttributes,
-              /** @type {ContentFormat} */
-              content2
-            );
-          }
-          break;
-        }
-      }
-    }
-    start2 = /** @type {Item} */
-    start2.right;
-  }
-  return cleanups;
-};
-const cleanupContextlessFormattingGap = (transaction, item) => {
-  while (item && item.right && (item.right.deleted || !item.right.countable)) {
-    item = item.right;
-  }
-  const attrs = /* @__PURE__ */ new Set();
-  while (item && (item.deleted || !item.countable)) {
-    if (!item.deleted && item.content.constructor === ContentFormat) {
-      const key = (
-        /** @type {ContentFormat} */
-        item.content.key
-      );
-      if (attrs.has(key)) {
-        item.delete(transaction);
-      } else {
-        attrs.add(key);
-      }
-    }
-    item = item.left;
-  }
-};
-const cleanupYTextFormatting = (type) => {
-  let res = 0;
-  transact(
-    /** @type {Doc} */
-    type.doc,
-    (transaction) => {
-      let start2 = (
-        /** @type {Item} */
-        type._start
-      );
-      let end = type._start;
-      let startAttributes = create$4();
-      const currentAttributes = copy(startAttributes);
-      while (end) {
-        if (end.deleted === false) {
-          switch (end.content.constructor) {
-            case ContentFormat:
-              updateCurrentAttributes(
-                currentAttributes,
-                /** @type {ContentFormat} */
-                end.content
-              );
-              break;
-            default:
-              res += cleanupFormattingGap(transaction, start2, end, startAttributes, currentAttributes);
-              startAttributes = copy(currentAttributes);
-              start2 = end;
-              break;
-          }
-        }
-        end = end.right;
-      }
-    }
-  );
-  return res;
-};
-const cleanupYTextAfterTransaction = (transaction) => {
-  const needFullCleanup = /* @__PURE__ */ new Set();
-  const doc2 = transaction.doc;
-  for (const [client, afterClock] of transaction.afterState.entries()) {
-    const clock = transaction.beforeState.get(client) || 0;
-    if (afterClock === clock) {
-      continue;
-    }
-    iterateStructs(
-      transaction,
-      /** @type {Array<Item|GC>} */
-      doc2.store.clients.get(client),
-      clock,
-      afterClock,
-      (item) => {
-        if (!item.deleted && /** @type {Item} */
-        item.content.constructor === ContentFormat && item.constructor !== GC) {
-          needFullCleanup.add(
-            /** @type {any} */
-            item.parent
-          );
-        }
-      }
-    );
-  }
-  transact(doc2, (t2) => {
-    iterateDeletedStructs(transaction, transaction.deleteSet, (item) => {
-      if (item instanceof GC || !/** @type {YText} */
-      item.parent._hasFormatting || needFullCleanup.has(
-        /** @type {YText} */
-        item.parent
-      )) {
-        return;
-      }
-      const parent = (
-        /** @type {YText} */
-        item.parent
-      );
-      if (item.content.constructor === ContentFormat) {
-        needFullCleanup.add(parent);
-      } else {
-        cleanupContextlessFormattingGap(t2, item);
-      }
-    });
-    for (const yText of needFullCleanup) {
-      cleanupYTextFormatting(yText);
-    }
-  });
-};
-class AbstractStruct {
-  /**
-   * @param {ID} id
-   * @param {number} length
-   */
-  constructor(id2, length2) {
-    this.id = id2;
-    this.length = length2;
-  }
-  /**
-   * @type {boolean}
-   */
-  get deleted() {
-    throw methodUnimplemented();
-  }
-  /**
-   * Merge this struct with the item to the right.
-   * This method is already assuming that `this.id.clock + this.length === this.id.clock`.
-   * Also this method does *not* remove right from StructStore!
-   * @param {AbstractStruct} right
-   * @return {boolean} wether this merged with right
-   */
-  mergeWith(right) {
-    return false;
-  }
-  /**
-   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.
-   * @param {number} offset
-   * @param {number} encodingRef
-   */
-  write(encoder, offset, encodingRef) {
-    throw methodUnimplemented();
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {number} offset
-   */
-  integrate(transaction, offset) {
-    throw methodUnimplemented();
-  }
-}
-const structGCRefNumber = 0;
-class GC extends AbstractStruct {
-  get deleted() {
-    return true;
-  }
-  delete() {
-  }
-  /**
-   * @param {GC} right
-   * @return {boolean}
-   */
-  mergeWith(right) {
-    if (this.constructor !== right.constructor) {
-      return false;
-    }
-    this.length += right.length;
-    return true;
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {number} offset
-   */
-  integrate(transaction, offset) {
-    if (offset > 0) {
-      this.id.clock += offset;
-      this.length -= offset;
-    }
-    addStruct(transaction.doc.store, this);
-  }
-  /**
-   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
-   * @param {number} offset
-   */
-  write(encoder, offset) {
-    encoder.writeInfo(structGCRefNumber);
-    encoder.writeLen(this.length - offset);
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @return {null | number}
-   */
-  getMissing(transaction, store) {
-    return null;
-  }
-}
-class ContentDeleted {
-  /**
-   * @param {number} len
-   */
-  constructor(len) {
-    this.len = len;
-  }
-  /**
-   * @return {number}
-   */
-  getLength() {
-    return this.len;
-  }
-  /**
-   * @return {Array<any>}
-   */
-  getContent() {
-    return [];
-  }
-  /**
-   * @return {boolean}
-   */
-  isCountable() {
-    return false;
-  }
-  /**
-   * @return {ContentDeleted}
-   */
-  copy() {
-    return new ContentDeleted(this.len);
-  }
-  /**
-   * @param {number} offset
-   * @return {ContentDeleted}
-   */
-  splice(offset) {
-    const right = new ContentDeleted(this.len - offset);
-    this.len = offset;
-    return right;
-  }
-  /**
-   * @param {ContentDeleted} right
-   * @return {boolean}
-   */
-  mergeWith(right) {
-    this.len += right.len;
-    return true;
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
-   */
-  integrate(transaction, item) {
-    addToDeleteSet(transaction.deleteSet, item.id.client, item.id.clock, this.len);
-    item.markDeleted();
-  }
-  /**
-   * @param {Transaction} transaction
-   */
-  delete(transaction) {
-  }
-  /**
-   * @param {StructStore} store
-   */
-  gc(store) {
-  }
-  /**
-   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
-   * @param {number} offset
-   */
-  write(encoder, offset) {
-    encoder.writeLen(this.len - offset);
-  }
-  /**
-   * @return {number}
-   */
-  getRef() {
-    return 1;
-  }
-}
-class ContentFormat {
-  /**
-   * @param {string} key
-   * @param {Object} value
-   */
-  constructor(key, value) {
-    this.key = key;
-    this.value = value;
-  }
-  /**
-   * @return {number}
-   */
-  getLength() {
-    return 1;
-  }
-  /**
-   * @return {Array<any>}
-   */
-  getContent() {
-    return [];
-  }
-  /**
-   * @return {boolean}
-   */
-  isCountable() {
-    return false;
-  }
-  /**
-   * @return {ContentFormat}
-   */
-  copy() {
-    return new ContentFormat(this.key, this.value);
-  }
-  /**
-   * @param {number} _offset
-   * @return {ContentFormat}
-   */
-  splice(_offset) {
-    throw methodUnimplemented();
-  }
-  /**
-   * @param {ContentFormat} _right
-   * @return {boolean}
-   */
-  mergeWith(_right) {
-    return false;
-  }
-  /**
-   * @param {Transaction} _transaction
-   * @param {Item} item
-   */
-  integrate(_transaction, item) {
-    const p = (
-      /** @type {YText} */
-      item.parent
-    );
-    p._searchMarker = null;
-    p._hasFormatting = true;
-  }
-  /**
-   * @param {Transaction} transaction
-   */
-  delete(transaction) {
-  }
-  /**
-   * @param {StructStore} store
-   */
-  gc(store) {
-  }
-  /**
-   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
-   * @param {number} offset
-   */
-  write(encoder, offset) {
-    encoder.writeKey(this.key);
-    encoder.writeJSON(this.value);
-  }
-  /**
-   * @return {number}
-   */
-  getRef() {
-    return 6;
-  }
-}
-class ContentType {
-  /**
-   * @param {AbstractType<any>} type
-   */
-  constructor(type) {
-    this.type = type;
-  }
-  /**
-   * @return {number}
-   */
-  getLength() {
-    return 1;
-  }
-  /**
-   * @return {Array<any>}
-   */
-  getContent() {
-    return [this.type];
-  }
-  /**
-   * @return {boolean}
-   */
-  isCountable() {
-    return true;
-  }
-  /**
-   * @return {ContentType}
-   */
-  copy() {
-    return new ContentType(this.type._copy());
-  }
-  /**
-   * @param {number} offset
-   * @return {ContentType}
-   */
-  splice(offset) {
-    throw methodUnimplemented();
-  }
-  /**
-   * @param {ContentType} right
-   * @return {boolean}
-   */
-  mergeWith(right) {
-    return false;
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {Item} item
-   */
-  integrate(transaction, item) {
-    this.type._integrate(transaction.doc, item);
-  }
-  /**
-   * @param {Transaction} transaction
-   */
-  delete(transaction) {
-    let item = this.type._start;
-    while (item !== null) {
-      if (!item.deleted) {
-        item.delete(transaction);
-      } else if (item.id.clock < (transaction.beforeState.get(item.id.client) || 0)) {
-        transaction._mergeStructs.push(item);
-      }
-      item = item.right;
-    }
-    this.type._map.forEach((item2) => {
-      if (!item2.deleted) {
-        item2.delete(transaction);
-      } else if (item2.id.clock < (transaction.beforeState.get(item2.id.client) || 0)) {
-        transaction._mergeStructs.push(item2);
-      }
-    });
-    transaction.changed.delete(this.type);
-  }
-  /**
-   * @param {StructStore} store
-   */
-  gc(store) {
-    let item = this.type._start;
-    while (item !== null) {
-      item.gc(store, true);
-      item = item.right;
-    }
-    this.type._start = null;
-    this.type._map.forEach(
-      /** @param {Item | null} item */
-      (item2) => {
-        while (item2 !== null) {
-          item2.gc(store, true);
-          item2 = item2.left;
-        }
-      }
-    );
-    this.type._map = /* @__PURE__ */ new Map();
-  }
-  /**
-   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder
-   * @param {number} offset
-   */
-  write(encoder, offset) {
-    this.type._write(encoder);
-  }
-  /**
-   * @return {number}
-   */
-  getRef() {
-    return 7;
-  }
-}
-const followRedone = (store, id2) => {
-  let nextID2 = id2;
-  let diff = 0;
-  let item;
-  do {
-    if (diff > 0) {
-      nextID2 = createID(nextID2.client, nextID2.clock + diff);
-    }
-    item = getItem(store, nextID2);
-    diff = nextID2.clock - item.id.clock;
-    nextID2 = item.redone;
-  } while (nextID2 !== null && item instanceof Item);
-  return {
-    item,
-    diff
-  };
-};
-const keepItem = (item, keep) => {
-  while (item !== null && item.keep !== keep) {
-    item.keep = keep;
-    item = /** @type {AbstractType<any>} */
-    item.parent._item;
-  }
-};
-const splitItem = (transaction, leftItem, diff) => {
-  const { client, clock } = leftItem.id;
-  const rightItem = new Item(
-    createID(client, clock + diff),
-    leftItem,
-    createID(client, clock + diff - 1),
-    leftItem.right,
-    leftItem.rightOrigin,
-    leftItem.parent,
-    leftItem.parentSub,
-    leftItem.content.splice(diff)
-  );
-  if (leftItem.deleted) {
-    rightItem.markDeleted();
-  }
-  if (leftItem.keep) {
-    rightItem.keep = true;
-  }
-  if (leftItem.redone !== null) {
-    rightItem.redone = createID(leftItem.redone.client, leftItem.redone.clock + diff);
-  }
-  leftItem.right = rightItem;
-  if (rightItem.right !== null) {
-    rightItem.right.left = rightItem;
-  }
-  transaction._mergeStructs.push(rightItem);
-  if (rightItem.parentSub !== null && rightItem.right === null) {
-    rightItem.parent._map.set(rightItem.parentSub, rightItem);
-  }
-  leftItem.length = diff;
-  return rightItem;
-};
-const isDeletedByUndoStack = (stack, id2) => some(
-  stack,
-  /** @param {StackItem} s */
-  (s) => isDeleted(s.deletions, id2)
-);
-const redoItem = (transaction, item, redoitems, itemsToDelete, ignoreRemoteMapChanges, um) => {
-  const doc2 = transaction.doc;
-  const store = doc2.store;
-  const ownClientID = doc2.clientID;
-  const redone = item.redone;
-  if (redone !== null) {
-    return getItemCleanStart(transaction, redone);
-  }
-  let parentItem = (
-    /** @type {AbstractType<any>} */
-    item.parent._item
-  );
-  let left = null;
-  let right;
-  if (parentItem !== null && parentItem.deleted === true) {
-    if (parentItem.redone === null && (!redoitems.has(parentItem) || redoItem(transaction, parentItem, redoitems, itemsToDelete, ignoreRemoteMapChanges, um) === null)) {
-      return null;
-    }
-    while (parentItem.redone !== null) {
-      parentItem = getItemCleanStart(transaction, parentItem.redone);
-    }
-  }
-  const parentType = parentItem === null ? (
-    /** @type {AbstractType<any>} */
-    item.parent
-  ) : (
-    /** @type {ContentType} */
-    parentItem.content.type
-  );
-  if (item.parentSub === null) {
-    left = item.left;
-    right = item;
-    while (left !== null) {
-      let leftTrace = left;
-      while (leftTrace !== null && /** @type {AbstractType<any>} */
-      leftTrace.parent._item !== parentItem) {
-        leftTrace = leftTrace.redone === null ? null : getItemCleanStart(transaction, leftTrace.redone);
-      }
-      if (leftTrace !== null && /** @type {AbstractType<any>} */
-      leftTrace.parent._item === parentItem) {
-        left = leftTrace;
-        break;
-      }
-      left = left.left;
-    }
-    while (right !== null) {
-      let rightTrace = right;
-      while (rightTrace !== null && /** @type {AbstractType<any>} */
-      rightTrace.parent._item !== parentItem) {
-        rightTrace = rightTrace.redone === null ? null : getItemCleanStart(transaction, rightTrace.redone);
-      }
-      if (rightTrace !== null && /** @type {AbstractType<any>} */
-      rightTrace.parent._item === parentItem) {
-        right = rightTrace;
-        break;
-      }
-      right = right.right;
-    }
-  } else {
-    right = null;
-    if (item.right && !ignoreRemoteMapChanges) {
-      left = item;
-      while (left !== null && left.right !== null && (left.right.redone || isDeleted(itemsToDelete, left.right.id) || isDeletedByUndoStack(um.undoStack, left.right.id) || isDeletedByUndoStack(um.redoStack, left.right.id))) {
-        left = left.right;
-        while (left.redone)
-          left = getItemCleanStart(transaction, left.redone);
-      }
-      if (left && left.right !== null) {
-        return null;
-      }
-    } else {
-      left = parentType._map.get(item.parentSub) || null;
-    }
-  }
-  const nextClock = getState(store, ownClientID);
-  const nextId = createID(ownClientID, nextClock);
-  const redoneItem = new Item(
-    nextId,
-    left,
-    left && left.lastId,
-    right,
-    right && right.id,
-    parentType,
-    item.parentSub,
-    item.content.copy()
-  );
-  item.redone = nextId;
-  keepItem(redoneItem, true);
-  redoneItem.integrate(transaction, 0);
-  return redoneItem;
-};
-class Item extends AbstractStruct {
-  /**
-   * @param {ID} id
-   * @param {Item | null} left
-   * @param {ID | null} origin
-   * @param {Item | null} right
-   * @param {ID | null} rightOrigin
-   * @param {AbstractType<any>|ID|null} parent Is a type if integrated, is null if it is possible to copy parent from left or right, is ID before integration to search for it.
-   * @param {string | null} parentSub
-   * @param {AbstractContent} content
-   */
-  constructor(id2, left, origin, right, rightOrigin, parent, parentSub, content2) {
-    super(id2, content2.getLength());
-    this.origin = origin;
-    this.left = left;
-    this.right = right;
-    this.rightOrigin = rightOrigin;
-    this.parent = parent;
-    this.parentSub = parentSub;
-    this.redone = null;
-    this.content = content2;
-    this.info = this.content.isCountable() ? BIT2 : 0;
-  }
-  /**
-   * This is used to mark the item as an indexed fast-search marker
-   *
-   * @type {boolean}
-   */
-  set marker(isMarked) {
-    if ((this.info & BIT4) > 0 !== isMarked) {
-      this.info ^= BIT4;
-    }
-  }
-  get marker() {
-    return (this.info & BIT4) > 0;
-  }
-  /**
-   * If true, do not garbage collect this Item.
-   */
-  get keep() {
-    return (this.info & BIT1) > 0;
-  }
-  set keep(doKeep) {
-    if (this.keep !== doKeep) {
-      this.info ^= BIT1;
-    }
-  }
-  get countable() {
-    return (this.info & BIT2) > 0;
-  }
-  /**
-   * Whether this item was deleted or not.
-   * @type {Boolean}
-   */
-  get deleted() {
-    return (this.info & BIT3) > 0;
-  }
-  set deleted(doDelete) {
-    if (this.deleted !== doDelete) {
-      this.info ^= BIT3;
-    }
-  }
-  markDeleted() {
-    this.info |= BIT3;
-  }
-  /**
-   * Return the creator clientID of the missing op or define missing items and return null.
-   *
-   * @param {Transaction} transaction
-   * @param {StructStore} store
-   * @return {null | number}
-   */
-  getMissing(transaction, store) {
-    if (this.origin && this.origin.client !== this.id.client && this.origin.clock >= getState(store, this.origin.client)) {
-      return this.origin.client;
-    }
-    if (this.rightOrigin && this.rightOrigin.client !== this.id.client && this.rightOrigin.clock >= getState(store, this.rightOrigin.client)) {
-      return this.rightOrigin.client;
-    }
-    if (this.parent && this.parent.constructor === ID && this.id.client !== this.parent.client && this.parent.clock >= getState(store, this.parent.client)) {
-      return this.parent.client;
-    }
-    if (this.origin) {
-      this.left = getItemCleanEnd(transaction, store, this.origin);
-      this.origin = this.left.lastId;
-    }
-    if (this.rightOrigin) {
-      this.right = getItemCleanStart(transaction, this.rightOrigin);
-      this.rightOrigin = this.right.id;
-    }
-    if (this.left && this.left.constructor === GC || this.right && this.right.constructor === GC) {
-      this.parent = null;
-    } else if (!this.parent) {
-      if (this.left && this.left.constructor === Item) {
-        this.parent = this.left.parent;
-        this.parentSub = this.left.parentSub;
-      }
-      if (this.right && this.right.constructor === Item) {
-        this.parent = this.right.parent;
-        this.parentSub = this.right.parentSub;
-      }
-    } else if (this.parent.constructor === ID) {
-      const parentItem = getItem(store, this.parent);
-      if (parentItem.constructor === GC) {
-        this.parent = null;
-      } else {
-        this.parent = /** @type {ContentType} */
-        parentItem.content.type;
-      }
-    }
-    return null;
-  }
-  /**
-   * @param {Transaction} transaction
-   * @param {number} offset
-   */
-  integrate(transaction, offset) {
-    if (offset > 0) {
-      this.id.clock += offset;
-      this.left = getItemCleanEnd(transaction, transaction.doc.store, createID(this.id.client, this.id.clock - 1));
-      this.origin = this.left.lastId;
-      this.content = this.content.splice(offset);
-      this.length -= offset;
-    }
-    if (this.parent) {
-      if (!this.left && (!this.right || this.right.left !== null) || this.left && this.left.right !== this.right) {
-        let left = this.left;
-        let o;
-        if (left !== null) {
-          o = left.right;
-        } else if (this.parentSub !== null) {
-          o = /** @type {AbstractType<any>} */
-          this.parent._map.get(this.parentSub) || null;
-          while (o !== null && o.left !== null) {
-            o = o.left;
-          }
-        } else {
-          o = /** @type {AbstractType<any>} */
-          this.parent._start;
-        }
-        const conflictingItems = /* @__PURE__ */ new Set();
-        const itemsBeforeOrigin = /* @__PURE__ */ new Set();
-        while (o !== null && o !== this.right) {
-          itemsBeforeOrigin.add(o);
-          conflictingItems.add(o);
-          if (compareIDs(this.origin, o.origin)) {
-            if (o.id.client < this.id.client) {
-              left = o;
-              conflictingItems.clear();
-            } else if (compareIDs(this.rightOrigin, o.rightOrigin)) {
-              break;
-            }
-          } else if (o.origin !== null && itemsBeforeOrigin.has(getItem(transaction.doc.store, o.origin))) {
-            if (!conflictingItems.has(getItem(transaction.doc.store, o.origin))) {
-              left = o;
-              conflictingItems.clear();
-            }
-          } else {
-            break;
-          }
-          o = o.right;
-        }
-        this.left = left;
-      }
-      if (this.left !== null) {
-        const right = this.left.right;
-        this.right = right;
-        this.left.right = this;
-      } else {
-        let r2;
-        if (this.parentSub !== null) {
-          r2 = /** @type {AbstractType<any>} */
-          this.parent._map.get(this.parentSub) || null;
-          while (r2 !== null && r2.left !== null) {
-            r2 = r2.left;
-          }
-        } else {
-          r2 = /** @type {AbstractType<any>} */
-          this.parent._start;
-          this.parent._start = this;
-        }
-        this.right = r2;
-      }
-      if (this.right !== null) {
-        this.right.left = this;
-      } else if (this.parentSub !== null) {
-        this.parent._map.set(this.parentSub, this);
-        if (this.left !== null) {
-          this.left.delete(transaction);
-        }
-      }
-      if (this.parentSub === null && this.countable && !this.deleted) {
-        this.parent._length += this.length;
-      }
-      addStruct(transaction.doc.store, this);
-      this.content.integrate(transaction, this);
-      addChangedTypeToTransaction(
-        transaction,
-        /** @type {AbstractType<any>} */
-        this.parent,
-        this.parentSub
-      );
-      if (
-        /** @type {AbstractType<any>} */
-        this.parent._item !== null && /** @type {AbstractType<any>} */
-        this.parent._item.deleted || this.parentSub !== null && this.right !== null
-      ) {
-        this.delete(transaction);
-      }
-    } else {
-      new GC(this.id, this.length).integrate(transaction, 0);
-    }
-  }
-  /**
-   * Returns the next non-deleted item
-   */
-  get next() {
-    let n = this.right;
-    while (n !== null && n.deleted) {
-      n = n.right;
-    }
-    return n;
-  }
-  /**
-   * Returns the previous non-deleted item
-   */
-  get prev() {
-    let n = this.left;
-    while (n !== null && n.deleted) {
-      n = n.left;
-    }
-    return n;
-  }
-  /**
-   * Computes the last content address of this Item.
-   */
-  get lastId() {
-    return this.length === 1 ? this.id : createID(this.id.client, this.id.clock + this.length - 1);
-  }
-  /**
-   * Try to merge two items
-   *
-   * @param {Item} right
-   * @return {boolean}
-   */
-  mergeWith(right) {
-    if (this.constructor === right.constructor && compareIDs(right.origin, this.lastId) && this.right === right && compareIDs(this.rightOrigin, right.rightOrigin) && this.id.client === right.id.client && this.id.clock + this.length === right.id.clock && this.deleted === right.deleted && this.redone === null && right.redone === null && this.content.constructor === right.content.constructor && this.content.mergeWith(right.content)) {
-      const searchMarker = (
-        /** @type {AbstractType<any>} */
-        this.parent._searchMarker
-      );
-      if (searchMarker) {
-        searchMarker.forEach((marker) => {
-          if (marker.p === right) {
-            marker.p = this;
-            if (!this.deleted && this.countable) {
-              marker.index -= this.length;
-            }
-          }
-        });
-      }
-      if (right.keep) {
-        this.keep = true;
-      }
-      this.right = right.right;
-      if (this.right !== null) {
-        this.right.left = this;
-      }
-      this.length += right.length;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Mark this Item as deleted.
-   *
-   * @param {Transaction} transaction
-   */
-  delete(transaction) {
-    if (!this.deleted) {
-      const parent = (
-        /** @type {AbstractType<any>} */
-        this.parent
-      );
-      if (this.countable && this.parentSub === null) {
-        parent._length -= this.length;
-      }
-      this.markDeleted();
-      addToDeleteSet(transaction.deleteSet, this.id.client, this.id.clock, this.length);
-      addChangedTypeToTransaction(transaction, parent, this.parentSub);
-      this.content.delete(transaction);
-    }
-  }
-  /**
-   * @param {StructStore} store
-   * @param {boolean} parentGCd
-   */
-  gc(store, parentGCd) {
-    if (!this.deleted) {
-      throw unexpectedCase();
-    }
-    this.content.gc(store);
-    if (parentGCd) {
-      replaceStruct(store, this, new GC(this.id, this.length));
-    } else {
-      this.content = new ContentDeleted(this.length);
-    }
-  }
-  /**
-   * Transform the properties of this type to binary and write it to an
-   * BinaryEncoder.
-   *
-   * This is called when this Item is sent to a remote peer.
-   *
-   * @param {UpdateEncoderV1 | UpdateEncoderV2} encoder The encoder to write data to.
-   * @param {number} offset
-   */
-  write(encoder, offset) {
-    const origin = offset > 0 ? createID(this.id.client, this.id.clock + offset - 1) : this.origin;
-    const rightOrigin = this.rightOrigin;
-    const parentSub = this.parentSub;
-    const info = this.content.getRef() & BITS5 | (origin === null ? 0 : BIT8) | // origin is defined
-    (rightOrigin === null ? 0 : BIT7) | // right origin is defined
-    (parentSub === null ? 0 : BIT6);
-    encoder.writeInfo(info);
-    if (origin !== null) {
-      encoder.writeLeftID(origin);
-    }
-    if (rightOrigin !== null) {
-      encoder.writeRightID(rightOrigin);
-    }
-    if (origin === null && rightOrigin === null) {
-      const parent = (
-        /** @type {AbstractType<any>} */
-        this.parent
-      );
-      if (parent._item !== void 0) {
-        const parentItem = parent._item;
-        if (parentItem === null) {
-          const ykey = findRootTypeKey(parent);
-          encoder.writeParentInfo(true);
-          encoder.writeString(ykey);
-        } else {
-          encoder.writeParentInfo(false);
-          encoder.writeLeftID(parentItem.id);
-        }
-      } else if (parent.constructor === String) {
-        encoder.writeParentInfo(true);
-        encoder.writeString(parent);
-      } else if (parent.constructor === ID) {
-        encoder.writeParentInfo(false);
-        encoder.writeLeftID(parent);
-      } else {
-        unexpectedCase();
-      }
-      if (parentSub !== null) {
-        encoder.writeString(parentSub);
-      }
-    }
-    this.content.write(encoder, offset);
-  }
-}
-const glo = (
-  /** @type {any} */
-  typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {}
-);
-const importIdentifier = "__ $YJS$ __";
-if (glo[importIdentifier] === true) {
-  console.error("Yjs was already imported. This breaks constructor checks and will lead to issues! - https://github.com/yjs/yjs/issues/438");
-}
-glo[importIdentifier] = true;
 class Text {
   /**
   Get the line description around the given position.
@@ -3068,10 +156,10 @@ class Text {
   }
 }
 class TextLeaf extends Text {
-  constructor(text2, length2 = textLength(text2)) {
+  constructor(text2, length = textLength(text2)) {
     super();
     this.text = text2;
-    this.length = length2;
+    this.length = length;
   }
   get lines() {
     return this.text.length;
@@ -3150,10 +238,10 @@ class TextLeaf extends Text {
   }
 }
 class TextNode extends Text {
-  constructor(children, length2) {
+  constructor(children, length) {
     super();
     this.children = children;
-    this.length = length2;
+    this.length = length;
     this.lines = 0;
     for (let child of children)
       this.lines += child.lines;
@@ -3189,9 +277,9 @@ class TextNode extends Text {
           let updated = child.replace(from2 - pos, to - pos, text2);
           let totalLines = this.lines - child.lines + updated.lines;
           if (updated.lines < totalLines >> 5 - 1 && updated.lines > totalLines >> 5 + 1) {
-            let copy2 = this.children.slice();
-            copy2[i] = updated;
-            return new TextNode(copy2, this.length - (to - from2) + text2.length);
+            let copy = this.children.slice();
+            copy[i] = updated;
+            return new TextNode(copy, this.length - (to - from2) + text2.length);
           }
           return super.replace(pos, end, updated);
         }
@@ -3219,18 +307,18 @@ class TextNode extends Text {
   scanIdentical(other, dir) {
     if (!(other instanceof TextNode))
       return 0;
-    let length2 = 0;
+    let length = 0;
     let [iA, iB, eA, eB] = dir > 0 ? [0, 0, this.children.length, other.children.length] : [this.children.length - 1, other.children.length - 1, -1, -1];
     for (; ; iA += dir, iB += dir) {
       if (iA == eA || iB == eB)
-        return length2;
+        return length;
       let chA = this.children[iA], chB = other.children[iB];
       if (chA != chB)
-        return length2 + chA.scanIdentical(chB, dir);
-      length2 += chA.length + 1;
+        return length + chA.scanIdentical(chB, dir);
+      length += chA.length + 1;
     }
   }
-  static from(children, length2 = children.reduce((l, ch) => l + ch.length + 1, -1)) {
+  static from(children, length = children.reduce((l, ch) => l + ch.length + 1, -1)) {
     let lines = 0;
     for (let ch of children)
       lines += ch.lines;
@@ -3238,7 +326,7 @@ class TextNode extends Text {
       let flat = [];
       for (let ch of children)
         ch.flatten(flat);
-      return new TextLeaf(flat, length2);
+      return new TextLeaf(flat, length);
     }
     let chunk = Math.max(
       32,
@@ -3276,15 +364,15 @@ class TextNode extends Text {
     for (let child of children)
       add(child);
     flush();
-    return chunked.length == 1 ? chunked[0] : new TextNode(chunked, length2);
+    return chunked.length == 1 ? chunked[0] : new TextNode(chunked, length);
   }
 }
 Text.empty = /* @__PURE__ */ new TextLeaf([""], 0);
 function textLength(text2) {
-  let length2 = -1;
+  let length = -1;
   for (let line of text2)
-    length2 += line.length + 1;
-  return length2;
+    length += line.length + 1;
+  return length;
 }
 function appendText(text2, target, from2 = 0, to = 1e9) {
   for (let pos = 0, i = 0, first = true; i < text2.length && pos <= to; i++) {
@@ -3857,14 +945,14 @@ class ChangeSet extends ChangeDesc {
   Create a change set for the given changes, for a document of the
   given length, using `lineSep` as line separator.
   */
-  static of(changes, length2, lineSep) {
+  static of(changes, length, lineSep) {
     let sections = [], inserted = [], pos = 0;
     let total = null;
     function flush(force = false) {
       if (!force && !sections.length)
         return;
-      if (pos < length2)
-        addSection(sections, length2 - pos, -1);
+      if (pos < length)
+        addSection(sections, length - pos, -1);
       let set = new ChangeSet(sections, inserted);
       total = total ? total.compose(set.map(total)) : set;
       sections = [];
@@ -3876,14 +964,14 @@ class ChangeSet extends ChangeDesc {
         for (let sub of spec)
           process2(sub);
       } else if (spec instanceof ChangeSet) {
-        if (spec.length != length2)
-          throw new RangeError(`Mismatched change set length (got ${spec.length}, expected ${length2})`);
+        if (spec.length != length)
+          throw new RangeError(`Mismatched change set length (got ${spec.length}, expected ${length})`);
         flush();
         total = total ? total.compose(spec.map(total)) : spec;
       } else {
         let { from: from2, to = from2, insert: insert2 } = spec;
-        if (from2 > to || from2 < 0 || to > length2)
-          throw new RangeError(`Invalid change range ${from2} to ${to} (in doc of length ${length2})`);
+        if (from2 > to || from2 < 0 || to > length)
+          throw new RangeError(`Invalid change range ${from2} to ${to} (in doc of length ${length})`);
         let insText = !insert2 ? Text.empty : typeof insert2 == "string" ? Text.of(insert2.split(lineSep || DefaultSplit)) : insert2;
         let insLen = insText.length;
         if (from2 == to && insLen == 0)
@@ -3904,8 +992,8 @@ class ChangeSet extends ChangeDesc {
   /**
   Create an empty changeset of the given length.
   */
-  static empty(length2) {
-    return new ChangeSet(length2 ? [length2, -1] : [], []);
+  static empty(length) {
+    return new ChangeSet(length ? [length, -1] : [], []);
   }
   /**
   Create a changeset from its JSON representation (as produced by
@@ -4853,8 +1941,8 @@ class StateEffectType {
   /**
   @internal
   */
-  constructor(map2) {
-    this.map = map2;
+  constructor(map) {
+    this.map = map;
   }
   /**
   Create a [state effect](https://codemirror.net/6/docs/ref/#state.StateEffect) instance of this
@@ -4914,7 +2002,7 @@ class StateEffect {
 }
 StateEffect.reconfigure = /* @__PURE__ */ StateEffect.define();
 StateEffect.appendConfig = /* @__PURE__ */ StateEffect.define();
-class Transaction2 {
+class Transaction {
   constructor(startState, changes, selection, effects, annotations, scrollIntoView2) {
     this.startState = startState;
     this.changes = changes;
@@ -4926,14 +2014,14 @@ class Transaction2 {
     this._state = null;
     if (selection)
       checkSelection(selection, changes.newLength);
-    if (!annotations.some((a) => a.type == Transaction2.time))
-      this.annotations = annotations.concat(Transaction2.time.of(Date.now()));
+    if (!annotations.some((a) => a.type == Transaction.time))
+      this.annotations = annotations.concat(Transaction.time.of(Date.now()));
   }
   /**
   @internal
   */
   static create(startState, changes, selection, effects, annotations, scrollIntoView2) {
-    return new Transaction2(startState, changes, selection, effects, annotations, scrollIntoView2);
+    return new Transaction(startState, changes, selection, effects, annotations, scrollIntoView2);
   }
   /**
   The new document produced by the transaction. Contrary to
@@ -4998,14 +2086,14 @@ class Transaction2 {
   `"select.pointer"` will match it.
   */
   isUserEvent(event) {
-    let e = this.annotation(Transaction2.userEvent);
+    let e = this.annotation(Transaction.userEvent);
     return !!(e && (e == event || e.length > event.length && e.slice(0, event.length) == event && e[event.length] == "."));
   }
 }
-Transaction2.time = /* @__PURE__ */ Annotation.define();
-Transaction2.userEvent = /* @__PURE__ */ Annotation.define();
-Transaction2.addToHistory = /* @__PURE__ */ Annotation.define();
-Transaction2.remote = /* @__PURE__ */ Annotation.define();
+Transaction.time = /* @__PURE__ */ Annotation.define();
+Transaction.userEvent = /* @__PURE__ */ Annotation.define();
+Transaction.addToHistory = /* @__PURE__ */ Annotation.define();
+Transaction.remote = /* @__PURE__ */ Annotation.define();
 function joinRanges(a, b) {
   let result = [];
   for (let iA = 0, iB = 0; ; ) {
@@ -5047,7 +2135,7 @@ function mergeTransaction(a, b, sequential) {
 function resolveTransactionInner(state, spec, docSize) {
   let sel = spec.selection, annotations = asArray$1(spec.annotations);
   if (spec.userEvent)
-    annotations = annotations.concat(Transaction2.userEvent.of(spec.userEvent));
+    annotations = annotations.concat(Transaction.userEvent.of(spec.userEvent));
   return {
     changes: spec.changes instanceof ChangeSet ? spec.changes : ChangeSet.of(spec.changes || [], docSize, state.facet(lineSeparator)),
     selection: sel && (sel instanceof EditorSelection ? sel : EditorSelection.single(sel.anchor, sel.head)),
@@ -5066,7 +2154,7 @@ function resolveTransaction(state, specs, filter) {
     let seq = !!specs[i].sequential;
     s = mergeTransaction(s, resolveTransactionInner(state, specs[i], seq ? s.changes.newLength : state.doc.length), seq);
   }
-  let tr = Transaction2.create(state, s.changes, s.selection, s.effects, s.annotations, s.scrollIntoView);
+  let tr = Transaction.create(state, s.changes, s.selection, s.effects, s.annotations, s.scrollIntoView);
   return extendTransaction(filter ? filterTransaction(tr) : tr);
 }
 function filterTransaction(tr) {
@@ -5091,14 +2179,14 @@ function filterTransaction(tr) {
       changes = filtered.changes;
       back = filtered.filtered.mapDesc(filtered.changes).invertedDesc;
     }
-    tr = Transaction2.create(state, changes, tr.selection && tr.selection.map(back), StateEffect.mapEffects(tr.effects, back), tr.annotations, tr.scrollIntoView);
+    tr = Transaction.create(state, changes, tr.selection && tr.selection.map(back), StateEffect.mapEffects(tr.effects, back), tr.annotations, tr.scrollIntoView);
   }
   let filters = state.facet(transactionFilter);
   for (let i = filters.length - 1; i >= 0; i--) {
     let filtered = filters[i](tr);
-    if (filtered instanceof Transaction2)
+    if (filtered instanceof Transaction)
       tr = filtered;
-    else if (Array.isArray(filtered) && filtered.length == 1 && filtered[0] instanceof Transaction2)
+    else if (Array.isArray(filtered) && filtered.length == 1 && filtered[0] instanceof Transaction)
       tr = filtered[0];
     else
       tr = resolveTransaction(state, asArray$1(filtered), false);
@@ -5112,7 +2200,7 @@ function extendTransaction(tr) {
     if (extension && Object.keys(extension).length)
       spec = mergeTransaction(spec, resolveTransactionInner(state, extension, tr.changes.newLength), true);
   }
-  return spec == tr ? tr : Transaction2.create(state, tr.changes, tr.selection, spec.effects, spec.annotations, spec.scrollIntoView);
+  return spec == tr ? tr : Transaction.create(state, tr.changes, tr.selection, spec.effects, spec.annotations, spec.scrollIntoView);
 }
 const none = [];
 function asArray$1(value) {
@@ -5392,9 +2480,9 @@ class EditorState {
   literal dollar sign.
   */
   phrase(phrase, ...insert2) {
-    for (let map2 of this.facet(EditorState.phrases))
-      if (Object.prototype.hasOwnProperty.call(map2, phrase)) {
-        phrase = map2[phrase];
+    for (let map of this.facet(EditorState.phrases))
+      if (Object.prototype.hasOwnProperty.call(map, phrase)) {
+        phrase = map[phrase];
         break;
       }
     if (insert2.length)
@@ -5453,7 +2541,7 @@ class EditorState {
   this returns null.
   */
   wordAt(pos) {
-    let { text: text2, from: from2, length: length2 } = this.doc.lineAt(pos);
+    let { text: text2, from: from2, length } = this.doc.lineAt(pos);
     let cat = this.charCategorizer(pos);
     let start2 = pos - from2, end = pos - from2;
     while (start2 > 0) {
@@ -5462,7 +2550,7 @@ class EditorState {
         break;
       start2 = prev;
     }
-    while (end < length2) {
+    while (end < length) {
       let next = findClusterBreak(text2, end);
       if (cat(text2.slice(end, next)) != CharCategory.Word)
         break;
@@ -5755,7 +2843,7 @@ class RangeSet {
     let sharedChunks = findSharedChunks(a, b, textDiff);
     let sideA = new SpanCursor(a, sharedChunks, minPointSize);
     let sideB = new SpanCursor(b, sharedChunks, minPointSize);
-    textDiff.iterGaps((fromA, fromB, length2) => compare(sideA, fromA, sideB, fromB, length2, comparator));
+    textDiff.iterGaps((fromA, fromB, length) => compare(sideA, fromA, sideB, fromB, length, comparator));
     if (textDiff.empty && textDiff.length == 0)
       compare(sideA, 0, sideB, 0, 0, comparator);
   }
@@ -6220,10 +3308,10 @@ class SpanCursor {
     return open;
   }
 }
-function compare(a, startA, b, startB, length2, comparator) {
+function compare(a, startA, b, startB, length, comparator) {
   a.goto(startA);
   b.goto(startB);
-  let endB = startB + length2;
+  let endB = startB + length;
   let pos = startB, dPos = startB - startA;
   for (; ; ) {
     let diff = a.to + dPos - b.to || a.endSide - b.endSide;
@@ -7167,14 +4255,14 @@ function mergeChildrenInto(parent, from2, to, insert2, openStart, openEnd) {
   replaceRange(parent, fromI, fromOff, toI, toOff, insert2, 0, openStart, openEnd);
 }
 let nav = typeof navigator != "undefined" ? navigator : { userAgent: "", vendor: "", platform: "" };
-let doc = typeof document != "undefined" ? document : { documentElement: { style: {} } };
+let doc$1 = typeof document != "undefined" ? document : { documentElement: { style: {} } };
 const ie_edge = /* @__PURE__ */ /Edge\/(\d+)/.exec(nav.userAgent);
 const ie_upto10 = /* @__PURE__ */ /MSIE \d/.test(nav.userAgent);
 const ie_11up = /* @__PURE__ */ /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(nav.userAgent);
 const ie = !!(ie_upto10 || ie_11up || ie_edge);
 const gecko = !ie && /* @__PURE__ */ /gecko\/(\d+)/i.test(nav.userAgent);
 const chrome = !ie && /* @__PURE__ */ /Chrome\/(\d+)/.exec(nav.userAgent);
-const webkit = "webkitFontSmoothing" in doc.documentElement.style;
+const webkit = "webkitFontSmoothing" in doc$1.documentElement.style;
 const safari = !ie && /* @__PURE__ */ /Apple Computer/.test(nav.vendor);
 const ios = safari && (/* @__PURE__ */ /Mobile\/\w+/.test(nav.userAgent) || nav.maxTouchPoints > 2);
 var browser = {
@@ -7182,7 +4270,7 @@ var browser = {
   windows: /* @__PURE__ */ /Win/.test(nav.platform),
   linux: /* @__PURE__ */ /Linux|X11/.test(nav.platform),
   ie,
-  ie_version: ie_upto10 ? doc.documentMode || 6 : ie_11up ? +ie_11up[1] : ie_edge ? +ie_edge[1] : 0,
+  ie_version: ie_upto10 ? doc$1.documentMode || 6 : ie_11up ? +ie_11up[1] : ie_edge ? +ie_edge[1] : 0,
   gecko,
   gecko_version: gecko ? +(/* @__PURE__ */ /Firefox\/(\d+)/.exec(nav.userAgent) || [0, 0])[1] : 0,
   chrome: !!chrome,
@@ -7192,7 +4280,7 @@ var browser = {
   webkit,
   safari,
   webkit_version: webkit ? +(/* @__PURE__ */ /\bAppleWebKit\/(\d+)/.exec(navigator.userAgent) || [0, 0])[1] : 0,
-  tabSize: doc.documentElement.style.tabSize != null ? "tab-size" : "-moz-tab-size"
+  tabSize: doc$1.documentElement.style.tabSize != null ? "tab-size" : "-moz-tab-size"
 };
 const MaxJoinLen = 256;
 class TextView extends ContentView {
@@ -7247,11 +4335,11 @@ class TextView extends ContentView {
   }
 }
 class MarkView extends ContentView {
-  constructor(mark, children = [], length2 = 0) {
+  constructor(mark, children = [], length = 0) {
     super();
     this.mark = mark;
     this.children = children;
-    this.length = length2;
+    this.length = length;
     for (let ch of children)
       ch.setParent(this);
   }
@@ -7298,13 +4386,13 @@ class MarkView extends ContentView {
       off = end;
       i++;
     }
-    let length2 = this.length - from2;
+    let length = this.length - from2;
     this.length = from2;
     if (detachFrom > -1) {
       this.children.length = detachFrom;
       this.markDirty();
     }
-    return new MarkView(this.mark, result, length2);
+    return new MarkView(this.mark, result, length);
   }
   domAtPos(pos) {
     return inlineDOMAtPos(this, pos);
@@ -7314,16 +4402,16 @@ class MarkView extends ContentView {
   }
 }
 function textCoords(text2, pos, side) {
-  let length2 = text2.nodeValue.length;
-  if (pos > length2)
-    pos = length2;
+  let length = text2.nodeValue.length;
+  if (pos > length)
+    pos = length;
   let from2 = pos, to = pos, flatten2 = 0;
-  if (pos == 0 && side < 0 || pos == length2 && side >= 0) {
+  if (pos == 0 && side < 0 || pos == length && side >= 0) {
     if (!(browser.chrome || browser.gecko)) {
       if (pos) {
         from2--;
         flatten2 = 1;
-      } else if (to < length2) {
+      } else if (to < length) {
         to++;
         flatten2 = -1;
       }
@@ -7331,7 +4419,7 @@ function textCoords(text2, pos, side) {
   } else {
     if (side < 0)
       from2--;
-    else if (to < length2)
+    else if (to < length)
       to++;
   }
   let rects = textRange(text2, from2, to).getClientRects();
@@ -7343,13 +4431,13 @@ function textCoords(text2, pos, side) {
   return flatten2 ? flattenRect(rect, flatten2 < 0) : rect || null;
 }
 class WidgetView extends ContentView {
-  static create(widget, length2, side) {
-    return new WidgetView(widget, length2, side);
+  static create(widget, length, side) {
+    return new WidgetView(widget, length, side);
   }
-  constructor(widget, length2, side) {
+  constructor(widget, length, side) {
     super();
     this.widget = widget;
-    this.length = length2;
+    this.length = length;
     this.side = side;
     this.prevWidget = null;
   }
@@ -7771,10 +4859,10 @@ class LineView extends ContentView {
   }
 }
 class BlockWidgetView extends ContentView {
-  constructor(widget, length2, deco) {
+  constructor(widget, length, deco) {
     super();
     this.widget = widget;
-    this.length = length2;
+    this.length = length;
     this.deco = deco;
     this.breakAfter = 0;
     this.prevWidget = null;
@@ -8147,8 +5235,8 @@ class ContentBuilder {
     if (!this.posCovered() && !(openEnd && this.content.length && this.content[this.content.length - 1] instanceof BlockWidgetView))
       this.getLine();
   }
-  buildText(length2, active, openStart) {
-    while (length2 > 0) {
+  buildText(length, active, openStart) {
+    while (length > 0) {
       if (this.textOff == this.text.length) {
         let { value, lineBreak, done } = this.cursor.next(this.skip);
         this.skip = 0;
@@ -8164,7 +5252,7 @@ class ContentBuilder {
           this.flushBuffer();
           this.curLine = null;
           this.atCursorPos = true;
-          length2--;
+          length--;
           continue;
         } else {
           this.text = value;
@@ -8173,7 +5261,7 @@ class ContentBuilder {
       }
       let take = Math.min(
         this.text.length - this.textOff,
-        length2,
+        length,
         512
         /* T.Chunk */
       );
@@ -8181,7 +5269,7 @@ class ContentBuilder {
       this.getLine().append(wrapMarks(new TextView(this.text.slice(this.textOff, this.textOff + take)), active), openStart);
       this.atCursorPos = true;
       this.textOff += take;
-      length2 -= take;
+      length -= take;
       openStart = 0;
     }
   }
@@ -8598,8 +5686,8 @@ function computeOrder(line, direction, isolates) {
   computeSectionOrder(line, level, level, isolates, 0, line.length, order);
   return order;
 }
-function trivialOrder(length2) {
-  return [new BidiSpan(0, length2, 0)];
+function trivialOrder(length) {
+  return [new BidiSpan(0, length, 0)];
 }
 let movedOver = "";
 function moveVisually(line, order, dir, start2, forward) {
@@ -10620,10 +7708,10 @@ class HeightOracle {
       lines += Math.max(0, Math.ceil((to - from2 - lines * this.lineLength * 0.5) / this.lineLength));
     return this.lineHeight * lines;
   }
-  heightForLine(length2) {
+  heightForLine(length) {
     if (!this.lineWrapping)
       return this.lineHeight;
-    let lines = 1 + Math.max(0, Math.ceil((length2 - this.lineLength) / (this.lineLength - 5)));
+    let lines = 1 + Math.max(0, Math.ceil((length - this.lineLength) / (this.lineLength - 5)));
     return lines * this.lineHeight;
   }
   setDoc(doc2) {
@@ -10681,9 +7769,9 @@ class BlockInfo {
   /**
   @internal
   */
-  constructor(from2, length2, top2, height, _content) {
+  constructor(from2, length, top2, height, _content) {
     this.from = from2;
-    this.length = length2;
+    this.length = length;
     this.top = top2;
     this.height = height;
     this._content = _content;
@@ -10737,8 +7825,8 @@ var QueryType = /* @__PURE__ */ function(QueryType2) {
 }(QueryType || (QueryType = {}));
 const Epsilon = 1e-3;
 class HeightMap {
-  constructor(length2, height, flags = 2) {
-    this.length = length2;
+  constructor(length, height, flags = 2) {
+    this.length = length;
     this.height = height;
     this.flags = flags;
   }
@@ -10845,8 +7933,8 @@ class HeightMap {
 }
 HeightMap.prototype.size = 1;
 class HeightMapBlock extends HeightMap {
-  constructor(length2, height, deco) {
-    super(length2, height);
+  constructor(length, height, deco) {
+    super(length, height);
     this.deco = deco;
   }
   blockAt(_height, _oracle, top2, offset) {
@@ -10870,8 +7958,8 @@ class HeightMapBlock extends HeightMap {
   }
 }
 class HeightMapText extends HeightMapBlock {
-  constructor(length2, height) {
-    super(length2, height, null);
+  constructor(length, height) {
+    super(length, height, null);
     this.collapsed = 0;
     this.widgetHeight = 0;
     this.breaks = 0;
@@ -10906,8 +7994,8 @@ class HeightMapText extends HeightMapBlock {
   }
 }
 class HeightMapGap extends HeightMap {
-  constructor(length2) {
-    super(length2, 0);
+  constructor(length) {
+    super(length, 0);
   }
   heightMetrics(oracle, offset) {
     let firstLine = oracle.doc.lineAt(offset).number, lastLine = oracle.doc.lineAt(offset + this.length).number;
@@ -10932,8 +8020,8 @@ class HeightMapGap extends HeightMap {
       return new BlockInfo(line.from, line.length, lineTop, lineHeight, 0);
     } else {
       let line = Math.max(0, Math.min(lastLine - firstLine, Math.floor((height - top2) / perLine)));
-      let { from: from2, length: length2 } = oracle.doc.line(firstLine + line);
-      return new BlockInfo(from2, length2, top2 + perLine * line, perLine, 0);
+      let { from: from2, length } = oracle.doc.line(firstLine + line);
+      return new BlockInfo(from2, length, top2 + perLine * line, perLine, 0);
     }
   }
   lineAt(value, type, oracle, top2, offset) {
@@ -11236,13 +8324,13 @@ class NodeBuilder {
     if (deco && deco.endSide > 0)
       this.covering = block;
   }
-  addLineDeco(height, breaks, length2) {
+  addLineDeco(height, breaks, length) {
     let line = this.ensureLine();
-    line.length += length2;
-    line.collapsed += length2;
+    line.length += length;
+    line.collapsed += length;
     line.widgetHeight = Math.max(line.widgetHeight, height);
     line.breaks += breaks;
-    this.writtenTo = this.pos = this.pos + length2;
+    this.writtenTo = this.pos = this.pos + length;
   }
   finish(from2) {
     let last = this.nodes.length == 0 ? null : this.nodes[this.nodes.length - 1];
@@ -11560,21 +8648,21 @@ class ViewState {
   }
   getViewport(bias, scrollTarget) {
     let marginTop = 0.5 - Math.max(-0.5, Math.min(0.5, bias / 1e3 / 2));
-    let map2 = this.heightMap, oracle = this.heightOracle;
+    let map = this.heightMap, oracle = this.heightOracle;
     let { visibleTop, visibleBottom } = this;
-    let viewport = new Viewport(map2.lineAt(visibleTop - marginTop * 1e3, QueryType.ByHeight, oracle, 0, 0).from, map2.lineAt(visibleBottom + (1 - marginTop) * 1e3, QueryType.ByHeight, oracle, 0, 0).to);
+    let viewport = new Viewport(map.lineAt(visibleTop - marginTop * 1e3, QueryType.ByHeight, oracle, 0, 0).from, map.lineAt(visibleBottom + (1 - marginTop) * 1e3, QueryType.ByHeight, oracle, 0, 0).to);
     if (scrollTarget) {
       let { head } = scrollTarget.range;
       if (head < viewport.from || head > viewport.to) {
         let viewHeight = Math.min(this.editorHeight, this.pixelViewport.bottom - this.pixelViewport.top);
-        let block = map2.lineAt(head, QueryType.ByPos, oracle, 0, 0), topPos;
+        let block = map.lineAt(head, QueryType.ByPos, oracle, 0, 0), topPos;
         if (scrollTarget.y == "center")
           topPos = (block.top + block.bottom) / 2 - viewHeight / 2;
         else if (scrollTarget.y == "start" || scrollTarget.y == "nearest" && head < viewport.from)
           topPos = block.top;
         else
           topPos = block.bottom - viewHeight;
-        viewport = new Viewport(map2.lineAt(topPos - 1e3 / 2, QueryType.ByHeight, oracle, 0, 0).from, map2.lineAt(topPos + viewHeight + 1e3 / 2, QueryType.ByHeight, oracle, 0, 0).to);
+        viewport = new Viewport(map.lineAt(topPos - 1e3 / 2, QueryType.ByHeight, oracle, 0, 0).from, map.lineAt(topPos + viewHeight + 1e3 / 2, QueryType.ByHeight, oracle, 0, 0).to);
       }
     }
     return viewport;
@@ -12203,10 +9291,10 @@ class DOMReader {
       if (point.node == node && node.childNodes[point.offset] == next)
         point.pos = this.text.length;
   }
-  findPointInside(node, length2) {
+  findPointInside(node, length) {
     for (let point of this.points)
       if (node.nodeType == 3 ? point.node == node : node.contains(point.node))
-        point.pos = this.text.length + (isAtEnd(node, point.node, point.offset) ? length2 : 0);
+        point.pos = this.text.length + (isAtEnd(node, point.node, point.offset) ? length : 0);
   }
 }
 function isAtEnd(parent, node, offset) {
@@ -12946,7 +10034,7 @@ class EditorView {
     this.requestMeasure();
   }
   dispatch(...input) {
-    let trs = input.length == 1 && input[0] instanceof Transaction2 ? input : input.length == 1 && Array.isArray(input[0]) ? input[0] : [this.state.update(...input)];
+    let trs = input.length == 1 && input[0] instanceof Transaction ? input : input.length == 1 && Array.isArray(input[0]) ? input[0] : [this.state.update(...input)];
     this.dispatchTransactions(trs, this);
   }
   /**
@@ -13817,10 +10905,10 @@ const keymap = /* @__PURE__ */ Facet.define({ enables: handleKeyEvents });
 const Keymaps = /* @__PURE__ */ new WeakMap();
 function getKeymap(state) {
   let bindings = state.facet(keymap);
-  let map2 = Keymaps.get(bindings);
-  if (!map2)
-    Keymaps.set(bindings, map2 = buildKeymap(bindings.reduce((a, b) => a.concat(b), [])));
-  return map2;
+  let map = Keymaps.get(bindings);
+  if (!map)
+    Keymaps.set(bindings, map = buildKeymap(bindings.reduce((a, b) => a.concat(b), [])));
+  return map;
 }
 let storedPrefix = null;
 const PrefixTimeout = 4e3;
@@ -13890,7 +10978,7 @@ function buildKeymap(bindings, platform = currentPlatform) {
   }
   return bound;
 }
-function runHandlers(map2, event, view, scope) {
+function runHandlers(map, event, view, scope) {
   let name2 = keyName(event);
   let charCode = codePointAt(name2, 0), isChar = codePointSize(charCode) == name2.length && name2 != " ";
   let prefix = "", handled = false, prevented = false, stopPropagation = false;
@@ -13921,7 +11009,7 @@ function runHandlers(map2, event, view, scope) {
     }
     return false;
   };
-  let scopeObj = map2[scope], baseName, shiftName;
+  let scopeObj = map[scope], baseName, shiftName;
   if (scopeObj) {
     if (runFor(scopeObj[prefix + modifiers(name2, event, !isChar)])) {
       handled = true;
@@ -14470,8 +11558,8 @@ class YRange {
    */
   toJSON() {
     return {
-      yanchor: relativePositionToJSON(this.yanchor),
-      yhead: relativePositionToJSON(this.yhead)
+      yanchor: Y.relativePositionToJSON(this.yanchor),
+      yhead: Y.relativePositionToJSON(this.yhead)
     };
   }
   /**
@@ -14479,14 +11567,14 @@ class YRange {
    * @return {YRange}
    */
   static fromJSON(json2) {
-    return new YRange(createRelativePositionFromJSON(json2.yanchor), createRelativePositionFromJSON(json2.yhead));
+    return new YRange(Y.createRelativePositionFromJSON(json2.yanchor), Y.createRelativePositionFromJSON(json2.yhead));
   }
 }
 class YSyncConfig {
   constructor(ytext, awareness) {
     this.ytext = ytext;
     this.awareness = awareness;
-    this.undoManager = new UndoManager(ytext);
+    this.undoManager = new Y.UndoManager(ytext);
   }
   /**
    * Helper function to transform an absolute index position to a Yjs-based relative position
@@ -14516,13 +11604,13 @@ class YSyncConfig {
    * @param {number} [assoc]
    */
   toYPos(pos, assoc = 0) {
-    return createRelativePositionFromTypeIndex(this.ytext, pos, assoc);
+    return Y.createRelativePositionFromTypeIndex(this.ytext, pos, assoc);
   }
   /**
    * @param {Y.RelativePosition | Object} rpos
    */
   fromYPos(rpos) {
-    const pos = createAbsolutePositionFromRelativePosition(createRelativePositionFromJSON(rpos), this.ytext.doc);
+    const pos = Y.createAbsolutePositionFromRelativePosition(Y.createRelativePositionFromJSON(rpos), this.ytext.doc);
     if (pos == null || pos.type !== this.ytext) {
       throw new Error("[y-codemirror] The position you want to retrieve was created by a different document");
     }
@@ -14615,6 +11703,61 @@ class YSyncPluginValue {
   }
 }
 const ySync = ViewPlugin.fromClass(YSyncPluginValue);
+class Pair {
+  /**
+   * @param {L} left
+   * @param {R} right
+   */
+  constructor(left, right) {
+    this.left = left;
+    this.right = right;
+  }
+}
+const create = (left, right) => new Pair(left, right);
+const forEach = (arr, f) => arr.forEach((p) => f(p.left, p.right));
+const doc = (
+  /** @type {Document} */
+  typeof document !== "undefined" ? document : {}
+);
+const createElement = (name2) => doc.createElement(name2);
+const createDocumentFragment = () => doc.createDocumentFragment();
+const createTextNode = (text2) => doc.createTextNode(text2);
+typeof DOMParser !== "undefined" ? new DOMParser() : null;
+const setAttributes = (el, attrs) => {
+  forEach(attrs, (key, value) => {
+    if (value === false) {
+      el.removeAttribute(key);
+    } else if (value === true) {
+      el.setAttribute(key, "");
+    } else {
+      el.setAttribute(key, value);
+    }
+  });
+  return el;
+};
+const fragment = (children) => {
+  const fragment2 = createDocumentFragment();
+  for (let i = 0; i < children.length; i++) {
+    appendChild(fragment2, children[i]);
+  }
+  return fragment2;
+};
+const append = (parent, nodes) => {
+  appendChild(parent, fragment(nodes));
+  return parent;
+};
+const element = (name2, attrs = [], children = []) => append(setAttributes(createElement(name2), attrs), children);
+const text = createTextNode;
+const appendChild = (parent, child) => parent.appendChild(child);
+doc.ELEMENT_NODE;
+doc.TEXT_NODE;
+doc.CDATA_SECTION_NODE;
+doc.COMMENT_NODE;
+doc.DOCUMENT_NODE;
+doc.DOCUMENT_TYPE_NODE;
+doc.DOCUMENT_FRAGMENT_NODE;
+const min = (a, b) => a < b ? a : b;
+const max = (a, b) => a > b ? a : b;
 const yRemoteSelectionsTheme = EditorView.baseTheme({
   ".cm-ySelection": {},
   ".cm-yLineSelection": {
@@ -14685,14 +11828,14 @@ class YRemoteCaretWidget extends WidgetType {
   toDOM() {
     return (
       /** @type {HTMLElement} */
-      element("span", [create$1("class", "cm-ySelectionCaret"), create$1("style", `background-color: ${this.color}; border-color: ${this.color}`)], [
+      element("span", [create("class", "cm-ySelectionCaret"), create("style", `background-color: ${this.color}; border-color: ${this.color}`)], [
         text("⁠"),
         element("div", [
-          create$1("class", "cm-ySelectionCaretDot")
+          create("class", "cm-ySelectionCaretDot")
         ]),
         text("⁠"),
         element("div", [
-          create$1("class", "cm-ySelectionInfo")
+          create("class", "cm-ySelectionInfo")
         ], [
           text(this.name)
         ]),
@@ -14750,12 +11893,12 @@ class YRemoteSelectionsPluginValue {
     if (localAwarenessState != null) {
       const hasFocus = update.view.hasFocus && update.view.dom.ownerDocument.hasFocus();
       const sel = hasFocus ? update.state.selection.main : null;
-      const currentAnchor = localAwarenessState.cursor == null ? null : createRelativePositionFromJSON(localAwarenessState.cursor.anchor);
-      const currentHead = localAwarenessState.cursor == null ? null : createRelativePositionFromJSON(localAwarenessState.cursor.head);
+      const currentAnchor = localAwarenessState.cursor == null ? null : Y.createRelativePositionFromJSON(localAwarenessState.cursor.anchor);
+      const currentHead = localAwarenessState.cursor == null ? null : Y.createRelativePositionFromJSON(localAwarenessState.cursor.head);
       if (sel != null) {
-        const anchor = createRelativePositionFromTypeIndex(ytext, sel.anchor);
-        const head = createRelativePositionFromTypeIndex(ytext, sel.head);
-        if (localAwarenessState.cursor == null || !compareRelativePositions(currentAnchor, anchor) || !compareRelativePositions(currentHead, head)) {
+        const anchor = Y.createRelativePositionFromTypeIndex(ytext, sel.anchor);
+        const head = Y.createRelativePositionFromTypeIndex(ytext, sel.head);
+        if (localAwarenessState.cursor == null || !Y.compareRelativePositions(currentAnchor, anchor) || !Y.compareRelativePositions(currentHead, head)) {
           awareness.setLocalStateField("cursor", {
             anchor,
             head
@@ -14773,8 +11916,8 @@ class YRemoteSelectionsPluginValue {
       if (cursor == null || cursor.anchor == null || cursor.head == null) {
         return;
       }
-      const anchor = createAbsolutePositionFromRelativePosition(cursor.anchor, ydoc);
-      const head = createAbsolutePositionFromRelativePosition(cursor.head, ydoc);
+      const anchor = Y.createAbsolutePositionFromRelativePosition(cursor.anchor, ydoc);
+      const head = Y.createAbsolutePositionFromRelativePosition(cursor.head, ydoc);
       if (anchor == null || head == null || anchor.type !== ytext || head.type !== ytext) {
         return;
       }
@@ -14938,7 +12081,7 @@ class YUndoManagerPluginValue {
 const yUndoManager = ViewPlugin.fromClass(YUndoManagerPluginValue);
 const undo = ({ state, dispatch }) => state.facet(yUndoManagerFacet).undo() || true;
 const redo = ({ state, dispatch }) => state.facet(yUndoManagerFacet).redo() || true;
-const yCollab = (ytext, awareness, { undoManager = new UndoManager(ytext) } = {}) => {
+const yCollab = (ytext, awareness, { undoManager = new Y.UndoManager(ytext) } = {}) => {
   const ySyncConfig = new YSyncConfig(ytext, awareness);
   const plugins = [
     ySyncFacet.of(ySyncConfig),
@@ -15113,11 +12256,11 @@ class NodeType {
   names, separated by spaces, in a single property name to map
   multiple node names to a single value.
   */
-  static match(map2) {
+  static match(map) {
     let direct = /* @__PURE__ */ Object.create(null);
-    for (let prop in map2)
+    for (let prop in map)
       for (let name2 of prop.split(" "))
-        direct[name2] = map2[prop];
+        direct[name2] = map[prop];
     return (node) => {
       for (let groups = node.prop(NodeProp.group), i = -1; i < (groups ? groups.length : 0); i++) {
         let found = direct[i < 0 ? node.name : groups[i]];
@@ -15179,11 +12322,11 @@ class Tree {
   /**
   Construct a new tree. See also [`Tree.build`](#common.Tree^build).
   */
-  constructor(type, children, positions, length2, props) {
+  constructor(type, children, positions, length, props) {
     this.type = type;
     this.children = children;
     this.positions = positions;
-    this.length = length2;
+    this.length = length;
     this.props = null;
     if (props && props.length) {
       this.props = /* @__PURE__ */ Object.create(null);
@@ -15327,7 +12470,7 @@ class Tree {
   [`NodeType.none`](#common.NodeType^none).
   */
   balance(config = {}) {
-    return this.children.length <= 8 ? this : balanceRange(NodeType.none, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length2) => new Tree(this.type, children, positions, length2, this.propValues), config.makeTree || ((children, positions, length2) => new Tree(NodeType.none, children, positions, length2)));
+    return this.children.length <= 8 ? this : balanceRange(NodeType.none, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length) => new Tree(this.type, children, positions, length, this.propValues), config.makeTree || ((children, positions, length) => new Tree(NodeType.none, children, positions, length)));
   }
   /**
   Build a tree from a postfix-ordered buffer of node information,
@@ -15369,9 +12512,9 @@ class TreeBuffer {
   /**
   Create a tree buffer.
   */
-  constructor(buffer, length2, set) {
+  constructor(buffer, length, set) {
     this.buffer = buffer;
-    this.length = length2;
+    this.length = length;
     this.set = set;
   }
   /**
@@ -15428,15 +12571,15 @@ class TreeBuffer {
   */
   slice(startI, endI, from2) {
     let b = this.buffer;
-    let copy2 = new Uint16Array(endI - startI), len = 0;
+    let copy = new Uint16Array(endI - startI), len = 0;
     for (let i = startI, j = 0; i < endI; ) {
-      copy2[j++] = b[i++];
-      copy2[j++] = b[i++] - from2;
-      let to = copy2[j++] = b[i++] - from2;
-      copy2[j++] = b[i++] - startI;
+      copy[j++] = b[i++];
+      copy[j++] = b[i++] - from2;
+      let to = copy[j++] = b[i++] - from2;
+      copy[j++] = b[i++] - startI;
       len = Math.max(len, to);
     }
-    return new TreeBuffer(copy2, len, this.set);
+    return new TreeBuffer(copy, len, this.set);
   }
 }
 function checkSide(side, pos, from2, to) {
@@ -16296,15 +13439,15 @@ function buildTree(data) {
     }
   }
   function makeBalanced(type) {
-    return (children2, positions2, length3) => {
+    return (children2, positions2, length2) => {
       let lookAhead2 = 0, lastI = children2.length - 1, last, lookAheadProp;
       if (lastI >= 0 && (last = children2[lastI]) instanceof Tree) {
-        if (!lastI && last.type == type && last.length == length3)
+        if (!lastI && last.type == type && last.length == length2)
           return last;
         if (lookAheadProp = last.prop(NodeProp.lookAhead))
           lookAhead2 = positions2[lastI] + last.length + lookAheadProp;
       }
-      return makeTree(type, children2, positions2, length3, lookAhead2);
+      return makeTree(type, children2, positions2, length2, lookAhead2);
     };
   }
   function makeRepeatLeaf(children2, positions2, base2, i, from2, to, type, lookAhead2) {
@@ -16316,7 +13459,7 @@ function buildTree(data) {
     children2.push(makeTree(nodeSet2.types[type], localChildren, localPositions, to - from2, lookAhead2 - to));
     positions2.push(from2 - base2);
   }
-  function makeTree(type, children2, positions2, length3, lookAhead2 = 0, props) {
+  function makeTree(type, children2, positions2, length2, lookAhead2 = 0, props) {
     if (contextHash) {
       let pair2 = [NodeProp.contextHash, contextHash];
       props = props ? [pair2].concat(props) : [pair2];
@@ -16325,7 +13468,7 @@ function buildTree(data) {
       let pair2 = [NodeProp.lookAhead, lookAhead2];
       props = props ? [pair2].concat(props) : [pair2];
     }
-    return new Tree(type, children2, positions2, length3, props);
+    return new Tree(type, children2, positions2, length2, props);
   }
   function findBufferSize(maxSize, inRepeat) {
     let fork = cursor.fork();
@@ -16395,8 +13538,8 @@ function buildTree(data) {
   let children = [], positions = [];
   while (cursor.pos > 0)
     takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1, 0);
-  let length2 = (_a2 = data.length) !== null && _a2 !== void 0 ? _a2 : children.length ? positions[0] + children[0].length : 0;
-  return new Tree(types2[data.topID], children.reverse(), positions.reverse(), length2);
+  let length = (_a2 = data.length) !== null && _a2 !== void 0 ? _a2 : children.length ? positions[0] + children[0].length : 0;
+  return new Tree(types2[data.topID], children.reverse(), positions.reverse(), length);
 }
 const nodeSizeCache = /* @__PURE__ */ new WeakMap();
 function nodeSize(balanceType, node) {
@@ -16416,7 +13559,7 @@ function nodeSize(balanceType, node) {
   }
   return size;
 }
-function balanceRange(balanceType, children, positions, from2, to, start2, length2, mkTop, mkTree) {
+function balanceRange(balanceType, children, positions, from2, to, start2, length, mkTop, mkTree) {
   let total = 0;
   for (let i = from2; i < to; i++)
     total += nodeSize(balanceType, children[i]);
@@ -16443,14 +13586,14 @@ function balanceRange(balanceType, children, positions, from2, to, start2, lengt
         }
         localChildren.push(children2[groupFrom]);
       } else {
-        let length3 = positions2[i - 1] + children2[i - 1].length - groupStart;
-        localChildren.push(balanceRange(balanceType, children2, positions2, groupFrom, i, groupStart, length3, null, mkTree));
+        let length2 = positions2[i - 1] + children2[i - 1].length - groupStart;
+        localChildren.push(balanceRange(balanceType, children2, positions2, groupFrom, i, groupStart, length2, null, mkTree));
       }
       localPositions.push(groupStart + offset - start2);
     }
   }
   divide(children, positions, from2, to, 0);
-  return (mkTop || mkTree)(localChildren, localPositions, length2);
+  return (mkTop || mkTree)(localChildren, localPositions, length);
 }
 class NodeWeakMap {
   constructor() {
@@ -16807,7 +13950,7 @@ function materialize(cursor) {
   } while (!cursor.tree);
   let base2 = cursor.tree, i = base2.children.indexOf(buffer);
   let buf = base2.children[i], b = buf.buffer, newStack = [i];
-  function split(startI, endI, type, innerOffset, length2, stackPos) {
+  function split(startI, endI, type, innerOffset, length, stackPos) {
     let targetI = stack[stackPos];
     let children = [], positions = [];
     sliceBuf(buf, startI, targetI, children, positions, innerOffset);
@@ -16817,7 +13960,7 @@ function materialize(cursor) {
     children.push(child);
     positions.push(from2 - innerOffset);
     sliceBuf(buf, b[targetI + 3], endI, children, positions, innerOffset);
-    return new Tree(type, children, positions, length2);
+    return new Tree(type, children, positions, length);
   }
   base2.children[i] = split(0, b.length, NodeType.none, 0, buf.length, stack.length - 1);
   for (let index of newStack) {
@@ -16912,7 +14055,7 @@ let FragmentCursor$1 = class FragmentCursor {
   }
 };
 function punchRanges(outer, ranges) {
-  let copy2 = null, current = ranges;
+  let copy = null, current = ranges;
   for (let i = 1, j = 0; i < outer.length; i++) {
     let gapFrom = outer[i - 1].to, gapTo = outer[i].from;
     for (; j < current.length; j++) {
@@ -16921,16 +14064,16 @@ function punchRanges(outer, ranges) {
         break;
       if (r2.to <= gapFrom)
         continue;
-      if (!copy2)
-        current = copy2 = ranges.slice();
+      if (!copy)
+        current = copy = ranges.slice();
       if (r2.from < gapFrom) {
-        copy2[j] = new Range2(r2.from, gapFrom);
+        copy[j] = new Range2(r2.from, gapFrom);
         if (r2.to > gapTo)
-          copy2.splice(j + 1, 0, new Range2(gapTo, r2.to));
+          copy.splice(j + 1, 0, new Range2(gapTo, r2.to));
       } else if (r2.to > gapTo) {
-        copy2[j--] = new Range2(gapTo, r2.to);
+        copy[j--] = new Range2(gapTo, r2.to);
       } else {
-        copy2.splice(j--, 1);
+        copy.splice(j--, 1);
       }
     }
   }
@@ -17142,13 +14285,13 @@ class Rule {
 }
 Rule.empty = new Rule([], 2, null);
 function tagHighlighter(tags2, options) {
-  let map2 = /* @__PURE__ */ Object.create(null);
+  let map = /* @__PURE__ */ Object.create(null);
   for (let style of tags2) {
     if (!Array.isArray(style.tag))
-      map2[style.tag.id] = style.class;
+      map[style.tag.id] = style.class;
     else
       for (let tag of style.tag)
-        map2[tag.id] = style.class;
+        map[tag.id] = style.class;
   }
   let { scope, all = null } = options || {};
   return {
@@ -17156,7 +14299,7 @@ function tagHighlighter(tags2, options) {
       let cls = all;
       for (let tag of tags3) {
         for (let sub of tag.set) {
-          let tagClass = map2[sub.id];
+          let tagClass = map[sub.id];
           if (tagClass) {
             cls = cls ? cls + " " + tagClass : tagClass;
             break;
@@ -19639,10 +16782,10 @@ class Stack {
   @internal
   */
   recoverByDelete(next, nextEnd) {
-    let isNode2 = next <= this.p.parser.maxNode;
-    if (isNode2)
+    let isNode = next <= this.p.parser.maxNode;
+    if (isNode)
       this.storeNode(next, this.pos, nextEnd, 4);
-    this.storeNode(0, this.pos, nextEnd, isNode2 ? 8 : 4);
+    this.storeNode(0, this.pos, nextEnd, isNode ? 8 : 4);
     this.pos = this.reducePos = nextEnd;
     this.score -= 190;
   }
@@ -21043,42 +18186,42 @@ class LRParser extends Parser {
   kept from the original parser.
   */
   configure(config) {
-    let copy2 = Object.assign(Object.create(LRParser.prototype), this);
+    let copy = Object.assign(Object.create(LRParser.prototype), this);
     if (config.props)
-      copy2.nodeSet = this.nodeSet.extend(...config.props);
+      copy.nodeSet = this.nodeSet.extend(...config.props);
     if (config.top) {
       let info = this.topRules[config.top];
       if (!info)
         throw new RangeError(`Invalid top rule name ${config.top}`);
-      copy2.top = info;
+      copy.top = info;
     }
     if (config.tokenizers)
-      copy2.tokenizers = this.tokenizers.map((t2) => {
+      copy.tokenizers = this.tokenizers.map((t2) => {
         let found = config.tokenizers.find((r2) => r2.from == t2);
         return found ? found.to : t2;
       });
     if (config.specializers) {
-      copy2.specializers = this.specializers.slice();
-      copy2.specializerSpecs = this.specializerSpecs.map((s, i) => {
+      copy.specializers = this.specializers.slice();
+      copy.specializerSpecs = this.specializerSpecs.map((s, i) => {
         let found = config.specializers.find((r2) => r2.from == s.external);
         if (!found)
           return s;
         let spec = Object.assign(Object.assign({}, s), { external: found.to });
-        copy2.specializers[i] = getSpecializer(spec);
+        copy.specializers[i] = getSpecializer(spec);
         return spec;
       });
     }
     if (config.contextTracker)
-      copy2.context = config.contextTracker;
+      copy.context = config.contextTracker;
     if (config.dialect)
-      copy2.dialect = this.parseDialect(config.dialect);
+      copy.dialect = this.parseDialect(config.dialect);
     if (config.strict != null)
-      copy2.strict = config.strict;
+      copy.strict = config.strict;
     if (config.wrap)
-      copy2.wrappers = copy2.wrappers.concat(config.wrap);
+      copy.wrappers = copy.wrappers.concat(config.wrap);
     if (config.bufferLength != null)
-      copy2.bufferLength = config.bufferLength;
-    return copy2;
+      copy.bufferLength = config.bufferLength;
+    return copy;
   }
   /**
   Tells you whether any [parse wrappers](#lr.ParserConfig.wrap)
@@ -24148,7 +21291,7 @@ const jsonLanguage = /* @__PURE__ */ LRLanguage.define({
 function json() {
   return new LanguageSupport(jsonLanguage);
 }
-const castOpen = 1, HeredocString = 2, interpolatedStringContent = 263, EscapeSequence = 3, afterInterpolation = 264, automaticSemicolon = 265, eof$1 = 266, abstract = 4, and = 5, array = 6, as = 7, Boolean$1 = 8, _break = 9, _case = 10, _catch = 11, clone = 12, _const = 13, _continue = 14, _default = 15, declare = 16, _do = 17, echo = 18, _else = 19, elseif = 20, enddeclare = 21, endfor = 22, endforeach = 23, endif = 24, endswitch = 25, endwhile = 26, _enum = 27, _extends = 28, final = 29, _finally = 30, fn = 31, _for = 32, foreach = 33, from = 34, _function = 35, global$1 = 36, goto = 37, _if = 38, _implements = 39, include = 40, include_once = 41, _instanceof = 42, insteadof = 43, _interface = 44, list = 45, match = 46, namespace = 47, _new = 48, _null = 49, or = 50, print = 51, _require = 52, require_once = 53, _return = 54, _switch = 55, _throw = 56, trait = 57, _try = 58, unset = 59, use = 60, _var = 61, Visibility = 62, _while = 63, xor = 64, _yield = 65;
+const castOpen = 1, HeredocString = 2, interpolatedStringContent = 263, EscapeSequence = 3, afterInterpolation = 264, automaticSemicolon = 265, eof$1 = 266, abstract = 4, and = 5, array = 6, as = 7, Boolean$1 = 8, _break = 9, _case = 10, _catch = 11, clone = 12, _const = 13, _continue = 14, _default = 15, declare = 16, _do = 17, echo = 18, _else = 19, elseif = 20, enddeclare = 21, endfor = 22, endforeach = 23, endif = 24, endswitch = 25, endwhile = 26, _enum = 27, _extends = 28, final = 29, _finally = 30, fn = 31, _for = 32, foreach = 33, from = 34, _function = 35, global = 36, goto = 37, _if = 38, _implements = 39, include = 40, include_once = 41, _instanceof = 42, insteadof = 43, _interface = 44, list = 45, match = 46, namespace = 47, _new = 48, _null = 49, or = 50, print = 51, _require = 52, require_once = 53, _return = 54, _switch = 55, _throw = 56, trait = 57, _try = 58, unset = 59, use = 60, _var = 61, Visibility = 62, _while = 63, xor = 64, _yield = 65;
 const keywordMap = {
   abstract,
   and,
@@ -24183,7 +21326,7 @@ const keywordMap = {
   foreach,
   from,
   function: _function,
-  global: global$1,
+  global,
   goto,
   if: _if,
   implements: _implements,
@@ -29303,11 +26446,11 @@ const variables = () => ViewPlugin.fromClass(
     )
   }
 );
-const hasProvider = (params2) => "provider" in params2 && !!toValue(params2.provider);
-const useCodeMirror = (params2) => {
+const hasProvider = (params) => "provider" in params && !!toValue(params.provider);
+const useCodeMirror = (params) => {
   const codeMirror = ref(null);
   watch(
-    params2.codeMirrorRef,
+    params.codeMirrorRef,
     () => {
       var _a2;
       (_a2 = codeMirror.value) == null ? void 0 : _a2.destroy();
@@ -29320,38 +26463,38 @@ const useCodeMirror = (params2) => {
     return (_a2 = codeMirror.value) == null ? void 0 : _a2.destroy();
   });
   function mountCodeMirror() {
-    if (params2.codeMirrorRef.value) {
-      const provider = hasProvider(params2) ? toValue(params2.provider) : null;
+    if (params.codeMirrorRef.value) {
+      const provider = hasProvider(params) ? toValue(params.provider) : null;
       const extensions = getCodeMirrorExtensions({
         ...extensionConfig.value,
         provider
       });
       codeMirror.value = new EditorView({
-        parent: params2.codeMirrorRef.value,
+        parent: params.codeMirrorRef.value,
         extensions
       });
-      if (!hasProvider(params2))
-        setCodeMirrorContent(toValue(params2.content));
+      if (!hasProvider(params))
+        setCodeMirrorContent(toValue(params.content));
     }
   }
   const extensionConfig = computed(() => ({
-    onChange: params2.onChange,
-    onBlur: params2.onBlur,
-    onFocus: params2.onFocus,
-    languages: toValue(params2.languages),
-    classes: toValue(params2.classes),
-    readOnly: toValue(params2.readOnly),
-    lineNumbers: toValue(params2.lineNumbers),
-    withVariables: toValue(params2.withVariables),
-    disableEnter: toValue(params2.withVariables),
-    withoutTheme: toValue(params2.withoutTheme),
-    additionalExtensions: toValue(params2.extensions)
+    onChange: params.onChange,
+    onBlur: params.onBlur,
+    onFocus: params.onFocus,
+    languages: toValue(params.languages),
+    classes: toValue(params.classes),
+    readOnly: toValue(params.readOnly),
+    lineNumbers: toValue(params.lineNumbers),
+    withVariables: toValue(params.withVariables),
+    disableEnter: toValue(params.withVariables),
+    withoutTheme: toValue(params.withoutTheme),
+    additionalExtensions: toValue(params.extensions)
   }));
   watch(
-    () => hasProvider(params2) ? toValue(params2.provider) : null,
+    () => hasProvider(params) ? toValue(params.provider) : null,
     () => {
       var _a2;
-      if (hasProvider(params2)) {
+      if (hasProvider(params)) {
         (_a2 = codeMirror.value) == null ? void 0 : _a2.destroy();
         mountCodeMirror();
       }
@@ -29363,7 +26506,7 @@ const useCodeMirror = (params2) => {
       if (!codeMirror.value)
         return;
       else {
-        const provider = hasProvider(params2) ? toValue(params2.provider) : null;
+        const provider = hasProvider(params) ? toValue(params.provider) : null;
         const extensions = getCodeMirrorExtensions({
           ...extensionConfig.value,
           provider
@@ -29395,11 +26538,11 @@ const useCodeMirror = (params2) => {
     });
   };
   watch(
-    () => toValue(params2.content),
+    () => toValue(params.content),
     () => {
-      if (hasProvider(params2))
+      if (hasProvider(params))
         return;
-      setCodeMirrorContent(toValue(params2.content));
+      setCodeMirrorContent(toValue(params.content));
     },
     { immediate: true }
   );