zurfyx-lexical-react 0.39.1-nightly.20251225.0

package/npm/LexicalExtensionComposer.dev.js

@@ -0,0 +1,105 @@
+/**
+ * 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.
+ *
+ */
+
+'use strict';
+
+var extension = require('@lexical/extension');
+var ReactExtension = require('@lexical/react/ReactExtension');
+var ReactProviderExtension = require('@lexical/react/ReactProviderExtension');
+var lexical = require('lexical');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+/**
+ * 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.
+ *
+ */
+/**
+ * The equivalent of LexicalComposer for an extension. Make sure that your extension
+ * argument is stable (e.g. using module scope or useMemo) so
+ * that you are not re-creating the editor on every render!
+ *
+ * @example
+ * Module scoped extension
+ * ```tsx
+ * const extension = defineExtension({
+ *   name: "[root]",
+ *   dependencies: [RichTextExtension, HistoryExtension, EmojiExtension]
+ * });
+ * function MyEditor({ children }) {
+ *   return (<LexicalExtensionComposer extension={extension}>{children}</LexicalExtensionComposer>);
+ * }
+ * ```
+ *
+ * @example
+ * useMemo extension
+ * ```tsx
+ * function MyEditor({ emojiBaseUrl, children }) {
+ *   const extension = useMemo(() => {
+ *     return defineExtension({
+ *       name: "[root]",
+ *       dependencies: [
+ *         RichTextExtension,
+ *         HistoryExtension,
+ *         configExtension(EmojiExtension, { emojiBaseUrl }),
+ *       ],
+ *     });
+ *   }, [emojiBaseUrl]);
+ *   return (<LexicalExtensionComposer extension={extension}>{children}</LexicalExtensionComposer>);
+ * }
+ * ```
+ *
+ * @example
+ * Incorrect usage with unstable extension
+ * ```tsx
+ * function MyBrokenEditor({ emojiBaseUrl }) {
+ *   // This argument is not stable, the editor is re-created every render and
+ *   // all state is lost!
+ *   const extension = defineExtension({
+ *     name: "[root]",
+ *     dependencies: [RichTextExtension, HistoryExtension, EmojiExtension]
+ *   });
+ *   return (<LexicalExtensionComposer extension={extension}>{children}</LexicalExtensionComposer>);
+ * }
+ * ```
+ */
+function LexicalExtensionComposer({
+  extension: extension$1,
+  children,
+  contentEditable
+}) {
+  const editor = react.useMemo(() => {
+    const builder = extension.LexicalBuilder.fromExtensions([ReactProviderExtension.ReactProviderExtension, lexical.configExtension(ReactExtension.ReactExtension, contentEditable === undefined ? {} : {
+      contentEditable
+    }), extension$1]);
+    return builder.buildEditor();
+  }, [contentEditable, extension$1]);
+  react.useEffect(() => {
+    // Strict mode workaround
+    let didMount = false;
+    queueMicrotask(() => {
+      didMount = true;
+    });
+    return () => {
+      if (didMount) {
+        editor.dispose();
+      }
+    };
+  }, [editor]);
+  const {
+    Component
+  } = extension.getExtensionDependencyFromEditor(editor, ReactExtension.ReactExtension).output;
+  return /*#__PURE__*/jsxRuntime.jsx(Component, {
+    children: children
+  });
+}
+
+exports.LexicalExtensionComposer = LexicalExtensionComposer;

package/npm/LexicalExtensionComposer.dev.mjs

