@pixerate/editor 0.22.0 → 0.24.0

package/dist/chunk-G2I4QJOT.cjs

@@ -0,0 +1,762 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;// src/history/HistoryManager.ts
+var sumBytes = (parts) => parts.reduce((n, p) => n + p.bytes, 0);
+function undoParts(parts) {
+  for (let i = parts.length - 1; i >= 0; i--) parts[i].undo();
+}
+function redoParts(parts) {
+  for (let i = 0; i < parts.length; i++) parts[i].redo();
+}
+var HistoryManager = (_class = class {
+  __init() {this.undoStack = []}
+  __init2() {this.redoStack = []}
+  
+  
+  
+  __init3() {this.isApplying = false}
+  __init4() {this.batchDepth = 0}
+  __init5() {this.currentBatch = null}
+  __init6() {this.listeners = /* @__PURE__ */ new Set()}
+  
+  
+  __init7() {this.cachedEntries = null}
+  __init8() {this.nextId = 1}
+  __init9() {this.revision = 0}
+  /** Bumped by `clear()`; marks from an earlier epoch are stale. */
+  __init10() {this.epoch = 0}
+  /** Number of steps dropped from the bottom (depth / byte budget) so far. */
+  __init11() {this.dropped = 0}
+  /** Key of the gesture that the top step belongs to (see `executeMerged`). */
+  __init12() {this.gestureKey = null}
+  __init13() {this.gestureEntryId = null}
+  /** Key every merged execute takes while a gesture is held (`beginGesture`). */
+  __init14() {this.heldKey = null}
+  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);_class.prototype.__init11.call(this);_class.prototype.__init12.call(this);_class.prototype.__init13.call(this);_class.prototype.__init14.call(this);
+    this.maxDepth = _nullishCoalesce(options.maxDepth, () => ( 50));
+    this.maxBytes = Math.max(0, _nullishCoalesce(options.maxBytes, () => ( 0)));
+    this.sizeOf = options.sizeOf;
+    this.onStateChange = options.onStateChange;
+    this.cachedState = this.computeState();
+  }
+  computeState() {
+    const canUndo = this.undoStack.length > 0;
+    const canRedo = this.redoStack.length > 0;
+    return {
+      canUndo,
+      canRedo,
+      undoName: canUndo ? this.undoStack[this.undoStack.length - 1].name : "",
+      redoName: canRedo ? this.redoStack[this.redoStack.length - 1].name : "",
+      undoCount: this.undoStack.length,
+      redoCount: this.redoStack.length
+    };
+  }
+  /**
+   * Returns a snapshot of the current history state.
+   * Cached to maintain referential equality across renders for useSyncExternalStore.
+   */
+  getState() {
+    return this.cachedState;
+  }
+  /**
+   * Monotonic counter bumped on every history change (execute, merge, undo,
+   * redo, revert, clear). Useful as a cache key, e.g. for `DirtyTracker`.
+   */
+  getRevision() {
+    return this.revision;
+  }
+  notify() {
+    this.revision++;
+    this.cachedState = this.computeState();
+    this.cachedEntries = null;
+    const state = this.cachedState;
+    _optionalChain([this, 'access', _ => _.onStateChange, 'optionalCall', _2 => _2(state)]);
+    this.listeners.forEach((listener) => {
+      try {
+        listener(state);
+      } catch (err) {
+        console.error("[HistoryManager] Error in state listener:", err);
+      }
+    });
+  }
+  measure(command) {
+    const n = this.sizeOf ? this.sizeOf(command) : _nullishCoalesce(command.byteSize, () => ( 0));
+    return Number.isFinite(n) && n > 0 ? n : 0;
+  }
+  makeEntry(command, timestamp) {
+    const part = {
+      undo: command.undo,
+      redo: _nullishCoalesce(command.redo, () => ( command.execute)),
+      tag: command.tag,
+      bytes: this.measure(command)
+    };
+    return {
+      id: this.nextId++,
+      name: command.name,
+      tag: command.tag,
+      timestamp,
+      parts: [part],
+      bytes: part.bytes
+    };
+  }
+  /** Pushes a step, clears redo and applies the depth and byte limits. */
+  record(entry) {
+    this.undoStack.push(entry);
+    while (this.undoStack.length > this.maxDepth) {
+      this.undoStack.shift();
+      this.dropped++;
+    }
+    this.redoStack = [];
+    this.trim();
+  }
+  /**
+   * Keeps the stacks within `maxBytes`: the oldest undo steps that do not fit
+   * are dropped, but the most recent undo step is always kept.
+   */
+  trim() {
+    if (this.maxBytes <= 0 || this.undoStack.length <= 1) return;
+    let total = this.getByteSize();
+    while (total > this.maxBytes && this.undoStack.length > 1) {
+      total -= this.undoStack.shift().bytes;
+      this.dropped++;
+    }
+  }
+  /** Approximate bytes held by the undo and redo stacks (see `maxBytes`). */
+  getByteSize() {
+    let total = 0;
+    for (const e of this.undoStack) total += e.bytes;
+    for (const e of this.redoStack) total += e.bytes;
+    return total;
+  }
+  resetGesture() {
+    this.gestureKey = null;
+    this.gestureEntryId = null;
+  }
+  /**
+   * Executes a command and pushes it onto the undo stack.
+   * Clears the redo stack and ends the current gesture.
+   */
+  execute(command) {
+    if (this.isApplying) {
+      command.execute();
+      return;
+    }
+    if (this.batchDepth > 0 && this.currentBatch) {
+      command.execute();
+      this.currentBatch.push({
+        ...command,
+        timestamp: _nullishCoalesce(command.timestamp, () => ( Date.now()))
+      });
+      return;
+    }
+    command.execute();
+    this.record(this.makeEntry(command, _nullishCoalesce(command.timestamp, () => ( Date.now()))));
+    this.resetGesture();
+    this.notify();
+  }
+  /**
+   * Executes a command as part of a continuous interaction (slider scrub, node drag).
+   *
+   * - With `options.key` (or while a gesture is held with `beginGesture`):
+   *   consecutive merged executes with the same key fold into one undo step,
+   *   however long the gesture lasts. Recording any other command, undo, redo,
+   *   `revertTo`, `goTo`, `clear` or `endGesture()` ends the gesture.
+   * - Without a key: coalesces with the previous command if they share the same
+   *   `tag` and occurred within `windowMs` (default: 300ms).
+   */
+  executeMerged(command, options = {}) {
+    const now = Date.now();
+    const key = _nullishCoalesce(this.heldKey, () => ( options.key));
+    if (key !== void 0) {
+      if (this.isApplying || this.batchDepth > 0) {
+        this.execute({ ...command, timestamp: now });
+        return;
+      }
+      const top = this.undoStack[this.undoStack.length - 1];
+      if (top && this.gestureKey === key && this.gestureEntryId === top.id) {
+        command.execute();
+        const redo = _nullishCoalesce(command.redo, () => ( command.execute));
+        const bytes = this.measure(command);
+        const last = top.parts[top.parts.length - 1];
+        if (last.tag !== void 0 && last.tag === command.tag) {
+          top.parts[top.parts.length - 1] = { undo: last.undo, redo, tag: last.tag, bytes };
+        } else {
+          top.parts.push({ undo: command.undo, redo, tag: command.tag, bytes });
+        }
+        top.bytes = sumBytes(top.parts);
+        top.timestamp = now;
+        this.redoStack = [];
+        this.trim();
+        this.notify();
+        return;
+      }
+      this.execute({ ...command, timestamp: now });
+      const pushed = this.undoStack[this.undoStack.length - 1];
+      if (pushed) {
+        this.gestureKey = key;
+        this.gestureEntryId = pushed.id;
+      }
+      return;
+    }
+    const windowMs = _nullishCoalesce(options.windowMs, () => ( 300));
+    if (command.tag && this.undoStack.length > 0 && this.batchDepth === 0 && !this.isApplying) {
+      const top = this.undoStack[this.undoStack.length - 1];
+      const elapsed = top.timestamp ? now - top.timestamp : Infinity;
+      if (top.tag === command.tag && elapsed <= windowMs) {
+        command.execute();
+        const initialParts = top.parts;
+        const bytes = this.measure(command);
+        this.undoStack[this.undoStack.length - 1] = {
+          id: top.id,
+          name: command.name,
+          tag: command.tag,
+          timestamp: now,
+          parts: [
+            {
+              undo: () => undoParts(initialParts),
+              redo: _nullishCoalesce(command.redo, () => ( command.execute)),
+              tag: command.tag,
+              bytes
+            }
+          ],
+          bytes
+        };
+        this.redoStack = [];
+        this.resetGesture();
+        this.trim();
+        this.notify();
+        return;
+      }
+    }
+    this.execute({ ...command, timestamp: now });
+  }
+  /**
+   * Holds a gesture: until `endGesture()`, every `executeMerged` call (whatever
+   * its own key or tag) joins one undo step, e.g. an automation pass and
+   * whatever is dragged during it. Commands recorded with `execute` still end
+   * the current step; the next merged execute then starts a new one.
+   */
+  beginGesture(key) {
+    if (this.heldKey === key) return;
+    this.heldKey = key;
+    this.resetGesture();
+  }
+  /** Ends the current (keyed or held) gesture; the next merged execute starts a new step. */
+  endGesture() {
+    this.heldKey = null;
+    this.resetGesture();
+  }
+  /** The key of the gesture currently merging into the top step, if any. */
+  getGestureKey() {
+    return _nullishCoalesce(this.heldKey, () => ( this.gestureKey));
+  }
+  /**
+   * Batches multiple commands executed within `fn` into a single atomic undo entry.
+   */
+  batch(name, fn) {
+    if (this.isApplying) {
+      fn();
+      return;
+    }
+    if (this.batchDepth > 0) {
+      fn();
+      return;
+    }
+    this.batchDepth++;
+    this.currentBatch = [];
+    try {
+      fn();
+    } catch (error) {
+      const executed = _nullishCoalesce(this.currentBatch, () => ( []));
+      this.batchDepth--;
+      this.currentBatch = null;
+      this.rollback(executed);
+      throw error;
+    }
+    this.batchDepth--;
+    const batchCommands = _nullishCoalesce(this.currentBatch, () => ( []));
+    this.currentBatch = null;
+    if (batchCommands.length > 0) {
+      const run = () => {
+        for (let i = 0; i < batchCommands.length; i++) {
+          (_nullishCoalesce(batchCommands[i].redo, () => ( batchCommands[i].execute)))();
+        }
+      };
+      const bytes = batchCommands.reduce((n, c) => n + this.measure(c), 0);
+      this.record({
+        id: this.nextId++,
+        name,
+        timestamp: Date.now(),
+        parts: [
+          {
+            undo: () => {
+              for (let i = batchCommands.length - 1; i >= 0; i--) {
+                batchCommands[i].undo();
+              }
+            },
+            redo: run,
+            bytes
+          }
+        ],
+        bytes
+      });
+      this.resetGesture();
+      this.notify();
+    }
+  }
+  /**
+   * Reverts already-executed commands of an aborted batch, newest first.
+   * Commands executed by the undo closures themselves are not recorded.
+   */
+  rollback(commands) {
+    const wasApplying = this.isApplying;
+    this.isApplying = true;
+    try {
+      for (let i = commands.length - 1; i >= 0; i--) {
+        try {
+          commands[i].undo();
+        } catch (err) {
+          console.error(
+            `[HistoryManager] Error rolling back "${commands[i].name}" of a failed batch:`,
+            err
+          );
+        }
+      }
+    } finally {
+      this.isApplying = wasApplying;
+    }
+  }
+  /** Undoes the top step (caller holds `isApplying`). Throws leave it on the stack. */
+  undoOne() {
+    const entry = this.undoStack[this.undoStack.length - 1];
+    undoParts(entry.parts);
+    this.undoStack.pop();
+    this.redoStack.push(entry);
+  }
+  redoOne() {
+    const entry = this.redoStack[this.redoStack.length - 1];
+    redoParts(entry.parts);
+    this.redoStack.pop();
+    this.undoStack.push(entry);
+  }
+  /**
+   * Reverts the most recent command on the undo stack.
+   * Returns true if a command was undone, false otherwise.
+   */
+  undo() {
+    if (this.undoStack.length === 0 || this.isApplying || this.batchDepth > 0) {
+      return false;
+    }
+    this.isApplying = true;
+    this.resetGesture();
+    try {
+      this.undoOne();
+      return true;
+    } finally {
+      this.isApplying = false;
+      this.notify();
+    }
+  }
+  /**
+   * Re-applies the most recent undone command on the redo stack.
+   * Returns true if a command was redone, false otherwise.
+   */
+  redo() {
+    if (this.redoStack.length === 0 || this.isApplying || this.batchDepth > 0) {
+      return false;
+    }
+    this.isApplying = true;
+    this.resetGesture();
+    try {
+      this.redoOne();
+      return true;
+    } finally {
+      this.isApplying = false;
+      this.notify();
+    }
+  }
+  /**
+   * Captures the current point in the history (its top step), for `revertTo`.
+   */
+  mark() {
+    const top = this.undoStack[this.undoStack.length - 1];
+    return {
+      topId: top ? top.id : null,
+      nextId: this.nextId,
+      epoch: this.epoch,
+      dropped: this.dropped
+    };
+  }
+  /** Whether `mark` still points into the undo history. */
+  isMarkValid(mark) {
+    if (mark.epoch !== this.epoch) return false;
+    if (mark.topId === null) return mark.dropped === this.dropped;
+    return this.undoStack.some((e) => e.id === mark.topId);
+  }
+  /**
+   * Takes back every step made since `mark` (merged or not), e.g. to cancel a
+   * drag with Escape: the state returns to how it was at `mark`, and neither
+   * undo nor redo keeps the reverted steps. Does nothing when `mark` has left
+   * the history (undone past, dropped by the limits, or cleared).
+   * Returns how many steps were taken back.
+   */
+  revertTo(mark) {
+    if (this.isApplying || this.batchDepth > 0 || !this.isMarkValid(mark)) {
+      return 0;
+    }
+    const redoBefore = this.redoStack.length;
+    let n = 0;
+    this.isApplying = true;
+    this.resetGesture();
+    try {
+      while (this.undoStack.length > 0) {
+        const top = this.undoStack[this.undoStack.length - 1];
+        if (top.id === mark.topId) break;
+        undoParts(top.parts);
+        this.undoStack.pop();
+        n++;
+      }
+    } finally {
+      this.isApplying = false;
+      this.redoStack = n > 0 ? [] : this.redoStack.filter((e) => e.id < mark.nextId);
+      if (n > 0 || this.redoStack.length !== redoBefore) this.notify();
+    }
+    return n;
+  }
+  /**
+   * Lists the steps for a History panel: undo steps oldest first, then redo
+   * steps (the next redo first). Cached until the history changes.
+   */
+  getEntries() {
+    if (this.cachedEntries) return this.cachedEntries;
+    const u = this.undoStack.length;
+    const entries = this.undoStack.map((e, index) => ({
+      id: e.id,
+      label: e.name,
+      index,
+      current: index === u - 1,
+      undone: false
+    }));
+    for (let i = this.redoStack.length - 1; i >= 0; i--) {
+      const e = this.redoStack[i];
+      entries.push({
+        id: e.id,
+        label: e.name,
+        index: entries.length,
+        current: false,
+        undone: true
+      });
+    }
+    this.cachedEntries = entries;
+    return entries;
+  }
+  /**
+   * Undoes or redoes until the step at `index` (from `getEntries`) is the
+   * current one; `-1` undoes everything. Returns how many steps were applied.
+   */
+  goTo(index) {
+    if (this.isApplying || this.batchDepth > 0) return 0;
+    const total = this.undoStack.length + this.redoStack.length;
+    const target = Math.max(0, Math.min(total, Math.floor(index) + 1));
+    if (target === this.undoStack.length) return 0;
+    let n = 0;
+    this.isApplying = true;
+    this.resetGesture();
+    try {
+      while (this.undoStack.length > target) {
+        this.undoOne();
+        n++;
+      }
+      while (this.undoStack.length < target) {
+        this.redoOne();
+        n++;
+      }
+    } finally {
+      this.isApplying = false;
+      this.notify();
+    }
+    return n;
+  }
+  /**
+   * Clears both undo and redo stacks.
+   */
+  clear() {
+    this.undoStack = [];
+    this.redoStack = [];
+    this.epoch++;
+    this.resetGesture();
+    this.notify();
+  }
+  /**
+   * Subscribes to history state changes.
+   * The listener is immediately invoked with the current state.
+   * Returns an unsubscribe function.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.getState());
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Utility helper to create a Command from before/after state snapshots.
+   */
+  static createSnapshotCommand(options) {
+    return {
+      name: options.name,
+      tag: options.tag,
+      execute: () => options.apply(options.after),
+      undo: () => options.apply(options.before),
+      redo: () => options.apply(options.after)
+    };
+  }
+}, _class);
+function createHistoryManager(options = {}) {
+  return new HistoryManager(options);
+}
+
+// src/dirty.ts
+function defaultIsEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!defaultIsEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!defaultIsEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+var isThenable = (value) => !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+var DirtyTracker = (_class2 = class {
+  
+  
+  
+  __init15() {this.normalizedBaseline = null}
+  /** `isDirty` result as of a revision (and baseline version). */
+  __init16() {this.cache = null}
+  __init17() {this.baselineVersion = 0}
+  __init18() {this.suppressDepth = 0}
+  __init19() {this.hasValue = false}
+  
+  __init20() {this.dirtyState = false}
+  __init21() {this.listeners = /* @__PURE__ */ new Set()}
+  constructor(initialBaseline, options) {;_class2.prototype.__init15.call(this);_class2.prototype.__init16.call(this);_class2.prototype.__init17.call(this);_class2.prototype.__init18.call(this);_class2.prototype.__init19.call(this);_class2.prototype.__init20.call(this);_class2.prototype.__init21.call(this);
+    this.baseline = initialBaseline;
+    if (typeof options === "function") {
+      this.isEqual = options;
+    } else {
+      this.isEqual = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.isEqual]), () => ( defaultIsEqual));
+      this.normalize = _optionalChain([options, 'optionalAccess', _4 => _4.normalize]);
+    }
+  }
+  /**
+   * Returns current baseline value.
+   */
+  getBaseline() {
+    return this.baseline;
+  }
+  changeBaseline(value) {
+    this.baseline = value;
+    this.baselineVersion++;
+    this.normalizedBaseline = null;
+    this.cache = null;
+  }
+  /**
+   * Sets a new baseline value without triggering any dirty state.
+   * If a value is being tracked (`update`), `dirty` is recomputed against it.
+   */
+  setBaseline(value) {
+    this.changeBaseline(value);
+    if (this.hasValue) {
+      this.setDirtyState(this.compare(this.lastValue));
+    }
+  }
+  compare(current) {
+    if (!this.normalize) return !this.isEqual(this.baseline, current);
+    this.normalizedBaseline ??= { value: this.normalize(this.baseline) };
+    return !this.isEqual(
+      this.normalizedBaseline.value,
+      this.normalize(current)
+    );
+  }
+  /**
+   * Checks whether the given value differs from the baseline.
+   * With a `revision` (e.g. `HistoryManager.getRevision()`), the result is
+   * cached and reused for the same revision until the baseline changes.
+   */
+  isDirty(current, revision) {
+    if (revision === void 0) return this.compare(current);
+    const cache = this.cache;
+    if (cache && cache.revision === revision && cache.baseline === this.baselineVersion) {
+      return cache.dirty;
+    }
+    const dirty = this.compare(current);
+    this.cache = { revision, baseline: this.baselineVersion, dirty };
+    return dirty;
+  }
+  /**
+   * Resets the baseline to the provided current value (or clears dirty status).
+   */
+  reset(current) {
+    this.changeBaseline(current);
+    this.hasValue = true;
+    this.lastValue = current;
+    this.setDirtyState(false);
+  }
+  /**
+   * Records the current value and returns whether it is dirty. While
+   * suppressed (`suppress`), the value becomes the new baseline instead, so
+   * programmatic loads and restores never mark the document dirty.
+   */
+  update(current, revision) {
+    this.hasValue = true;
+    this.lastValue = current;
+    if (this.suppressDepth > 0) {
+      this.changeBaseline(current);
+      this.setDirtyState(false);
+      return false;
+    }
+    const dirty = this.isDirty(current, revision);
+    this.setDirtyState(dirty);
+    return dirty;
+  }
+  /** Whether the last value passed to `update` differs from the baseline. */
+  get dirty() {
+    return this.dirtyState;
+  }
+  /** Whether `suppress` is currently running. */
+  get suppressed() {
+    return this.suppressDepth > 0;
+  }
+  /**
+   * Marks the document saved: `current` (default: the last value passed to
+   * `update`) becomes the baseline.
+   */
+  markClean(...args) {
+    if (args.length > 0) {
+      this.reset(args[0]);
+    } else if (this.hasValue) {
+      this.reset(this.lastValue);
+    } else {
+      this.setDirtyState(false);
+    }
+  }
+  /**
+   * Runs `fn` without marking anything dirty: every `update` during it
+   * rebaselines. Re-entrant (depth counter). If `fn` returns a promise, the
+   * suppression lasts until it settles.
+   */
+  suppress(fn) {
+    this.suppressDepth++;
+    let result;
+    try {
+      result = fn();
+    } catch (error) {
+      this.suppressDepth--;
+      throw error;
+    }
+    if (isThenable(result)) {
+      const release = () => {
+        this.suppressDepth--;
+      };
+      return result.then(
+        (value) => {
+          release();
+          return value;
+        },
+        (error) => {
+          release();
+          throw error;
+        }
+      );
+    }
+    this.suppressDepth--;
+    return result;
+  }
+  /**
+   * Subscribes to changes of `dirty`. The listener is called immediately with
+   * the current value. Returns an unsubscribe function.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.dirtyState);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  setDirtyState(dirty) {
+    if (dirty === this.dirtyState) return;
+    this.dirtyState = dirty;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(dirty);
+      } catch (err) {
+        console.error("[DirtyTracker] Error in listener:", err);
+      }
+    });
+  }
+}, _class2);
+function createDirtyTracker(initialBaseline, options) {
+  return new DirtyTracker(initialBaseline, options);
+}
+function withoutDirty(tracker, fn) {
+  return tracker.suppress(fn);
+}
+function bindDirtyToHistory(options) {
+  const { history, getValue } = options;
+  const tracker = _nullishCoalesce(options.tracker, () => ( new DirtyTracker(getValue(), {
+    isEqual: options.isEqual,
+    normalize: options.normalize
+  })));
+  const unsubscribe = history.subscribe(() => {
+    tracker.update(getValue(), _optionalChain([history, 'access', _5 => _5.getRevision, 'optionalCall', _6 => _6()]));
+  });
+  return {
+    tracker,
+    get dirty() {
+      return tracker.dirty;
+    },
+    markClean: () => tracker.markClean(getValue()),
+    suppress: (fn) => {
+      const rebaseline = () => {
+        if (!tracker.suppressed) tracker.reset(getValue());
+      };
+      const result = tracker.suppress(fn);
+      if (isThenable(result)) {
+        return result.then((value) => {
+          rebaseline();
+          return value;
+        });
+      }
+      rebaseline();
+      return result;
+    },
+    refresh: () => tracker.update(getValue()),
+    subscribe: (listener) => tracker.subscribe(listener),
+    destroy: unsubscribe
+  };
+}
+
+
+
+
+
+
+
+
+
+exports.defaultIsEqual = defaultIsEqual; exports.DirtyTracker = DirtyTracker; exports.createDirtyTracker = createDirtyTracker; exports.withoutDirty = withoutDirty; exports.bindDirtyToHistory = bindDirtyToHistory; exports.HistoryManager = HistoryManager; exports.createHistoryManager = createHistoryManager;
+//# sourceMappingURL=chunk-G2I4QJOT.cjs.map