@jxsuite/studio 2.0.0 → 2.1.0

package/dist/chunks/studio-rq0vxb19.js

@@ -1,3744 +0,0 @@
-import {
-  defaultContentFormat,
-  formatByName,
-  formatForPath
-} from "./studio-97qcgvdn.js";
-import {
-  getPlatform
-} from "./studio-9smfzqhc.js";
-import {
-  applyDocOpToDoc,
-  childArray,
-  cloneValue
-} from "./studio-5ehhackm.js";
-import {
-  __require
-} from "./studio-md4gps17.js";
-
-// ../../node_modules/@vue/shared/dist/shared.esm-bundler.js
-function makeMap(str) {
-  const map = /* @__PURE__ */ Object.create(null);
-  for (const key of str.split(","))
-    map[key] = 1;
-  return (val) => (val in map);
-}
-var EMPTY_OBJ = Object.freeze({});
-var EMPTY_ARR = Object.freeze([]);
-var extend = Object.assign;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-var hasOwn = (val, key) => hasOwnProperty.call(val, key);
-var isArray = Array.isArray;
-var isMap = (val) => toTypeString(val) === "[object Map]";
-var isFunction = (val) => typeof val === "function";
-var isString = (val) => typeof val === "string";
-var isSymbol = (val) => typeof val === "symbol";
-var isObject = (val) => val !== null && typeof val === "object";
-var objectToString = Object.prototype.toString;
-var toTypeString = (value) => objectToString.call(value);
-var toRawType = (value) => {
-  return toTypeString(value).slice(8, -1);
-};
-var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
-var cacheStringFunction = (fn) => {
-  const cache = /* @__PURE__ */ Object.create(null);
-  return (str) => {
-    const hit = cache[str];
-    return hit || (cache[str] = fn(str));
-  };
-};
-var camelizeRE = /-\w/g;
-var camelize = cacheStringFunction((str) => {
-  return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
-});
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
-var capitalize = cacheStringFunction((str) => {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-});
-var toHandlerKey = cacheStringFunction((str) => {
-  const s = str ? `on${capitalize(str)}` : ``;
-  return s;
-});
-var hasChanged = (value, oldValue) => !Object.is(value, oldValue);
-var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
-var isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
-
-// ../../node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
-function warn(msg, ...args) {
-  console.warn(`[Vue warn] ${msg}`, ...args);
-}
-var activeEffectScope;
-
-class EffectScope {
-  constructor(detached = false) {
-    this.detached = detached;
-    this._active = true;
-    this._on = 0;
-    this.effects = [];
-    this.cleanups = [];
-    this._isPaused = false;
-    this._warnOnRun = true;
-    this.__v_skip = true;
-    if (!detached && activeEffectScope) {
-      if (activeEffectScope.active) {
-        this.parent = activeEffectScope;
-        this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
-      } else {
-        this._active = false;
-        this._warnOnRun = false;
-      }
-    }
-  }
-  get active() {
-    return this._active;
-  }
-  pause() {
-    if (this._active) {
-      this._isPaused = true;
-      let i, l;
-      if (this.scopes) {
-        const scopes = this.scopes.slice();
-        for (i = 0, l = scopes.length;i < l; i++) {
-          scopes[i].pause();
-        }
-      }
-      for (i = 0, l = this.effects.length;i < l; i++) {
-        this.effects[i].pause();
-      }
-    }
-  }
-  resume() {
-    if (this._active) {
-      if (this._isPaused) {
-        this._isPaused = false;
-        let i, l;
-        if (this.scopes) {
-          const scopes = this.scopes.slice();
-          for (i = 0, l = scopes.length;i < l; i++) {
-            scopes[i].resume();
-          }
-        }
-        const effects = this.effects.slice();
-        for (i = 0, l = effects.length;i < l; i++) {
-          effects[i].resume();
-        }
-      }
-    }
-  }
-  run(fn) {
-    if (this._active) {
-      const currentEffectScope = activeEffectScope;
-      try {
-        activeEffectScope = this;
-        return fn();
-      } finally {
-        activeEffectScope = currentEffectScope;
-      }
-    } else if (this._warnOnRun) {
-      warn(`cannot run an inactive effect scope.`);
-    }
-  }
-  on() {
-    if (++this._on === 1) {
-      this.prevScope = activeEffectScope;
-      activeEffectScope = this;
-    }
-  }
-  off() {
-    if (this._on > 0 && --this._on === 0) {
-      if (activeEffectScope === this) {
-        activeEffectScope = this.prevScope;
-      } else {
-        let current = activeEffectScope;
-        while (current) {
-          if (current.prevScope === this) {
-            current.prevScope = this.prevScope;
-            break;
-          }
-          current = current.prevScope;
-        }
-      }
-      this.prevScope = undefined;
-    }
-  }
-  stop(fromParent) {
-    if (this._active) {
-      this._active = false;
-      let i, l;
-      for (i = 0, l = this.effects.length;i < l; i++) {
-        this.effects[i].stop();
-      }
-      this.effects.length = 0;
-      for (i = 0, l = this.cleanups.length;i < l; i++) {
-        this.cleanups[i]();
-      }
-      this.cleanups.length = 0;
-      if (this.scopes) {
-        const scopes = this.scopes.slice();
-        for (i = 0, l = scopes.length;i < l; i++) {
-          scopes[i].stop(true);
-        }
-        this.scopes.length = 0;
-      }
-      if (!this.detached && this.parent && !fromParent) {
-        const last = this.parent.scopes.pop();
-        if (last && last !== this) {
-          this.parent.scopes[this.index] = last;
-          last.index = this.index;
-        }
-      }
-      this.parent = undefined;
-    }
-  }
-}
-function effectScope(detached) {
-  return new EffectScope(detached);
-}
-function onScopeDispose(fn, failSilently = false) {
-  if (activeEffectScope) {
-    activeEffectScope.cleanups.push(fn);
-  } else if (!failSilently) {
-    warn(`onScopeDispose() is called when there is no active effect scope to be associated with.`);
-  }
-}
-var activeSub;
-var pausedQueueEffects = /* @__PURE__ */ new WeakSet;
-
-class ReactiveEffect {
-  constructor(fn) {
-    this.fn = fn;
-    this.deps = undefined;
-    this.depsTail = undefined;
-    this.flags = 1 | 4;
-    this.next = undefined;
-    this.cleanup = undefined;
-    this.scheduler = undefined;
-    if (activeEffectScope) {
-      if (activeEffectScope.active) {
-        activeEffectScope.effects.push(this);
-      } else {
-        this.flags &= -2;
-      }
-    }
-  }
-  pause() {
-    this.flags |= 64;
-  }
-  resume() {
-    if (this.flags & 64) {
-      this.flags &= -65;
-      if (pausedQueueEffects.has(this)) {
-        pausedQueueEffects.delete(this);
-        this.trigger();
-      }
-    }
-  }
-  notify() {
-    if (this.flags & 2 && !(this.flags & 32)) {
-      return;
-    }
-    if (!(this.flags & 8)) {
-      batch(this);
-    }
-  }
-  run() {
-    if (!(this.flags & 1)) {
-      return this.fn();
-    }
-    this.flags |= 2;
-    cleanupEffect(this);
-    prepareDeps(this);
-    const prevEffect = activeSub;
-    const prevShouldTrack = shouldTrack;
-    activeSub = this;
-    shouldTrack = true;
-    try {
-      return this.fn();
-    } finally {
-      if (activeSub !== this) {
-        warn("Active effect was not restored correctly - this is likely a Vue internal bug.");
-      }
-      cleanupDeps(this);
-      activeSub = prevEffect;
-      shouldTrack = prevShouldTrack;
-      this.flags &= -3;
-    }
-  }
-  stop() {
-    if (this.flags & 1) {
-      for (let link = this.deps;link; link = link.nextDep) {
-        removeSub(link);
-      }
-      this.deps = this.depsTail = undefined;
-      cleanupEffect(this);
-      this.onStop && this.onStop();
-      this.flags &= -2;
-    }
-  }
-  trigger() {
-    if (this.flags & 64) {
-      pausedQueueEffects.add(this);
-    } else if (this.scheduler) {
-      this.scheduler();
-    } else {
-      this.runIfDirty();
-    }
-  }
-  runIfDirty() {
-    if (isDirty(this)) {
-      this.run();
-    }
-  }
-  get dirty() {
-    return isDirty(this);
-  }
-}
-var batchDepth = 0;
-var batchedSub;
-var batchedComputed;
-function batch(sub, isComputed = false) {
-  sub.flags |= 8;
-  if (isComputed) {
-    sub.next = batchedComputed;
-    batchedComputed = sub;
-    return;
-  }
-  sub.next = batchedSub;
-  batchedSub = sub;
-}
-function startBatch() {
-  batchDepth++;
-}
-function endBatch() {
-  if (--batchDepth > 0) {
-    return;
-  }
-  if (batchedComputed) {
-    let e = batchedComputed;
-    batchedComputed = undefined;
-    while (e) {
-      const next = e.next;
-      e.next = undefined;
-      e.flags &= -9;
-      e = next;
-    }
-  }
-  let error;
-  while (batchedSub) {
-    let e = batchedSub;
-    batchedSub = undefined;
-    while (e) {
-      const next = e.next;
-      e.next = undefined;
-      e.flags &= -9;
-      if (e.flags & 1) {
-        try {
-          e.trigger();
-        } catch (err) {
-          if (!error)
-            error = err;
-        }
-      }
-      e = next;
-    }
-  }
-  if (error)
-    throw error;
-}
-function prepareDeps(sub) {
-  for (let link = sub.deps;link; link = link.nextDep) {
-    link.version = -1;
-    link.prevActiveLink = link.dep.activeLink;
-    link.dep.activeLink = link;
-  }
-}
-function cleanupDeps(sub) {
-  let head;
-  let tail = sub.depsTail;
-  let link = tail;
-  while (link) {
-    const prev = link.prevDep;
-    if (link.version === -1) {
-      if (link === tail)
-        tail = prev;
-      removeSub(link);
-      removeDep(link);
-    } else {
-      head = link;
-    }
-    link.dep.activeLink = link.prevActiveLink;
-    link.prevActiveLink = undefined;
-    link = prev;
-  }
-  sub.deps = head;
-  sub.depsTail = tail;
-}
-function isDirty(sub) {
-  for (let link = sub.deps;link; link = link.nextDep) {
-    if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
-      return true;
-    }
-  }
-  if (sub._dirty) {
-    return true;
-  }
-  return false;
-}
-function refreshComputed(computed) {
-  if (computed.flags & 4 && !(computed.flags & 16)) {
-    return;
-  }
-  computed.flags &= -17;
-  if (computed.globalVersion === globalVersion) {
-    return;
-  }
-  computed.globalVersion = globalVersion;
-  if (!computed.isSSR && computed.flags & 128 && (!computed.deps && !computed._dirty || !isDirty(computed))) {
-    return;
-  }
-  computed.flags |= 2;
-  const dep = computed.dep;
-  const prevSub = activeSub;
-  const prevShouldTrack = shouldTrack;
-  activeSub = computed;
-  shouldTrack = true;
-  try {
-    prepareDeps(computed);
-    const value = computed.fn(computed._value);
-    if (dep.version === 0 || hasChanged(value, computed._value)) {
-      computed.flags |= 128;
-      computed._value = value;
-      dep.version++;
-    }
-  } catch (err) {
-    dep.version++;
-    throw err;
-  } finally {
-    activeSub = prevSub;
-    shouldTrack = prevShouldTrack;
-    cleanupDeps(computed);
-    computed.flags &= -3;
-  }
-}
-function removeSub(link, soft = false) {
-  const { dep, prevSub, nextSub } = link;
-  if (prevSub) {
-    prevSub.nextSub = nextSub;
-    link.prevSub = undefined;
-  }
-  if (nextSub) {
-    nextSub.prevSub = prevSub;
-    link.nextSub = undefined;
-  }
-  if (dep.subsHead === link) {
-    dep.subsHead = nextSub;
-  }
-  if (dep.subs === link) {
-    dep.subs = prevSub;
-    if (!prevSub && dep.computed) {
-      dep.computed.flags &= -5;
-      for (let l = dep.computed.deps;l; l = l.nextDep) {
-        removeSub(l, true);
-      }
-    }
-  }
-  if (!soft && !--dep.sc && dep.map) {
-    dep.map.delete(dep.key);
-  }
-}
-function removeDep(link) {
-  const { prevDep, nextDep } = link;
-  if (prevDep) {
-    prevDep.nextDep = nextDep;
-    link.prevDep = undefined;
-  }
-  if (nextDep) {
-    nextDep.prevDep = prevDep;
-    link.nextDep = undefined;
-  }
-}
-function effect(fn, options) {
-  if (fn.effect instanceof ReactiveEffect) {
-    fn = fn.effect.fn;
-  }
-  const e = new ReactiveEffect(fn);
-  if (options) {
-    extend(e, options);
-  }
-  try {
-    e.run();
-  } catch (err) {
-    e.stop();
-    throw err;
-  }
-  const runner = e.run.bind(e);
-  runner.effect = e;
-  return runner;
-}
-var shouldTrack = true;
-var trackStack = [];
-function pauseTracking() {
-  trackStack.push(shouldTrack);
-  shouldTrack = false;
-}
-function resetTracking() {
-  const last = trackStack.pop();
-  shouldTrack = last === undefined ? true : last;
-}
-function onEffectCleanup(fn, failSilently = false) {
-  if (activeSub instanceof ReactiveEffect) {
-    activeSub.cleanup = fn;
-  } else if (!failSilently) {
-    warn(`onEffectCleanup() was called when there was no active effect to associate with.`);
-  }
-}
-function cleanupEffect(e) {
-  const { cleanup } = e;
-  e.cleanup = undefined;
-  if (cleanup) {
-    const prevSub = activeSub;
-    activeSub = undefined;
-    try {
-      cleanup();
-    } finally {
-      activeSub = prevSub;
-    }
-  }
-}
-var globalVersion = 0;
-
-class Link {
-  constructor(sub, dep) {
-    this.sub = sub;
-    this.dep = dep;
-    this.version = dep.version;
-    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = undefined;
-  }
-}
-
-class Dep {
-  constructor(computed) {
-    this.computed = computed;
-    this.version = 0;
-    this.activeLink = undefined;
-    this.subs = undefined;
-    this.map = undefined;
-    this.key = undefined;
-    this.sc = 0;
-    this.__v_skip = true;
-    if (true) {
-      this.subsHead = undefined;
-    }
-  }
-  track(debugInfo) {
-    if (!activeSub || !shouldTrack || activeSub === this.computed) {
-      return;
-    }
-    let link = this.activeLink;
-    if (link === undefined || link.sub !== activeSub) {
-      link = this.activeLink = new Link(activeSub, this);
-      if (!activeSub.deps) {
-        activeSub.deps = activeSub.depsTail = link;
-      } else {
-        link.prevDep = activeSub.depsTail;
-        activeSub.depsTail.nextDep = link;
-        activeSub.depsTail = link;
-      }
-      addSub(link);
-    } else if (link.version === -1) {
-      link.version = this.version;
-      if (link.nextDep) {
-        const next = link.nextDep;
-        next.prevDep = link.prevDep;
-        if (link.prevDep) {
-          link.prevDep.nextDep = next;
-        }
-        link.prevDep = activeSub.depsTail;
-        link.nextDep = undefined;
-        activeSub.depsTail.nextDep = link;
-        activeSub.depsTail = link;
-        if (activeSub.deps === link) {
-          activeSub.deps = next;
-        }
-      }
-    }
-    if (activeSub.onTrack) {
-      activeSub.onTrack(extend({
-        effect: activeSub
-      }, debugInfo));
-    }
-    return link;
-  }
-  trigger(debugInfo) {
-    this.version++;
-    globalVersion++;
-    this.notify(debugInfo);
-  }
-  notify(debugInfo) {
-    startBatch();
-    try {
-      if (true) {
-        for (let head = this.subsHead;head; head = head.nextSub) {
-          if (head.sub.onTrigger && !(head.sub.flags & 8)) {
-            head.sub.onTrigger(extend({
-              effect: head.sub
-            }, debugInfo));
-          }
-        }
-      }
-      for (let link = this.subs;link; link = link.prevSub) {
-        if (link.sub.notify()) {
-          link.sub.dep.notify();
-        }
-      }
-    } finally {
-      endBatch();
-    }
-  }
-}
-function addSub(link) {
-  link.dep.sc++;
-  if (link.sub.flags & 4) {
-    const computed = link.dep.computed;
-    if (computed && !link.dep.subs) {
-      computed.flags |= 4 | 16;
-      for (let l = computed.deps;l; l = l.nextDep) {
-        addSub(l);
-      }
-    }
-    const currentTail = link.dep.subs;
-    if (currentTail !== link) {
-      link.prevSub = currentTail;
-      if (currentTail)
-        currentTail.nextSub = link;
-    }
-    if (link.dep.subsHead === undefined) {
-      link.dep.subsHead = link;
-    }
-    link.dep.subs = link;
-  }
-}
-var targetMap = /* @__PURE__ */ new WeakMap;
-var ITERATE_KEY = /* @__PURE__ */ Symbol("Object iterate");
-var MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol("Map keys iterate");
-var ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol("Array iterate");
-function track(target, type, key) {
-  if (shouldTrack && activeSub) {
-    let depsMap = targetMap.get(target);
-    if (!depsMap) {
-      targetMap.set(target, depsMap = /* @__PURE__ */ new Map);
-    }
-    let dep = depsMap.get(key);
-    if (!dep) {
-      depsMap.set(key, dep = new Dep);
-      dep.map = depsMap;
-      dep.key = key;
-    }
-    if (true) {
-      dep.track({
-        target,
-        type,
-        key
-      });
-    } else {}
-  }
-}
-function trigger(target, type, key, newValue, oldValue, oldTarget) {
-  const depsMap = targetMap.get(target);
-  if (!depsMap) {
-    globalVersion++;
-    return;
-  }
-  const run = (dep) => {
-    if (dep) {
-      if (true) {
-        dep.trigger({
-          target,
-          type,
-          key,
-          newValue,
-          oldValue,
-          oldTarget
-        });
-      } else {}
-    }
-  };
-  startBatch();
-  if (type === "clear") {
-    depsMap.forEach(run);
-  } else {
-    const targetIsArray = isArray(target);
-    const isArrayIndex = targetIsArray && isIntegerKey(key);
-    if (targetIsArray && key === "length") {
-      const newLength = Number(newValue);
-      depsMap.forEach((dep, key2) => {
-        if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
-          run(dep);
-        }
-      });
-    } else {
-      if (key !== undefined || depsMap.has(undefined)) {
-        run(depsMap.get(key));
-      }
-      if (isArrayIndex) {
-        run(depsMap.get(ARRAY_ITERATE_KEY));
-      }
-      switch (type) {
-        case "add":
-          if (!targetIsArray) {
-            run(depsMap.get(ITERATE_KEY));
-            if (isMap(target)) {
-              run(depsMap.get(MAP_KEY_ITERATE_KEY));
-            }
-          } else if (isArrayIndex) {
-            run(depsMap.get("length"));
-          }
-          break;
-        case "delete":
-          if (!targetIsArray) {
-            run(depsMap.get(ITERATE_KEY));
-            if (isMap(target)) {
-              run(depsMap.get(MAP_KEY_ITERATE_KEY));
-            }
-          }
-          break;
-        case "set":
-          if (isMap(target)) {
-            run(depsMap.get(ITERATE_KEY));
-          }
-          break;
-      }
-    }
-  }
-  endBatch();
-}
-function reactiveReadArray(array) {
-  const raw = toRaw(array);
-  if (raw === array)
-    return raw;
-  track(raw, "iterate", ARRAY_ITERATE_KEY);
-  return isShallow(array) ? raw : raw.map(toReactive);
-}
-function shallowReadArray(arr) {
-  track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
-  return arr;
-}
-function toWrapped(target, item) {
-  if (isReadonly(target)) {
-    return isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
-  }
-  return toReactive(item);
-}
-var arrayInstrumentations = {
-  __proto__: null,
-  [Symbol.iterator]() {
-    return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
-  },
-  concat(...args) {
-    return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x));
-  },
-  entries() {
-    return iterator(this, "entries", (value) => {
-      value[1] = toWrapped(this, value[1]);
-      return value;
-    });
-  },
-  every(fn, thisArg) {
-    return apply(this, "every", fn, thisArg, undefined, arguments);
-  },
-  filter(fn, thisArg) {
-    return apply(this, "filter", fn, thisArg, (v) => v.map((item) => toWrapped(this, item)), arguments);
-  },
-  find(fn, thisArg) {
-    return apply(this, "find", fn, thisArg, (item) => toWrapped(this, item), arguments);
-  },
-  findIndex(fn, thisArg) {
-    return apply(this, "findIndex", fn, thisArg, undefined, arguments);
-  },
-  findLast(fn, thisArg) {
-    return apply(this, "findLast", fn, thisArg, (item) => toWrapped(this, item), arguments);
-  },
-  findLastIndex(fn, thisArg) {
-    return apply(this, "findLastIndex", fn, thisArg, undefined, arguments);
-  },
-  forEach(fn, thisArg) {
-    return apply(this, "forEach", fn, thisArg, undefined, arguments);
-  },
-  includes(...args) {
-    return searchProxy(this, "includes", args);
-  },
-  indexOf(...args) {
-    return searchProxy(this, "indexOf", args);
-  },
-  join(separator) {
-    return reactiveReadArray(this).join(separator);
-  },
-  lastIndexOf(...args) {
-    return searchProxy(this, "lastIndexOf", args);
-  },
-  map(fn, thisArg) {
-    return apply(this, "map", fn, thisArg, undefined, arguments);
-  },
-  pop() {
-    return noTracking(this, "pop");
-  },
-  push(...args) {
-    return noTracking(this, "push", args);
-  },
-  reduce(fn, ...args) {
-    return reduce(this, "reduce", fn, args);
-  },
-  reduceRight(fn, ...args) {
-    return reduce(this, "reduceRight", fn, args);
-  },
-  shift() {
-    return noTracking(this, "shift");
-  },
-  some(fn, thisArg) {
-    return apply(this, "some", fn, thisArg, undefined, arguments);
-  },
-  splice(...args) {
-    return noTracking(this, "splice", args);
-  },
-  toReversed() {
-    return reactiveReadArray(this).toReversed();
-  },
-  toSorted(comparer) {
-    return reactiveReadArray(this).toSorted(comparer);
-  },
-  toSpliced(...args) {
-    return reactiveReadArray(this).toSpliced(...args);
-  },
-  unshift(...args) {
-    return noTracking(this, "unshift", args);
-  },
-  values() {
-    return iterator(this, "values", (item) => toWrapped(this, item));
-  }
-};
-function iterator(self2, method, wrapValue) {
-  const arr = shallowReadArray(self2);
-  const iter = arr[method]();
-  if (arr !== self2 && !isShallow(self2)) {
-    iter._next = iter.next;
-    iter.next = () => {
-      const result = iter._next();
-      if (!result.done) {
-        result.value = wrapValue(result.value);
-      }
-      return result;
-    };
-  }
-  return iter;
-}
-var arrayProto = Array.prototype;
-function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
-  const arr = shallowReadArray(self2);
-  const needsWrap = arr !== self2 && !isShallow(self2);
-  const methodFn = arr[method];
-  if (methodFn !== arrayProto[method]) {
-    const result2 = methodFn.apply(self2, args);
-    return needsWrap ? toReactive(result2) : result2;
-  }
-  let wrappedFn = fn;
-  if (arr !== self2) {
-    if (needsWrap) {
-      wrappedFn = function(item, index) {
-        return fn.call(this, toWrapped(self2, item), index, self2);
-      };
-    } else if (fn.length > 2) {
-      wrappedFn = function(item, index) {
-        return fn.call(this, item, index, self2);
-      };
-    }
-  }
-  const result = methodFn.call(arr, wrappedFn, thisArg);
-  return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
-}
-function reduce(self2, method, fn, args) {
-  const arr = shallowReadArray(self2);
-  const needsWrap = arr !== self2 && !isShallow(self2);
-  let wrappedFn = fn;
-  let wrapInitialAccumulator = false;
-  if (arr !== self2) {
-    if (needsWrap) {
-      wrapInitialAccumulator = args.length === 0;
-      wrappedFn = function(acc, item, index) {
-        if (wrapInitialAccumulator) {
-          wrapInitialAccumulator = false;
-          acc = toWrapped(self2, acc);
-        }
-        return fn.call(this, acc, toWrapped(self2, item), index, self2);
-      };
-    } else if (fn.length > 3) {
-      wrappedFn = function(acc, item, index) {
-        return fn.call(this, acc, item, index, self2);
-      };
-    }
-  }
-  const result = arr[method](wrappedFn, ...args);
-  return wrapInitialAccumulator ? toWrapped(self2, result) : result;
-}
-function searchProxy(self2, method, args) {
-  const arr = toRaw(self2);
-  track(arr, "iterate", ARRAY_ITERATE_KEY);
-  const res = arr[method](...args);
-  if ((res === -1 || res === false) && isProxy(args[0])) {
-    args[0] = toRaw(args[0]);
-    return arr[method](...args);
-  }
-  return res;
-}
-function noTracking(self2, method, args = []) {
-  pauseTracking();
-  startBatch();
-  const res = toRaw(self2)[method].apply(self2, args);
-  endBatch();
-  resetTracking();
-  return res;
-}
-var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
-var builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
-function hasOwnProperty2(key) {
-  if (!isSymbol(key))
-    key = String(key);
-  const obj = toRaw(this);
-  track(obj, "has", key);
-  return obj.hasOwnProperty(key);
-}
-
-class BaseReactiveHandler {
-  constructor(_isReadonly = false, _isShallow = false) {
-    this._isReadonly = _isReadonly;
-    this._isShallow = _isShallow;
-  }
-  get(target, key, receiver) {
-    if (key === "__v_skip")
-      return target["__v_skip"];
-    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
-    if (key === "__v_isReactive") {
-      return !isReadonly2;
-    } else if (key === "__v_isReadonly") {
-      return isReadonly2;
-    } else if (key === "__v_isShallow") {
-      return isShallow2;
-    } else if (key === "__v_raw") {
-      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
-        return target;
-      }
-      return;
-    }
-    const targetIsArray = isArray(target);
-    if (!isReadonly2) {
-      let fn;
-      if (targetIsArray && (fn = arrayInstrumentations[key])) {
-        return fn;
-      }
-      if (key === "hasOwnProperty") {
-        return hasOwnProperty2;
-      }
-    }
-    const res = Reflect.get(target, key, isRef(target) ? target : receiver);
-    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
-      return res;
-    }
-    if (!isReadonly2) {
-      track(target, "get", key);
-    }
-    if (isShallow2) {
-      return res;
-    }
-    if (isRef(res)) {
-      const value = targetIsArray && isIntegerKey(key) ? res : res.value;
-      return isReadonly2 && isObject(value) ? readonly(value) : value;
-    }
-    if (isObject(res)) {
-      return isReadonly2 ? readonly(res) : reactive(res);
-    }
-    return res;
-  }
-}
-
-class MutableReactiveHandler extends BaseReactiveHandler {
-  constructor(isShallow2 = false) {
-    super(false, isShallow2);
-  }
-  set(target, key, value, receiver) {
-    let oldValue = target[key];
-    const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
-    if (!this._isShallow) {
-      const isOldValueReadonly = isReadonly(oldValue);
-      if (!isShallow(value) && !isReadonly(value)) {
-        oldValue = toRaw(oldValue);
-        value = toRaw(value);
-      }
-      if (!isArrayWithIntegerKey && isRef(oldValue) && !isRef(value)) {
-        if (isOldValueReadonly) {
-          if (true) {
-            warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target[key]);
-          }
-          return true;
-        } else {
-          oldValue.value = value;
-          return true;
-        }
-      }
-    }
-    const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
-    const result = Reflect.set(target, key, value, isRef(target) ? target : receiver);
-    if (target === toRaw(receiver) && result) {
-      if (!hadKey) {
-        trigger(target, "add", key, value);
-      } else if (hasChanged(value, oldValue)) {
-        trigger(target, "set", key, value, oldValue);
-      }
-    }
-    return result;
-  }
-  deleteProperty(target, key) {
-    const hadKey = hasOwn(target, key);
-    const oldValue = target[key];
-    const result = Reflect.deleteProperty(target, key);
-    if (result && hadKey) {
-      trigger(target, "delete", key, undefined, oldValue);
-    }
-    return result;
-  }
-  has(target, key) {
-    const result = Reflect.has(target, key);
-    if (!isSymbol(key) || !builtInSymbols.has(key)) {
-      track(target, "has", key);
-    }
-    return result;
-  }
-  ownKeys(target) {
-    track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
-    return Reflect.ownKeys(target);
-  }
-}
-
-class ReadonlyReactiveHandler extends BaseReactiveHandler {
-  constructor(isShallow2 = false) {
-    super(true, isShallow2);
-  }
-  set(target, key) {
-    if (true) {
-      warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
-    }
-    return true;
-  }
-  deleteProperty(target, key) {
-    if (true) {
-      warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
-    }
-    return true;
-  }
-}
-var mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler;
-var readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler;
-var toShallow = (value) => value;
-var getProto = (v) => Reflect.getPrototypeOf(v);
-function createIterableMethod(method, isReadonly2, isShallow2) {
-  return function(...args) {
-    const target = this["__v_raw"];
-    const rawTarget = toRaw(target);
-    const targetIsMap = isMap(rawTarget);
-    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
-    const isKeyOnly = method === "keys" && targetIsMap;
-    const innerIterator = target[method](...args);
-    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
-    !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
-    return extend(Object.create(innerIterator), {
-      next() {
-        const { value, done } = innerIterator.next();
-        return done ? { value, done } : {
-          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
-          done
-        };
-      }
-    });
-  };
-}
-function createReadonlyMethod(type) {
-  return function(...args) {
-    if (true) {
-      const key = args[0] ? `on key "${args[0]}" ` : ``;
-      warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
-    }
-    return type === "delete" ? false : type === "clear" ? undefined : this;
-  };
-}
-function createInstrumentations(readonly, shallow) {
-  const instrumentations = {
-    get(key) {
-      const target = this["__v_raw"];
-      const rawTarget = toRaw(target);
-      const rawKey = toRaw(key);
-      if (!readonly) {
-        if (hasChanged(key, rawKey)) {
-          track(rawTarget, "get", key);
-        }
-        track(rawTarget, "get", rawKey);
-      }
-      const { has } = getProto(rawTarget);
-      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
-      if (has.call(rawTarget, key)) {
-        return wrap(target.get(key));
-      } else if (has.call(rawTarget, rawKey)) {
-        return wrap(target.get(rawKey));
-      } else if (target !== rawTarget) {
-        target.get(key);
-      }
-    },
-    get size() {
-      const target = this["__v_raw"];
-      !readonly && track(toRaw(target), "iterate", ITERATE_KEY);
-      return target.size;
-    },
-    has(key) {
-      const target = this["__v_raw"];
-      const rawTarget = toRaw(target);
-      const rawKey = toRaw(key);
-      if (!readonly) {
-        if (hasChanged(key, rawKey)) {
-          track(rawTarget, "has", key);
-        }
-        track(rawTarget, "has", rawKey);
-      }
-      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
-    },
-    forEach(callback, thisArg) {
-      const observed = this;
-      const target = observed["__v_raw"];
-      const rawTarget = toRaw(target);
-      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
-      !readonly && track(rawTarget, "iterate", ITERATE_KEY);
-      return target.forEach((value, key) => {
-        return callback.call(thisArg, wrap(value), wrap(key), observed);
-      });
-    }
-  };
-  extend(instrumentations, readonly ? {
-    add: createReadonlyMethod("add"),
-    set: createReadonlyMethod("set"),
-    delete: createReadonlyMethod("delete"),
-    clear: createReadonlyMethod("clear")
-  } : {
-    add(value) {
-      const target = toRaw(this);
-      const proto = getProto(target);
-      const rawValue = toRaw(value);
-      const valueToAdd = !shallow && !isShallow(value) && !isReadonly(value) ? rawValue : value;
-      const hadKey = proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue);
-      if (!hadKey) {
-        target.add(valueToAdd);
-        trigger(target, "add", valueToAdd, valueToAdd);
-      }
-      return this;
-    },
-    set(key, value) {
-      if (!shallow && !isShallow(value) && !isReadonly(value)) {
-        value = toRaw(value);
-      }
-      const target = toRaw(this);
-      const { has, get } = getProto(target);
-      let hadKey = has.call(target, key);
-      if (!hadKey) {
-        key = toRaw(key);
-        hadKey = has.call(target, key);
-      } else if (true) {
-        checkIdentityKeys(target, has, key);
-      }
-      const oldValue = get.call(target, key);
-      target.set(key, value);
-      if (!hadKey) {
-        trigger(target, "add", key, value);
-      } else if (hasChanged(value, oldValue)) {
-        trigger(target, "set", key, value, oldValue);
-      }
-      return this;
-    },
-    delete(key) {
-      const target = toRaw(this);
-      const { has, get } = getProto(target);
-      let hadKey = has.call(target, key);
-      if (!hadKey) {
-        key = toRaw(key);
-        hadKey = has.call(target, key);
-      } else if (true) {
-        checkIdentityKeys(target, has, key);
-      }
-      const oldValue = get ? get.call(target, key) : undefined;
-      const result = target.delete(key);
-      if (hadKey) {
-        trigger(target, "delete", key, undefined, oldValue);
-      }
-      return result;
-    },
-    clear() {
-      const target = toRaw(this);
-      const hadItems = target.size !== 0;
-      const oldTarget = isMap(target) ? new Map(target) : new Set(target);
-      const result = target.clear();
-      if (hadItems) {
-        trigger(target, "clear", undefined, undefined, oldTarget);
-      }
-      return result;
-    }
-  });
-  const iteratorMethods = [
-    "keys",
-    "values",
-    "entries",
-    Symbol.iterator
-  ];
-  iteratorMethods.forEach((method) => {
-    instrumentations[method] = createIterableMethod(method, readonly, shallow);
-  });
-  return instrumentations;
-}
-function createInstrumentationGetter(isReadonly2, shallow) {
-  const instrumentations = createInstrumentations(isReadonly2, shallow);
-  return (target, key, receiver) => {
-    if (key === "__v_isReactive") {
-      return !isReadonly2;
-    } else if (key === "__v_isReadonly") {
-      return isReadonly2;
-    } else if (key === "__v_raw") {
-      return target;
-    }
-    return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
-  };
-}
-var mutableCollectionHandlers = {
-  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
-};
-var readonlyCollectionHandlers = {
-  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
-};
-function checkIdentityKeys(target, has, key) {
-  const rawKey = toRaw(key);
-  if (rawKey !== key && has.call(target, rawKey)) {
-    const type = toRawType(target);
-    warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
-  }
-}
-var reactiveMap = /* @__PURE__ */ new WeakMap;
-var shallowReactiveMap = /* @__PURE__ */ new WeakMap;
-var readonlyMap = /* @__PURE__ */ new WeakMap;
-var shallowReadonlyMap = /* @__PURE__ */ new WeakMap;
-function targetTypeMap(rawType) {
-  switch (rawType) {
-    case "Object":
-    case "Array":
-      return 1;
-    case "Map":
-    case "Set":
-    case "WeakMap":
-    case "WeakSet":
-      return 2;
-    default:
-      return 0;
-  }
-}
-function reactive(target) {
-  if (/* @__PURE__ */ isReadonly(target)) {
-    return target;
-  }
-  return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
-}
-function readonly(target) {
-  return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
-}
-function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
-  if (!isObject(target)) {
-    if (true) {
-      warn(`value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(target)}`);
-    }
-    return target;
-  }
-  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
-    return target;
-  }
-  if (target["__v_skip"] || !Object.isExtensible(target)) {
-    return target;
-  }
-  const existingProxy = proxyMap.get(target);
-  if (existingProxy) {
-    return existingProxy;
-  }
-  const targetType = targetTypeMap(toRawType(target));
-  if (targetType === 0) {
-    return target;
-  }
-  const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
-  proxyMap.set(target, proxy);
-  return proxy;
-}
-function isReactive(value) {
-  if (/* @__PURE__ */ isReadonly(value)) {
-    return /* @__PURE__ */ isReactive(value["__v_raw"]);
-  }
-  return !!(value && value["__v_isReactive"]);
-}
-function isReadonly(value) {
-  return !!(value && value["__v_isReadonly"]);
-}
-function isShallow(value) {
-  return !!(value && value["__v_isShallow"]);
-}
-function isProxy(value) {
-  return value ? !!value["__v_raw"] : false;
-}
-function toRaw(observed) {
-  const raw = observed && observed["__v_raw"];
-  return raw ? /* @__PURE__ */ toRaw(raw) : observed;
-}
-var toReactive = (value) => isObject(value) ? /* @__PURE__ */ reactive(value) : value;
-var toReadonly = (value) => isObject(value) ? /* @__PURE__ */ readonly(value) : value;
-function isRef(r) {
-  return r ? r["__v_isRef"] === true : false;
-}
-function ref(value) {
-  return createRef(value, false);
-}
-function createRef(rawValue, shallow) {
-  if (/* @__PURE__ */ isRef(rawValue)) {
-    return rawValue;
-  }
-  return new RefImpl(rawValue, shallow);
-}
-
-class RefImpl {
-  constructor(value, isShallow2) {
-    this.dep = new Dep;
-    this["__v_isRef"] = true;
-    this["__v_isShallow"] = false;
-    this._rawValue = isShallow2 ? value : toRaw(value);
-    this._value = isShallow2 ? value : toReactive(value);
-    this["__v_isShallow"] = isShallow2;
-  }
-  get value() {
-    if (true) {
-      this.dep.track({
-        target: this,
-        type: "get",
-        key: "value"
-      });
-    } else {}
-    return this._value;
-  }
-  set value(newValue) {
-    const oldValue = this._rawValue;
-    const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
-    newValue = useDirectValue ? newValue : toRaw(newValue);
-    if (hasChanged(newValue, oldValue)) {
-      this._rawValue = newValue;
-      this._value = useDirectValue ? newValue : toReactive(newValue);
-      if (true) {
-        this.dep.trigger({
-          target: this,
-          type: "set",
-          key: "value",
-          newValue,
-          oldValue
-        });
-      } else {}
-    }
-  }
-}
-class ComputedRefImpl {
-  constructor(fn, setter, isSSR) {
-    this.fn = fn;
-    this.setter = setter;
-    this._value = undefined;
-    this.dep = new Dep(this);
-    this.__v_isRef = true;
-    this.deps = undefined;
-    this.depsTail = undefined;
-    this.flags = 16;
-    this.globalVersion = globalVersion - 1;
-    this.next = undefined;
-    this.effect = this;
-    this["__v_isReadonly"] = !setter;
-    this.isSSR = isSSR;
-  }
-  notify() {
-    this.flags |= 16;
-    if (!(this.flags & 8) && activeSub !== this) {
-      batch(this, true);
-      return true;
-    } else if (true)
-      ;
-  }
-  get value() {
-    const link = this.dep.track({
-      target: this,
-      type: "get",
-      key: "value"
-    });
-    refreshComputed(this);
-    if (link) {
-      link.version = this.dep.version;
-    }
-    return this._value;
-  }
-  set value(newValue) {
-    if (this.setter) {
-      this.setter(newValue);
-    } else if (true) {
-      warn("Write operation failed: computed value is readonly");
-    }
-  }
-}
-function computed(getterOrOptions, debugOptions, isSSR = false) {
-  let getter;
-  let setter;
-  if (isFunction(getterOrOptions)) {
-    getter = getterOrOptions;
-  } else {
-    getter = getterOrOptions.get;
-    setter = getterOrOptions.set;
-  }
-  const cRef = new ComputedRefImpl(getter, setter, isSSR);
-  if (debugOptions && !isSSR) {
-    cRef.onTrack = debugOptions.onTrack;
-    cRef.onTrigger = debugOptions.onTrigger;
-  }
-  return cRef;
-}
-// ../schema/src/guards.ts
-function isJsonObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isRef2(value) {
-  return isJsonObject(value) && typeof value.$ref === "string";
-}
-function isFunctionDef(value) {
-  return isJsonObject(value) && value.$prototype === "Function";
-}
-function isExpressionDef(value) {
-  return isJsonObject(value) && isJsonObject(value.$expression);
-}
-function isNamedFormulaDef(value) {
-  return isExpressionDef(value) && Array.isArray(value.parameters) && value.parameters.length > 0;
-}
-function hasStructuredBody(value) {
-  return isFunctionDef(value) && Array.isArray(value.body);
-}
-function isPrototypeDef(value) {
-  return isJsonObject(value) && typeof value.$prototype === "string" && value.$prototype !== "Function";
-}
-function isServerFnDef(value) {
-  return isJsonObject(value) && value.timing === "server" && typeof value.$src === "string" && typeof value.$export === "string" && !value.$prototype;
-}
-var SCHEMA_KEYWORDS = new Set([
-  "type",
-  "enum",
-  "minimum",
-  "maximum",
-  "minLength",
-  "maxLength",
-  "pattern",
-  "format",
-  "items",
-  "properties",
-  "required",
-  "description",
-  "title",
-  "$comment"
-]);
-function isMappedArray(value) {
-  return isJsonObject(value) && value.$prototype === "Array";
-}
-function isTemplateString(value) {
-  return typeof value === "string" && value.includes("${");
-}
-function bodyReturnsValue(body) {
-  return /\breturn\b[^\S\n]*(?![;}\s]|$)/.test(body);
-}
-function isNestedStyle(value) {
-  return typeof value === "object" && value !== null;
-}
-function getNestedStyle(style, key) {
-  const value = style?.[key];
-  return isNestedStyle(value) ? value : undefined;
-}
-function ensureNestedStyle(style, key) {
-  const existing = style[key];
-  if (isNestedStyle(existing)) {
-    return existing;
-  }
-  const created = {};
-  style[key] = created;
-  return created;
-}
-function isEventBinding(value) {
-  return isRef2(value) || isFunctionDef(value) || isExpressionDef(value);
-}
-function getEventBinding(node, key) {
-  const value = node[key];
-  return isEventBinding(value) ? value : undefined;
-}
-function paramNames(parameters) {
-  if (!parameters) {
-    return [];
-  }
-  return parameters.map((p) => typeof p === "string" ? p : p.name);
-}
-
-// src/state.ts
-function getNodeAtPath(doc, path) {
-  let node = doc;
-  for (const key of path) {
-    if (node == null) {
-      return;
-    }
-    node = node[key];
-  }
-  return node;
-}
-function childList(node) {
-  return Array.isArray(node?.children) ? node.children : [];
-}
-function normalizeArrayChildren(node) {
-  if (!node || typeof node !== "object") {
-    return node;
-  }
-  if (Array.isArray(node)) {
-    for (const child of node) {
-      normalizeArrayChildren(child);
-    }
-    return node;
-  }
-  const n = node;
-  const { children } = n;
-  if (children && typeof children === "object" && !Array.isArray(children) && children.$prototype === "Array") {
-    n.children = [children];
-  }
-  if (Array.isArray(n.children)) {
-    for (const child of n.children) {
-      normalizeArrayChildren(child);
-    }
-  }
-  if (n.$prototype === "Array" && n.map && typeof n.map === "object") {
-    normalizeArrayChildren(n.map);
-  }
-  if (n.cases && typeof n.cases === "object") {
-    for (const caseDef of Object.values(n.cases)) {
-      normalizeArrayChildren(caseDef);
-    }
-  }
-  return node;
-}
-function parentElementPath(path) {
-  return path.length >= 2 ? path.slice(0, -2) : null;
-}
-function childIndex(path) {
-  return path.at(-1);
-}
-function pathKey(path) {
-  return path.join("/");
-}
-function pathsEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (!a || !b || a.length !== b.length) {
-    return false;
-  }
-  return a.every((v, i) => v === b[i]);
-}
-function isAncestor(path, descendant) {
-  if (path.length > descendant.length) {
-    return false;
-  }
-  return path.every((v, i) => v === descendant[i]);
-}
-function flattenTree(doc, path = [], depth = 0) {
-  const rows = [];
-  collectRows(doc, path, depth, rows, false);
-  return rows;
-}
-function collectRows(doc, path, depth, out, skipSelf) {
-  if (typeof doc === "string" || typeof doc === "number" || typeof doc === "boolean") {
-    if (!skipSelf) {
-      out.push({ depth, node: doc, nodeType: "text", path });
-    }
-    return;
-  }
-  if (doc.$prototype === "Array") {
-    if (!skipSelf) {
-      out.push({ depth, node: doc, nodeType: "map", path });
-    }
-    const mapDef = doc.map;
-    if (mapDef && typeof mapDef === "object") {
-      collectRows(mapDef, [...path, "map"], depth + 1, out, false);
-    }
-    return;
-  }
-  if (!skipSelf) {
-    out.push({ depth, node: doc, nodeType: "element", path });
-  }
-  if (doc.$props && (doc.tagName || "").includes("-") && !Array.isArray(doc.children)) {
-    return;
-  }
-  const { children } = doc;
-  if (Array.isArray(children)) {
-    for (let i = 0;i < children.length; i++) {
-      const childPath = [...path, "children", i];
-      collectRows(children[i], childPath, depth + 1, out, false);
-    }
-  } else if (children && typeof children === "object" && children.$prototype === "Array") {
-    collectRows(children, [...path, "children"], depth + 1, out, false);
-  }
-  if (doc.$switch && doc.cases && typeof doc.cases === "object") {
-    for (const [caseName, caseDef] of Object.entries(doc.cases)) {
-      const casePath = [...path, "cases", caseName];
-      if (caseDef && typeof caseDef === "object" && caseDef.$ref) {
-        out.push({
-          depth: depth + 1,
-          node: caseDef,
-          nodeType: "case-ref",
-          path: casePath
-        });
-      } else if (caseDef && typeof caseDef === "object") {
-        out.push({
-          depth: depth + 1,
-          node: caseDef,
-          nodeType: "case",
-          path: casePath
-        });
-        collectRows(caseDef, casePath, depth + 2, out, true);
-      }
-    }
-  }
-}
-function nodeLabel(node) {
-  if (!node) {
-    return "?";
-  }
-  if (node.$prototype === "Array") {
-    const { items } = node;
-    const ref2 = (isRef2(items) ? items.$ref : undefined) || "items";
-    return `Repeater → ${ref2}`;
-  }
-  if (node.$title) {
-    return node.$title;
-  }
-  if (node.$id) {
-    return node.$id;
-  }
-  if (node.tagName === "slot") {
-    const name = node.attributes?.name;
-    return typeof name === "string" && name.trim() ? `slot: ${name.trim()}` : "slot";
-  }
-  const tag = node.tagName ?? "div";
-  const suffix = node.$switch ? " ⇆" : "";
-  if (typeof node.textContent === "string" && node.textContent.length > 0) {
-    return `${tag} — ${node.textContent.slice(0, 24)}${suffix}`;
-  }
-  return tag + suffix;
-}
-function createState(doc) {
-  const initial = { document: doc, selection: null };
-  return {
-    canvas: {
-      error: null,
-      scope: null,
-      status: "idle"
-    },
-    content: { frontmatter: {} },
-    dirty: false,
-    document: doc,
-    documentPath: null,
-    documentStack: [],
-    fileHandle: null,
-    handlersSource: null,
-    history: [initial],
-    historyIndex: 0,
-    hover: null,
-    mode: "component",
-    selection: null,
-    ui: {
-      activeMedia: null,
-      activeSelector: null,
-      editingFunction: null,
-      featureToggles: {},
-      gitBranches: null,
-      gitCommitMessage: "",
-      gitDiffState: null,
-      gitError: null,
-      gitLoading: false,
-      gitStatus: null,
-      inspectorSections: {},
-      pendingInlineEdit: null,
-      rightTab: "properties",
-      settingsTab: "stylebook",
-      styleFilter: "",
-      styleFilterActive: false,
-      styleSections: {},
-      styleShorthands: {},
-      stylebookCustomizedOnly: false,
-      stylebookFilter: "",
-      stylebookSelection: null,
-      stylebookTab: "elements",
-      zoom: 1
-    }
-  };
-}
-var projectState = null;
-function setProjectState(ps) {
-  projectState = ps;
-}
-function requireProjectState() {
-  return projectState;
-}
-
-// src/utils/studio-utils.ts
-function camelToKebab(str) {
-  return str.replaceAll(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
-}
-function camelToLabel(prop) {
-  return prop.replaceAll(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase());
-}
-function toCamelCase(str) {
-  return str.replaceAll(/[^a-zA-Z0-9]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[A-Z]/, (c) => c.toLowerCase());
-}
-function kebabToLabel(val) {
-  return val.replaceAll(/(^|-)(\w)/g, (_, sep, c) => (sep ? " " : "") + c.toUpperCase());
-}
-function propLabel(entry, prop) {
-  return entry?.$label || camelToLabel(prop);
-}
-function attrLabel(entry, attr) {
-  if (entry?.$label) {
-    return entry.$label;
-  }
-  if (attr.includes("-")) {
-    return attr.replaceAll(/(^|-)(\w)/g, (_, sep, c) => (sep ? " " : "") + c.toUpperCase());
-  }
-  return camelToLabel(attr);
-}
-function abbreviateValue(val) {
-  const map = {
-    baseline: "base",
-    column: "col",
-    "column-reverse": "col-r",
-    contents: "cnt",
-    "flex-end": "end",
-    "flex-start": "start",
-    "flow-root": "flow",
-    inline: "inl",
-    "inline-block": "i-blk",
-    "inline-flex": "i-flx",
-    "inline-grid": "i-grd",
-    normal: "norm",
-    nowrap: "no-wr",
-    "row-reverse": "row-r",
-    "space-around": "arnd",
-    "space-between": "betw",
-    "space-evenly": "even",
-    stretch: "str",
-    "wrap-reverse": "wr-rev"
-  };
-  return map[val] || val;
-}
-function inferInputType(entry) {
-  if (entry.$shorthand === true) {
-    return "shorthand";
-  }
-  if (entry.$input === "button-group") {
-    return "button-group";
-  }
-  if (entry.$input === "media") {
-    return "media";
-  }
-  if (entry.format === "color") {
-    return "color";
-  }
-  if (entry.format === "uri-reference") {
-    return "media";
-  }
-  if (entry.$units !== undefined) {
-    return "number-unit";
-  }
-  if (entry.type === "number") {
-    return "number";
-  }
-  if (Array.isArray(entry.enum)) {
-    return "select";
-  }
-  if (Array.isArray(entry.examples) || Array.isArray(entry.presets)) {
-    return "combobox";
-  }
-  return "text";
-}
-function findContentTypeSchema(documentPath, projectConfig) {
-  if (!documentPath || !projectConfig?.content) {
-    return null;
-  }
-  const docPath = documentPath.replaceAll("\\", "/");
-  for (const [name, def2] of Object.entries(projectConfig.content)) {
-    if (!def2.source || !def2.schema) {
-      continue;
-    }
-    const src = def2.source.replace(/^\.\//, "").replace(/\/$/, "");
-    const hasExt = src.includes(".") && !src.endsWith("/");
-    if (hasExt) {
-      if (docPath === src || docPath.endsWith(`/${src}`)) {
-        return { name, schema: def2.schema };
-      }
-    } else {
-      const ext = def2.format === "json" ? ".json" : formatByName(def2.format)?.extensions[0] ?? defaultContentFormat()?.extensions[0] ?? ".json";
-      if (docPath.startsWith(`${src}/`) && docPath.endsWith(ext)) {
-        return { name, schema: def2.schema };
-      }
-    }
-  }
-  return null;
-}
-function friendlyNameToVar(name, prefix) {
-  const slug = name.trim().toLowerCase().replaceAll(/[^a-z0-9\s-]/g, "").replaceAll(/\s+/g, "-").replaceAll(/-+/g, "-").replaceAll(/^-|-$/g, "");
-  if (!slug) {
-    return "";
-  }
-  return `${prefix}${slug}`;
-}
-function varDisplayName(varName, prefix) {
-  return varName.replace(new RegExp(`^${prefix.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)}`), "").replace(/^--/, "").replaceAll("-", " ").replaceAll(/\b\w/g, (c) => c.toUpperCase()) || varName;
-}
-function parseCemType(typeText) {
-  if (!typeText) {
-    return { kind: "text" };
-  }
-  const t = typeText.trim().replaceAll(/\s*\|\s*undefined\b/g, "").trim();
-  if (t === "boolean") {
-    return { kind: "boolean" };
-  }
-  if (t === "number") {
-    return { kind: "number" };
-  }
-  const enumMatch = t.match(/^'[^']*'(\s*\|\s*'[^']*')+$/);
-  if (enumMatch) {
-    const options = [...t.matchAll(/'([^']*)'/g)].map((m) => m[1]);
-    return { kind: "combobox", options };
-  }
-  return { kind: "text" };
-}
-function jsonClone(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-// src/tabs/patch-ops.ts
-var _consumer = null;
-function setPatchConsumer(consumer) {
-  _consumer = consumer;
-}
-function getPatchConsumer() {
-  return _consumer;
-}
-var _recording = null;
-var _docOps = null;
-var _fmOps = null;
-var _invertible = true;
-function beginRecording() {
-  _recording = [];
-  _docOps = [];
-  _fmOps = [];
-  _invertible = true;
-}
-function recordPatch(op) {
-  if (_recording) {
-    _recording.push(op);
-  }
-}
-function recordDocOp(pair) {
-  if (_docOps) {
-    _docOps.push(pair);
-  }
-}
-function recordFmOp(op) {
-  if (_fmOps) {
-    _fmOps.push(op);
-  }
-}
-function endRecording() {
-  const record = {
-    docOps: _docOps ?? [],
-    fmOps: _fmOps ?? [],
-    invertible: _invertible,
-    ops: _recording ?? []
-  };
-  _recording = null;
-  _docOps = null;
-  _fmOps = null;
-  _invertible = true;
-  return record;
-}
-
-// src/tabs/transact.ts
-var HISTORY_LIMIT = 100;
-var CHECKPOINT_INTERVAL = 20;
-function patchHistoryEnabled() {
-  try {
-    return typeof localStorage === "undefined" || !localStorage.getItem("jx-legacy-history");
-  } catch {
-    return true;
-  }
-}
-function setKeyPair(path, key, before, after) {
-  return {
-    forward: { key, op: "set-key", path, value: after },
-    inverse: { key, op: "set-key", path, value: before }
-  };
-}
-function shiftPrefixedIndex(parentPath, path, spliceIndex, delta, inclusive) {
-  const d = parentPath.length;
-  const isProperPrefix = d < path.length && parentPath.every((seg, i) => seg === path[i]);
-  if (!isProperPrefix || path[d] !== "children" || typeof path[d + 1] !== "number") {
-    return path;
-  }
-  const idx = path[d + 1];
-  if (inclusive ? idx < spliceIndex : idx <= spliceIndex) {
-    return path;
-  }
-  const shifted = [...path];
-  shifted[d + 1] = idx + delta;
-  return shifted;
-}
-var _transactObserver = null;
-function setTransactObserver(fn) {
-  _transactObserver = fn;
-}
-var _transactGate = null;
-function setTransactGate(fn) {
-  _transactGate = fn;
-}
-function transactDoc(tab, mutationFn, {
-  skipHistory = false,
-  origin = "user",
-  coalesceKey = null
-} = {}) {
-  if (!tab) {
-    return;
-  }
-  if (origin !== "remote" && _transactGate?.(tab, origin)) {
-    return;
-  }
-  const selectionBefore = tab.session.selection ? [...tab.session.selection] : null;
-  beginRecording();
-  let record;
-  try {
-    mutationFn(tab);
-  } finally {
-    record = endRecording();
-  }
-  const raw = toRaw(tab.doc.document);
-  const newRef = { ...raw };
-  const consumer = getPatchConsumer();
-  const verdict = consumer === null ? { patchable: false, reason: "no-patch-consumer" } : record.ops.length === 0 ? { patchable: false, reason: "unrecorded-mutation" } : consumer.classify(tab, record.ops);
-  if (verdict.patchable) {
-    consumer.markConsumed(newRef);
-  }
-  tab.doc.document = newRef;
-  if (verdict.patchable) {
-    try {
-      consumer.apply(tab, record.ops, record);
-    } catch (error) {
-      consumer.escalate(`patch-apply-failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  if (!skipHistory && !_batchTab) {
-    pushHistoryEntry(tab, raw, record, selectionBefore, coalesceKey);
-  }
-  tab.doc.dirty = true;
-  _transactObserver?.(tab, record, origin);
-}
-function pushHistoryEntry(tab, raw, record, selectionBefore, coalesceKey = null) {
-  const truncated = tab.history.snapshots.slice(0, tab.history.index + 1);
-  const useOps = patchHistoryEnabled() && record.invertible && (record.docOps.length > 0 || record.fmOps.length > 0);
-  const prev = truncated.at(-1);
-  if (coalesceKey && useOps && prev && prev.coalesceKey === coalesceKey && prev.inverseOps) {
-    prev.forwardOps = [...prev.forwardOps ?? [], ...record.docOps.map((pair) => pair.forward)];
-    prev.inverseOps = [...prev.inverseOps, ...record.docOps.map((pair) => pair.inverse)];
-    prev.selection = tab.session.selection ? [...tab.session.selection] : null;
-    if (prev.document) {
-      prev.document = jsonClone(raw);
-    }
-    tab.history.snapshots = truncated;
-    tab.history.index = truncated.length - 1;
-    return;
-  }
-  const needCheckpoint = !useOps || truncated.length % CHECKPOINT_INTERVAL === 0;
-  truncated.push({
-    document: needCheckpoint ? jsonClone(raw) : null,
-    fmOps: useOps && record.fmOps.length > 0 ? record.fmOps : null,
-    forwardOps: useOps ? record.docOps.map((p) => p.forward) : null,
-    inverseOps: useOps ? record.docOps.map((p) => p.inverse) : null,
-    coalesceKey,
-    selection: tab.session.selection ? [...tab.session.selection] : null,
-    selectionBefore
-  });
-  if (truncated.length > HISTORY_LIMIT) {
-    if (!truncated[1].document) {
-      truncated[1].document = materializeState(truncated, 1);
-    }
-    truncated.shift();
-  }
-  tab.history.snapshots = truncated;
-  tab.history.index = truncated.length - 1;
-}
-function materializeState(snapshots, target) {
-  let base = target;
-  while (base >= 0 && !snapshots[base].document) {
-    base -= 1;
-  }
-  if (base < 0) {
-    throw new Error("history-missing-checkpoint");
-  }
-  const doc = jsonClone(snapshots[base].document);
-  for (let i = base + 1;i <= target; i++) {
-    for (const op of snapshots[i].forwardOps ?? []) {
-      applyDocOpToDoc(doc, op);
-    }
-  }
-  return doc;
-}
-function transact(tab, fn, opts) {
-  transactDoc(tab, (t) => fn(t.doc.document), opts);
-}
-function applyExternalDocOps(tab, ops) {
-  transactDoc(tab, (t) => {
-    for (const op of ops) {
-      applyDocOp(t, op);
-    }
-  }, { origin: "remote", skipHistory: true });
-}
-var DOC_META_KEYS = new Set(["state", "$media", "$head", "$elements", "imports", "$layout"]);
-function applyDocOp(tab, op) {
-  const prev = op.op === "set-key" ? getNodeAtPath(tab.doc.document, op.path)?.[op.key] : null;
-  applyDocOpToDoc(tab.doc.document, op);
-  recordDocOp({ forward: op, inverse: op });
-  switch (op.op) {
-    case "set-key": {
-      if (DOC_META_KEYS.has(op.key)) {
-        recordPatch({ key: op.key, op: "doc-meta" });
-      } else if (op.key === "style") {
-        recordPatch({ op: "set-style", path: op.path });
-      } else if (op.key === "textContent") {
-        recordPatch({ op: "set-text", path: op.path });
-      } else if (op.key === "attributes" || op.key === "cases" || op.key === "$props") {
-        recordPatch({ op: "replace", path: op.path });
-      } else {
-        const isEvent = op.key.startsWith("on") && (isEventBinding(op.value) || isEventBinding(prev));
-        recordPatch({ isEvent, key: op.key, op: "set-prop", path: op.path });
-      }
-      return;
-    }
-    case "insert-child": {
-      recordPatch({ index: op.index, op: "insert", parentPath: op.parentPath });
-      return;
-    }
-    case "remove-child": {
-      recordPatch({ op: "remove", path: [...op.parentPath, "children", op.index] });
-      return;
-    }
-    case "set-child": {
-      recordPatch({ op: "replace", path: [...op.parentPath, "children", op.index] });
-      return;
-    }
-    case "move-child": {
-      recordPatch({
-        fromPath: [...op.fromParentPath, "children", op.fromIndex],
-        op: "move",
-        toIndex: op.toIndex,
-        toParentPath: op.toParentPath
-      });
-      break;
-    }
-    default: {
-      break;
-    }
-  }
-}
-var _batchTab = null;
-var _batchEndNotifier = null;
-function setBatchEndNotifier(fn) {
-  _batchEndNotifier = fn;
-}
-function beginBatch(tab) {
-  _batchTab = tab;
-}
-function endBatch2() {
-  const tab = _batchTab;
-  if (tab && !_historyDelegates.has(tab)) {
-    const raw = toRaw(tab.doc.document);
-    const snapshot = {
-      document: jsonClone(raw),
-      selection: tab.session.selection ? [...tab.session.selection] : null
-    };
-    const truncated = tab.history.snapshots.slice(0, tab.history.index + 1);
-    truncated.push(snapshot);
-    if (truncated.length > HISTORY_LIMIT) {
-      truncated.shift();
-    }
-    tab.history.snapshots = truncated;
-    tab.history.index = truncated.length - 1;
-  }
-  _batchTab = null;
-  if (tab) {
-    _batchEndNotifier?.(tab);
-  }
-}
-function isBatching() {
-  return _batchTab !== null;
-}
-var _historyDelegates = new WeakMap;
-function setHistoryDelegate(tab, delegate) {
-  if (delegate) {
-    _historyDelegates.set(tab, delegate);
-  } else {
-    _historyDelegates.delete(tab);
-  }
-}
-function canUndo(tab) {
-  const delegate = _historyDelegates.get(tab);
-  return delegate ? delegate.canUndo(tab) : tab.history.index > 0;
-}
-function canRedo(tab) {
-  const delegate = _historyDelegates.get(tab);
-  return delegate ? delegate.canRedo(tab) : tab.history.index < tab.history.snapshots.length - 1;
-}
-function restoreState(tab, index) {
-  const { snapshots } = tab.history;
-  tab.doc.document = materializeState(snapshots, index);
-  const snap = snapshots[index];
-  tab.session.selection = snap.selection ? [...toRaw(snap.selection)] : null;
-}
-function assertHistoryConsistency(tab, index) {
-  try {
-    if (typeof localStorage === "undefined" || !localStorage.getItem("jx-canvas-debug")) {
-      return;
-    }
-  } catch {
-    return;
-  }
-  const expected = JSON.stringify(materializeState(tab.history.snapshots, index));
-  const actual = JSON.stringify(jsonClone(toRaw(tab.doc.document)));
-  if (expected !== actual) {
-    console.error("jx history: ops-based undo/redo diverged from checkpoint replay", {
-      index
-    });
-  }
-}
-function undo(tab) {
-  const delegate = _historyDelegates.get(tab);
-  if (delegate) {
-    delegate.undo(tab);
-    return;
-  }
-  if (tab.history.index <= 0) {
-    return;
-  }
-  const entry = tab.history.snapshots[tab.history.index];
-  const inverseOps = patchHistoryEnabled() ? entry.inverseOps : null;
-  const fmOps = patchHistoryEnabled() ? entry.fmOps : null;
-  if (inverseOps && inverseOps.length > 0 || fmOps && fmOps.length > 0) {
-    transactDoc(tab, (t) => {
-      if (inverseOps) {
-        for (let i = inverseOps.length - 1;i >= 0; i--) {
-          applyDocOp(t, toRaw(inverseOps[i]));
-        }
-      }
-      if (fmOps) {
-        for (let i = fmOps.length - 1;i >= 0; i--) {
-          const op = toRaw(fmOps[i]);
-          applyFmState(t, op.field, op.before);
-        }
-      }
-    }, { origin: "history", skipHistory: true });
-    tab.session.selection = entry.selectionBefore ? [...toRaw(entry.selectionBefore)] : null;
-    tab.history.index -= 1;
-    assertHistoryConsistency(tab, tab.history.index);
-  } else {
-    tab.history.index -= 1;
-    restoreState(tab, tab.history.index);
-  }
-  tab.doc.dirty = true;
-}
-function redo(tab) {
-  const delegate = _historyDelegates.get(tab);
-  if (delegate) {
-    delegate.redo(tab);
-    return;
-  }
-  if (tab.history.index >= tab.history.snapshots.length - 1) {
-    return;
-  }
-  const entry = tab.history.snapshots[tab.history.index + 1];
-  const forwardOps = patchHistoryEnabled() ? entry.forwardOps : null;
-  const fmOps = patchHistoryEnabled() ? entry.fmOps : null;
-  if (forwardOps && forwardOps.length > 0 || fmOps && fmOps.length > 0) {
-    transactDoc(tab, (t) => {
-      if (forwardOps) {
-        for (const op of forwardOps) {
-          applyDocOp(t, toRaw(op));
-        }
-      }
-      if (fmOps) {
-        for (const op of fmOps) {
-          const raw = toRaw(op);
-          applyFmState(t, raw.field, raw.after);
-        }
-      }
-    }, { origin: "history", skipHistory: true });
-    tab.session.selection = entry.selection ? [...toRaw(entry.selection)] : null;
-    tab.history.index += 1;
-    assertHistoryConsistency(tab, tab.history.index);
-  } else {
-    tab.history.index += 1;
-    restoreState(tab, tab.history.index);
-  }
-  tab.doc.dirty = true;
-}
-function mutateInsertNode(tab, parentPath, index, nodeDef) {
-  const parent = getNodeAtPath(tab.doc.document, parentPath);
-  if (!parent) {
-    return;
-  }
-  childArray(parent).splice(index, 0, structuredClone(nodeDef));
-  recordPatch({ index, op: "insert", parentPath });
-  recordDocOp({
-    forward: { index, node: cloneValue(nodeDef), op: "insert-child", parentPath },
-    inverse: { index, op: "remove-child", parentPath }
-  });
-}
-function mutateRemoveNode(tab, path) {
-  if (!path || path.length < 2) {
-    return;
-  }
-  const elemPath = parentElementPath(path);
-  const idx = childIndex(path);
-  const [removed] = getNodeAtPath(tab.doc.document, elemPath).children.splice(idx, 1);
-  recordPatch({ op: "remove", path });
-  recordDocOp({
-    forward: { index: idx, op: "remove-child", parentPath: elemPath },
-    inverse: { index: idx, node: cloneValue(removed), op: "insert-child", parentPath: elemPath }
-  });
-  if (tab.session.selection && isAncestor(path, tab.session.selection)) {
-    tab.session.selection = null;
-  }
-}
-function mutateDuplicateNode(tab, path) {
-  if (!path || path.length < 2) {
-    return;
-  }
-  const node = getNodeAtPath(tab.doc.document, path);
-  if (!node) {
-    return;
-  }
-  const elemPath = parentElementPath(path);
-  const idx = childIndex(path);
-  const clone = structuredClone(toRaw(node));
-  getNodeAtPath(tab.doc.document, elemPath).children.splice(idx + 1, 0, clone);
-  recordPatch({ index: idx + 1, op: "insert", parentPath: elemPath });
-  recordDocOp({
-    forward: { index: idx + 1, node: cloneValue(clone), op: "insert-child", parentPath: elemPath },
-    inverse: { index: idx + 1, op: "remove-child", parentPath: elemPath }
-  });
-  tab.session.selection = [...elemPath, "children", idx + 1];
-}
-function mutateWrapNode(tab, path, wrapperTag = "div") {
-  if (!path || path.length < 2) {
-    return;
-  }
-  const node = getNodeAtPath(tab.doc.document, path);
-  if (!node) {
-    return;
-  }
-  const elemPath = parentElementPath(path);
-  const idx = childIndex(path);
-  const wrapper = {
-    children: [structuredClone(toRaw(node))],
-    tagName: wrapperTag
-  };
-  const original = cloneValue(node);
-  getNodeAtPath(tab.doc.document, elemPath).children.splice(idx, 1, wrapper);
-  recordPatch({ op: "replace", path });
-  recordDocOp({
-    forward: { index: idx, node: cloneValue(wrapper), op: "set-child", parentPath: elemPath },
-    inverse: { index: idx, node: original, op: "set-child", parentPath: elemPath }
-  });
-  tab.session.selection = [...elemPath, "children", idx];
-}
-function mutateMoveNode(tab, fromPath, toParentPath, toIndex) {
-  const doc = tab.doc.document;
-  const fromParentPath = parentElementPath(fromPath);
-  const fromIdx = childIndex(fromPath);
-  if (!fromParentPath || typeof fromIdx !== "number") {
-    return;
-  }
-  const fromParent = getNodeAtPath(doc, fromParentPath);
-  const toParent = getNodeAtPath(doc, toParentPath);
-  if (!fromParent || !Array.isArray(fromParent.children) || !toParent) {
-    return;
-  }
-  const [node] = fromParent.children.splice(fromIdx, 1);
-  if (node === undefined) {
-    return;
-  }
-  let adjustedIndex = toIndex;
-  if (fromParent === toParent && fromIdx < toIndex) {
-    adjustedIndex -= 1;
-  }
-  childArray(toParent).splice(adjustedIndex, 0, node);
-  recordPatch({ fromPath, op: "move", toIndex: adjustedIndex, toParentPath });
-  recordDocOp({
-    forward: {
-      fromIndex: fromIdx,
-      fromParentPath,
-      op: "move-child",
-      toIndex: adjustedIndex,
-      toParentPath
-    },
-    inverse: {
-      fromIndex: adjustedIndex,
-      fromParentPath: shiftPrefixedIndex(fromParentPath, toParentPath, fromIdx, -1, false),
-      op: "move-child",
-      toIndex: fromIdx,
-      toParentPath: shiftPrefixedIndex(toParentPath, fromParentPath, adjustedIndex, 1, true)
-    }
-  });
-  if (pathsEqual(tab.session.selection, fromPath)) {
-    let idx = toIndex;
-    if (fromParentPath.length === toParentPath.length && fromParentPath.every((v, i) => v === toParentPath[i]) && fromIdx < toIndex) {
-      idx = toIndex - 1;
-    }
-    tab.session.selection = [...toParentPath, "children", idx];
-  }
-}
-function mutateUpdateProperty(tab, path, key, value) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  const prev = node[key];
-  const before = cloneValue(prev);
-  if (value === undefined || value === null || value === "") {
-    delete node[key];
-  } else {
-    node[key] = value;
-  }
-  recordDocOp(setKeyPair(path, key, before, cloneValue(node[key])));
-  if (key === "textContent") {
-    recordPatch({ op: "set-text", path });
-  } else if (key === "style") {
-    recordPatch({ op: "set-style", path });
-  } else {
-    const bindingValue = value === undefined || value === null || value === "" ? prev : value;
-    const isEvent = key.startsWith("on") && isEventBinding(bindingValue);
-    recordPatch({ isEvent, key, op: "set-prop", path });
-  }
-}
-function mutateUpdateStyle(tab, path, prop, value) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  const styleBefore = cloneValue(node.style);
-  if (!node.style) {
-    node.style = {};
-  }
-  if (value === undefined || value === "") {
-    delete node.style[prop];
-  } else {
-    node.style[prop] = value;
-  }
-  if (Object.keys(node.style).length === 0) {
-    delete node.style;
-  }
-  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
-  recordPatch({ op: "set-style", path });
-}
-function mutateUpdateAttribute(tab, path, attr, value) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  const attrsBefore = cloneValue(node.attributes);
-  if (!node.attributes) {
-    node.attributes = {};
-  }
-  if (value === undefined || value === "") {
-    delete node.attributes[attr];
-  } else {
-    node.attributes[attr] = value;
-  }
-  if (Object.keys(node.attributes).length === 0) {
-    delete node.attributes;
-  }
-  recordDocOp(setKeyPair(path, "attributes", attrsBefore, cloneValue(node.attributes)));
-  recordPatch({ attr, op: "set-attr", path });
-}
-function mutateUpdateMediaStyle(tab, path, mediaName, prop, value) {
-  if (!mediaName) {
-    return mutateUpdateStyle(tab, path, prop, value);
-  }
-  const node = getNodeAtPath(tab.doc.document, path);
-  const styleBefore = cloneValue(node.style);
-  if (!node.style) {
-    node.style = {};
-  }
-  const key = `@${mediaName}`;
-  const media = ensureNestedStyle(node.style, key);
-  if (value === undefined || value === "") {
-    delete media[prop];
-    if (Object.keys(media).length === 0) {
-      delete node.style[key];
-    }
-  } else {
-    media[prop] = value;
-  }
-  if (Object.keys(node.style).length === 0) {
-    delete node.style;
-  }
-  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
-  recordPatch({ op: "set-style", path });
-}
-function mutateUpdateNestedStyle(tab, path, selector, prop, value) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  const styleBefore = cloneValue(node.style);
-  if (!node.style) {
-    node.style = {};
-  }
-  const block = ensureNestedStyle(node.style, selector);
-  if (value === undefined || value === "") {
-    delete block[prop];
-    if (Object.keys(block).length === 0) {
-      delete node.style[selector];
-    }
-  } else {
-    block[prop] = value;
-  }
-  if (Object.keys(node.style).length === 0) {
-    delete node.style;
-  }
-  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
-  recordPatch({ op: "set-style", path });
-}
-function mutateUpdateMediaNestedStyle(tab, path, mediaName, selector, prop, value) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  const styleBefore = cloneValue(node.style);
-  if (!node.style) {
-    node.style = {};
-  }
-  const key = `@${mediaName}`;
-  const media = ensureNestedStyle(node.style, key);
-  const block = ensureNestedStyle(media, selector);
-  if (value === undefined || value === "") {
-    delete block[prop];
-    if (Object.keys(block).length === 0) {
-      delete media[selector];
-    }
-    if (Object.keys(media).length === 0) {
-      delete node.style[key];
-    }
-  } else {
-    block[prop] = value;
-  }
-  if (Object.keys(node.style).length === 0) {
-    delete node.style;
-  }
-  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
-  recordPatch({ op: "set-style", path });
-}
-function mutateUpdateNestedStylePath(tab, path, stylePath, prop, value) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  const styleBefore = cloneValue(node.style);
-  if (!node.style) {
-    node.style = {};
-  }
-  let obj = node.style;
-  for (const seg of stylePath) {
-    obj = ensureNestedStyle(obj, seg);
-  }
-  if (value === undefined || value === "") {
-    delete obj[prop];
-    let cur = node.style;
-    for (let i = 0;i < stylePath.length && cur; i++) {
-      const child = getNestedStyle(cur, stylePath[i]);
-      if (child && Object.keys(child).length === 0) {
-        delete cur[stylePath[i]];
-        break;
-      }
-      cur = child;
-    }
-  } else {
-    obj[prop] = value;
-  }
-  if (Object.keys(node.style).length === 0) {
-    delete node.style;
-  }
-  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
-  recordPatch({ op: "set-style", path });
-}
-function mutateUpdateMediaNestedStylePath(tab, path, mediaName, stylePath, prop, value) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  const styleBefore = cloneValue(node.style);
-  if (!node.style) {
-    node.style = {};
-  }
-  const key = `@${mediaName}`;
-  const media = ensureNestedStyle(node.style, key);
-  let obj = media;
-  for (const seg of stylePath) {
-    obj = ensureNestedStyle(obj, seg);
-  }
-  if (value === undefined || value === "") {
-    delete obj[prop];
-    let cur = media;
-    for (let i = 0;i < stylePath.length && cur; i++) {
-      const child = getNestedStyle(cur, stylePath[i]);
-      if (child && Object.keys(child).length === 0) {
-        delete cur[stylePath[i]];
-        break;
-      }
-      cur = child;
-    }
-    if (Object.keys(media).length === 0) {
-      delete node.style[key];
-    }
-  } else {
-    obj[prop] = value;
-  }
-  if (Object.keys(node.style).length === 0) {
-    delete node.style;
-  }
-  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
-  recordPatch({ op: "set-style", path });
-}
-function mutateReplaceStyle(tab, path, style) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  const styleBefore = cloneValue(node.style);
-  if (style && Object.keys(style).length > 0) {
-    node.style = style;
-  } else {
-    delete node.style;
-  }
-  recordDocOp(setKeyPair(path, "style", styleBefore, cloneValue(node.style)));
-  recordPatch({ op: "set-style", path });
-}
-function mutateAddDef(tab, name, def2) {
-  const doc = tab.doc.document;
-  const before = cloneValue(doc.state);
-  if (!doc.state) {
-    doc.state = {};
-  }
-  doc.state[name] = def2;
-  recordDocOp(setKeyPair([], "state", before, cloneValue(doc.state)));
-  recordPatch({ key: "state", op: "doc-meta" });
-}
-function mutateRemoveDef(tab, name) {
-  const doc = tab.doc.document;
-  if (doc.state) {
-    const before = cloneValue(doc.state);
-    delete doc.state[name];
-    if (Object.keys(doc.state).length === 0) {
-      delete doc.state;
-    }
-    recordDocOp(setKeyPair([], "state", before, cloneValue(doc.state)));
-    recordPatch({ key: "state", op: "doc-meta" });
-  }
-}
-function mutateUpdateDef(tab, name, updates) {
-  const doc = tab.doc.document;
-  const stateBefore = cloneValue(doc.state);
-  if (!doc.state) {
-    doc.state = {};
-  }
-  const existing = doc.state[name];
-  const entry = existing == null ? {} : typeof existing !== "object" || Array.isArray(existing) ? { default: existing } : existing;
-  doc.state[name] = entry;
-  Object.assign(entry, updates);
-  for (const k of Object.keys(entry)) {
-    if (entry[k] === undefined || entry[k] === null) {
-      delete entry[k];
-    }
-  }
-  recordDocOp(setKeyPair([], "state", stateBefore, cloneValue(doc.state)));
-  recordPatch({ key: "state", op: "doc-meta" });
-}
-function mutateRenameDef(tab, oldName, newName) {
-  const doc = tab.doc.document;
-  if (!doc.state || !doc.state[oldName]) {
-    return;
-  }
-  const before = cloneValue(doc.state);
-  doc.state[newName] = doc.state[oldName];
-  delete doc.state[oldName];
-  recordDocOp(setKeyPair([], "state", before, cloneValue(doc.state)));
-  recordPatch({ key: "state", op: "doc-meta" });
-}
-function mutateUpdateMedia(tab, name, query) {
-  const doc = tab.doc.document;
-  const mediaBefore = cloneValue(doc.$media);
-  if (!doc.$media) {
-    doc.$media = {};
-  }
-  if (query === undefined || query === "") {
-    delete doc.$media[name];
-    if (Object.keys(doc.$media).length === 0) {
-      delete doc.$media;
-    }
-  } else {
-    doc.$media[name] = query;
-  }
-  recordDocOp(setKeyPair([], "$media", mediaBefore, cloneValue(doc.$media)));
-  recordPatch({ key: "$media", op: "doc-meta" });
-}
-function mutateUpdateProp(tab, path, propName, value) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  const propsBefore = cloneValue(node.$props);
-  if (!node.$props) {
-    node.$props = {};
-  }
-  if (value === undefined || value === null || value === "") {
-    delete node.$props[propName];
-  } else {
-    node.$props[propName] = value;
-  }
-  if (Object.keys(node.$props).length === 0) {
-    delete node.$props;
-  }
-  recordDocOp(setKeyPair(path, "$props", propsBefore, cloneValue(node.$props)));
-  recordPatch({ op: "replace", path });
-}
-function mutateAddSwitchCase(tab, path, caseName, caseDef) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  const before = cloneValue(node.cases);
-  if (!node.cases) {
-    node.cases = {};
-  }
-  node.cases[caseName] = caseDef || { tagName: "div", textContent: caseName };
-  recordDocOp(setKeyPair(path, "cases", before, cloneValue(node.cases)));
-  recordPatch({ op: "replace", path });
-}
-function mutateRemoveSwitchCase(tab, path, caseName) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  if (node.cases) {
-    const before = cloneValue(node.cases);
-    delete node.cases[caseName];
-    recordDocOp(setKeyPair(path, "cases", before, cloneValue(node.cases)));
-    recordPatch({ op: "replace", path });
-  }
-}
-function mutateRenameSwitchCase(tab, path, oldName, newName) {
-  const node = getNodeAtPath(tab.doc.document, path);
-  if (!node.cases || !node.cases[oldName]) {
-    return;
-  }
-  const before = cloneValue(node.cases);
-  node.cases[newName] = node.cases[oldName];
-  delete node.cases[oldName];
-  recordDocOp(setKeyPair(path, "cases", before, cloneValue(node.cases)));
-  recordPatch({ op: "replace", path });
-}
-function mutateUpdateFrontmatter(tab, field, value) {
-  const fm = tab.doc.content.frontmatter;
-  const before = Object.hasOwn(fm, field) ? cloneValue(fm[field]) : undefined;
-  const deletes = value === undefined || value === null || value === "";
-  if (deletes) {
-    delete fm[field];
-  } else {
-    fm[field] = value;
-  }
-  const after = deletes ? undefined : cloneValue(value);
-  recordFmOp({ after, before, field });
-  tab.doc.dirty = true;
-}
-function applyFmState(tab, field, value) {
-  if (value === undefined) {
-    delete tab.doc.content.frontmatter[field];
-  } else {
-    tab.doc.content.frontmatter[field] = value;
-  }
-}
-
-// src/collab/collab-state.ts
-var states = new WeakMap;
-var attachedPaths = new Map;
-function collabState(tab) {
-  const key = toRaw(tab);
-  let state = states.get(key);
-  if (!state) {
-    state = reactive({
-      active: false,
-      peers: [],
-      readOnly: false,
-      sourceCanonical: false,
-      status: "detached"
-    });
-    states.set(key, state);
-  }
-  return state;
-}
-function registerCollabPath(path) {
-  attachedPaths.set(path, (attachedPaths.get(path) ?? 0) + 1);
-}
-function unregisterCollabPath(path) {
-  const count = attachedPaths.get(path) ?? 0;
-  if (count <= 1) {
-    attachedPaths.delete(path);
-  } else {
-    attachedPaths.set(path, count - 1);
-  }
-}
-function isCollabPath(path) {
-  return attachedPaths.has(path.replaceAll("\\", "/"));
-}
-
-// src/collab/collab-session.ts
-var SYNC_TIMEOUT_MS = 8000;
-var MIRROR_DEBOUNCE_MS = 800;
-var MIRROR_MAX_LAG_MS = 2500;
-var collabModulePromise = null;
-function loadCollab() {
-  collabModulePromise ??= import("./index-baeg2x3y.js");
-  return collabModulePromise;
-}
-function maybePlatform() {
-  try {
-    return getPlatform();
-  } catch {
-    return null;
-  }
-}
-var _serialize = null;
-function configureCollabSerializer(fn) {
-  _serialize = fn;
-}
-var _parse = null;
-function configureCollabParser(fn) {
-  _parse = fn;
-}
-var _notify = () => {};
-function configureCollabNotifier(fn) {
-  _notify = fn ?? (() => {});
-}
-var runtimes = new WeakMap;
-function rawTab(tab) {
-  return toRaw(tab);
-}
-function runtimeOf(tab) {
-  return runtimes.get(rawTab(tab));
-}
-function runtimeFor(tab) {
-  const key = rawTab(tab);
-  let runtime = runtimes.get(key);
-  if (!runtime) {
-    runtime = { attaching: null, generation: 0, session: null, watcherInstalled: false };
-    runtimes.set(key, runtime);
-  }
-  return runtime;
-}
-var hooksInstalled = false;
-function installGlobalHooks() {
-  if (hooksInstalled) {
-    return;
-  }
-  hooksInstalled = true;
-  setTransactObserver(onTransact);
-  setBatchEndNotifier(onBatchEnd);
-  setTransactGate((tab) => {
-    const session = runtimeOf(tab)?.session;
-    if (session?.synced && collabState(tab).sourceCanonical && !session.inSourceMode) {
-      _notify("Source editing in progress — structural edits are paused");
-      return "source-canonical";
-    }
-    return null;
-  });
-}
-function onTransact(tab, record, origin) {
-  const session = runtimeOf(tab)?.session;
-  if (!session || !session.synced) {
-    return;
-  }
-  session.lastSeenRef = toRaw(tab.doc.document);
-  if (origin === "remote") {
-    scheduleMirror(session);
-    return;
-  }
-  if (session.canWrite) {
-    publishRecord(session, record);
-    scheduleMirror(session);
-  }
-}
-function onBatchEnd(tab) {
-  const session = runtimeOf(tab)?.session;
-  if (!session?.synced || session.batchOps === null) {
-    return;
-  }
-  const ops = session.batchOps;
-  const needsDiff = session.batchNeedsDiff;
-  session.batchOps = null;
-  session.batchNeedsDiff = false;
-  if (!session.canWrite) {
-    return;
-  }
-  session.undoManager?.stopCapturing();
-  if (needsDiff) {
-    publishDiff(session);
-  } else if (ops.length > 0) {
-    try {
-      session.collab.applyDocOpsToY(session.handle.doc, ops, session.collab.LOCAL_ORIGIN);
-    } catch {
-      publishDiff(session);
-    }
-  }
-  session.undoManager?.stopCapturing();
-}
-function publishRecord(session, record) {
-  const forward = record.docOps.map((pair) => pair.forward);
-  if (isBatching()) {
-    session.batchOps ??= [];
-    if (forward.length === 0) {
-      session.batchNeedsDiff = true;
-    } else {
-      session.batchOps.push(...forward);
-    }
-    return;
-  }
-  if (forward.length === 0) {
-    publishDiff(session);
-    return;
-  }
-  try {
-    session.collab.applyDocOpsToY(session.handle.doc, forward, session.collab.LOCAL_ORIGIN);
-  } catch {
-    publishDiff(session);
-  }
-}
-function publishDiff(session) {
-  const { collab, handle, tab } = session;
-  const before = collab.yDocToJson(handle.doc);
-  const after = jsonClone(toRaw(tab.doc.document));
-  const ops = collab.diffDocs(before, after);
-  if (ops === null) {
-    collab.replaceYStructure(handle.doc, after, collab.LOCAL_ORIGIN);
-  } else if (ops.length > 0) {
-    try {
-      collab.applyDocOpsToY(handle.doc, ops, collab.LOCAL_ORIGIN);
-    } catch {
-      collab.replaceYStructure(handle.doc, after, collab.LOCAL_ORIGIN);
-    }
-  }
-}
-function reconcileTabFromY(session) {
-  const next = session.collab.yDocToJson(session.handle.doc);
-  transactDoc(session.tab, (t) => {
-    const target = t.doc.document;
-    for (const key of Object.keys(target)) {
-      if (!(key in next)) {
-        delete target[key];
-      }
-    }
-    Object.assign(target, next);
-  }, { origin: "remote", skipHistory: true });
-}
-function isReconciler(session) {
-  if (!session.canWrite) {
-    return false;
-  }
-  const { awareness } = session.handle;
-  let lowest = awareness.clientID;
-  for (const [clientId, state] of awareness.getStates()) {
-    if (state.canWrite !== false && clientId < lowest) {
-      lowest = clientId;
-    }
-  }
-  return lowest === session.handle.awareness.clientID;
-}
-function scheduleMirror(session) {
-  if (!_serialize || !isReconciler(session)) {
-    return;
-  }
-  if (session.collab.canonicalOf(session.handle.doc) === "source") {
-    return;
-  }
-  const now = Date.now();
-  session.lastMirrorAt ??= now;
-  if (now - session.lastMirrorAt >= MIRROR_MAX_LAG_MS) {
-    if (session.mirrorTimer) {
-      clearTimeout(session.mirrorTimer);
-      session.mirrorTimer = null;
-    }
-    session.lastMirrorAt = now;
-    mirrorNow(session);
-    return;
-  }
-  if (session.mirrorTimer) {
-    clearTimeout(session.mirrorTimer);
-  }
-  session.mirrorTimer = setTimeout(() => {
-    session.mirrorTimer = null;
-    session.lastMirrorAt = Date.now();
-    mirrorNow(session);
-  }, MIRROR_DEBOUNCE_MS);
-}
-async function mirrorNow(session) {
-  if (!_serialize || !session.synced) {
-    return;
-  }
-  try {
-    const text = await _serialize(session.tab);
-    session.collab.updateSourceText(session.handle.doc, text, session.collab.MIRROR_ORIGIN);
-  } catch {}
-}
-async function sourceParseNow(session) {
-  if (!_parse || !session.synced || !session.canWrite) {
-    return;
-  }
-  const { collab, handle, tab } = session;
-  const rev = collab.canonicalRevOf(handle.doc);
-  const text = collab.sourceText(handle.doc).toString();
-  let parsed;
-  try {
-    parsed = await _parse(tab, text);
-  } catch {
-    return;
-  }
-  if (!session.synced || collab.canonicalRevOf(handle.doc) !== rev) {
-    return;
-  }
-  const ops = collab.diffDocs(collab.yDocToJson(handle.doc), parsed.document);
-  if (ops === null) {
-    collab.replaceYStructure(handle.doc, parsed.document, collab.MIRROR_ORIGIN);
-  } else if (ops.length > 0) {
-    try {
-      collab.applyDocOpsToY(handle.doc, ops, collab.MIRROR_ORIGIN);
-    } catch {
-      collab.replaceYStructure(handle.doc, parsed.document, collab.MIRROR_ORIGIN);
-    }
-  }
-  const frontmatter = collab.frontmatterMap(handle.doc);
-  const next = parsed.frontmatter ?? {};
-  handle.doc.transact(() => {
-    const sharedKeys = [...frontmatter.keys()];
-    for (const key of sharedKeys) {
-      if (!(key in next)) {
-        frontmatter.delete(key);
-      }
-    }
-    for (const [key, value] of Object.entries(next)) {
-      if (!collab.deepEqual(frontmatter.get(key), value)) {
-        frontmatter.set(key, value);
-      }
-    }
-  }, collab.MIRROR_ORIGIN);
-}
-function collabSourceContext(tab) {
-  const session = runtimeOf(tab)?.session;
-  if (!session?.synced) {
-    return null;
-  }
-  const { collab, handle } = session;
-  return {
-    awareness: handle.awareness,
-    enter: async () => {
-      session.inSourceMode = true;
-      const local = handle.awareness.getLocalState();
-      if (local) {
-        handle.awareness.setLocalState({ ...local, mode: "source" });
-      }
-      if (!session.canWrite) {
-        return;
-      }
-      let serialized = null;
-      if (_serialize) {
-        try {
-          serialized = await _serialize(tab);
-        } catch {
-          serialized = null;
-        }
-      }
-      collab.acquireSourceCanonical(handle.doc, serialized ?? collab.sourceText(handle.doc).toString(), collab.LOCAL_ORIGIN);
-    },
-    leave: () => {
-      session.inSourceMode = false;
-      const local = handle.awareness.getLocalState();
-      if (local) {
-        handle.awareness.setLocalState({ ...local, mode: "structure" });
-      }
-      if (!session.canWrite) {
-        return;
-      }
-      const others = collab.otherSourceEditors(handle.awareness, session.path, handle.awareness.clientID);
-      if (others.length === 0) {
-        sourceParseNow(session).then(() => {
-          collab.releaseSourceCanonical(handle.doc, collab.LOCAL_ORIGIN);
-        });
-      }
-    },
-    localOrigin: collab.LOCAL_ORIGIN,
-    readOnly: !session.canWrite,
-    text: collab.sourceText(handle.doc)
-  };
-}
-async function collabSave(tab) {
-  const session = runtimeOf(tab)?.session;
-  if (!session?.synced) {
-    return false;
-  }
-  if (session.mirrorTimer) {
-    clearTimeout(session.mirrorTimer);
-    session.mirrorTimer = null;
-  }
-  if (session.canWrite) {
-    await mirrorNow(session);
-  }
-  await session.handle.flush();
-  return true;
-}
-async function flushAllCollab() {
-  for (const tab of liveTabs) {
-    const session = runtimeOf(tab)?.session;
-    if (session?.synced) {
-      await collabSave(tab);
-    }
-  }
-}
-var liveTabs = new Set;
-function ensureCollab(tab) {
-  const platform = maybePlatform();
-  if (!platform?.collab || !tab.documentPath) {
-    return;
-  }
-  const runtime = runtimeFor(tab);
-  if (runtime.watcherInstalled) {
-    return;
-  }
-  runtime.watcherInstalled = true;
-  installGlobalHooks();
-  liveTabs.add(tab);
-  tab.scope.run(() => {
-    effect(() => {
-      const drilled = (tab.session.documentStack?.length ?? 0) > 0;
-      if (drilled) {
-        detachSession(tab);
-      } else {
-        attachSession(tab);
-      }
-    });
-    onScopeDispose(() => {
-      liveTabs.delete(tab);
-      detachSession(tab);
-    });
-  });
-}
-function rekeyCollab(tab) {
-  const runtime = runtimeOf(tab);
-  if (!runtime?.watcherInstalled) {
-    ensureCollab(tab);
-    return;
-  }
-  detachSession(tab);
-  attachSession(tab);
-}
-async function attachSession(tab) {
-  const runtime = runtimeFor(tab);
-  if (runtime.session || runtime.attaching) {
-    return;
-  }
-  const { documentPath: path } = tab;
-  const platform = maybePlatform();
-  if (!path || !platform?.collab) {
-    return;
-  }
-  const { generation } = runtime;
-  const state = collabState(tab);
-  state.status = "connecting";
-  const attempt = (async () => {
-    try {
-      const [collab, handle] = await Promise.all([loadCollab(), platform.collab(path)]);
-      if (!handle) {
-        state.status = "detached";
-        return;
-      }
-      if (runtime.generation !== generation) {
-        handle.destroy();
-        return;
-      }
-      let timer = null;
-      const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error("collab-sync-timeout")), SYNC_TIMEOUT_MS);
-      });
-      try {
-        await Promise.race([handle.whenSynced, timeout]);
-      } finally {
-        if (timer) {
-          clearTimeout(timer);
-        }
-      }
-      if (runtime.generation !== generation) {
-        handle.destroy();
-        return;
-      }
-      runtime.session = createSession(tab, path, collab, handle);
-      state.active = true;
-      state.status = "synced";
-      state.readOnly = !runtime.session.canWrite;
-      registerCollabPath(path);
-    } catch {
-      state.status = "detached";
-      state.active = false;
-    } finally {
-      runtime.attaching = null;
-    }
-  })();
-  runtime.attaching = attempt;
-  await attempt;
-}
-function detachSession(tab) {
-  const runtime = runtimeOf(tab);
-  if (!runtime) {
-    return;
-  }
-  runtime.generation += 1;
-  const { session } = runtime;
-  runtime.session = null;
-  const state = collabState(tab);
-  state.active = false;
-  state.status = "detached";
-  state.peers = [];
-  if (!session) {
-    return;
-  }
-  unregisterCollabPath(session.path);
-  if (session.mirrorTimer) {
-    clearTimeout(session.mirrorTimer);
-  }
-  if (session.sourceParseTimer) {
-    clearTimeout(session.sourceParseTimer);
-  }
-  for (const dispose of session.disposers) {
-    try {
-      dispose();
-    } catch {}
-  }
-  setHistoryDelegate(tab, null);
-  tab.history.snapshots = [
-    {
-      document: jsonClone(toRaw(tab.doc.document)),
-      selection: tab.session.selection ? [...tab.session.selection] : null
-    }
-  ];
-  tab.history.index = 0;
-  session.undoManager?.destroy();
-  session.handle.destroy();
-}
-function createSession(tab, path, collab, handle) {
-  const identity = handle.identity();
-  const session = {
-    applyingRemoteFrontmatter: false,
-    batchNeedsDiff: false,
-    batchOps: null,
-    canWrite: identity ? identity.permission !== "read" : true,
-    collab,
-    disposers: [],
-    handle,
-    inSourceMode: false,
-    lastSeenRef: toRaw(tab.doc.document),
-    mirrorTimer: null,
-    path,
-    sourceParseTimer: null,
-    synced: false,
-    tab,
-    undoManager: null
-  };
-  const meta = collab.metaMap(handle.doc);
-  if (meta.get("structureSeeded") === true) {
-    const yJson = collab.yDocToJson(handle.doc);
-    const tabJson = jsonClone(toRaw(tab.doc.document));
-    if (!collab.deepEqual(yJson, tabJson)) {
-      const ops = collab.diffDocs(tabJson, yJson);
-      if (ops === null) {
-        session.synced = true;
-        reconcileTabFromY(session);
-        session.synced = false;
-      } else if (ops.length > 0) {
-        applyExternalDocOps(tab, ops);
-      }
-    }
-    session.applyingRemoteFrontmatter = true;
-    const sharedFrontmatter = collab.frontmatterMap(handle.doc);
-    for (const [key, value] of sharedFrontmatter.entries()) {
-      tab.doc.content.frontmatter[key] = value;
-    }
-    session.applyingRemoteFrontmatter = false;
-  } else if (session.canWrite) {
-    collab.seedStructure(handle.doc, jsonClone(toRaw(tab.doc.document)), {
-      frontmatter: jsonClone(toRaw(tab.doc.content.frontmatter)),
-      origin: collab.SEED_ORIGIN,
-      sourceFormat: tab.doc.sourceFormat
-    });
-  }
-  session.lastSeenRef = toRaw(tab.doc.document);
-  session.disposers.push(handle.onDirty((dirty) => {
-    tab.doc.dirty = dirty;
-  }));
-  handle.awareness.setLocalState({
-    canWrite: session.canWrite,
-    focusedPath: path,
-    structuralSelection: null,
-    user: identity ? {
-      avatarUrl: identity.avatarUrl,
-      color: identity.color,
-      login: identity.login,
-      name: identity.name
-    } : {
-      color: collab.colorForKey(String(handle.awareness.clientID)),
-      login: `guest-${handle.awareness.clientID % 1000}`
-    }
-  });
-  const undoManager = new collab.UndoManager([collab.structureMap(handle.doc), collab.frontmatterMap(handle.doc)], { trackedOrigins: new Set([collab.LOCAL_ORIGIN]) });
-  session.undoManager = undoManager;
-  const onStackAdd = ({ stackItem }) => {
-    stackItem.meta.set("selection", tab.session.selection ? [...tab.session.selection] : null);
-  };
-  const onStackPop = ({ stackItem }) => {
-    const selection = stackItem.meta.get("selection");
-    tab.session.selection = selection ? [...selection] : null;
-  };
-  undoManager.on("stack-item-added", onStackAdd);
-  undoManager.on("stack-item-popped", onStackPop);
-  session.disposers.push(() => {
-    undoManager.off("stack-item-added", onStackAdd);
-    undoManager.off("stack-item-popped", onStackPop);
-  });
-  setHistoryDelegate(tab, {
-    canRedo: () => undoManager.canRedo(),
-    canUndo: () => undoManager.canUndo(),
-    redo: () => {
-      undoManager.redo();
-    },
-    undo: () => {
-      undoManager.undo();
-    }
-  });
-  const structure = collab.structureMap(handle.doc);
-  const structureObserver = (events, transaction) => {
-    if (transaction.origin === collab.LOCAL_ORIGIN || !session.synced) {
-      return;
-    }
-    const ops = collab.yEventsToDocOps(events);
-    if (ops === null) {
-      reconcileTabFromY(session);
-      return;
-    }
-    if (ops.length === 0) {
-      return;
-    }
-    try {
-      applyExternalDocOps(tab, ops);
-    } catch {
-      reconcileTabFromY(session);
-    }
-  };
-  structure.observeDeep(structureObserver);
-  session.disposers.push(() => structure.unobserveDeep(structureObserver));
-  const tabState = collabState(tab);
-  tabState.sourceCanonical = collab.canonicalOf(handle.doc) === "source";
-  const lockMeta = collab.metaMap(handle.doc);
-  const lockObserver = () => {
-    tabState.sourceCanonical = collab.canonicalOf(handle.doc) === "source";
-  };
-  lockMeta.observe(lockObserver);
-  session.disposers.push(() => lockMeta.unobserve(lockObserver));
-  const source = collab.sourceText(handle.doc);
-  const sourceObserver = (_event, transaction) => {
-    if (transaction.origin === collab.MIRROR_ORIGIN || !session.synced) {
-      return;
-    }
-    if (collab.canonicalOf(handle.doc) !== "source") {
-      return;
-    }
-    if (!collab.isSourceReconciler(handle.awareness, session.path)) {
-      return;
-    }
-    if (session.sourceParseTimer) {
-      clearTimeout(session.sourceParseTimer);
-    }
-    session.sourceParseTimer = setTimeout(() => {
-      session.sourceParseTimer = null;
-      sourceParseNow(session);
-    }, 600);
-  };
-  source.observe(sourceObserver);
-  session.disposers.push(() => source.unobserve(sourceObserver));
-  const frontmatter = collab.frontmatterMap(handle.doc);
-  const frontmatterObserver = (event, transaction) => {
-    if (transaction.origin === collab.LOCAL_ORIGIN || !session.synced) {
-      return;
-    }
-    session.applyingRemoteFrontmatter = true;
-    try {
-      for (const [key, change] of event.changes.keys) {
-        if (change.action === "delete") {
-          delete tab.doc.content.frontmatter[key];
-        } else {
-          tab.doc.content.frontmatter[key] = frontmatter.get(key);
-        }
-      }
-    } finally {
-      session.applyingRemoteFrontmatter = false;
-    }
-  };
-  frontmatter.observe(frontmatterObserver);
-  session.disposers.push(() => frontmatter.unobserve(frontmatterObserver));
-  tab.scope.run(() => {
-    let lastJson = JSON.stringify(tab.doc.content.frontmatter);
-    effect(() => {
-      const json = JSON.stringify(tab.doc.content.frontmatter);
-      if (json === lastJson) {
-        return;
-      }
-      lastJson = json;
-      if (session.applyingRemoteFrontmatter || !session.synced || !session.canWrite) {
-        return;
-      }
-      const local = JSON.parse(json);
-      handle.doc.transact(() => {
-        const sharedKeys = [...frontmatter.keys()];
-        for (const key of sharedKeys) {
-          if (!(key in local)) {
-            frontmatter.delete(key);
-          }
-        }
-        for (const [key, value] of Object.entries(local)) {
-          if (!collab.deepEqual(frontmatter.get(key), value)) {
-            frontmatter.set(key, value);
-          }
-        }
-      }, collab.LOCAL_ORIGIN);
-      scheduleMirror(session);
-    });
-    effect(() => {
-      const structuralSelection = tab.session.selection ? [...tab.session.selection] : null;
-      const local = handle.awareness.getLocalState();
-      if (local) {
-        handle.awareness.setLocalState({ ...local, structuralSelection });
-      }
-    });
-    effect(() => {
-      const ref2 = toRaw(tab.doc.document);
-      queueMicrotask(() => {
-        const current = runtimeOf(tab)?.session;
-        if (current !== session || !session.synced || !session.canWrite) {
-          return;
-        }
-        const nowRef = toRaw(tab.doc.document);
-        if (nowRef !== ref2 || nowRef === session.lastSeenRef) {
-          return;
-        }
-        session.lastSeenRef = nowRef;
-        publishDiff(session);
-        scheduleMirror(session);
-      });
-    });
-  });
-  const state = collabState(tab);
-  const awarenessObserver = () => {
-    const peers = [];
-    for (const [clientId, peerState] of handle.awareness.getStates()) {
-      if (clientId !== handle.awareness.clientID && peerState["user"]) {
-        peers.push({ clientId, state: peerState });
-      }
-    }
-    state.peers = peers;
-  };
-  awarenessObserver();
-  handle.awareness.on("change", awarenessObserver);
-  session.disposers.push(() => handle.awareness.off("change", awarenessObserver), handle.onStatus((status) => {
-    if (status === "offline" || status === "connecting") {
-      state.status = "offline";
-    } else if (session.synced) {
-      state.status = "synced";
-    }
-  }), handle.onReset(() => {
-    detachSession(tab);
-    attachSession(tab);
-  }));
-  session.synced = true;
-  return session;
-}
-
-// src/tabs/tab.ts
-function createDefaultUi(canvasMode, preview = false) {
-  return {
-    activeMedia: null,
-    activeSelector: null,
-    canvasMode,
-    editZoom: 1,
-    editingFormula: null,
-    editingFunction: null,
-    featureToggles: {},
-    frontmatterOpen: true,
-    gitBranches: null,
-    gitCommitMessage: "",
-    gitDiffState: null,
-    gitError: null,
-    gitLoading: false,
-    gitStatus: null,
-    inspectorSections: {},
-    pendingInlineEdit: null,
-    preview,
-    previewColorScheme: "auto",
-    previewParams: {},
-    previewProps: null,
-    rightTab: "properties",
-    settingsTab: "stylebook",
-    showLayout: true,
-    styleFilter: "",
-    styleFilterActive: false,
-    styleSections: {},
-    styleShorthands: {},
-    stylebookCustomizedOnly: false,
-    stylebookFilter: "",
-    stylebookSelection: null,
-    stylebookTab: "elements",
-    zoom: 1
-  };
-}
-var ALL_MODES = ["edit", "design", "preview", "source", "stylebook"];
-function createTab({
-  id,
-  documentPath = null,
-  fileHandle = null,
-  document: document2,
-  frontmatter,
-  sourceFormat = null,
-  capabilities
-}) {
-  const scope = effectScope();
-  normalizeArrayChildren(document2);
-  const resolvedModes = capabilities?.modes ?? inferModes(documentPath, sourceFormat);
-  const initialCanvasMode = resolvedModes.find((m) => m !== "preview") ?? "edit";
-  const initialPreview = resolvedModes[0] === "preview";
-  const tab = scope.run(() => ({
-    capabilities: { modes: resolvedModes },
-    doc: reactive({
-      content: { frontmatter: frontmatter || {} },
-      dirty: false,
-      document: document2,
-      handlersSource: null,
-      mode: inferDocumentMode(documentPath, sourceFormat),
-      sourceFormat
-    }),
-    documentPath,
-    fileHandle,
-    history: reactive({
-      index: 0,
-      snapshots: [{ document: structuredClone(document2), selection: null }]
-    }),
-    id,
-    scope,
-    session: reactive({
-      canvas: {
-        error: null,
-        livePreviews: null,
-        pendingInlineEdit: null,
-        scope: null,
-        status: "idle"
-      },
-      clipboard: null,
-      documentStack: [],
-      hover: null,
-      selection: null,
-      ui: createDefaultUi(initialCanvasMode, initialPreview)
-    })
-  }));
-  return tab;
-}
-function inferModes(documentPath, sourceFormat) {
-  if (documentPath === "project.json") {
-    return ["stylebook", "source"];
-  }
-  const format = formatByName(sourceFormat) ?? formatForPath(documentPath);
-  if (format) {
-    return format.studio?.modes ?? ["edit", "design", "preview", "source"];
-  }
-  return ALL_MODES;
-}
-function inferDocumentMode(documentPath, sourceFormat) {
-  const format = formatByName(sourceFormat) ?? formatForPath(documentPath);
-  if (format) {
-    return format.studio?.documentMode?.default ?? "content";
-  }
-  return "component";
-}
-function disposeTab(tab) {
-  tab.scope.stop();
-}
-
-// src/workspace/workspace.ts
-var workspace = reactive({
-  activeTabId: null,
-  clipboard: null,
-  componentRegistry: [],
-  fileTree: {
-    dirs: new Map,
-    expanded: new Set,
-    searchQuery: "",
-    selectedPath: null
-  },
-  projectConfig: null,
-  projectRoot: null,
-  styleClipboard: null,
-  tabOrder: [],
-  tabs: new Map,
-  ui: {
-    activityBar: "files"
-  }
-});
-var activeTab = computed(() => workspace.activeTabId ? workspace.tabs.get(workspace.activeTabId) ?? null : null);
-function setWorkspaceProject(root, config = null) {
-  workspace.projectRoot = root;
-  workspace.projectConfig = config;
-}
-function isTabActive(tab) {
-  const active = activeTab.value;
-  return tab !== null && active !== null && toRaw(active) === toRaw(tab);
-}
-function openTab(opts) {
-  const tab = createTab(opts);
-  workspace.tabs.set(tab.id, tab);
-  workspace.tabOrder.push(tab.id);
-  workspace.activeTabId = tab.id;
-  ensureCollab(tab);
-  return tab;
-}
-function closeTab(tabId) {
-  const tab = workspace.tabs.get(tabId);
-  if (!tab) {
-    return;
-  }
-  disposeTab(tab);
-  workspace.tabs.delete(tabId);
-  workspace.tabOrder = workspace.tabOrder.filter((id) => id !== tabId);
-  if (workspace.activeTabId === tabId) {
-    workspace.activeTabId = workspace.tabOrder.at(-1) || null;
-  }
-}
-function closeAllTabs() {
-  const tabs = [...workspace.tabs.values()];
-  workspace.tabs.clear();
-  workspace.tabOrder = [];
-  workspace.activeTabId = null;
-  for (const tab of tabs) {
-    disposeTab(tab);
-  }
-}
-function replaceAllTabs(newTabOpts) {
-  const oldIds = [...workspace.tabs.keys()];
-  const oldTabs = [...workspace.tabs.values()];
-  const newTab = createTab(newTabOpts);
-  workspace.tabs.set(newTab.id, newTab);
-  workspace.activeTabId = newTab.id;
-  workspace.tabOrder = [newTab.id];
-  ensureCollab(newTab);
-  for (const id of oldIds) {
-    if (id === newTab.id) {
-      continue;
-    }
-    workspace.tabs.delete(id);
-  }
-  for (const tab of oldTabs) {
-    disposeTab(tab);
-  }
-  return newTab;
-}
-function activateTab(tabId) {
-  if (workspace.tabs.has(tabId)) {
-    workspace.activeTabId = tabId;
-  }
-}
-function renameTab(oldId, newId, newDocumentPath) {
-  const tab = workspace.tabs.get(oldId);
-  if (!tab) {
-    return;
-  }
-  tab.id = newId;
-  tab.documentPath = newDocumentPath;
-  workspace.tabs.delete(oldId);
-  workspace.tabs.set(newId, tab);
-  workspace.tabOrder = workspace.tabOrder.map((id) => id === oldId ? newId : id);
-  if (workspace.activeTabId === oldId) {
-    workspace.activeTabId = newId;
-  }
-  rekeyCollab(tab);
-}
-// src/utils/strip-events.ts
-function stripEventHandlers(node) {
-  if (!node || typeof node !== "object") {
-    return node;
-  }
-  if (Array.isArray(node)) {
-    return node.map((n) => stripEventHandlers(n));
-  }
-  const out = {};
-  for (const [k, v] of Object.entries(node)) {
-    if (k.startsWith("on") && isEventBinding(v)) {
-      continue;
-    }
-    if (k === "children") {
-      out.children = Array.isArray(v) ? v.map((c) => stripEventHandlers(c)) : stripEventHandlers(v);
-    } else if (k === "cases" && typeof v === "object") {
-      const cases = {};
-      for (const [ck, cv] of Object.entries(v)) {
-        cases[ck] = stripEventHandlers(cv);
-      }
-      out.cases = cases;
-    } else if (k === "state" && typeof v === "object" && v !== null) {
-      const state = {};
-      for (const [sk, sv] of Object.entries(v)) {
-        if (sv && typeof sv === "object" && sv.timing === "server") {
-          continue;
-        }
-        state[sk] = sv;
-      }
-      out.state = state;
-    } else if (k === "style" || k === "attributes" || k === "$media") {
-      out[k] = v;
-    } else {
-      out[k] = v;
-    }
-  }
-  return out;
-}
-
-// src/store.ts
-var canvasWrap = null;
-var activityBar = null;
-var leftPanel = null;
-var rightPanel = null;
-var chatPanelEl = null;
-var toolbarEl = null;
-var statusbarEl = null;
-var frontmatterPanelEl = null;
-function initShellRefs() {
-  canvasWrap = document.querySelector("#canvas-wrap");
-  activityBar = document.querySelector("#activity-bar");
-  leftPanel = document.querySelector("#left-panel");
-  rightPanel = document.querySelector("#right-panel");
-  chatPanelEl = document.querySelector("#chat-panel");
-  toolbarEl = document.querySelector("#toolbar");
-  statusbarEl = document.querySelector("#statusbar");
-  frontmatterPanelEl = document.querySelector("#frontmatter-panel");
-}
-var canvasPanels = [];
-var VOID_ELEMENTS = new Set([
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-]);
-var COMMON_SELECTORS = [
-  ":hover",
-  ":focus",
-  ":active",
-  ":focus-within",
-  ":focus-visible",
-  ":disabled",
-  ":first-child",
-  ":last-child",
-  "::before",
-  "::after",
-  "::placeholder"
-];
-function isNestedSelector(k) {
-  return k.startsWith(":") || k.startsWith(".") || k.startsWith("&") || k.startsWith("[");
-}
-var _styleDebounceTimers = new Map;
-function debouncedStyleCommit(prop, ms, fn) {
-  return (...args) => {
-    clearTimeout(_styleDebounceTimers.get(prop));
-    _styleDebounceTimers.set(prop, setTimeout(() => {
-      _styleDebounceTimers.delete(prop);
-      fn(...args);
-    }, ms));
-  };
-}
-function cancelStyleDebounce(prop) {
-  clearTimeout(_styleDebounceTimers.get(prop));
-  _styleDebounceTimers.delete(prop);
-}
-var _renderers = new Map;
-function registerRenderer(name, fn) {
-  _renderers.set(name, fn);
-}
-function render() {
-  for (const [name, fn] of _renderers.entries()) {
-    try {
-      fn();
-    } catch (error) {
-      console.error(`Renderer "${name}" failed:`, error);
-    }
-  }
-}
-function renderOnly(...names) {
-  for (const name of names) {
-    const fn = _renderers.get(name);
-    if (!fn) {
-      continue;
-    }
-    try {
-      fn();
-    } catch (error) {
-      console.error(`Renderer "${name}" failed:`, error);
-    }
-  }
-}
-function updateSession(patch) {
-  const tab = activeTab.value;
-  if (tab) {
-    if (patch.selection !== undefined) {
-      tab.session.selection = patch.selection;
-    }
-    if (patch.hover !== undefined) {
-      tab.session.hover = patch.hover;
-    }
-    if (patch.clipboard !== undefined) {
-      tab.session.clipboard = patch.clipboard;
-    }
-    if (patch.ui) {
-      for (const [k, v] of Object.entries(patch.ui)) {
-        tab.session.ui[k] = v;
-      }
-    }
-    if (patch.canvas) {
-      for (const [k, v] of Object.entries(patch.canvas)) {
-        tab.session.canvas[k] = v;
-      }
-    }
-  }
-}
-function updateUi(field, value) {
-  const tab = activeTab.value;
-  if (tab) {
-    tab.session.ui[field] = value;
-  }
-}
-function updateCanvas(patch) {
-  const tab = activeTab.value;
-  if (tab) {
-    for (const [k, v] of Object.entries(patch)) {
-      tab.session.canvas[k] = v;
-    }
-  }
-}
-
-export { isJsonObject, isRef2 as isRef, isFunctionDef, isExpressionDef, isNamedFormulaDef, hasStructuredBody, isPrototypeDef, isServerFnDef, isMappedArray, isTemplateString, bodyReturnsValue, getNestedStyle, getEventBinding, paramNames, effectScope, onScopeDispose, effect, onEffectCleanup, reactive, toRaw, isRef as isRef1, ref, computed, getNodeAtPath, childList, parentElementPath, childIndex, pathKey, pathsEqual, isAncestor, flattenTree, nodeLabel, createState, projectState, setProjectState, requireProjectState, setPatchConsumer, transactDoc, transact, beginBatch, endBatch2 as endBatch, isBatching, setHistoryDelegate, canUndo, canRedo, undo, redo, mutateInsertNode, mutateRemoveNode, mutateDuplicateNode, mutateWrapNode, mutateMoveNode, mutateUpdateProperty, mutateUpdateStyle, mutateUpdateAttribute, mutateUpdateMediaStyle, mutateUpdateNestedStyle, mutateUpdateMediaNestedStyle, mutateUpdateNestedStylePath, mutateUpdateMediaNestedStylePath, mutateReplaceStyle, mutateAddDef, mutateRemoveDef, mutateUpdateDef, mutateRenameDef, mutateUpdateMedia, mutateUpdateProp, mutateAddSwitchCase, mutateRemoveSwitchCase, mutateRenameSwitchCase, mutateUpdateFrontmatter, collabState, isCollabPath, camelToKebab, camelToLabel, toCamelCase, kebabToLabel, propLabel, attrLabel, abbreviateValue, inferInputType, findContentTypeSchema, friendlyNameToVar, varDisplayName, parseCemType, jsonClone, configureCollabSerializer, configureCollabParser, configureCollabNotifier, collabSourceContext, collabSave, flushAllCollab, workspace, activeTab, setWorkspaceProject, isTabActive, openTab, closeTab, closeAllTabs, replaceAllTabs, activateTab, renameTab, stripEventHandlers, canvasWrap, activityBar, leftPanel, rightPanel, chatPanelEl, toolbarEl, statusbarEl, frontmatterPanelEl, initShellRefs, canvasPanels, VOID_ELEMENTS, COMMON_SELECTORS, isNestedSelector, debouncedStyleCommit, cancelStyleDebounce, registerRenderer, render, renderOnly, updateSession, updateUi, updateCanvas };
-
-//# debugId=46676D06D14A28A964756E2164756E21
-//# sourceMappingURL=studio-rq0vxb19.js.map