@@ -0,0 +1,103 @@
+/**
+ * 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 { LexicalBuilder, getExtensionDependencyFromEditor } from '@lexical/extension';
+import { ReactExtension } from '@lexical/react/ReactExtension';
+import { ReactProviderExtension } from '@lexical/react/ReactProviderExtension';
+import { configExtension } from 'lexical';
+import { useMemo, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+/**
+ * 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.
+ *
+ */
+/**
+ * The equivalent of LexicalComposer for an extension. Make sure that your extension
+ * argument is stable (e.g. using module scope or useMemo) so
+ * that you are not re-creating the editor on every render!
+ *
+ * @example
+ * Module scoped extension
+ * ```tsx
+ * const extension = defineExtension({
+ *   name: "[root]",
+ *   dependencies: [RichTextExtension, HistoryExtension, EmojiExtension]
+ * });
+ * function MyEditor({ children }) {
+ *   return (<LexicalExtensionComposer extension={extension}>{children}</LexicalExtensionComposer>);
+ * }
+ * ```
+ *
+ * @example
+ * useMemo extension
+ * ```tsx
+ * function MyEditor({ emojiBaseUrl, children }) {
+ *   const extension = useMemo(() => {
+ *     return defineExtension({
+ *       name: "[root]",
+ *       dependencies: [
+ *         RichTextExtension,
+ *         HistoryExtension,
+ *         configExtension(EmojiExtension, { emojiBaseUrl }),
+ *       ],
+ *     });
+ *   }, [emojiBaseUrl]);
+ *   return (<LexicalExtensionComposer extension={extension}>{children}</LexicalExtensionComposer>);
+ * }
+ * ```
+ *
+ * @example
+ * Incorrect usage with unstable extension
+ * ```tsx
+ * function MyBrokenEditor({ emojiBaseUrl }) {
+ *   // This argument is not stable, the editor is re-created every render and
+ *   // all state is lost!
+ *   const extension = defineExtension({
+ *     name: "[root]",
+ *     dependencies: [RichTextExtension, HistoryExtension, EmojiExtension]
+ *   });
+ *   return (<LexicalExtensionComposer extension={extension}>{children}</LexicalExtensionComposer>);
+ * }
+ * ```
+ */
+function LexicalExtensionComposer({
+  extension,
+  children,
+  contentEditable
+}) {
+  const editor = useMemo(() => {
+    const builder = LexicalBuilder.fromExtensions([ReactProviderExtension, configExtension(ReactExtension, contentEditable === undefined ? {} : {
+      contentEditable
+    }), extension]);
+    return builder.buildEditor();
+  }, [contentEditable, extension]);
+  useEffect(() => {
+    // Strict mode workaround
+    let didMount = false;
+    queueMicrotask(() => {
+      didMount = true;
+    });
+    return () => {
+      if (didMount) {
+        editor.dispose();
+      }
+    };
+  }, [editor]);
+  const {
+    Component
+  } = getExtensionDependencyFromEditor(editor, ReactExtension).output;
+  return /*#__PURE__*/jsx(Component, {
+    children: children
+  });
+}
+
+export { LexicalExtensionComposer };

package/npm/LexicalExtensionComposer.js

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ *
+ */
+
+'use strict'
+const LexicalExtensionComposer = process.env.NODE_ENV !== 'production' ? require('./LexicalExtensionComposer.dev.js') : require('./LexicalExtensionComposer.prod.js');
+module.exports = LexicalExtensionComposer;

package/npm/LexicalExtensionComposer.js.flow

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+/**
+ * LexicalExtensionComposer
+ */
+import type {AnyLexicalExtensionArgument} from 'lexical';
+import type {ReactConfig} from '@lexical/react/ReactExtension';
+export type LexicalExtensionComposerProps = {
+  extension: AnyLexicalExtensionArgument;
+  children: React.Node;
+  contentEditable?: ReactConfig['contentEditable'];
+}
+declare export function LexicalExtensionComposer(props: LexicalExtensionComposerProps): React.Node;

package/npm/LexicalExtensionComposer.mjs

