@likec4/core 1.44.0 → 1.45.0

package/dist/shared/core.vzLtp8i3.mjs

@@ -0,0 +1,1282 @@
+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.DEieYfbG.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 = typeof e === "function" ? 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 getPrototypeOf = Object.getPrototypeOf;
+function isDraft(value) {
+  return !!value && !!value[DRAFT_STATE];
+}
+function isDraftable(value) {
+  if (!value)
+    return false;
+  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
+}
+var objectCtorString = Object.prototype.constructor.toString();
+var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
+function isPlainObject(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null || proto === Object.prototype)
+    return true;
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object)
+    return true;
+  if (typeof Ctor !== "function")
+    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) : Object.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_ : Array.isArray(thing) ? 1 /* Array */ : isMap(thing) ? 2 /* Map */ : isSet(thing) ? 3 /* Set */ : 0 /* Object */;
+}
+function has(thing, prop) {
+  return getArchtype(thing) === 2 /* Map */ ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
+}
+function set(thing, propOrOldValue, value) {
+  const t = getArchtype(thing);
+  if (t === 2 /* Map */)
+    thing.set(propOrOldValue, value);
+  else if (t === 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;
+  }
+}
+function isMap(target) {
+  return target instanceof Map;
+}
+function isSet(target) {
+  return target instanceof Set;
+}
+function latest(state) {
+  return state.copy_ || state.base_;
+}
+function shallowCopy(base, strict) {
+  if (isMap(base)) {
+    return new Map(base);
+  }
+  if (isSet(base)) {
+    return new Set(base);
+  }
+  if (Array.isArray(base))
+    return Array.prototype.slice.call(base);
+  const isPlain = isPlainObject(base);
+  if (strict === true || strict === "class_only" && !isPlain) {
+    const descriptors = Object.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 Object.create(getPrototypeOf(base), descriptors);
+  } else {
+    const proto = getPrototypeOf(base);
+    if (proto !== null && isPlain) {
+      return { ...base };
+    }
+    const obj = Object.create(proto);
+    return Object.assign(obj, base);
+  }
+}
+function freeze(obj, deep = false) {
+  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
+    return obj;
+  if (getArchtype(obj) > 1) {
+    Object.defineProperties(obj, {
+      set: dontMutateMethodOverride,
+      add: dontMutateMethodOverride,
+      clear: dontMutateMethodOverride,
+      delete: dontMutateMethodOverride
+    });
+  }
+  Object.freeze(obj);
+  if (deep)
+    Object.values(obj).forEach((value) => freeze(value, true));
+  return obj;
+}
+function dontMutateFrozenCollections() {
+  die(2);
+}
+var dontMutateMethodOverride = {
+  value: dontMutateFrozenCollections
+};
+function isFrozen(obj) {
+  if (obj === null || typeof obj !== "object")
+    return true;
+  return Object.isFrozen(obj);
+}
+
+// src/utils/plugins.ts
+var plugins = {};
+function getPlugin(pluginKey) {
+  const plugin = plugins[pluginKey];
+  if (!plugin) {
+    die(0, pluginKey);
+  }
+  return plugin;
+}
+
+// src/core/scope.ts
+var currentScope;
+function getCurrentScope() {
+  return currentScope;
+}
+function createScope(parent_, immer_) {
+  return {
+    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
+  };
+}
+function usePatchesInScope(scope, patchListener) {
+  if (patchListener) {
+    getPlugin("Patches");
+    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_;
+  }
+}
+function enterScope(immer2) {
+  return 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);
+      if (!scope.parent_)
+        maybeFreeze(scope, result);
+    }
+    if (scope.patches_) {
+      getPlugin("Patches").generateReplacementPatches_(
+        baseDraft[DRAFT_STATE].base_,
+        result,
+        scope.patches_,
+        scope.inversePatches_
+      );
+    }
+  } else {
+    result = finalize(scope, baseDraft, []);
+  }
+  revokeScope(scope);
+  if (scope.patches_) {
+    scope.patchListener_(scope.patches_, scope.inversePatches_);
+  }
+  return result !== NOTHING ? result : void 0;
+}
+function finalize(rootScope, value, path) {
+  if (isFrozen(value))
+    return value;
+  const useStrictIteration = rootScope.immer_.shouldUseStrictIteration();
+  const state = value[DRAFT_STATE];
+  if (!state) {
+    each(
+      value,
+      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path),
+      useStrictIteration
+    );
+    return value;
+  }
+  if (state.scope_ !== rootScope)
+    return value;
+  if (!state.modified_) {
+    maybeFreeze(rootScope, state.base_, true);
+    return state.base_;
+  }
+  if (!state.finalized_) {
+    state.finalized_ = true;
+    state.scope_.unfinalizedDrafts_--;
+    const result = state.copy_;
+    let resultEach = result;
+    let isSet2 = false;
+    if (state.type_ === 3 /* Set */) {
+      resultEach = new Set(result);
+      result.clear();
+      isSet2 = true;
+    }
+    each(
+      resultEach,
+      (key, childValue) => finalizeProperty(
+        rootScope,
+        state,
+        result,
+        key,
+        childValue,
+        path,
+        isSet2
+      ),
+      useStrictIteration
+    );
+    maybeFreeze(rootScope, result, false);
+    if (path && rootScope.patches_) {
+      getPlugin("Patches").generatePatches_(
+        state,
+        path,
+        rootScope.patches_,
+        rootScope.inversePatches_
+      );
+    }
+  }
+  return state.copy_;
+}
+function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
+  if (childValue == null) {
+    return;
+  }
+  if (typeof childValue !== "object" && !targetIsSet) {
+    return;
+  }
+  const childIsFrozen = isFrozen(childValue);
+  if (childIsFrozen && !targetIsSet) {
+    return;
+  }
+  if (process.env.NODE_ENV !== "production" && childValue === targetObject)
+    die(5);
+  if (isDraft(childValue)) {
+    const path = rootPath && parentState && parentState.type_ !== 3 /* Set */ && // Set objects are atomic since they have no keys.
+    !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
+    const res = finalize(rootScope, childValue, path);
+    set(targetObject, prop, res);
+    if (isDraft(res)) {
+      rootScope.canAutoFreeze_ = false;
+    } else
+      return;
+  } else if (targetIsSet) {
+    targetObject.add(childValue);
+  }
+  if (isDraftable(childValue) && !childIsFrozen) {
+    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+      return;
+    }
+    if (parentState && parentState.base_ && parentState.base_[prop] === childValue && childIsFrozen) {
+      return;
+    }
+    finalize(rootScope, childValue);
+    if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && (isMap(targetObject) ? targetObject.has(prop) : Object.prototype.propertyIsEnumerable.call(targetObject, prop)))
+      maybeFreeze(rootScope, childValue);
+  }
+}
+function maybeFreeze(scope, value, deep = false) {
+  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
+    freeze(value, deep);
+  }
+}
+
+// src/core/proxy.ts
+function createProxyProxy(base, parent) {
+  const isArray = Array.isArray(base);
+  const state = {
+    type_: isArray ? 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).
+    assigned_: {},
+    // 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
+  };
+  let target = state;
+  let traps = objectTraps;
+  if (isArray) {
+    target = [state];
+    traps = arrayTraps;
+  }
+  const { revoke, proxy } = Proxy.revocable(target, traps);
+  state.draft_ = proxy;
+  state.revoke_ = revoke;
+  return proxy;
+}
+var objectTraps = {
+  get(state, prop) {
+    if (prop === DRAFT_STATE)
+      return state;
+    const source = latest(state);
+    if (!has(source, prop)) {
+      return readPropFromProto(state, source, prop);
+    }
+    const value = source[prop];
+    if (state.finalized_ || !isDraftable(value)) {
+      return value;
+    }
+    if (value === peek(state.base_, prop)) {
+      prepareCopy(state);
+      return state.copy_[prop] = createProxy(value, state);
+    }
+    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_[prop] = false;
+        return true;
+      }
+      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
+        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_[prop] = true;
+    return true;
+  },
+  deleteProperty(state, prop) {
+    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+      state.assigned_[prop] = false;
+      prepareCopy(state);
+      markChanged(state);
+    } else {
+      delete state.assigned_[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() {
+    arguments[0] = arguments[0][0];
+    return fn.apply(this, arguments);
+  };
+});
+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.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_ = true;
+    /**
+     * 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 (typeof base === "function" && typeof recipe !== "function") {
+        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 (typeof recipe !== "function")
+        die(6);
+      if (patchListener !== void 0 && typeof patchListener !== "function")
+        die(7);
+      let result;
+      if (isDraftable(base)) {
+        const scope = enterScope(this);
+        const proxy = createProxy(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 || typeof base !== "object") {
+        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("Patches").generateReplacementPatches_(base, result, p, ip);
+          patchListener(p, ip);
+        }
+        return result;
+      } else
+        die(1, base);
+    };
+    this.produceWithPatches = (base, recipe) => {
+      if (typeof base === "function") {
+        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 (typeof config?.autoFreeze === "boolean")
+      this.setAutoFreeze(config.autoFreeze);
+    if (typeof config?.useStrictShallowCopy === "boolean")
+      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+    if (typeof config?.useStrictIteration === "boolean")
+      this.setUseStrictIteration(config.useStrictIteration);
+  }
+  createDraft(base) {
+    if (!isDraftable(base))
+      die(8);
+    if (isDraft(base))
+      base = current(base);
+    const scope = enterScope(this);
+    const proxy = createProxy(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("Patches").applyPatches_;
+    if (isDraft(base)) {
+      return applyPatchesImpl(base, patches);
+    }
+    return this.produce(
+      base,
+      (draft) => applyPatchesImpl(draft, patches)
+    );
+  }
+};
+function createProxy(value, parent) {
+  const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
+  const scope = parent ? parent.scope_ : getCurrentScope();
+  scope.drafts_.push(draft);
+  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;
+function castDraft(value) {
+  return 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 drifts = [...viewDrifts];
+  if (t$c(drifts, 1)) {
+    result.drifts = drifts;
+  } else {
+    if ("drifts" in result) {
+      delete result.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$1 as b, calcDriftsFromSnapshot as c, t$4 as d, t$5 as e, t$2 as f, buildElementNotations as g, t as h, n$5 as n, t$3 as t };