@likec4/core 1.47.0 → 1.48.0

package/dist/shared/core.DjcWextK.mjs

@@ -1,1371 +0,0 @@
-import { a as t$8, t as t$9 } from './core.3ZhnKAlZ.mjs';
-import { t as t$7, a as t$c } from './core.BsSXS-_R.mjs';
-import { a as t$d } from './core.DGcIbsj4.mjs';
-import { b as _layout, t as isDynamicView, u as e$3 } from './core.DH7TXqXf.mjs';
-import { e as e$4 } from './core.BKlholso.mjs';
-import { e as e$2, t as t$a } from './core.Coi_LOUZ.mjs';
-import { t as t$b } from './core.CbT8JVYL.mjs';
-import { n as n$6 } from './core.BhNcrwzK.mjs';
-import { i as invariant } from './core.D4npX2q8.mjs';
-import { s as symmetricDifference } from './core.DbfO90vF.mjs';
-import { i as ihead } from './core.uFk_o9X6.mjs';
-import { i as ifilter } from './core.DRJma0Ol.mjs';
-
-const e$1={asc:(e,t)=>e>t,desc:(e,t)=>e<t};function t$6(e,t){let[n,...a]=t;if(!i$1(n)){let t=r$2(...a);return e(n,t)}let o=r$2(n,...a);return t=>e(t,o)}function r$2(t,n,...i){let a=typeof t==`function`?t:t[0],o=typeof t==`function`?`asc`:t[1],{[o]:s}=e$1,c=n===void 0?void 0:r$2(n,...i);return (e,t)=>{let n=a(e),r=a(t);return s(n,r)?1:s(r,n)?-1:c?.(e,t)??0}}function i$1(t){if(a(t))return  true;if(typeof t!=`object`||!Array.isArray(t))return  false;let[n,r,...i]=t;return a(n)&&typeof r==`string`&&r in e$1&&i.length===0}const a=e=>typeof e==`function`&&e.length===1;
-
-function n$5(...t){return t$7(r$1,t,i)}const r$1=(e,t)=>e.filter(t),i=e=>(n,r,i)=>e(n,r,i)?{done:false,hasNext:true,next:n}:t$8;
-
-function t$5(...t){return t$7(n$4,t,r)}const n$4=(e,t)=>e.flatMap(t),r=e=>(t,n,r)=>{let i=e(t,n,r);return Array.isArray(i)?{done:false,hasNext:true,hasMany:true,next:i}:{done:false,hasNext:true,next:i}};
-
-function t$4(...t){return t$7(n$3,t)}const n$3=(e,t)=>{let n=Object.create(null);for(let r=0;r<e.length;r++){let i=e[r],a=t(i,r,e);if(a!==void 0){let e=n[a];e===void 0?n[a]=[i]:e.push(i);}}return Object.setPrototypeOf(n,Object.prototype),n};
-
-function e(e){return typeof e==`number`&&!Number.isNaN(e)}
-
-function t$3(...t){return t$7(n$2,t)}function n$2(e,t){let n={};for(let[r,i]of Object.entries(e))n[r]=t(i,r,e);return n}
-
-function t$2(...t){return t$7(n$1,t)}function n$1(e,t){let n={};for(let r of t)r in e&&(n[r]=e[r]);return n}
-
-function t$1(...t){return n=>t$9(n,...t)}
-
-function t(...t){return t$6(n,t)}const n=(e,t)=>[...e].sort(t);
-
-// src/utils/env.ts
-var NOTHING = Symbol.for("immer-nothing");
-var DRAFTABLE = Symbol.for("immer-draftable");
-var DRAFT_STATE = Symbol.for("immer-state");
-
-// src/utils/errors.ts
-var errors = process.env.NODE_ENV !== "production" ? [
-  // All error codes, starting by 0:
-  function(plugin) {
-    return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
-  },
-  function(thing) {
-    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
-  },
-  "This object has been frozen and should not be mutated",
-  function(data) {
-    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
-  },
-  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
-  "Immer forbids circular references",
-  "The first or second argument to `produce` must be a function",
-  "The third argument to `produce` must be a function or undefined",
-  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
-  "First argument to `finishDraft` must be a draft returned by `createDraft`",
-  function(thing) {
-    return `'current' expects a draft, got: ${thing}`;
-  },
-  "Object.defineProperty() cannot be used on an Immer draft",
-  "Object.setPrototypeOf() cannot be used on an Immer draft",
-  "Immer only supports deleting array indices",
-  "Immer only supports setting array indices and the 'length' property",
-  function(thing) {
-    return `'original' expects a draft, got: ${thing}`;
-  }
-  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
-  // See Patches.ts for additional errors
-] : [];
-function die(error, ...args) {
-  if (process.env.NODE_ENV !== "production") {
-    const e = errors[error];
-    const msg = isFunction(e) ? e.apply(null, args) : e;
-    throw new Error(`[Immer] ${msg}`);
-  }
-  throw new Error(
-    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
-  );
-}
-
-// src/utils/common.ts
-var O = Object;
-var getPrototypeOf = O.getPrototypeOf;
-var CONSTRUCTOR = "constructor";
-var PROTOTYPE = "prototype";
-var CONFIGURABLE = "configurable";
-var ENUMERABLE = "enumerable";
-var WRITABLE = "writable";
-var VALUE = "value";
-var isDraft = (value) => !!value && !!value[DRAFT_STATE];
-function isDraftable(value) {
-  if (!value)
-    return false;
-  return isPlainObject(value) || isArray(value) || !!value[DRAFTABLE] || !!value[CONSTRUCTOR]?.[DRAFTABLE] || isMap(value) || isSet(value);
-}
-var objectCtorString = O[PROTOTYPE][CONSTRUCTOR].toString();
-var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
-function isPlainObject(value) {
-  if (!value || !isObjectish(value))
-    return false;
-  const proto = getPrototypeOf(value);
-  if (proto === null || proto === O[PROTOTYPE])
-    return true;
-  const Ctor = O.hasOwnProperty.call(proto, CONSTRUCTOR) && proto[CONSTRUCTOR];
-  if (Ctor === Object)
-    return true;
-  if (!isFunction(Ctor))
-    return false;
-  let ctorString = cachedCtorStrings.get(Ctor);
-  if (ctorString === void 0) {
-    ctorString = Function.toString.call(Ctor);
-    cachedCtorStrings.set(Ctor, ctorString);
-  }
-  return ctorString === objectCtorString;
-}
-function each(obj, iter, strict = true) {
-  if (getArchtype(obj) === 0 /* Object */) {
-    const keys = strict ? Reflect.ownKeys(obj) : O.keys(obj);
-    keys.forEach((key) => {
-      iter(key, obj[key], obj);
-    });
-  } else {
-    obj.forEach((entry, index) => iter(index, entry, obj));
-  }
-}
-function getArchtype(thing) {
-  const state = thing[DRAFT_STATE];
-  return state ? state.type_ : isArray(thing) ? 1 /* Array */ : isMap(thing) ? 2 /* Map */ : isSet(thing) ? 3 /* Set */ : 0 /* Object */;
-}
-var has = (thing, prop, type = getArchtype(thing)) => type === 2 /* Map */ ? thing.has(prop) : O[PROTOTYPE].hasOwnProperty.call(thing, prop);
-var get = (thing, prop, type = getArchtype(thing)) => (
-  // @ts-ignore
-  type === 2 /* Map */ ? thing.get(prop) : thing[prop]
-);
-var set = (thing, propOrOldValue, value, type = getArchtype(thing)) => {
-  if (type === 2 /* Map */)
-    thing.set(propOrOldValue, value);
-  else if (type === 3 /* Set */) {
-    thing.add(value);
-  } else
-    thing[propOrOldValue] = value;
-};
-function is(x, y) {
-  if (x === y) {
-    return x !== 0 || 1 / x === 1 / y;
-  } else {
-    return x !== x && y !== y;
-  }
-}
-var isArray = Array.isArray;
-var isMap = (target) => target instanceof Map;
-var isSet = (target) => target instanceof Set;
-var isObjectish = (target) => typeof target === "object";
-var isFunction = (target) => typeof target === "function";
-var isBoolean = (target) => typeof target === "boolean";
-function isArrayIndex(value) {
-  const n = +value;
-  return Number.isInteger(n) && String(n) === value;
-}
-var latest = (state) => state.copy_ || state.base_;
-var getFinalValue = (state) => state.modified_ ? state.copy_ : state.base_;
-function shallowCopy(base, strict) {
-  if (isMap(base)) {
-    return new Map(base);
-  }
-  if (isSet(base)) {
-    return new Set(base);
-  }
-  if (isArray(base))
-    return Array[PROTOTYPE].slice.call(base);
-  const isPlain = isPlainObject(base);
-  if (strict === true || strict === "class_only" && !isPlain) {
-    const descriptors = O.getOwnPropertyDescriptors(base);
-    delete descriptors[DRAFT_STATE];
-    let keys = Reflect.ownKeys(descriptors);
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      const desc = descriptors[key];
-      if (desc[WRITABLE] === false) {
-        desc[WRITABLE] = true;
-        desc[CONFIGURABLE] = true;
-      }
-      if (desc.get || desc.set)
-        descriptors[key] = {
-          [CONFIGURABLE]: true,
-          [WRITABLE]: true,
-          // could live with !!desc.set as well here...
-          [ENUMERABLE]: desc[ENUMERABLE],
-          [VALUE]: base[key]
-        };
-    }
-    return O.create(getPrototypeOf(base), descriptors);
-  } else {
-    const proto = getPrototypeOf(base);
-    if (proto !== null && isPlain) {
-      return { ...base };
-    }
-    const obj = O.create(proto);
-    return O.assign(obj, base);
-  }
-}
-function freeze(obj, deep = false) {
-  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
-    return obj;
-  if (getArchtype(obj) > 1) {
-    O.defineProperties(obj, {
-      set: dontMutateMethodOverride,
-      add: dontMutateMethodOverride,
-      clear: dontMutateMethodOverride,
-      delete: dontMutateMethodOverride
-    });
-  }
-  O.freeze(obj);
-  if (deep)
-    each(
-      obj,
-      (_key, value) => {
-        freeze(value, true);
-      },
-      false
-    );
-  return obj;
-}
-function dontMutateFrozenCollections() {
-  die(2);
-}
-var dontMutateMethodOverride = {
-  [VALUE]: dontMutateFrozenCollections
-};
-function isFrozen(obj) {
-  if (obj === null || !isObjectish(obj))
-    return true;
-  return O.isFrozen(obj);
-}
-
-// src/utils/plugins.ts
-var PluginMapSet = "MapSet";
-var PluginPatches = "Patches";
-var PluginArrayMethods = "ArrayMethods";
-var plugins = {};
-function getPlugin(pluginKey) {
-  const plugin = plugins[pluginKey];
-  if (!plugin) {
-    die(0, pluginKey);
-  }
-  return plugin;
-}
-var isPluginLoaded = (pluginKey) => !!plugins[pluginKey];
-
-// src/core/scope.ts
-var currentScope;
-var getCurrentScope = () => currentScope;
-var createScope = (parent_, immer_) => ({
-  drafts_: [],
-  parent_,
-  immer_,
-  // Whenever the modified draft contains a draft from another scope, we
-  // need to prevent auto-freezing so the unowned draft can be finalized.
-  canAutoFreeze_: true,
-  unfinalizedDrafts_: 0,
-  handledSet_: /* @__PURE__ */ new Set(),
-  processedForPatches_: /* @__PURE__ */ new Set(),
-  mapSetPlugin_: isPluginLoaded(PluginMapSet) ? getPlugin(PluginMapSet) : void 0,
-  arrayMethodsPlugin_: isPluginLoaded(PluginArrayMethods) ? getPlugin(PluginArrayMethods) : void 0
-});
-function usePatchesInScope(scope, patchListener) {
-  if (patchListener) {
-    scope.patchPlugin_ = getPlugin(PluginPatches);
-    scope.patches_ = [];
-    scope.inversePatches_ = [];
-    scope.patchListener_ = patchListener;
-  }
-}
-function revokeScope(scope) {
-  leaveScope(scope);
-  scope.drafts_.forEach(revokeDraft);
-  scope.drafts_ = null;
-}
-function leaveScope(scope) {
-  if (scope === currentScope) {
-    currentScope = scope.parent_;
-  }
-}
-var enterScope = (immer2) => currentScope = createScope(currentScope, immer2);
-function revokeDraft(draft) {
-  const state = draft[DRAFT_STATE];
-  if (state.type_ === 0 /* Object */ || state.type_ === 1 /* Array */)
-    state.revoke_();
-  else
-    state.revoked_ = true;
-}
-
-// src/core/finalize.ts
-function processResult(result, scope) {
-  scope.unfinalizedDrafts_ = scope.drafts_.length;
-  const baseDraft = scope.drafts_[0];
-  const isReplaced = result !== void 0 && result !== baseDraft;
-  if (isReplaced) {
-    if (baseDraft[DRAFT_STATE].modified_) {
-      revokeScope(scope);
-      die(4);
-    }
-    if (isDraftable(result)) {
-      result = finalize(scope, result);
-    }
-    const { patchPlugin_ } = scope;
-    if (patchPlugin_) {
-      patchPlugin_.generateReplacementPatches_(
-        baseDraft[DRAFT_STATE].base_,
-        result,
-        scope
-      );
-    }
-  } else {
-    result = finalize(scope, baseDraft);
-  }
-  maybeFreeze(scope, result, true);
-  revokeScope(scope);
-  if (scope.patches_) {
-    scope.patchListener_(scope.patches_, scope.inversePatches_);
-  }
-  return result !== NOTHING ? result : void 0;
-}
-function finalize(rootScope, value) {
-  if (isFrozen(value))
-    return value;
-  const state = value[DRAFT_STATE];
-  if (!state) {
-    const finalValue = handleValue(value, rootScope.handledSet_, rootScope);
-    return finalValue;
-  }
-  if (!isSameScope(state, rootScope)) {
-    return value;
-  }
-  if (!state.modified_) {
-    return state.base_;
-  }
-  if (!state.finalized_) {
-    const { callbacks_ } = state;
-    if (callbacks_) {
-      while (callbacks_.length > 0) {
-        const callback = callbacks_.pop();
-        callback(rootScope);
-      }
-    }
-    generatePatchesAndFinalize(state, rootScope);
-  }
-  return state.copy_;
-}
-function maybeFreeze(scope, value, deep = false) {
-  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
-    freeze(value, deep);
-  }
-}
-function markStateFinalized(state) {
-  state.finalized_ = true;
-  state.scope_.unfinalizedDrafts_--;
-}
-var isSameScope = (state, rootScope) => state.scope_ === rootScope;
-var EMPTY_LOCATIONS_RESULT = [];
-function updateDraftInParent(parent, draftValue, finalizedValue, originalKey) {
-  const parentCopy = latest(parent);
-  const parentType = parent.type_;
-  if (originalKey !== void 0) {
-    const currentValue = get(parentCopy, originalKey, parentType);
-    if (currentValue === draftValue) {
-      set(parentCopy, originalKey, finalizedValue, parentType);
-      return;
-    }
-  }
-  if (!parent.draftLocations_) {
-    const draftLocations = parent.draftLocations_ = /* @__PURE__ */ new Map();
-    each(parentCopy, (key, value) => {
-      if (isDraft(value)) {
-        const keys = draftLocations.get(value) || [];
-        keys.push(key);
-        draftLocations.set(value, keys);
-      }
-    });
-  }
-  const locations = parent.draftLocations_.get(draftValue) ?? EMPTY_LOCATIONS_RESULT;
-  for (const location of locations) {
-    set(parentCopy, location, finalizedValue, parentType);
-  }
-}
-function registerChildFinalizationCallback(parent, child, key) {
-  parent.callbacks_.push(function childCleanup(rootScope) {
-    const state = child;
-    if (!state || !isSameScope(state, rootScope)) {
-      return;
-    }
-    rootScope.mapSetPlugin_?.fixSetContents(state);
-    const finalizedValue = getFinalValue(state);
-    updateDraftInParent(parent, state.draft_ ?? state, finalizedValue, key);
-    generatePatchesAndFinalize(state, rootScope);
-  });
-}
-function generatePatchesAndFinalize(state, rootScope) {
-  const shouldFinalize = state.modified_ && !state.finalized_ && (state.type_ === 3 /* Set */ || state.type_ === 1 /* Array */ && state.allIndicesReassigned_ || (state.assigned_?.size ?? 0) > 0);
-  if (shouldFinalize) {
-    const { patchPlugin_ } = rootScope;
-    if (patchPlugin_) {
-      const basePath = patchPlugin_.getPath(state);
-      if (basePath) {
-        patchPlugin_.generatePatches_(state, basePath, rootScope);
-      }
-    }
-    markStateFinalized(state);
-  }
-}
-function handleCrossReference(target, key, value) {
-  const { scope_ } = target;
-  if (isDraft(value)) {
-    const state = value[DRAFT_STATE];
-    if (isSameScope(state, scope_)) {
-      state.callbacks_.push(function crossReferenceCleanup() {
-        prepareCopy(target);
-        const finalizedValue = getFinalValue(state);
-        updateDraftInParent(target, value, finalizedValue, key);
-      });
-    }
-  } else if (isDraftable(value)) {
-    target.callbacks_.push(function nestedDraftCleanup() {
-      const targetCopy = latest(target);
-      if (get(targetCopy, key, target.type_) === value) {
-        if (scope_.drafts_.length > 1 && (target.assigned_.get(key) ?? false) === true && target.copy_) {
-          handleValue(
-            get(target.copy_, key, target.type_),
-            scope_.handledSet_,
-            scope_
-          );
-        }
-      }
-    });
-  }
-}
-function handleValue(target, handledSet, rootScope) {
-  if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
-    return target;
-  }
-  if (isDraft(target) || handledSet.has(target) || !isDraftable(target) || isFrozen(target)) {
-    return target;
-  }
-  handledSet.add(target);
-  each(target, (key, value) => {
-    if (isDraft(value)) {
-      const state = value[DRAFT_STATE];
-      if (isSameScope(state, rootScope)) {
-        const updatedValue = getFinalValue(state);
-        set(target, key, updatedValue, target.type_);
-        markStateFinalized(state);
-      }
-    } else if (isDraftable(value)) {
-      handleValue(value, handledSet, rootScope);
-    }
-  });
-  return target;
-}
-
-// src/core/proxy.ts
-function createProxyProxy(base, parent) {
-  const baseIsArray = isArray(base);
-  const state = {
-    type_: baseIsArray ? 1 /* Array */ : 0 /* Object */,
-    // Track which produce call this is associated with.
-    scope_: parent ? parent.scope_ : getCurrentScope(),
-    // True for both shallow and deep changes.
-    modified_: false,
-    // Used during finalization.
-    finalized_: false,
-    // Track which properties have been assigned (true) or deleted (false).
-    // actually instantiated in `prepareCopy()`
-    assigned_: void 0,
-    // The parent draft state.
-    parent_: parent,
-    // The base state.
-    base_: base,
-    // The base proxy.
-    draft_: null,
-    // set below
-    // The base copy with any updated values.
-    copy_: null,
-    // Called by the `produce` function.
-    revoke_: null,
-    isManual_: false,
-    // `callbacks` actually gets assigned in `createProxy`
-    callbacks_: void 0
-  };
-  let target = state;
-  let traps = objectTraps;
-  if (baseIsArray) {
-    target = [state];
-    traps = arrayTraps;
-  }
-  const { revoke, proxy } = Proxy.revocable(target, traps);
-  state.draft_ = proxy;
-  state.revoke_ = revoke;
-  return [proxy, state];
-}
-var objectTraps = {
-  get(state, prop) {
-    if (prop === DRAFT_STATE)
-      return state;
-    let arrayPlugin = state.scope_.arrayMethodsPlugin_;
-    const isArrayWithStringProp = state.type_ === 1 /* Array */ && typeof prop === "string";
-    if (isArrayWithStringProp) {
-      if (arrayPlugin?.isArrayOperationMethod(prop)) {
-        return arrayPlugin.createMethodInterceptor(state, prop);
-      }
-    }
-    const source = latest(state);
-    if (!has(source, prop, state.type_)) {
-      return readPropFromProto(state, source, prop);
-    }
-    const value = source[prop];
-    if (state.finalized_ || !isDraftable(value)) {
-      return value;
-    }
-    if (isArrayWithStringProp && state.operationMethod && arrayPlugin?.isMutatingArrayMethod(
-      state.operationMethod
-    ) && isArrayIndex(prop)) {
-      return value;
-    }
-    if (value === peek(state.base_, prop)) {
-      prepareCopy(state);
-      const childKey = state.type_ === 1 /* Array */ ? +prop : prop;
-      const childDraft = createProxy(state.scope_, value, state, childKey);
-      return state.copy_[childKey] = childDraft;
-    }
-    return value;
-  },
-  has(state, prop) {
-    return prop in latest(state);
-  },
-  ownKeys(state) {
-    return Reflect.ownKeys(latest(state));
-  },
-  set(state, prop, value) {
-    const desc = getDescriptorFromProto(latest(state), prop);
-    if (desc?.set) {
-      desc.set.call(state.draft_, value);
-      return true;
-    }
-    if (!state.modified_) {
-      const current2 = peek(latest(state), prop);
-      const currentState = current2?.[DRAFT_STATE];
-      if (currentState && currentState.base_ === value) {
-        state.copy_[prop] = value;
-        state.assigned_.set(prop, false);
-        return true;
-      }
-      if (is(value, current2) && (value !== void 0 || has(state.base_, prop, state.type_)))
-        return true;
-      prepareCopy(state);
-      markChanged(state);
-    }
-    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
-    (value !== void 0 || prop in state.copy_) || // special case: NaN
-    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
-      return true;
-    state.copy_[prop] = value;
-    state.assigned_.set(prop, true);
-    handleCrossReference(state, prop, value);
-    return true;
-  },
-  deleteProperty(state, prop) {
-    prepareCopy(state);
-    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
-      state.assigned_.set(prop, false);
-      markChanged(state);
-    } else {
-      state.assigned_.delete(prop);
-    }
-    if (state.copy_) {
-      delete state.copy_[prop];
-    }
-    return true;
-  },
-  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
-  // the same guarantee in ES5 mode.
-  getOwnPropertyDescriptor(state, prop) {
-    const owner = latest(state);
-    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
-    if (!desc)
-      return desc;
-    return {
-      [WRITABLE]: true,
-      [CONFIGURABLE]: state.type_ !== 1 /* Array */ || prop !== "length",
-      [ENUMERABLE]: desc[ENUMERABLE],
-      [VALUE]: owner[prop]
-    };
-  },
-  defineProperty() {
-    die(11);
-  },
-  getPrototypeOf(state) {
-    return getPrototypeOf(state.base_);
-  },
-  setPrototypeOf() {
-    die(12);
-  }
-};
-var arrayTraps = {};
-each(objectTraps, (key, fn) => {
-  arrayTraps[key] = function() {
-    const args = arguments;
-    args[0] = args[0][0];
-    return fn.apply(this, args);
-  };
-});
-arrayTraps.deleteProperty = function(state, prop) {
-  if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop)))
-    die(13);
-  return arrayTraps.set.call(this, state, prop, void 0);
-};
-arrayTraps.set = function(state, prop, value) {
-  if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop)))
-    die(14);
-  return objectTraps.set.call(this, state[0], prop, value, state[0]);
-};
-function peek(draft, prop) {
-  const state = draft[DRAFT_STATE];
-  const source = state ? latest(state) : draft;
-  return source[prop];
-}
-function readPropFromProto(state, source, prop) {
-  const desc = getDescriptorFromProto(source, prop);
-  return desc ? VALUE in desc ? desc[VALUE] : (
-    // This is a very special case, if the prop is a getter defined by the
-    // prototype, we should invoke it with the draft as context!
-    desc.get?.call(state.draft_)
-  ) : void 0;
-}
-function getDescriptorFromProto(source, prop) {
-  if (!(prop in source))
-    return void 0;
-  let proto = getPrototypeOf(source);
-  while (proto) {
-    const desc = Object.getOwnPropertyDescriptor(proto, prop);
-    if (desc)
-      return desc;
-    proto = getPrototypeOf(proto);
-  }
-  return void 0;
-}
-function markChanged(state) {
-  if (!state.modified_) {
-    state.modified_ = true;
-    if (state.parent_) {
-      markChanged(state.parent_);
-    }
-  }
-}
-function prepareCopy(state) {
-  if (!state.copy_) {
-    state.assigned_ = /* @__PURE__ */ new Map();
-    state.copy_ = shallowCopy(
-      state.base_,
-      state.scope_.immer_.useStrictShallowCopy_
-    );
-  }
-}
-
-// src/core/immerClass.ts
-var Immer2 = class {
-  constructor(config) {
-    this.autoFreeze_ = true;
-    this.useStrictShallowCopy_ = false;
-    this.useStrictIteration_ = false;
-    /**
-     * The `produce` function takes a value and a "recipe function" (whose
-     * return value often depends on the base state). The recipe function is
-     * free to mutate its first argument however it wants. All mutations are
-     * only ever applied to a __copy__ of the base state.
-     *
-     * Pass only a function to create a "curried producer" which relieves you
-     * from passing the recipe function every time.
-     *
-     * Only plain objects and arrays are made mutable. All other objects are
-     * considered uncopyable.
-     *
-     * Note: This function is __bound__ to its `Immer` instance.
-     *
-     * @param {any} base - the initial state
-     * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified
-     * @param {Function} patchListener - optional function that will be called with all the patches produced here
-     * @returns {any} a new state, or the initial state if nothing was modified
-     */
-    this.produce = (base, recipe, patchListener) => {
-      if (isFunction(base) && !isFunction(recipe)) {
-        const defaultBase = recipe;
-        recipe = base;
-        const self = this;
-        return function curriedProduce(base2 = defaultBase, ...args) {
-          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
-        };
-      }
-      if (!isFunction(recipe))
-        die(6);
-      if (patchListener !== void 0 && !isFunction(patchListener))
-        die(7);
-      let result;
-      if (isDraftable(base)) {
-        const scope = enterScope(this);
-        const proxy = createProxy(scope, base, void 0);
-        let hasError = true;
-        try {
-          result = recipe(proxy);
-          hasError = false;
-        } finally {
-          if (hasError)
-            revokeScope(scope);
-          else
-            leaveScope(scope);
-        }
-        usePatchesInScope(scope, patchListener);
-        return processResult(result, scope);
-      } else if (!base || !isObjectish(base)) {
-        result = recipe(base);
-        if (result === void 0)
-          result = base;
-        if (result === NOTHING)
-          result = void 0;
-        if (this.autoFreeze_)
-          freeze(result, true);
-        if (patchListener) {
-          const p = [];
-          const ip = [];
-          getPlugin(PluginPatches).generateReplacementPatches_(base, result, {
-            patches_: p,
-            inversePatches_: ip
-          });
-          patchListener(p, ip);
-        }
-        return result;
-      } else
-        die(1, base);
-    };
-    this.produceWithPatches = (base, recipe) => {
-      if (isFunction(base)) {
-        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
-      }
-      let patches, inversePatches;
-      const result = this.produce(base, recipe, (p, ip) => {
-        patches = p;
-        inversePatches = ip;
-      });
-      return [result, patches, inversePatches];
-    };
-    if (isBoolean(config?.autoFreeze))
-      this.setAutoFreeze(config.autoFreeze);
-    if (isBoolean(config?.useStrictShallowCopy))
-      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
-    if (isBoolean(config?.useStrictIteration))
-      this.setUseStrictIteration(config.useStrictIteration);
-  }
-  createDraft(base) {
-    if (!isDraftable(base))
-      die(8);
-    if (isDraft(base))
-      base = current(base);
-    const scope = enterScope(this);
-    const proxy = createProxy(scope, base, void 0);
-    proxy[DRAFT_STATE].isManual_ = true;
-    leaveScope(scope);
-    return proxy;
-  }
-  finishDraft(draft, patchListener) {
-    const state = draft && draft[DRAFT_STATE];
-    if (!state || !state.isManual_)
-      die(9);
-    const { scope_: scope } = state;
-    usePatchesInScope(scope, patchListener);
-    return processResult(void 0, scope);
-  }
-  /**
-   * Pass true to automatically freeze all copies created by Immer.
-   *
-   * By default, auto-freezing is enabled.
-   */
-  setAutoFreeze(value) {
-    this.autoFreeze_ = value;
-  }
-  /**
-   * Pass true to enable strict shallow copy.
-   *
-   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
-   */
-  setUseStrictShallowCopy(value) {
-    this.useStrictShallowCopy_ = value;
-  }
-  /**
-   * Pass false to use faster iteration that skips non-enumerable properties
-   * but still handles symbols for compatibility.
-   *
-   * By default, strict iteration is enabled (includes all own properties).
-   */
-  setUseStrictIteration(value) {
-    this.useStrictIteration_ = value;
-  }
-  shouldUseStrictIteration() {
-    return this.useStrictIteration_;
-  }
-  applyPatches(base, patches) {
-    let i;
-    for (i = patches.length - 1; i >= 0; i--) {
-      const patch = patches[i];
-      if (patch.path.length === 0 && patch.op === "replace") {
-        base = patch.value;
-        break;
-      }
-    }
-    if (i > -1) {
-      patches = patches.slice(i + 1);
-    }
-    const applyPatchesImpl = getPlugin(PluginPatches).applyPatches_;
-    if (isDraft(base)) {
-      return applyPatchesImpl(base, patches);
-    }
-    return this.produce(
-      base,
-      (draft) => applyPatchesImpl(draft, patches)
-    );
-  }
-};
-function createProxy(rootScope, value, parent, key) {
-  const [draft, state] = isMap(value) ? getPlugin(PluginMapSet).proxyMap_(value, parent) : isSet(value) ? getPlugin(PluginMapSet).proxySet_(value, parent) : createProxyProxy(value, parent);
-  const scope = parent?.scope_ ?? getCurrentScope();
-  scope.drafts_.push(draft);
-  state.callbacks_ = parent?.callbacks_ ?? [];
-  state.key_ = key;
-  if (parent && key !== void 0) {
-    registerChildFinalizationCallback(parent, state, key);
-  } else {
-    state.callbacks_.push(function rootDraftCleanup(rootScope2) {
-      rootScope2.mapSetPlugin_?.fixSetContents(state);
-      const { patchPlugin_ } = rootScope2;
-      if (state.modified_ && patchPlugin_) {
-        patchPlugin_.generatePatches_(state, [], rootScope2);
-      }
-    });
-  }
-  return draft;
-}
-
-// src/core/current.ts
-function current(value) {
-  if (!isDraft(value))
-    die(10, value);
-  return currentImpl(value);
-}
-function currentImpl(value) {
-  if (!isDraftable(value) || isFrozen(value))
-    return value;
-  const state = value[DRAFT_STATE];
-  let copy;
-  let strict = true;
-  if (state) {
-    if (!state.modified_)
-      return state.base_;
-    state.finalized_ = true;
-    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
-    strict = state.scope_.immer_.shouldUseStrictIteration();
-  } else {
-    copy = shallowCopy(value, true);
-  }
-  each(
-    copy,
-    (key, childValue) => {
-      set(copy, key, currentImpl(childValue));
-    },
-    strict
-  );
-  if (state) {
-    state.finalized_ = false;
-  }
-  return copy;
-}
-
-// src/immer.ts
-var immer = new Immer2();
-var produce = immer.produce;
-var castDraft = (value) => value;
-
-function buildElementNotations(nodes) {
-  return t$9(
-    nodes,
-    n$5((n) => !!n.notation),
-    t$4(e$2("notation")),
-    t$3(
-      t$1(
-        t$4(e$2("shape")),
-        t$3(
-          t$1(
-            t$4(e$2("color")),
-            t$3(
-              t$1(
-                t$b(e$2("kind")),
-                n$6()
-              )
-            ),
-            t$a(),
-            t$b(([color, kinds]) => ({
-              kinds,
-              color
-            }))
-          )
-        ),
-        t$a(),
-        t$5(
-          ([shape, colors]) => colors.map(({ color, kinds }) => ({
-            shape,
-            color,
-            kinds
-          }))
-        )
-      )
-    ),
-    t$a(),
-    t$5(
-      ([title, shapes]) => shapes.map(({ shape, color, kinds }) => ({
-        title,
-        shape,
-        color,
-        kinds
-      }))
-    ),
-    t(
-      e$2("shape"),
-      e$2("title"),
-      [
-        (n) => n.kinds.length,
-        "desc"
-      ]
-    )
-  );
-}
-
-const changed = (a, b) => {
-  if (a === b || e$3(a) && e$3(b)) {
-    return false;
-  }
-  return !t$d(a, b);
-};
-const MAX_ALLOWED_DRIFT = 5;
-function autoApplyMetaAndStyles(draft, next) {
-  draft.color = next.color;
-  draft.kind = next.kind;
-  draft.navigateTo = next.navigateTo ?? null;
-  draft.links = next.links ? [...next.links] : null;
-  draft.tags = [...next.tags];
-  if (e$3(next.style.border)) {
-    delete draft.style.border;
-  } else {
-    draft.style.border = next.style.border;
-  }
-  if (e(next.style.opacity)) {
-    draft.style.opacity = next.style.opacity;
-  } else {
-    delete draft.style.opacity;
-  }
-  if (e$3(next.style.multiple)) {
-    delete draft.style.multiple;
-  } else {
-    draft.style.multiple = next.style.multiple;
-  }
-}
-function autoApplyIcon(draft, next, sizeNotChanged) {
-  if (changed(next.icon ?? "none", draft.icon ?? "none")) {
-    const iconWasSet = e$4(draft.icon) && draft.icon !== "none";
-    switch (true) {
-      // Icon was set before and changed, auto-apply
-      case (iconWasSet && e$4(next.icon) && next.icon !== "none"): {
-        draft.icon = next.icon;
-        return true;
-      }
-      // Icon was set before and now removed, auto-apply
-      case (iconWasSet && (e$3(next.icon) || next.icon === "none")): {
-        draft.icon = "none";
-        return true;
-      }
-      // Icon was added
-      case (!iconWasSet && e$4(next.icon) && next.icon !== "none"): {
-        if (sizeNotChanged) {
-          draft.icon = next.icon;
-          return true;
-        } else {
-          return false;
-        }
-      }
-    }
-  }
-  return true;
-}
-function patchMarkdownOrString(draft, next) {
-  if (!draft) {
-    return next;
-  }
-  if ("md" in next) {
-    draft.md = next.md;
-    delete draft.txt;
-    return draft;
-  }
-  if ("txt" in next) {
-    draft.txt = next.txt;
-    delete draft.md;
-  }
-  return draft;
-}
-function autoApplyLabelsToLeaf(draft, next, sizeNotChanged) {
-  let applied = true;
-  if (changed(draft.title, next.title)) {
-    if (sizeNotChanged) {
-      draft.title = next.title;
-    } else {
-      applied = false;
-    }
-  }
-  if (changed(draft.description, next.description)) {
-    if (e$3(next.description)) {
-      delete draft.description;
-    } else if (sizeNotChanged) {
-      draft.description = patchMarkdownOrString(
-        draft.description,
-        next.description
-      );
-    } else {
-      applied = false;
-    }
-  }
-  if (changed(draft.technology, next.technology)) {
-    if (e$3(next.technology)) {
-      delete draft.technology;
-    } else if (sizeNotChanged) {
-      draft.technology = next.technology;
-    } else {
-      applied = false;
-    }
-  }
-  return applied;
-}
-function autoApplyLabelsToCompound(draft, next, _sizeNotChanged) {
-  draft.title = next.title;
-  if (e$3(next.description)) {
-    delete draft.description;
-  } else {
-    draft.description = patchMarkdownOrString(
-      draft.description,
-      next.description
-    );
-  }
-  if (e$3(next.technology)) {
-    delete draft.technology;
-  } else {
-    draft.technology = next.technology;
-  }
-  return true;
-}
-function applyManualLayout(autoLayouted, snapshot) {
-  invariant(autoLayouted.id === snapshot.id, "applyManualLayout: view ids do not match");
-  invariant(autoLayouted._stage === "layouted", "applyManualLayout: expected layouted view");
-  invariant(snapshot._stage === "layouted", "applyManualLayout: expected layouted snapshot");
-  invariant(autoLayouted._layout !== "manual", "applyManualLayout: expected auto-layouted view");
-  const viewDrifts = /* @__PURE__ */ new Set();
-  if (autoLayouted._type !== snapshot._type) {
-    viewDrifts.add("type-changed");
-  }
-  const nextNodes = new Map(autoLayouted.nodes.map((n) => [n.id, n]));
-  const nextEdges = new Map(autoLayouted.edges.map((e) => [e.id, e]));
-  const nodes = applyNodesManualLayout(snapshot.nodes, nextNodes, viewDrifts);
-  const edges = applyEdgesManualLayout(snapshot.edges, nextEdges, viewDrifts);
-  const nodeNotations = buildElementNotations(nodes);
-  const result = Object.assign(
-    { ...snapshot },
-    {
-      // Auto-layouted properties
-      title: autoLayouted.title ?? snapshot.title,
-      description: autoLayouted.description ?? snapshot.description,
-      tags: autoLayouted.tags ? [...autoLayouted.tags] : null,
-      links: autoLayouted.links ? [...autoLayouted.links] : null,
-      [_layout]: "manual",
-      ...nodeNotations && nodeNotations.length > 0 ? { notation: { nodes: nodeNotations } } : {},
-      nodes,
-      edges
-    }
-  );
-  if (isDynamicView(autoLayouted) && result._type === "dynamic") {
-    result.variant = autoLayouted.variant;
-  }
-  const writableV = result;
-  const drifts = [...viewDrifts];
-  if (t$c(drifts, 1)) {
-    writableV.drifts = drifts;
-  } else {
-    if ("drifts" in writableV) {
-      delete writableV.drifts;
-    }
-  }
-  return result;
-}
-function applyNodesManualLayout(snapshotNodes, nextNodes, viewDrifts) {
-  const nodes = snapshotNodes.map((node) => {
-    const next = nextNodes.get(node.id);
-    if (next) {
-      nextNodes.delete(next.id);
-    }
-    return produce(node, (draft) => {
-      if (!next) {
-        draft.drifts = ["removed"];
-        viewDrifts.add("nodes-removed");
-        return;
-      }
-      autoApplyMetaAndStyles(draft, next);
-      const nodeDrifts = /* @__PURE__ */ new Set();
-      const wasCompound = node.children.length > 0;
-      const willBeCompound = next.children.length > 0;
-      if (changed(draft.modelRef, next.modelRef) || changed(draft.deploymentRef, next.deploymentRef)) {
-        nodeDrifts.add("modelRef-changed");
-      }
-      if (willBeCompound && !wasCompound) {
-        nodeDrifts.add("became-compound");
-      }
-      if (!willBeCompound && wasCompound) {
-        nodeDrifts.add("became-leaf");
-      }
-      if (changed(draft.parent, next.parent)) {
-        nodeDrifts.add("parent-changed");
-      }
-      const sizeNotChanged = draft.width + MAX_ALLOWED_DRIFT >= next.width && draft.height + MAX_ALLOWED_DRIFT >= next.height;
-      if (changed(draft.shape, next.shape)) {
-        if (sizeNotChanged) {
-          draft.shape = next.shape;
-        } else {
-          nodeDrifts.add("shape-changed");
-        }
-      }
-      if (!autoApplyIcon(draft, next, sizeNotChanged && willBeCompound === wasCompound)) {
-        nodeDrifts.add("label-changed");
-      }
-      const autoApplyLabels = wasCompound ? autoApplyLabelsToCompound : autoApplyLabelsToLeaf;
-      if (!autoApplyLabels(draft, next, sizeNotChanged)) {
-        nodeDrifts.add("label-changed");
-      }
-      if (changed(node.notation, next.notation)) {
-        draft.notation = next.notation ?? null;
-      }
-      if (wasCompound && willBeCompound && symmetricDifference(new Set(node.children), new Set(next.children)).size > 0) {
-        nodeDrifts.add("children-changed");
-      }
-      const _drifts = [...nodeDrifts];
-      if (t$c(_drifts, 1)) {
-        viewDrifts.add("nodes-drift");
-        draft.drifts = _drifts;
-      } else {
-        delete draft.drifts;
-      }
-    });
-  });
-  if (nextNodes.size > 0) {
-    viewDrifts.add("nodes-added");
-  }
-  return nodes;
-}
-function applyEdgesManualLayout(snapshotEdges, nextEdges, viewDrifts) {
-  const edges = snapshotEdges.map((edge) => {
-    let next = nextEdges.get(edge.id) ?? t$9(
-      nextEdges.values(),
-      ifilter((e) => e.source === edge.source && e.target === edge.target),
-      ihead()
-    );
-    if (next) {
-      nextEdges.delete(next.id);
-    }
-    return produce(edge, (draft) => {
-      if (!next) {
-        draft.drifts = ["removed"];
-        viewDrifts.add("edges-removed");
-        return;
-      }
-      const edgeDrifts = /* @__PURE__ */ new Set();
-      const isSameId = edge.id === next.id;
-      switch (true) {
-        // IDs match, but source/target may have changed
-        case (isSameId && edge.source == next.source && edge.target == next.target): {
-          if (changed(draft.dir ?? "forward", next.dir ?? "forward")) {
-            edgeDrifts.add("direction-changed");
-          }
-          break;
-        }
-        case (isSameId && edge.source == next.target && edge.target == next.source): {
-          if (edge.source !== edge.target) {
-            edgeDrifts.add("direction-changed");
-          }
-          break;
-        }
-        case isSameId: {
-          if (edge.source != next.source) {
-            edgeDrifts.add("source-changed");
-          }
-          if (edge.target != next.target) {
-            edgeDrifts.add("target-changed");
-          }
-          break;
-        }
-        default: {
-          invariant(edge.id != next.id, "Unexpected case in edge drift detection, ids should not match");
-          invariant(edge.source == next.source, "Unexpected case in edge drift detection, sources should match");
-          invariant(edge.target == next.target, "Unexpected case in edge drift detection, targets should match");
-          if (changed(draft.dir ?? "forward", next.dir ?? "forward")) {
-            edgeDrifts.add("direction-changed");
-          }
-          break;
-        }
-      }
-      draft.color = next.color;
-      draft.line = next.line;
-      draft.navigateTo = next.navigateTo ?? null;
-      draft.tags = next.tags ? [...next.tags] : null;
-      if (changed(edge.notes, next.notes)) {
-        if (e$3(edge.notes) !== e$3(next.notes)) {
-          edgeDrifts.add("notes-changed");
-        }
-        draft.notes = next.notes ?? edge.notes;
-      }
-      if (next.astPath) {
-        draft.astPath = next.astPath;
-      } else {
-        delete draft.astPath;
-      }
-      const labelsBefore = t$2(edge, ["label", "description", "technology", "labelBBox"]);
-      const labelsAfter = t$2(next, ["label", "description", "technology", "labelBBox"]);
-      if (changed(labelsBefore, labelsAfter)) {
-        switch (true) {
-          case (next.labelBBox && !edge.labelBBox): {
-            edgeDrifts.add("label-added");
-            break;
-          }
-          case (edge.labelBBox && !next.labelBBox): {
-            edgeDrifts.add("label-removed");
-            break;
-          }
-          case (!!edge.labelBBox && !!next.labelBBox): {
-            const sizeChanged = next.labelBBox.width * next.labelBBox.height > (edge.labelBBox.width + MAX_ALLOWED_DRIFT) * (edge.labelBBox.height + MAX_ALLOWED_DRIFT);
-            if (sizeChanged) {
-              draft.labelBBox.width = Math.round(next.labelBBox.width);
-              draft.labelBBox.height = Math.round(next.labelBBox.height);
-            }
-            if (changed(edge.label, next.label)) {
-              if (e$3(next.label) !== e$3(edge.label)) {
-                edgeDrifts.add("label-changed");
-              }
-              draft.label = next.label ?? edge.label;
-            }
-            if (changed(edge.description, next.description)) {
-              if (e$3(next.description) !== e$3(edge.description)) {
-                edgeDrifts.add("label-changed");
-              }
-              if (next.description) {
-                draft.description = patchMarkdownOrString(
-                  edge.description,
-                  next.description
-                );
-              }
-            }
-            if (changed(edge.technology, next.technology)) {
-              if (e$3(next.technology) !== e$3(edge.technology)) {
-                edgeDrifts.add("label-changed");
-              }
-              draft.technology = next.technology ?? edge.technology ?? null;
-            }
-            break;
-          }
-          default:
-            invariant(!edge.labelBBox, "Unexpected case in edge labelBBox drift detection");
-            invariant(!next.labelBBox, "Unexpected case in next labelBBox drift detection");
-            break;
-        }
-      }
-      const _drifts = [...edgeDrifts];
-      if (t$c(_drifts, 1)) {
-        viewDrifts.add("edges-drift");
-        draft.drifts = _drifts;
-      } else {
-        delete draft.drifts;
-      }
-    });
-  });
-  if (nextEdges.size > 0) {
-    viewDrifts.add("edges-added");
-  }
-  return edges;
-}
-
-function calcDriftsFromSnapshot(autoLayouted, snapshot) {
-  const {
-    drifts,
-    ...manual
-  } = applyManualLayout(autoLayouted, snapshot);
-  if (drifts) {
-    const viewDrifts = /* @__PURE__ */ new Set();
-    if (drifts.includes("type-changed")) {
-      viewDrifts.add("type-changed");
-    }
-    const manualNodes = new Map(manual.nodes.map((n) => [n.id, n]));
-    const manualEdges = new Map(manual.edges.map((e) => [e.id, e]));
-    const nodes = autoLayouted.nodes.map((node) => {
-      const snapshotNode = manualNodes.get(node.id);
-      if (snapshotNode) {
-        manualNodes.delete(snapshotNode.id);
-      }
-      return produce(node, (draft) => {
-        if (!snapshotNode) {
-          viewDrifts.add("nodes-added");
-          draft.drifts = ["added"];
-          return;
-        }
-        if (snapshotNode.drifts) {
-          viewDrifts.add("nodes-drift");
-          draft.drifts = [...snapshotNode.drifts];
-        } else {
-          delete draft.drifts;
-        }
-      });
-    });
-    if (manualNodes.size > 0) {
-      viewDrifts.add("nodes-removed");
-    }
-    const edges = autoLayouted.edges.map((edge) => {
-      const snapshotEdge = manualEdges.get(edge.id) ?? t$9(
-        manualEdges.values(),
-        ifilter((e) => e.source === edge.source && e.target === edge.target),
-        ihead()
-      );
-      if (snapshotEdge) {
-        manualEdges.delete(snapshotEdge.id);
-      }
-      return produce(edge, (draft) => {
-        if (!snapshotEdge) {
-          viewDrifts.add("edges-added");
-          draft.drifts = ["added"];
-          return;
-        }
-        if (snapshotEdge.drifts) {
-          viewDrifts.add("edges-drift");
-          draft.drifts = [...snapshotEdge.drifts];
-        } else {
-          delete draft.drifts;
-        }
-      });
-    });
-    if (manualEdges.size > 0) {
-      viewDrifts.add("edges-removed");
-    }
-    const _viewDrifts = [...viewDrifts];
-    return produce(autoLayouted, (draft) => {
-      if (t$c(_viewDrifts, 1)) {
-        draft.drifts = _viewDrifts;
-      } else {
-        delete draft.drifts;
-      }
-      draft.nodes = castDraft(nodes);
-      draft.edges = castDraft(edges);
-      draft[_layout] = "auto";
-    });
-  }
-  return produce(autoLayouted, (draft) => {
-    delete draft.drifts;
-    draft[_layout] = "auto";
-  });
-}
-
-export { applyManualLayout as a, t$5 as b, calcDriftsFromSnapshot as c, t$2 as d, t$1 as e, t$4 as f, buildElementNotations as g, t as h, n$5 as n, t$3 as t };