@@ -0,0 +1,12 @@
+/**
+ * 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 './LexicalExtensionComposer.dev.mjs';
+import * as modProd from './LexicalExtensionComposer.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const LexicalExtensionComposer = mod.LexicalExtensionComposer;

package/npm/LexicalExtensionComposer.node.mjs

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV !== 'production' ? import('./LexicalExtensionComposer.dev.mjs') : import('./LexicalExtensionComposer.prod.mjs'));
+export const LexicalExtensionComposer = mod.LexicalExtensionComposer;

package/npm/LexicalExtensionComposer.prod.js

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ *
+ */
+
+"use strict";var e=require("@lexical/extension"),t=require("@lexical/react/ReactExtension"),i=require("@lexical/react/ReactProviderExtension"),n=require("lexical"),r=require("react"),o=require("react/jsx-runtime");exports.LexicalExtensionComposer=function({extension:c,children:s,contentEditable:x}){const a=r.useMemo(()=>e.LexicalBuilder.fromExtensions([i.ReactProviderExtension,n.configExtension(t.ReactExtension,void 0===x?{}:{contentEditable:x}),c]).buildEditor(),[x,c]);r.useEffect(()=>{let e=!1;return queueMicrotask(()=>{e=!0}),()=>{e&&a.dispose()}},[a]);const{Component:u}=e.getExtensionDependencyFromEditor(a,t.ReactExtension).output;return o.jsx(u,{children:s})};

package/npm/LexicalExtensionComposer.prod.mjs

@@ -0,0 +1,9 @@
+/**
+ * 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{LexicalBuilder as t,getExtensionDependencyFromEditor as e}from"@lexical/extension";import{ReactExtension as o}from"@lexical/react/ReactExtension";import{ReactProviderExtension as r}from"@lexical/react/ReactProviderExtension";import{configExtension as i}from"lexical";import{useMemo as n,useEffect as c}from"react";import{jsx as m}from"react/jsx-runtime";function l({extension:l,children:a,contentEditable:s}){const x=n(()=>t.fromExtensions([r,i(o,void 0===s?{}:{contentEditable:s}),l]).buildEditor(),[s,l]);c(()=>{let t=!1;return queueMicrotask(()=>{t=!0}),()=>{t&&x.dispose()}},[x]);const{Component:p}=e(x,o).output;return m(p,{children:a})}export{l as LexicalExtensionComposer};

package/npm/LexicalHashtagPlugin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 type { JSX } from 'react';
+export declare function HashtagPlugin(): JSX.Element | null;

package/npm/LexicalHashtagPlugin.dev.js

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ *
+ */
+
+'use strict';
+
+var hashtag = require('@lexical/hashtag');
+var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
+var react = require('react');
+
+/**
+ * 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.
+ *
+ */
+
+function HashtagPlugin() {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  react.useEffect(() => {
+    if (!editor.hasNodes([hashtag.HashtagNode])) {
+      throw new Error('HashtagPlugin: HashtagNode not registered on editor');
+    }
+    return hashtag.registerLexicalHashtag(editor);
+  }, [editor]);
+  return null;
+}
+
+exports.HashtagPlugin = HashtagPlugin;

package/npm/LexicalHashtagPlugin.dev.mjs

@@ -0,0 +1,32 @@
+/**
+ * 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 { HashtagNode, registerLexicalHashtag } from '@lexical/hashtag';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useEffect } from 'react';
+
+/**
+ * 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.
+ *
+ */
+
+function HashtagPlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    if (!editor.hasNodes([HashtagNode])) {
+      throw new Error('HashtagPlugin: HashtagNode not registered on editor');
+    }
+    return registerLexicalHashtag(editor);
+  }, [editor]);
+  return null;
+}
+
+export { HashtagPlugin };

package/npm/LexicalHashtagPlugin.js

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ *
+ */
+
+'use strict'
+const LexicalHashtagPlugin = process.env.NODE_ENV !== 'production' ? require('./LexicalHashtagPlugin.dev.js') : require('./LexicalHashtagPlugin.prod.js');
+module.exports = LexicalHashtagPlugin;

package/npm/LexicalHashtagPlugin.js.flow

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+declare export function HashtagPlugin(): React.Node;

package/npm/LexicalHashtagPlugin.mjs

