@lexical/history 0.38.0 → 0.38.1

package/{src/index.ts → LexicalHistory.dev.mjs}

@@ -6,126 +6,59 @@
  *
  */
 
-import type {EditorState, LexicalEditor, LexicalNode, NodeKey} from 'lexical';
+import { namedSignals, effect, batch, getPeerDependencyFromEditor } from '@lexical/extension';
+import { mergeRegister } from '@lexical/utils';
+import { defineExtension, safeCast, configExtension, UNDO_COMMAND, COMMAND_PRIORITY_EDITOR, REDO_COMMAND, CLEAR_EDITOR_COMMAND, CLEAR_HISTORY_COMMAND, CAN_REDO_COMMAND, CAN_UNDO_COMMAND, HISTORIC_TAG, HISTORY_PUSH_TAG, HISTORY_MERGE_TAG, $isRangeSelection, $isTextNode, $isRootNode } from 'lexical';
 
-import {
-  batch,
-  effect,
-  getPeerDependencyFromEditor,
-  namedSignals,
-  ReadonlySignal,
-} from '@lexical/extension';
-import {mergeRegister} from '@lexical/utils';
-import {
-  $isRangeSelection,
-  $isRootNode,
-  $isTextNode,
-  CAN_REDO_COMMAND,
-  CAN_UNDO_COMMAND,
-  CLEAR_EDITOR_COMMAND,
-  CLEAR_HISTORY_COMMAND,
-  COMMAND_PRIORITY_EDITOR,
-  configExtension,
-  defineExtension,
-  HISTORIC_TAG,
-  HISTORY_MERGE_TAG,
-  HISTORY_PUSH_TAG,
-  REDO_COMMAND,
-  safeCast,
-  UNDO_COMMAND,
-} from 'lexical';
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
 
-type MergeAction = 0 | 1 | 2;
 const HISTORY_MERGE = 0;
 const HISTORY_PUSH = 1;
 const DISCARD_HISTORY_CANDIDATE = 2;
-
-type ChangeType = 0 | 1 | 2 | 3 | 4;
 const OTHER = 0;
 const COMPOSING_CHARACTER = 1;
 const INSERT_CHARACTER_AFTER_SELECTION = 2;
 const DELETE_CHARACTER_BEFORE_SELECTION = 3;
 const DELETE_CHARACTER_AFTER_SELECTION = 4;
