@lexical/history 0.37.1-nightly.20251027.0 → 0.38.0

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

@@ -6,59 +6,126 @@
  *
  */
 
-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 type {EditorState, LexicalEditor, LexicalNode, NodeKey} 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.
- *
- */
+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';
 
+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;
-function getDirtyNodes(editorState, dirtyLeaves, dirtyElements) {
+
+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> {
   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, nextEditorState, dirtyLeavesSet, dirtyElementsSet, isComposing) {
-  if (prevEditorState === null || dirtyLeavesSet.size === 0 && dirtyElementsSet.size === 0 && !isComposing) {
+
+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)
+  ) {
     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;
   }
@@ -69,58 +136,123 @@ function getChangeType(prevEditorState, nextEditorState, dirtyLeavesSet, dirtyEl
     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, prevEditorState, nextEditorState) {
+
+function isTextNodeUnchanged(
+  key: NodeKey,
+  prevEditorState: EditorState,
+  nextEditorState: EditorState,
+): boolean {
   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, delayOrStore) {
+
+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 {
   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
@@ -130,27 +262,50 @@ function createMergeActionGetter(editor, delayOrStore) {
       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;
       }
 
@@ -158,61 +313,80 @@ function createMergeActionGetter(editor, delayOrStore) {
       // 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, historyState) {
+
+function redo(editor: LexicalEditor, historyState: HistoryState): void {
   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, historyState) {
+
+function undo(editor: LexicalEditor, historyState: HistoryState): void {
   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) {
+
+function clearHistory(historyState: HistoryState) {
   historyState.undoStack = [];
   historyState.redoStack = [];
   historyState.current = null;
@@ -227,31 +401,53 @@ function clearHistory(historyState) {
  * instead of merging the current changes with the current stack.
  * @returns The listeners cleanup callback function.
  */
-function registerHistory(editor, historyState, delay) {
+export function registerHistory(
+  editor: LexicalEditor,
+  historyState: HistoryState,
+  delay: number | ReadonlySignal<number>,
+): () => void {
   const getMergeAction = createMergeActionGetter(editor, delay);
+
   const applyChange = ({
     editorState,
     prevEditorState,
     dirtyLeaves,
     dirtyElements,
-    tags
-  }) => {
+    tags,
+  }: {
+    editorState: EditorState;
+    prevEditorState: EditorState;
+    dirtyElements: Map<NodeKey, IntentionallyMarkedAsDirtyElement>;
+    dirtyLeaves: Set<NodeKey>;
+    tags: Set<string>;
+  }): void => {
     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);
       }
@@ -262,24 +458,48 @@ function registerHistory(editor, historyState, delay) {
     // 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;
 }
 
@@ -287,41 +507,65 @@ function registerHistory(editor, historyState, delay) {
  * Creates an empty history state.
  * @returns - The empty history state, as an object.
  */
-function createEmptyHistoryState() {
+export function createEmptyHistoryState(): HistoryState {
   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.
  */
 
-const HistoryExtension = defineExtension({
-  build: (editor, {
-    delay,
-    createInitialHistoryState,
-    disabled
-  }) => namedSignals({
-    delay,
-    disabled,
-    historyState: createInitialHistoryState(editor)
-  }),
-  config: safeCast({
+export const HistoryExtension = defineExtension({
+  build: (editor, {delay, createInitialHistoryState, disabled}) =>
+    namedSignals({
+      delay,
+      disabled,
+      historyState: createInitialHistoryState(editor),
+    }),
+  config: safeCast<HistoryConfig>({
     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) {
-  return editor ? getPeerDependencyFromEditor(editor, HistoryExtension.name) : null;
+
+function getHistoryPeer(editor: LexicalEditor | null | undefined) {
+  return editor
+    ? getPeerDependencyFromEditor<typeof HistoryExtension>(
+        editor,
+        HistoryExtension.name,
+      )
+    : null;
 }
 
 /**
@@ -329,30 +573,30 @@ function getHistoryPeer(editor) {
  * editor commands, via the \@lexical/history module, only if the parent editor
  * has a history plugin implementation.
  */
-const SharedHistoryExtension = defineExtension({
-  dependencies: [configExtension(HistoryExtension, {
-    createInitialHistoryState: () => {
-      throw new Error('SharedHistory did not inherit parent history');
-    },
-    disabled: true
-  })],
+export 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/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) Meta Platforms, Inc. and affiliates.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.