@@ -0,0 +1,12 @@
+/**
+ * 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 './LexicalHashtagPlugin.dev.mjs';
+import * as modProd from './LexicalHashtagPlugin.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const HashtagPlugin = mod.HashtagPlugin;

package/npm/LexicalHashtagPlugin.node.mjs

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV !== 'production' ? import('./LexicalHashtagPlugin.dev.mjs') : import('./LexicalHashtagPlugin.prod.mjs'));
+export const HashtagPlugin = mod.HashtagPlugin;

package/npm/LexicalHashtagPlugin.prod.js

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ *
+ */
+
+"use strict";var e=require("@lexical/hashtag"),r=require("@lexical/react/LexicalComposerContext"),t=require("react");exports.HashtagPlugin=function(){const[a]=r.useLexicalComposerContext();return t.useEffect(()=>{if(!a.hasNodes([e.HashtagNode]))throw new Error("HashtagPlugin: HashtagNode not registered on editor");return e.registerLexicalHashtag(a)},[a]),null};

package/npm/LexicalHashtagPlugin.prod.mjs

@@ -0,0 +1,9 @@
+/**
+ * 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{HashtagNode as r,registerLexicalHashtag as o}from"@lexical/hashtag";import{useLexicalComposerContext as t}from"@lexical/react/LexicalComposerContext";import{useEffect as e}from"react";function a(){const[a]=t();return e(()=>{if(!a.hasNodes([r]))throw new Error("HashtagPlugin: HashtagNode not registered on editor");return o(a)},[a]),null}export{a as HashtagPlugin};

package/npm/LexicalHistoryPlugin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 type { HistoryState } from '@lexical/history';
+export { createEmptyHistoryState } from '@lexical/history';
+export type { HistoryState };
+export declare function HistoryPlugin({ delay, externalHistoryState, }: {
+    delay?: number;
+    externalHistoryState?: HistoryState;
+}): null;

package/npm/LexicalHistoryPlugin.dev.js

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ *
+ */
+
+'use strict';
+
+var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
+var history = require('@lexical/history');
+var react = require('react');
+
+/**
+ * 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.
+ *
+ */
+
+function useHistory(editor, externalHistoryState, delay = 1000) {
+  const historyState = react.useMemo(() => externalHistoryState || history.createEmptyHistoryState(), [externalHistoryState]);
+  react.useEffect(() => {
+    return history.registerHistory(editor, historyState, delay);
+  }, [delay, editor, historyState]);
+}
+
+/**
+ * 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.
+ *
+ */
+
+function HistoryPlugin({
+  delay,
+  externalHistoryState
+}) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  useHistory(editor, externalHistoryState, delay);
+  return null;
+}
+
+exports.createEmptyHistoryState = history.createEmptyHistoryState;
+exports.HistoryPlugin = HistoryPlugin;

package/npm/LexicalHistoryPlugin.dev.mjs

@@ -0,0 +1,46 @@
+/**
+ * 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 { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { createEmptyHistoryState, registerHistory } from '@lexical/history';
+export { createEmptyHistoryState } from '@lexical/history';
+import { useMemo, useEffect } from 'react';
+
+/**
+ * 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.
+ *
+ */
+
+function useHistory(editor, externalHistoryState, delay = 1000) {
+  const historyState = useMemo(() => externalHistoryState || createEmptyHistoryState(), [externalHistoryState]);
+  useEffect(() => {
+    return registerHistory(editor, historyState, delay);
+  }, [delay, editor, historyState]);
+}
+
+/**
+ * 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.
+ *
+ */
+
+function HistoryPlugin({
+  delay,
+  externalHistoryState
+}) {
+  const [editor] = useLexicalComposerContext();
+  useHistory(editor, externalHistoryState, delay);
+  return null;
+}
+
+export { HistoryPlugin };