-
-export type HistoryStateEntry = {
-  editor: LexicalEditor;
-  editorState: EditorState;
-};
-export type HistoryState = {
-  current: null | HistoryStateEntry;
-  redoStack: Array<HistoryStateEntry>;
-  undoStack: Array<HistoryStateEntry>;
-};
-
-type IntentionallyMarkedAsDirtyElement = boolean;
-
-function getDirtyNodes(
-  editorState: EditorState,
-  dirtyLeaves: Set<NodeKey>,
-  dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>,
-): Array<LexicalNode> {
+function getDirtyNodes(editorState, dirtyLeaves, dirtyElements) {
   const nodeMap = editorState._nodeMap;
   const nodes = [];
-
   for (const dirtyLeafKey of dirtyLeaves) {
     const dirtyLeaf = nodeMap.get(dirtyLeafKey);
-
     if (dirtyLeaf !== undefined) {
       nodes.push(dirtyLeaf);
     }
   }
-
   for (const [dirtyElementKey, intentionallyMarkedAsDirty] of dirtyElements) {
     if (!intentionallyMarkedAsDirty) {
       continue;
     }
-
     const dirtyElement = nodeMap.get(dirtyElementKey);
-
     if (dirtyElement !== undefined && !$isRootNode(dirtyElement)) {
       nodes.push(dirtyElement);
     }
   }
-
   return nodes;
 }
-
-function getChangeType(
-  prevEditorState: null | EditorState,
-  nextEditorState: EditorState,
-  dirtyLeavesSet: Set<NodeKey>,
-  dirtyElementsSet: Map<NodeKey, IntentionallyMarkedAsDirtyElement>,
-  isComposing: boolean,
-): ChangeType {
-  if (
-    prevEditorState === null ||
-    (dirtyLeavesSet.size === 0 && dirtyElementsSet.size === 0 && !isComposing)
-  ) {
+function getChangeType(prevEditorState, nextEditorState, dirtyLeavesSet, dirtyElementsSet, isComposing) {
+  if (prevEditorState === null || dirtyLeavesSet.size === 0 && dirtyElementsSet.size === 0 && !isComposing) {
     return OTHER;
   }
-
   const nextSelection = nextEditorState._selection;
   const prevSelection = prevEditorState._selection;
-
   if (isComposing) {
     return COMPOSING_CHARACTER;
   }
-
-  if (
-    !$isRangeSelection(nextSelection) ||
-    !$isRangeSelection(prevSelection) ||
-    !prevSelection.isCollapsed() ||
-    !nextSelection.isCollapsed()
-  ) {
+  if (!$isRangeSelection(nextSelection) || !$isRangeSelection(prevSelection) || !prevSelection.isCollapsed() || !nextSelection.isCollapsed()) {
     return OTHER;
   }
-
-  const dirtyNodes = getDirtyNodes(
-    nextEditorState,
-    dirtyLeavesSet,
-    dirtyElementsSet,
-  );
-
+  const dirtyNodes = getDirtyNodes(nextEditorState, dirtyLeavesSet, dirtyElementsSet);
   if (dirtyNodes.length === 0) {
     return OTHER;
   }
@@ -136,123 +69,58 @@ function getChangeType(
     const nextNodeMap = nextEditorState._nodeMap;
     const nextAnchorNode = nextNodeMap.get(nextSelection.anchor.key);
     const prevAnchorNode = nextNodeMap.get(prevSelection.anchor.key);
-
-    if (
-      nextAnchorNode &&
-      prevAnchorNode &&
-      !prevEditorState._nodeMap.has(nextAnchorNode.__key) &&
-      $isTextNode(nextAnchorNode) &&
-      nextAnchorNode.__text.length === 1 &&
-      nextSelection.anchor.offset === 1
-    ) {
+    if (nextAnchorNode && prevAnchorNode && !prevEditorState._nodeMap.has(nextAnchorNode.__key) && $isTextNode(nextAnchorNode) && nextAnchorNode.__text.length === 1 && nextSelection.anchor.offset === 1) {
       return INSERT_CHARACTER_AFTER_SELECTION;
     }
-
     return OTHER;
   }
-
   const nextDirtyNode = dirtyNodes[0];
-
   const prevDirtyNode = prevEditorState._nodeMap.get(nextDirtyNode.__key);
-
-  if (
-    !$isTextNode(prevDirtyNode) ||
-    !$isTextNode(nextDirtyNode) ||
-    prevDirtyNode.__mode !== nextDirtyNode.__mode
-  ) {
+  if (!$isTextNode(prevDirtyNode) || !$isTextNode(nextDirtyNode) || prevDirtyNode.__mode !== nextDirtyNode.__mode) {
     return OTHER;
   }
-
   const prevText = prevDirtyNode.__text;
   const nextText = nextDirtyNode.__text;
-
   if (prevText === nextText) {
     return OTHER;
   }
-
   const nextAnchor = nextSelection.anchor;
   const prevAnchor = prevSelection.anchor;
-
   if (nextAnchor.key !== prevAnchor.key || nextAnchor.type !== 'text') {
     return OTHER;
   }
-
   const nextAnchorOffset = nextAnchor.offset;
   const prevAnchorOffset = prevAnchor.offset;
   const textDiff = nextText.length - prevText.length;
-
   if (textDiff === 1 && prevAnchorOffset === nextAnchorOffset - 1) {
     return INSERT_CHARACTER_AFTER_SELECTION;
   }
-
   if (textDiff === -1 && prevAnchorOffset === nextAnchorOffset + 1) {
     return DELETE_CHARACTER_BEFORE_SELECTION;
   }
-
   if (textDiff === -1 && prevAnchorOffset === nextAnchorOffset) {
     return DELETE_CHARACTER_AFTER_SELECTION;
   }
-
   return OTHER;
 }
-
-function isTextNodeUnchanged(
-  key: NodeKey,
-  prevEditorState: EditorState,
-  nextEditorState: EditorState,
-): boolean {
+function isTextNodeUnchanged(key, prevEditorState, nextEditorState) {
   const prevNode = prevEditorState._nodeMap.get(key);
   const nextNode = nextEditorState._nodeMap.get(key);
-
   const prevSelection = prevEditorState._selection;
   const nextSelection = nextEditorState._selection;
-  const isDeletingLine =
-    $isRangeSelection(prevSelection) &&
-    $isRangeSelection(nextSelection) &&
-    prevSelection.anchor.type === 'element' &&
-    prevSelection.focus.type === 'element' &&
-    nextSelection.anchor.type === 'text' &&
-    nextSelection.focus.type === 'text';
-
-  if (
-    !isDeletingLine &&
-    $isTextNode(prevNode) &&
-    $isTextNode(nextNode) &&
-    prevNode.__parent === nextNode.__parent
-  ) {
+  const isDeletingLine = $isRangeSelection(prevSelection) && $isRangeSelection(nextSelection) && prevSelection.anchor.type === 'element' && prevSelection.focus.type === 'element' && nextSelection.anchor.type === 'text' && nextSelection.focus.type === 'text';
+  if (!isDeletingLine && $isTextNode(prevNode) && $isTextNode(nextNode) && prevNode.__parent === nextNode.__parent) {
     // This has the assumption that object key order won't change if the
     // content did not change, which should normally be safe given
     // the manner in which nodes and exportJSON are typically implemented.
-    return (
-      JSON.stringify(prevEditorState.read(() => prevNode.exportJSON())) ===
-      JSON.stringify(nextEditorState.read(() => nextNode.exportJSON()))
-    );
+    return JSON.stringify(prevEditorState.read(() => prevNode.exportJSON())) === JSON.stringify(nextEditorState.read(() => nextNode.exportJSON()));
   }
   return false;
 }
-
-function createMergeActionGetter(
-  editor: LexicalEditor,
-  delayOrStore: number | ReadonlySignal<number>,
-): (
-  prevEditorState: null | EditorState,
-  nextEditorState: EditorState,
-  currentHistoryEntry: null | HistoryStateEntry,
-  dirtyLeaves: Set<NodeKey>,
-  dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>,
-  tags: Set<string>,
-) => MergeAction {
+function createMergeActionGetter(editor, delayOrStore) {
   let prevChangeTime = Date.now();
   let prevChangeType = OTHER;
-
-  return (
-    prevEditorState,
-    nextEditorState,
-    currentHistoryEntry,
-    dirtyLeaves,
-    dirtyElements,
-    tags,
-  ) => {
+  return (prevEditorState, nextEditorState, currentHistoryEntry, dirtyLeaves, dirtyElements, tags) => {
     const changeTime = Date.now();
 
     // If applying changes from history stack there's no need
@@ -262,50 +130,27 @@ function createMergeActionGetter(
       prevChangeTime = changeTime;
       return DISCARD_HISTORY_CANDIDATE;
     }
-
-    const changeType = getChangeType(
-      prevEditorState,
-      nextEditorState,
-      dirtyLeaves,
-      dirtyElements,
-      editor.isComposing(),
-    );
-
+    const changeType = getChangeType(prevEditorState, nextEditorState, dirtyLeaves, dirtyElements, editor.isComposing());
     const mergeAction = (() => {
-      const isSameEditor =
-        currentHistoryEntry === null || currentHistoryEntry.editor === editor;
+      const isSameEditor = currentHistoryEntry === null || currentHistoryEntry.editor === editor;
       const shouldPushHistory = tags.has(HISTORY_PUSH_TAG);
-      const shouldMergeHistory =
-        !shouldPushHistory && isSameEditor && tags.has(HISTORY_MERGE_TAG);
-
+      const shouldMergeHistory = !shouldPushHistory && isSameEditor && tags.has(HISTORY_MERGE_TAG);
       if (shouldMergeHistory) {
         return HISTORY_MERGE;
       }
-
       if (prevEditorState === null) {
         return HISTORY_PUSH;
       }
-
       const selection = nextEditorState._selection;
       const hasDirtyNodes = dirtyLeaves.size > 0 || dirtyElements.size > 0;
-
       if (!hasDirtyNodes) {
         if (selection !== null) {
           return HISTORY_MERGE;
         }
-
         return DISCARD_HISTORY_CANDIDATE;
       }
-
-      const delay =
-        typeof delayOrStore === 'number' ? delayOrStore : delayOrStore.peek();
-      if (
-        shouldPushHistory === false &&
-        changeType !== OTHER &&
-        changeType === prevChangeType &&
-        changeTime < prevChangeTime + delay &&
-        isSameEditor
-      ) {
+      const delay = typeof delayOrStore === 'number' ? delayOrStore : delayOrStore.peek();
+      if (shouldPushHistory === false && changeType !== OTHER && changeType === prevChangeType && changeTime < prevChangeTime + delay && isSameEditor) {
         return HISTORY_MERGE;
       }
 
@@ -313,80 +158,61 @@ function createMergeActionGetter(
       // due to some node transform reverting the change.
       if (dirtyLeaves.size === 1) {
         const dirtyLeafKey = Array.from(dirtyLeaves)[0];
-        if (
-          isTextNodeUnchanged(dirtyLeafKey, prevEditorState, nextEditorState)
-        ) {
+        if (isTextNodeUnchanged(dirtyLeafKey, prevEditorState, nextEditorState)) {
           return HISTORY_MERGE;
         }
       }
-
       return HISTORY_PUSH;
     })();
-
     prevChangeTime = changeTime;
     prevChangeType = changeType;
-
     return mergeAction;
   };
 }
-
-function redo(editor: LexicalEditor, historyState: HistoryState): void {
+function redo(editor, historyState) {
   const redoStack = historyState.redoStack;
   const undoStack = historyState.undoStack;
-
   if (redoStack.length !== 0) {
     const current = historyState.current;
-
     if (current !== null) {
       undoStack.push(current);
       editor.dispatchCommand(CAN_UNDO_COMMAND, true);
     }
-
     const historyStateEntry = redoStack.pop();
-
     if (redoStack.length === 0) {
       editor.dispatchCommand(CAN_REDO_COMMAND, false);
     }
-
     historyState.current = historyStateEntry || null;
-
     if (historyStateEntry) {
       historyStateEntry.editor.setEditorState(historyStateEntry.editorState, {
-        tag: HISTORIC_TAG,
+        tag: HISTORIC_TAG
       });
     }
   }
 }
-
-function undo(editor: LexicalEditor, historyState: HistoryState): void {
+function undo(editor, historyState) {
   const redoStack = historyState.redoStack;
   const undoStack = historyState.undoStack;
   const undoStackLength = undoStack.length;
-
   if (undoStackLength !== 0) {
     const current = historyState.current;
     const historyStateEntry = undoStack.pop();
-
     if (current !== null) {
       redoStack.push(current);
       editor.dispatchCommand(CAN_REDO_COMMAND, true);
     }
-
     if (undoStack.length === 0) {
       editor.dispatchCommand(CAN_UNDO_COMMAND, false);
     }
-
     historyState.current = historyStateEntry || null;
-
     if (historyStateEntry) {
       historyStateEntry.editor.setEditorState(historyStateEntry.editorState, {
-        tag: HISTORIC_TAG,
+        tag: HISTORIC_TAG
       });
     }
   }
 }
-
-function clearHistory(historyState: HistoryState) {
+function clearHistory(historyState) {
   historyState.undoStack = [];
   historyState.redoStack = [];
   historyState.current = null;
@@ -401,53 +227,31 @@ function clearHistory(historyState: HistoryState) {
  * instead of merging the current changes with the current stack.
  * @returns The listeners cleanup callback function.
  */
-export function registerHistory(
-  editor: LexicalEditor,
-  historyState: HistoryState,
-  delay: number | ReadonlySignal<number>,
-): () => void {
+function registerHistory(editor, historyState, delay) {
   const getMergeAction = createMergeActionGetter(editor, delay);
-
   const applyChange = ({
     editorState,
     prevEditorState,
     dirtyLeaves,
     dirtyElements,
-    tags,
-  }: {
-    editorState: EditorState;
-    prevEditorState: EditorState;
-    dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>;
-    dirtyLeaves: Set<NodeKey>;
-    tags: Set<string>;
-  }): void => {
+    tags
+  }) => {
     const current = historyState.current;
     const redoStack = historyState.redoStack;
     const undoStack = historyState.undoStack;
     const currentEditorState = current === null ? null : current.editorState;
-
     if (current !== null && editorState === currentEditorState) {
       return;
     }
-
-    const mergeAction = getMergeAction(
-      prevEditorState,
-      editorState,
-      current,
-      dirtyLeaves,
-      dirtyElements,
-      tags,
-    );
-
+    const mergeAction = getMergeAction(prevEditorState, editorState, current, dirtyLeaves, dirtyElements, tags);
     if (mergeAction === HISTORY_PUSH) {
       if (redoStack.length !== 0) {
         historyState.redoStack = [];
         editor.dispatchCommand(CAN_REDO_COMMAND, false);
       }
-
       if (current !== null) {
         undoStack.push({
-          ...current,
+          ...current
         });
         editor.dispatchCommand(CAN_UNDO_COMMAND, true);
       }
@@ -458,48 +262,24 @@ export function registerHistory(
     // Else we merge
     historyState.current = {
       editor,
-      editorState,
+      editorState
     };
   };
-
-  const unregister = mergeRegister(
-    editor.registerCommand(
-      UNDO_COMMAND,
-      () => {
-        undo(editor, historyState);
-        return true;
-      },
-      COMMAND_PRIORITY_EDITOR,
-    ),
-    editor.registerCommand(
-      REDO_COMMAND,
-      () => {
-        redo(editor, historyState);
-        return true;
-      },
-      COMMAND_PRIORITY_EDITOR,
-    ),
-    editor.registerCommand(
-      CLEAR_EDITOR_COMMAND,
-      () => {
-        clearHistory(historyState);
-        return false;
-      },
-      COMMAND_PRIORITY_EDITOR,
-    ),
-    editor.registerCommand(
-      CLEAR_HISTORY_COMMAND,
-      () => {
-        clearHistory(historyState);
-        editor.dispatchCommand(CAN_REDO_COMMAND, false);
-        editor.dispatchCommand(CAN_UNDO_COMMAND, false);
-        return true;
-      },
-      COMMAND_PRIORITY_EDITOR,
-    ),
-    editor.registerUpdateListener(applyChange),
-  );
-
+  const unregister = mergeRegister(editor.registerCommand(UNDO_COMMAND, () => {
+    undo(editor, historyState);
+    return true;
+  }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(REDO_COMMAND, () => {
+    redo(editor, historyState);
+    return true;
+  }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(CLEAR_EDITOR_COMMAND, () => {
+    clearHistory(historyState);
+    return false;
+  }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(CLEAR_HISTORY_COMMAND, () => {
+    clearHistory(historyState);
+    editor.dispatchCommand(CAN_REDO_COMMAND, false);
+    editor.dispatchCommand(CAN_UNDO_COMMAND, false);
+    return true;
+  }, COMMAND_PRIORITY_EDITOR), editor.registerUpdateListener(applyChange));
   return unregister;
 }
 
@@ -507,65 +287,41 @@ export function registerHistory(
  * Creates an empty history state.
  * @returns - The empty history state, as an object.
  */
-export function createEmptyHistoryState(): HistoryState {
+function createEmptyHistoryState() {
   return {
     current: null,
     redoStack: [],
-    undoStack: [],
+    undoStack: []
   };
 }
-
-export interface HistoryConfig {
-  /**
-   * The time (in milliseconds) the editor should delay generating a new history stack,
-   * instead of merging the current changes with the current stack. The default is 300ms.
-   */
-  delay: number;
-  /**
-   * The initial history state, the default is {@link createEmptyHistoryState}.
-   */
-  createInitialHistoryState: (editor: LexicalEditor) => HistoryState;
-  /**
-   * Whether history is disabled or not
-   */
-  disabled: boolean;
-}
-
 /**
  * Registers necessary listeners to manage undo/redo history stack and related
  * editor commands, via the \@lexical/history module.
  */
 
-export const HistoryExtension = defineExtension({
-  build: (editor, {delay, createInitialHistoryState, disabled}) =>
-    namedSignals({
-      delay,
-      disabled,
-      historyState: createInitialHistoryState(editor),
-    }),
-  config: safeCast<HistoryConfig>({
+const HistoryExtension = defineExtension({
+  build: (editor, {
+    delay,
+    createInitialHistoryState,
+    disabled
+  }) => namedSignals({
+    delay,
+    disabled,
+    historyState: createInitialHistoryState(editor)
+  }),
+  config: safeCast({
     createInitialHistoryState: createEmptyHistoryState,
     delay: 300,
-    disabled: typeof window === 'undefined',
+    disabled: typeof window === 'undefined'
   }),
   name: '@lexical/history/History',
   register: (editor, config, state) => {
     const stores = state.getOutput();
-    return effect(() =>
-      stores.disabled.value
-        ? undefined
-        : registerHistory(editor, stores.historyState.value, stores.delay),
-    );
-  },
+    return effect(() => stores.disabled.value ? undefined : registerHistory(editor, stores.historyState.value, stores.delay));
+  }
 });
-
-function getHistoryPeer(editor: LexicalEditor | null | undefined) {
-  return editor
-    ? getPeerDependencyFromEditor<typeof HistoryExtension>(
-        editor,
-        HistoryExtension.name,
-      )
-    : null;
+function getHistoryPeer(editor) {
+  return editor ? getPeerDependencyFromEditor(editor, HistoryExtension.name) : null;
 }
 
 /**
@@ -573,30 +329,30 @@ function getHistoryPeer(editor: LexicalEditor | null | undefined) {
  * editor commands, via the \@lexical/history module, only if the parent editor
  * has a history plugin implementation.
  */
-export const SharedHistoryExtension = defineExtension({
-  dependencies: [
-    configExtension(HistoryExtension, {
-      createInitialHistoryState: () => {
-        throw new Error('SharedHistory did not inherit parent history');
-      },
-      disabled: true,
-    }),
-  ],
+const SharedHistoryExtension = defineExtension({
+  dependencies: [configExtension(HistoryExtension, {
+    createInitialHistoryState: () => {
+      throw new Error('SharedHistory did not inherit parent history');
+    },
+    disabled: true
+  })],
   name: '@lexical/history/SharedHistory',
   register(editor, _config, state) {
-    const {output} = state.getDependency(HistoryExtension);
+    const {
+      output
+    } = state.getDependency(HistoryExtension);
     const parentPeer = getHistoryPeer(editor._parentEditor);
     if (!parentPeer) {
       return () => {};
     }
     const parentOutput = parentPeer.output;
-    return effect(() =>
-      batch(() => {
-        output.delay.value = parentOutput.delay.value;
-        output.historyState.value = parentOutput.historyState.value;
-        // Note that toggling the parent history will force this to be changed
-        output.disabled.value = parentOutput.disabled.value;
-      }),
-    );
-  },
+    return effect(() => batch(() => {
+      output.delay.value = parentOutput.delay.value;
+      output.historyState.value = parentOutput.historyState.value;
+      // Note that toggling the parent history will force this to be changed
+      output.disabled.value = parentOutput.disabled.value;
+    }));
+  }
 });
+
+export { HistoryExtension, SharedHistoryExtension, createEmptyHistoryState, registerHistory };

package/LexicalHistory.js

@@ -6,6 +6,6 @@
  *
  */
 
-'use strict';
-
-module.exports = require('./dist/LexicalHistory.js');
+'use strict'
+const LexicalHistory = process.env.NODE_ENV !== 'production' ? require('./LexicalHistory.dev.js') : require('./LexicalHistory.prod.js');
+module.exports = LexicalHistory;

package/LexicalHistory.mjs

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import * as modDev from './LexicalHistory.dev.mjs';
+import * as modProd from './LexicalHistory.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const HistoryExtension = mod.HistoryExtension;
+export const SharedHistoryExtension = mod.SharedHistoryExtension;
+export const createEmptyHistoryState = mod.createEmptyHistoryState;
+export const registerHistory = mod.registerHistory;