@embedpdf/plugin-history 2.15.1 → 3.0.0-next.16

package/dist/index.js

@@ -1,381 +1,352 @@
-import { BasePlugin, createEmitter } from "@embedpdf/core";
-const HISTORY_PLUGIN_ID = "history";
-const manifest = {
-  id: HISTORY_PLUGIN_ID,
-  name: "History Plugin",
-  version: "1.0.0",
-  provides: ["history"],
-  requires: [],
-  optional: [],
-  defaultConfig: {}
-};
-const INIT_HISTORY_STATE = "HISTORY/INIT_STATE";
-const CLEANUP_HISTORY_STATE = "HISTORY/CLEANUP_STATE";
-const SET_HISTORY_DOCUMENT_STATE = "HISTORY/SET_DOCUMENT_STATE";
-const SET_ACTIVE_HISTORY_DOCUMENT = "HISTORY/SET_ACTIVE_DOCUMENT";
-const initHistoryState = (documentId) => ({
-  type: INIT_HISTORY_STATE,
-  payload: { documentId }
-});
-const cleanupHistoryState = (documentId) => ({
-  type: CLEANUP_HISTORY_STATE,
-  payload: { documentId }
+import { n as HistoryToken, t as HISTORY_DEFAULTS } from "./contract-B7QL_Q3D.js";
+import { definePlugin, defineState } from "@embedpdf/core";
+import { EngineError, EngineErrorCode } from "@embedpdf/engine-core/runtime";
+//#region src/model.ts
+const emptyHistory = () => ({
+	undo: [],
+	redo: [],
+	merging: null,
+	nextSeq: 0
 });
-const setHistoryDocumentState = (documentId, state) => ({
-  type: SET_HISTORY_DOCUMENT_STATE,
-  payload: { documentId, state }
-});
-const _HistoryPlugin = class _HistoryPlugin extends BasePlugin {
-  constructor(id, registry) {
-    super(id, registry);
-    this.documentHistories = /* @__PURE__ */ new Map();
-    this.historyChange$ = createEmitter();
-  }
-  async initialize(_) {
-    this.logger.info("HistoryPlugin", "Initialize", "History plugin initialized");
-  }
-  // ─────────────────────────────────────────────────────────
-  // Document Lifecycle (from BasePlugin)
-  // ─────────────────────────────────────────────────────────
-  onDocumentLoadingStarted(documentId) {
-    this.dispatch(initHistoryState(documentId));
-    this.documentHistories.set(documentId, {
-      topicHistories: /* @__PURE__ */ new Map(),
-      globalTimeline: [],
-      globalIndex: -1
-    });
-    this.logger.debug(
-      "HistoryPlugin",
-      "DocumentOpened",
-      `Initialized history state for document: ${documentId}`
-    );
-  }
-  onDocumentClosed(documentId) {
-    this.dispatch(cleanupHistoryState(documentId));
-    this.documentHistories.delete(documentId);
-    this.logger.debug(
-      "HistoryPlugin",
-      "DocumentClosed",
-      `Cleaned up history state for document: ${documentId}`
-    );
-  }
-  // ─────────────────────────────────────────────────────────
-  // Helper Methods
-  // ─────────────────────────────────────────────────────────
-  getDocumentHistoryData(documentId) {
-    const id = documentId ?? this.getActiveDocumentId();
-    const data = this.documentHistories.get(id);
-    if (!data) {
-      throw new Error(`History data not found for document: ${id}`);
-    }
-    return data;
-  }
-  getDocumentHistoryState(documentId) {
-    const data = this.documentHistories.get(documentId);
-    if (!data) {
-      throw new Error(`History data not found for document: ${documentId}`);
-    }
-    const topics = {};
-    Array.from(data.topicHistories.entries()).forEach(([topic, history]) => {
-      topics[topic] = {
-        canUndo: history.currentIndex > -1,
-        canRedo: history.currentIndex < history.commands.length - 1
-      };
-    });
-    return {
-      global: {
-        canUndo: data.globalIndex > -1,
-        canRedo: data.globalIndex < data.globalTimeline.length - 1
-      },
-      topics
-    };
-  }
-  emitHistoryChange(documentId, topic) {
-    const state = this.getDocumentHistoryState(documentId);
-    this.dispatch(setHistoryDocumentState(documentId, state));
-    this.historyChange$.emit({
-      documentId,
-      topic,
-      state
-    });
-  }
-  // ─────────────────────────────────────────────────────────
-  // History Operations (per document)
-  // ─────────────────────────────────────────────────────────
-  register(command, topic, documentId) {
-    const data = this.getDocumentHistoryData(documentId);
-    if (!data.topicHistories.has(topic)) {
-      data.topicHistories.set(topic, { commands: [], currentIndex: -1 });
-    }
-    const topicHistory = data.topicHistories.get(topic);
-    topicHistory.commands.splice(topicHistory.currentIndex + 1);
-    topicHistory.commands.push(command);
-    topicHistory.currentIndex++;
-    const historyEntry = { command, topic };
-    data.globalTimeline.splice(data.globalIndex + 1);
-    data.globalTimeline.push(historyEntry);
-    data.globalIndex++;
-    command.execute();
-    this.emitHistoryChange(documentId, topic);
-  }
-  undo(topic, documentId) {
-    const data = this.getDocumentHistoryData(documentId);
-    let affectedTopic;
-    if (topic) {
-      const topicHistory = data.topicHistories.get(topic);
-      if (topicHistory && topicHistory.currentIndex > -1) {
-        topicHistory.commands[topicHistory.currentIndex].undo();
-        topicHistory.currentIndex--;
-        affectedTopic = topic;
-      }
-    } else {
-      if (data.globalIndex > -1) {
-        const entry = data.globalTimeline[data.globalIndex];
-        entry.command.undo();
-        data.topicHistories.get(entry.topic).currentIndex--;
-        data.globalIndex--;
-        affectedTopic = entry.topic;
-      }
-    }
-    if (affectedTopic) {
-      this.emitHistoryChange(documentId, affectedTopic);
-    }
-  }
-  redo(topic, documentId) {
-    const data = this.getDocumentHistoryData(documentId);
-    let affectedTopic;
-    if (topic) {
-      const topicHistory = data.topicHistories.get(topic);
-      if (topicHistory && topicHistory.currentIndex < topicHistory.commands.length - 1) {
-        topicHistory.currentIndex++;
-        topicHistory.commands[topicHistory.currentIndex].execute();
-        affectedTopic = topic;
-      }
-    } else {
-      if (data.globalIndex < data.globalTimeline.length - 1) {
-        data.globalIndex++;
-        const entry = data.globalTimeline[data.globalIndex];
-        entry.command.execute();
-        data.topicHistories.get(entry.topic).currentIndex++;
-        affectedTopic = entry.topic;
-      }
-    }
-    if (affectedTopic) {
-      this.emitHistoryChange(documentId, affectedTopic);
-    }
-  }
-  canUndo(topic, documentId) {
-    const data = this.getDocumentHistoryData(documentId);
-    if (topic) {
-      const history = data.topicHistories.get(topic);
-      return !!history && history.currentIndex > -1;
-    }
-    return data.globalIndex > -1;
-  }
-  canRedo(topic, documentId) {
-    const data = this.getDocumentHistoryData(documentId);
-    if (topic) {
-      const history = data.topicHistories.get(topic);
-      return !!history && history.currentIndex < history.commands.length - 1;
-    }
-    return data.globalIndex < data.globalTimeline.length - 1;
-  }
-  /**
-   * Purges history entries that match the given predicate based on command metadata.
-   * Used to remove commands that are no longer valid (e.g., after a permanent redaction commit).
-   *
-   * @param predicate A function that returns true for commands that should be purged
-   * @param topic If provided, only purges entries for that specific topic
-   * @param documentId The document to purge history for
-   * @returns The number of entries that were purged
-   */
-  purgeByMetadata(predicate, topic, documentId) {
-    const data = this.getDocumentHistoryData(documentId);
-    let purgedCount = 0;
-    const shouldPurge = (command) => {
-      return predicate(command.metadata);
-    };
-    const topicsToProcess = topic ? [topic] : Array.from(data.topicHistories.keys());
-    for (const topicName of topicsToProcess) {
-      const topicHistory = data.topicHistories.get(topicName);
-      if (!topicHistory) continue;
-      const newCommands = [];
-      let indexAdjustment = 0;
-      for (let i = 0; i < topicHistory.commands.length; i++) {
-        const command = topicHistory.commands[i];
-        if (shouldPurge(command)) {
-          if (i <= topicHistory.currentIndex) {
-            indexAdjustment++;
-          }
-          purgedCount++;
-        } else {
-          newCommands.push(command);
-        }
-      }
-      topicHistory.commands = newCommands;
-      topicHistory.currentIndex = Math.max(-1, topicHistory.currentIndex - indexAdjustment);
-    }
-    const newTimeline = [];
-    let globalIndexAdjustment = 0;
-    for (let i = 0; i < data.globalTimeline.length; i++) {
-      const entry = data.globalTimeline[i];
-      const matchesTopic = !topic || entry.topic === topic;
-      if (matchesTopic && shouldPurge(entry.command)) {
-        if (i <= data.globalIndex) {
-          globalIndexAdjustment++;
-        }
-      } else {
-        newTimeline.push(entry);
-      }
-    }
-    data.globalTimeline = newTimeline;
-    data.globalIndex = Math.max(-1, data.globalIndex - globalIndexAdjustment);
-    if (purgedCount > 0) {
-      this.emitHistoryChange(documentId, topic);
-      this.logger.debug(
-        "HistoryPlugin",
-        "PurgeByMetadata",
-        `Purged ${purgedCount} history entries for document: ${documentId}${topic ? `, topic: ${topic}` : ""}`
-      );
-    }
-    return purgedCount;
-  }
-  // ─────────────────────────────────────────────────────────
-  // Document Scoping
-  // ─────────────────────────────────────────────────────────
-  createHistoryScope(documentId) {
-    return {
-      register: (command, topic) => this.register(command, topic, documentId),
-      undo: (topic) => this.undo(topic, documentId),
-      redo: (topic) => this.redo(topic, documentId),
-      canUndo: (topic) => this.canUndo(topic, documentId),
-      canRedo: (topic) => this.canRedo(topic, documentId),
-      getHistoryState: () => this.getDocumentHistoryState(documentId),
-      onHistoryChange: (listener) => this.historyChange$.on((event) => {
-        if (event.documentId === documentId) {
-          listener(event.topic);
-        }
-      }),
-      purgeByMetadata: (predicate, topic) => this.purgeByMetadata(predicate, topic, documentId)
-    };
-  }
-  // ─────────────────────────────────────────────────────────
-  // Capability
-  // ─────────────────────────────────────────────────────────
-  buildCapability() {
-    return {
-      // Active document operations
-      register: (command, topic) => {
-        const documentId = this.getActiveDocumentId();
-        this.register(command, topic, documentId);
-      },
-      undo: (topic) => {
-        const documentId = this.getActiveDocumentId();
-        this.undo(topic, documentId);
-      },
-      redo: (topic) => {
-        const documentId = this.getActiveDocumentId();
-        this.redo(topic, documentId);
-      },
-      canUndo: (topic) => {
-        const documentId = this.getActiveDocumentId();
-        return this.canUndo(topic, documentId);
-      },
-      canRedo: (topic) => {
-        const documentId = this.getActiveDocumentId();
-        return this.canRedo(topic, documentId);
-      },
-      getHistoryState: () => {
-        const documentId = this.getActiveDocumentId();
-        return this.getDocumentHistoryState(documentId);
-      },
-      // Document-scoped operations
-      forDocument: (documentId) => this.createHistoryScope(documentId),
-      // Events
-      onHistoryChange: this.historyChange$.on,
-      // Purge operations
-      purgeByMetadata: (predicate, topic) => {
-        const documentId = this.getActiveDocumentId();
-        return this.purgeByMetadata(predicate, topic, documentId);
-      }
-    };
-  }
-  // ─────────────────────────────────────────────────────────
-  // Lifecycle
-  // ─────────────────────────────────────────────────────────
-  async destroy() {
-    this.historyChange$.clear();
-    this.documentHistories.clear();
-    super.destroy();
-  }
-};
-_HistoryPlugin.id = "history";
-let HistoryPlugin = _HistoryPlugin;
-const initialDocumentState = {
-  global: {
-    canUndo: false,
-    canRedo: false
-  },
-  topics: {}
+/** The stack a step takes its entry from, and the one it puts it on. */
+const stacksOf = (direction) => direction === "undo" ? {
+	from: "undo",
+	to: "redo"
+} : {
+	from: "redo",
+	to: "undo"
 };
-const initialState = {
-  documents: {},
-  activeDocumentId: null
+/** The entry the next step of `direction` takes, or `null`. */
+const nextOf = (history, direction) => history[direction].at(-1) ?? null;
+/**
+* A new change: it joins the newest entry when typing goes on under the same key, else it is a
+* new entry on top, and the oldest go past `limit`. Anything that could be redone is forgotten.
+*/
+function recorded(history, change, limit) {
+	const part = {
+		seq: history.nextSeq,
+		id: change.opId,
+		opId: change.opId,
+		forward: change.shows,
+		backward: change.undo
+	};
+	const top = history.undo.at(-1);
+	if (top && change.merge !== null && history.merging === change.merge) return {
+		undo: [...history.undo.slice(0, -1), {
+			...top,
+			parts: [...top.parts, part]
+		}],
+		redo: [],
+		merging: change.merge,
+		nextSeq: history.nextSeq + 1
+	};
+	const entry = {
+		seq: part.seq,
+		label: change.label,
+		merge: change.merge,
+		parts: [part]
+	};
+	return {
+		undo: [...history.undo, entry].slice(-Math.max(1, limit)),
+		redo: [],
+		merging: change.merge,
+		nextSeq: history.nextSeq + 1
+	};
+}
+/**
+* A step was staged: the entry `seq` leaves the top of its stack for the top of the other, each
+* part now named by the change that staged it (`opIds`, by part id).
+*/
+function stepped(history, direction, seq, opIds) {
+	const { from, to } = stacksOf(direction);
+	const entry = history[from].find((candidate) => candidate.seq === seq);
+	if (!entry) return history;
+	const moved = {
+		...entry,
+		parts: entry.parts.map((part) => ({
+			...part,
+			opId: opIds.get(part.id) ?? part.opId
+		}))
+	};
+	return {
+		...history,
+		[from]: history[from].filter((candidate) => candidate !== entry),
+		[to]: [...history[to], moved],
+		merging: null
+	};
+}
+/** Every entry without the parts `drop` picks, and without the entries left with none. */
+const withoutParts = (entries, drop) => {
+	let changed = false;
+	const kept = [];
+	for (const entry of entries) {
+		const parts = entry.parts.filter((part) => !drop(part));
+		if (parts.length === entry.parts.length) {
+			kept.push(entry);
+			continue;
+		}
+		changed = true;
+		if (parts.length) kept.push({
+			...entry,
+			parts
+		});
+	}
+	return changed ? kept : entries;
 };
-const reducer = (state = initialState, action) => {
-  switch (action.type) {
-    case INIT_HISTORY_STATE: {
-      const { documentId } = action.payload;
-      return {
-        ...state,
-        documents: {
-          ...state.documents,
-          [documentId]: { ...initialDocumentState }
-        }
-      };
-    }
-    case CLEANUP_HISTORY_STATE: {
-      const { documentId } = action.payload;
-      const { [documentId]: removed, ...remainingDocs } = state.documents;
-      return {
-        ...state,
-        documents: remainingDocs,
-        activeDocumentId: state.activeDocumentId === documentId ? null : state.activeDocumentId
-      };
-    }
-    case SET_HISTORY_DOCUMENT_STATE: {
-      const { documentId, state: docState } = action.payload;
-      if (!state.documents[documentId]) {
-        return state;
-      }
-      return {
-        ...state,
-        documents: {
-          ...state.documents,
-          [documentId]: docState
-        }
-      };
-    }
-    case SET_ACTIVE_HISTORY_DOCUMENT: {
-      return {
-        ...state,
-        activeDocumentId: action.payload
-      };
-    }
-    default:
-      return state;
-  }
+/**
+* The change `id` never happened (the engine refused it), or did nothing that can be undone:
+* its part goes, from whichever stack holds it.
+*/
+function forgotten(history, id) {
+	const undo = withoutParts(history.undo, (part) => part.id === id);
+	const redo = withoutParts(history.redo, (part) => part.id === id);
+	return undo === history.undo && redo === history.redo ? history : {
+		...history,
+		undo,
+		redo
+	};
+}
+/**
+* The engine refused one change of a step, so that part didn't move: it goes back where it
+* was, as `part` was before the step, into its entry there (or a new one with the entry's
+* number, in its place), wherever a later step had put it since. Its other parts stay where
+* the step put them.
+*/
+function stepRefused(history, direction, entry, part) {
+	const { from } = stacksOf(direction);
+	const { undo, redo } = forgotten(history, part.id);
+	const left = {
+		undo,
+		redo
+	};
+	const back = [...left[from]];
+	const at = back.findIndex((candidate) => candidate.seq === entry.seq);
+	if (at >= 0) {
+		const parts = [...back[at].parts, part].sort((left, right) => left.seq - right.seq);
+		back[at] = {
+			...back[at],
+			parts
+		};
+	} else {
+		const before = (candidate) => from === "undo" ? candidate.seq < entry.seq : candidate.seq > entry.seq;
+		const index = back.filter(before).length;
+		back.splice(index, 0, {
+			...entry,
+			parts: [part]
+		});
+	}
+	return {
+		...history,
+		...left,
+		[from]: back,
+		merging: null
+	};
+}
+/**
+* The engine can no longer undo the entry `seq` (a final change or a new version came after
+* it, or it is too old): it goes, and so does everything recorded before it.
+*/
+function unavailable(history, seq) {
+	const newer = (entry) => entry.seq > seq;
+	return {
+		...history,
+		undo: history.undo.filter(newer),
+		redo: history.redo.filter(newer),
+		merging: null
+	};
+}
+/** Nothing can be undone or redone. */
+const cleared = (history) => history.undo.length === 0 && history.redo.length === 0 && history.merging === null ? history : {
+	...history,
+	undo: [],
+	redo: [],
+	merging: null
 };
-const HistoryPluginPackage = {
-  manifest,
-  create: (registry) => new HistoryPlugin(HISTORY_PLUGIN_ID, registry),
-  reducer,
-  initialState
-};
-export {
-  HISTORY_PLUGIN_ID,
-  HistoryPlugin,
-  HistoryPluginPackage,
-  manifest
-};
-//# sourceMappingURL=index.js.map
+//#endregion
+//#region src/controller.ts
+/** The document events after which nothing before them can be undone. */
+const ENDS_UNDO = /* @__PURE__ */ new Set([
+	"redaction.applied",
+	"pages.flattened",
+	"signatures.completed",
+	"forms.repaired",
+	"document.versioned"
+]);
+/** Whether the engine refused an undo because it can't be undone any more. */
+const isUnavailable = (error) => EngineError.is(error.cause, EngineErrorCode.UndoUnavailable);
+/** How many of an undo's parts were left alone, in whole or in part. */
+const skippedIn = (result) => result.items.filter((item) => item.type === "skipped" || "skipped" in item && (item.skipped?.length ?? 0) > 0).length;
+function createHistoryController(ctx) {
+	const settings = ctx.settings();
+	const undone = ctx.events.source();
+	const undoFailed = ctx.events.source();
+	/**
+	* The changes the engine will never apply, while a step is on its way: a refused change, and
+	* a step that undid one. A step that names one is refused too, and changes nothing more.
+	*/
+	const dead = /* @__PURE__ */ new Set();
+	/** The parts forgotten while a step is on its way: a refusal of their step puts nothing back. */
+	const gone = /* @__PURE__ */ new Set();
+	let inFlight = 0;
+	const forget = (ids) => {
+		if (inFlight === 0) return;
+		for (const id of ids) gone.add(id);
+	};
+	const partsOf = (entries) => entries.flatMap((entry) => entry.parts.map((part) => part.id));
+	const clear = () => {
+		const history = ctx.state.get();
+		forget(partsOf([...history.undo, ...history.redo]));
+		ctx.state.update(cleared);
+	};
+	/**
+	* One step's change for one part, and what its answer does. `moot`: it named a change the
+	* engine never applied, or a part the history forgot, so its refusal says nothing new.
+	*/
+	const answerOf = (direction, entry, part, change) => change.result.then((result) => {
+		if (!result.meta.undoable) {
+			forget([part.id]);
+			ctx.state.update(forgotten, part.id);
+		}
+		return { skipped: skippedIn(result) };
+	}, (error) => {
+		dead.add(change.opId);
+		if (dead.has(part.opId) || gone.has(part.id)) return { moot: true };
+		if (isUnavailable(error)) {
+			const history = ctx.state.get();
+			const older = [...history.undo, ...history.redo].filter((other) => other.seq <= entry.seq);
+			forget(partsOf(older));
+			ctx.state.update(unavailable, entry.seq);
+		} else ctx.state.update(stepRefused, direction, entry, part);
+		return { error };
+	});
+	/**
+	* Take one step: the undo of each part of the next entry, as one change each (undo goes
+	* newest first, redo oldest first), staged now, so the views show it at once.
+	*/
+	const step = (direction) => {
+		ctx.changes.sendHolds();
+		const entry = nextOf(ctx.state.get(), direction);
+		if (!entry) return;
+		const parts = direction === "undo" ? [...entry.parts].reverse() : entry.parts;
+		const staged = [];
+		for (const part of parts) try {
+			const change = ctx.changes.stage({
+				label: entry.label,
+				undoOf: part.opId,
+				shows: direction === "undo" ? part.backward : part.forward
+			});
+			staged.push({
+				part,
+				change
+			});
+		} catch (error) {
+			if (staged.length === 0) throw error;
+			break;
+		}
+		ctx.state.update(stepped, direction, entry.seq, new Map(staged.map(({ part, change }) => [part.id, change.opId])));
+		inFlight += 1;
+		Promise.all(staged.map(({ part, change }) => answerOf(direction, entry, part, change))).then((answers) => {
+			inFlight -= 1;
+			if (inFlight === 0) {
+				dead.clear();
+				gone.clear();
+			}
+			const redo = direction === "redo";
+			if (answers.every((answer) => "moot" in answer)) return;
+			const failure = answers.find((answer) => "error" in answer);
+			if (failure && "error" in failure) {
+				undoFailed.emit({
+					label: entry.label,
+					redo,
+					reason: isUnavailable(failure.error) ? "unavailable" : "refused",
+					error: failure.error
+				});
+				return;
+			}
+			const skipped = answers.reduce((sum, answer) => sum + ("skipped" in answer ? answer.skipped : 0), 0);
+			undone.emit({
+				label: entry.label,
+				redo,
+				skipped
+			});
+		});
+	};
+	/** A change still being typed: what undo would undo before anything in the history. */
+	const openHold = () => ctx.changes.pending().find((change) => change.held && change.history) ?? null;
+	return {
+		api: {
+			...settings.api,
+			undo: () => step("undo"),
+			redo: () => step("redo"),
+			canUndo: () => openHold() !== null || ctx.state.get().undo.length > 0,
+			canRedo: () => openHold() === null && ctx.state.get().redo.length > 0,
+			getUndoLabel: () => openHold()?.label ?? nextOf(ctx.state.get(), "undo")?.label ?? null,
+			getRedoLabel: () => openHold() === null ? nextOf(ctx.state.get(), "redo")?.label ?? null : null,
+			clear,
+			onUndone: undone.on,
+			onUndoFailed: undoFailed.on
+		},
+		connect() {
+			ctx.listen(ctx.changes.onStaged, (change) => {
+				if (change.undoOf !== null || !change.history) return;
+				ctx.state.update(recorded, change, settings.get().limit);
+			});
+			ctx.listen(ctx.changes.onSettled, (settled) => {
+				const { change } = settled;
+				if (change.undoOf !== null || !change.history) return;
+				if (settled.status === "refused" || !settled.result.meta.undoable) {
+					if (settled.status === "refused" && inFlight > 0) dead.add(change.opId);
+					forget([change.opId]);
+					ctx.state.update(forgotten, change.opId);
+				}
+			});
+			ctx.listen(ctx.doc.events, (event) => {
+				if (ENDS_UNDO.has(event.type)) clear();
+			});
+		}
+	};
+}
+//#endregion
+//#region src/history.plugin.ts
+/**
+* Undo and redo, one history per open document, of what this session changes through the
+* viewer's plugins: every change they stage on the document's change queue is a step. No
+* dependencies and no engine state of its own. `config` is the settings the app registers,
+* over {@link HISTORY_DEFAULTS}.
+*/
+const historyPlugin = (config) => definePlugin({
+	id: "history",
+	token: HistoryToken,
+	scope: "document",
+	state: emptyHistory,
+	settings: {
+		defaults: HISTORY_DEFAULTS,
+		registered: config
+	},
+	create: createHistoryController
+});
+//#endregion
+//#region src/state.ts
+/**
+* The history page's State table as code: what `useHistoryState()` returns,
+* and the same fields in every other framework. What the undo and redo
+* buttons read.
+*/
+const historyState = defineState(HistoryToken, {
+	read: (history) => ({
+		canUndo: history.canUndo(),
+		canRedo: history.canRedo(),
+		undoLabel: history.getUndoLabel(),
+		redoLabel: history.getRedoLabel()
+	}),
+	empty: {
+		canUndo: false,
+		canRedo: false,
+		undoLabel: null,
+		redoLabel: null
+	}
+});
+//#endregion
+export { HISTORY_DEFAULTS, HistoryToken, historyPlugin, historyState };
+
+//# sourceMappingURL=index.js.map