package/npm/LexicalHistoryPlugin.js

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ *
+ */
+
+'use strict'
+const LexicalHistoryPlugin = process.env.NODE_ENV !== 'production' ? require('./LexicalHistoryPlugin.dev.js') : require('./LexicalHistoryPlugin.prod.js');
+module.exports = LexicalHistoryPlugin;

package/npm/LexicalHistoryPlugin.js.flow

@@ -0,0 +1,28 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+import type {BaseSelection, EditorState, LexicalEditor} from 'lexical';
+
+export type HistoryStateEntry = {
+  editor: LexicalEditor,
+  editorState: EditorState,
+  undoSelection?: BaseSelection | null,
+};
+
+export type HistoryState = {
+  current: null | HistoryStateEntry,
+  redoStack: Array<HistoryStateEntry>,
+  undoStack: Array<HistoryStateEntry>,
+};
+
+declare export function HistoryPlugin({
+  externalHistoryState?: HistoryState,
+}): React.Node;
+
+declare export function createEmptyHistoryState(): HistoryState;

package/npm/LexicalHistoryPlugin.mjs

@@ -0,0 +1,13 @@
+/**
+ * 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 './LexicalHistoryPlugin.dev.mjs';
+import * as modProd from './LexicalHistoryPlugin.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const HistoryPlugin = mod.HistoryPlugin;
+export const createEmptyHistoryState = mod.createEmptyHistoryState;

package/npm/LexicalHistoryPlugin.node.mjs

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV !== 'production' ? import('./LexicalHistoryPlugin.dev.mjs') : import('./LexicalHistoryPlugin.prod.mjs'));
+export const HistoryPlugin = mod.HistoryPlugin;
+export const createEmptyHistoryState = mod.createEmptyHistoryState;

package/npm/LexicalHistoryPlugin.prod.js

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ *
+ */
+
+"use strict";var e=require("@lexical/react/LexicalComposerContext"),t=require("@lexical/history"),r=require("react");exports.createEmptyHistoryState=t.createEmptyHistoryState,exports.HistoryPlugin=function({delay:o,externalHistoryState:i}){const[s]=e.useLexicalComposerContext();return function(e,o,i=1e3){const s=r.useMemo(()=>o||t.createEmptyHistoryState(),[o]);r.useEffect(()=>t.registerHistory(e,s,i),[i,e,s])}(s,i,o),null};

package/npm/LexicalHistoryPlugin.prod.mjs

@@ -0,0 +1,9 @@
+/**
+ * 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{useLexicalComposerContext as t}from"@lexical/react/LexicalComposerContext";import{createEmptyHistoryState as o,registerHistory as r}from"@lexical/history";export{createEmptyHistoryState}from"@lexical/history";import{useMemo as e,useEffect as i}from"react";function a({delay:a,externalHistoryState:c}){const[l]=t();return function(t,a,c=1e3){const l=e(()=>a||o(),[a]);i(()=>r(t,l,c),[c,t,l])}(l,c,a),null}export{a as HistoryPlugin};

package/npm/LexicalHorizontalRuleNode.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 type { DOMConversionMap } from 'lexical';
+import type { JSX } from 'react';
+import { $isHorizontalRuleNode, HorizontalRuleNode as BaseHorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND, type SerializedHorizontalRuleNode } from '@lexical/extension';
+export { $isHorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND, type SerializedHorizontalRuleNode, };
+/**
+ * @deprecated A pure Lexical implementation is available in `@lexical/extension` as HorizontalRuleExtension
+ */
+export declare class HorizontalRuleNode extends BaseHorizontalRuleNode {
+    static getType(): string;
+    static clone(node: HorizontalRuleNode): HorizontalRuleNode;
+    static importJSON(serializedNode: SerializedHorizontalRuleNode): HorizontalRuleNode;
+    static importDOM(): DOMConversionMap | null;
+    decorate(): JSX.Element;
+}
+/**
+ * @deprecated A pure Lexical implementation is available in `@lexical/extension` as HorizontalRuleExtension
+ */
+export declare function $createHorizontalRuleNode(): HorizontalRuleNode;