zurfyx-lexical-react 0.39.1-nightly.20251225.0

package/dist/LexicalHorizontalRuleNode.dev.mjs

@@ -0,0 +1,98 @@
+/**
+ * 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 { HorizontalRuleNode as HorizontalRuleNode$1 } from '@lexical/extension';
+export { $isHorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from '@lexical/extension';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection';
+import { mergeRegister, addClassNamesToElement, removeClassNamesFromElement } from '@lexical/utils';
+import { $applyNodeReplacement, CLICK_COMMAND, COMMAND_PRIORITY_LOW } from 'lexical';
+import { 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.
+ *
+ */
+
+function HorizontalRuleComponent({
+  nodeKey
+}) {
+  const [editor] = useLexicalComposerContext();
+  const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey);
+  useEffect(() => {
+    return mergeRegister(editor.registerCommand(CLICK_COMMAND, event => {
+      const hrElem = editor.getElementByKey(nodeKey);
+      if (event.target === hrElem) {
+        if (!event.shiftKey) {
+          clearSelection();
+        }
+        setSelected(!isSelected);
+        return true;
+      }
+      return false;
+    }, COMMAND_PRIORITY_LOW));
+  }, [clearSelection, editor, isSelected, nodeKey, setSelected]);
+  useEffect(() => {
+    const hrElem = editor.getElementByKey(nodeKey);
+    const isSelectedClassName = editor._config.theme.hrSelected ?? 'selected';
+    if (hrElem !== null) {
+      if (isSelected) {
+        addClassNamesToElement(hrElem, isSelectedClassName);
+      } else {
+        removeClassNamesFromElement(hrElem, isSelectedClassName);
+      }
+    }
+  }, [editor, isSelected, nodeKey]);
+  return null;
+}
+
+/**
+ * @deprecated A pure Lexical implementation is available in `@lexical/extension` as HorizontalRuleExtension
+ */
+class HorizontalRuleNode extends HorizontalRuleNode$1 {
+  static getType() {
+    return 'horizontalrule';
+  }
+  static clone(node) {
+    return new HorizontalRuleNode(node.__key);
+  }
+  static importJSON(serializedNode) {
+    return $createHorizontalRuleNode().updateFromJSON(serializedNode);
+  }
+  static importDOM() {
+    return {
+      hr: () => ({
+        conversion: $convertHorizontalRuleElement,
+        priority: 0
+      })
+    };
+  }
+  decorate() {
+    return /*#__PURE__*/jsx(HorizontalRuleComponent, {
+      nodeKey: this.__key
+    });
+  }
+}
+function $convertHorizontalRuleElement() {
+  return {
+    node: $createHorizontalRuleNode()
+  };
+}
+
+/**
+ * @deprecated A pure Lexical implementation is available in `@lexical/extension` as HorizontalRuleExtension
+ */
+function $createHorizontalRuleNode() {
+  return $applyNodeReplacement(new HorizontalRuleNode());
+}
+
+export { $createHorizontalRuleNode, HorizontalRuleNode };

package/dist/LexicalHorizontalRuleNode.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 LexicalHorizontalRuleNode = process.env.NODE_ENV !== 'production' ? require('./LexicalHorizontalRuleNode.dev.js') : require('./LexicalHorizontalRuleNode.prod.js');
+module.exports = LexicalHorizontalRuleNode;

package/dist/LexicalHorizontalRuleNode.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 './LexicalHorizontalRuleNode.dev.mjs';
+import * as modProd from './LexicalHorizontalRuleNode.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const $createHorizontalRuleNode = mod.$createHorizontalRuleNode;
+export const $isHorizontalRuleNode = mod.$isHorizontalRuleNode;
+export const HorizontalRuleNode = mod.HorizontalRuleNode;
+export const INSERT_HORIZONTAL_RULE_COMMAND = mod.INSERT_HORIZONTAL_RULE_COMMAND;

package/dist/LexicalHorizontalRuleNode.node.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.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV !== 'production' ? import('./LexicalHorizontalRuleNode.dev.mjs') : import('./LexicalHorizontalRuleNode.prod.mjs'));
+export const $createHorizontalRuleNode = mod.$createHorizontalRuleNode;
+export const $isHorizontalRuleNode = mod.$isHorizontalRuleNode;
+export const HorizontalRuleNode = mod.HorizontalRuleNode;
+export const INSERT_HORIZONTAL_RULE_COMMAND = mod.INSERT_HORIZONTAL_RULE_COMMAND;

package/dist/LexicalHorizontalRuleNode.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/LexicalComposerContext"),r=require("@lexical/react/useLexicalNodeSelection"),o=require("@lexical/utils"),n=require("lexical"),i=require("react"),l=require("react/jsx-runtime");function s({nodeKey:e}){const[l]=t.useLexicalComposerContext(),[s,a,c]=r.useLexicalNodeSelection(e);return i.useEffect(()=>o.mergeRegister(l.registerCommand(n.CLICK_COMMAND,t=>{const r=l.getElementByKey(e);return t.target===r&&(t.shiftKey||c(),a(!s),!0)},n.COMMAND_PRIORITY_LOW)),[c,l,s,e,a]),i.useEffect(()=>{const t=l.getElementByKey(e),r=l._config.theme.hrSelected??"selected";null!==t&&(s?o.addClassNamesToElement(t,r):o.removeClassNamesFromElement(t,r))},[l,s,e]),null}class a extends e.HorizontalRuleNode{static getType(){return"horizontalrule"}static clone(e){return new a(e.__key)}static importJSON(e){return u().updateFromJSON(e)}static importDOM(){return{hr:()=>({conversion:c,priority:0})}}decorate(){return l.jsx(s,{nodeKey:this.__key})}}function c(){return{node:u()}}function u(){return n.$applyNodeReplacement(new a)}exports.$isHorizontalRuleNode=e.$isHorizontalRuleNode,exports.INSERT_HORIZONTAL_RULE_COMMAND=e.INSERT_HORIZONTAL_RULE_COMMAND,exports.$createHorizontalRuleNode=u,exports.HorizontalRuleNode=a;

package/dist/LexicalHorizontalRuleNode.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{HorizontalRuleNode as e}from"@lexical/extension";export{$isHorizontalRuleNode,INSERT_HORIZONTAL_RULE_COMMAND}from"@lexical/extension";import{useLexicalComposerContext as t}from"@lexical/react/LexicalComposerContext";import{useLexicalNodeSelection as r}from"@lexical/react/useLexicalNodeSelection";import{mergeRegister as o,addClassNamesToElement as n,removeClassNamesFromElement as i}from"@lexical/utils";import{$applyNodeReplacement as l,CLICK_COMMAND as c,COMMAND_PRIORITY_LOW as a}from"lexical";import{useEffect as m}from"react";import{jsx as s}from"react/jsx-runtime";function u({nodeKey:e}){const[l]=t(),[s,u,p]=r(e);return m(()=>o(l.registerCommand(c,t=>{const r=l.getElementByKey(e);return t.target===r&&(t.shiftKey||p(),u(!s),!0)},a)),[p,l,s,e,u]),m(()=>{const t=l.getElementByKey(e),r=l._config.theme.hrSelected??"selected";null!==t&&(s?n(t,r):i(t,r))},[l,s,e]),null}class p extends e{static getType(){return"horizontalrule"}static clone(e){return new p(e.__key)}static importJSON(e){return f().updateFromJSON(e)}static importDOM(){return{hr:()=>({conversion:x,priority:0})}}decorate(){return s(u,{nodeKey:this.__key})}}function x(){return{node:f()}}function f(){return l(new p)}export{f as $createHorizontalRuleNode,p as HorizontalRuleNode};

package/dist/LexicalHorizontalRulePlugin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ *
+ */
+export declare function HorizontalRulePlugin(): null;

package/dist/LexicalHorizontalRulePlugin.dev.js

@@ -0,0 +1,44 @@
+/**
+ * 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 LexicalHorizontalRuleNode = require('@lexical/react/LexicalHorizontalRuleNode');
+var utils = require('@lexical/utils');
+var lexical = require('lexical');
+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 HorizontalRulePlugin() {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  react.useEffect(() => {
+    return editor.registerCommand(LexicalHorizontalRuleNode.INSERT_HORIZONTAL_RULE_COMMAND, type => {
+      const selection = lexical.$getSelection();
+      if (!lexical.$isRangeSelection(selection)) {
+        return false;
+      }
+      const focusNode = selection.focus.getNode();
+      if (focusNode !== null) {
+        const horizontalRuleNode = LexicalHorizontalRuleNode.$createHorizontalRuleNode();
+        utils.$insertNodeToNearestRoot(horizontalRuleNode);
+      }
+      return true;
+    }, lexical.COMMAND_PRIORITY_EDITOR);
+  }, [editor]);
+  return null;
+}
+
+exports.HorizontalRulePlugin = HorizontalRulePlugin;

package/dist/LexicalHorizontalRulePlugin.dev.mjs

@@ -0,0 +1,42 @@
+/**
+ * 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 { INSERT_HORIZONTAL_RULE_COMMAND, $createHorizontalRuleNode } from '@lexical/react/LexicalHorizontalRuleNode';
+import { $insertNodeToNearestRoot } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } from 'lexical';
+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 HorizontalRulePlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    return editor.registerCommand(INSERT_HORIZONTAL_RULE_COMMAND, type => {
+      const selection = $getSelection();
+      if (!$isRangeSelection(selection)) {
+        return false;
+      }
+      const focusNode = selection.focus.getNode();
+      if (focusNode !== null) {
+        const horizontalRuleNode = $createHorizontalRuleNode();
+        $insertNodeToNearestRoot(horizontalRuleNode);
+      }
+      return true;
+    }, COMMAND_PRIORITY_EDITOR);
+  }, [editor]);
+  return null;
+}
+
+export { HorizontalRulePlugin };

package/dist/LexicalHorizontalRulePlugin.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 LexicalHorizontalRulePlugin = process.env.NODE_ENV !== 'production' ? require('./LexicalHorizontalRulePlugin.dev.js') : require('./LexicalHorizontalRulePlugin.prod.js');
+module.exports = LexicalHorizontalRulePlugin;

package/dist/LexicalHorizontalRulePlugin.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 './LexicalHorizontalRulePlugin.dev.mjs';
+import * as modProd from './LexicalHorizontalRulePlugin.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const HorizontalRulePlugin = mod.HorizontalRulePlugin;

package/dist/LexicalHorizontalRulePlugin.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('./LexicalHorizontalRulePlugin.dev.mjs') : import('./LexicalHorizontalRulePlugin.prod.mjs'));
+export const HorizontalRulePlugin = mod.HorizontalRulePlugin;

package/dist/LexicalHorizontalRulePlugin.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"),r=require("@lexical/react/LexicalHorizontalRuleNode"),t=require("@lexical/utils"),o=require("lexical"),i=require("react");exports.HorizontalRulePlugin=function(){const[l]=e.useLexicalComposerContext();return i.useEffect(()=>l.registerCommand(r.INSERT_HORIZONTAL_RULE_COMMAND,e=>{const i=o.$getSelection();if(!o.$isRangeSelection(i))return!1;if(null!==i.focus.getNode()){const e=r.$createHorizontalRuleNode();t.$insertNodeToNearestRoot(e)}return!0},o.COMMAND_PRIORITY_EDITOR),[l]),null};

package/dist/LexicalHorizontalRulePlugin.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 o}from"@lexical/react/LexicalComposerContext";import{INSERT_HORIZONTAL_RULE_COMMAND as r,$createHorizontalRuleNode as t}from"@lexical/react/LexicalHorizontalRuleNode";import{$insertNodeToNearestRoot as e}from"@lexical/utils";import{$getSelection as i,$isRangeSelection as l,COMMAND_PRIORITY_EDITOR as c}from"lexical";import{useEffect as m}from"react";function n(){const[n]=o();return m(()=>n.registerCommand(r,o=>{const r=i();if(!l(r))return!1;if(null!==r.focus.getNode()){const o=t();e(o)}return!0},c),[n]),null}export{n as HorizontalRulePlugin};

package/dist/LexicalLinkPlugin.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 LinkAttributes } from '@lexical/link';
+type Props = {
+    validateUrl?: (url: string) => boolean;
+    attributes?: LinkAttributes;
+};
+export declare function LinkPlugin({ validateUrl, attributes }: Props): null;
+export {};

package/dist/LexicalLinkPlugin.dev.js

@@ -0,0 +1,43 @@
+/**
+ * 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 link = require('@lexical/link');
+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 LinkPlugin({
+  validateUrl,
+  attributes
+}) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  react.useEffect(() => {
+    if (!editor.hasNodes([link.LinkNode])) {
+      throw new Error('LinkPlugin: LinkNode not registered on editor');
+    }
+  });
+  react.useEffect(() => {
+    return link.registerLink(editor, extension.namedSignals({
+      attributes,
+      validateUrl
+    }));
+  }, [editor, validateUrl, attributes]);
+  return null;
+}
+
+exports.LinkPlugin = LinkPlugin;

package/dist/LexicalLinkPlugin.dev.mjs

@@ -0,0 +1,41 @@
+/**
+ * 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 { namedSignals } from '@lexical/extension';
+import { LinkNode, registerLink } from '@lexical/link';
+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 LinkPlugin({
+  validateUrl,
+  attributes
+}) {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    if (!editor.hasNodes([LinkNode])) {
+      throw new Error('LinkPlugin: LinkNode not registered on editor');
+    }
+  });
+  useEffect(() => {
+    return registerLink(editor, namedSignals({
+      attributes,
+      validateUrl
+    }));
+  }, [editor, validateUrl, attributes]);
+  return null;
+}
+
+export { LinkPlugin };

package/dist/LexicalLinkPlugin.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 LexicalLinkPlugin = process.env.NODE_ENV !== 'production' ? require('./LexicalLinkPlugin.dev.js') : require('./LexicalLinkPlugin.prod.js');
+module.exports = LexicalLinkPlugin;

package/dist/LexicalLinkPlugin.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 './LexicalLinkPlugin.dev.mjs';
+import * as modProd from './LexicalLinkPlugin.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const LinkPlugin = mod.LinkPlugin;

package/dist/LexicalLinkPlugin.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('./LexicalLinkPlugin.dev.mjs') : import('./LexicalLinkPlugin.prod.mjs'));
+export const LinkPlugin = mod.LinkPlugin;

package/dist/LexicalLinkPlugin.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"),r=require("@lexical/link"),i=require("@lexical/react/LexicalComposerContext"),t=require("react");exports.LinkPlugin=function({validateUrl:n,attributes:l}){const[o]=i.useLexicalComposerContext();return t.useEffect(()=>{if(!o.hasNodes([r.LinkNode]))throw new Error("LinkPlugin: LinkNode not registered on editor")}),t.useEffect(()=>r.registerLink(o,e.namedSignals({attributes:l,validateUrl:n})),[o,n,l]),null};

package/dist/LexicalLinkPlugin.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{namedSignals as r}from"@lexical/extension";import{LinkNode as t,registerLink as e}from"@lexical/link";import{useLexicalComposerContext as o}from"@lexical/react/LexicalComposerContext";import{useEffect as i}from"react";function l({validateUrl:l,attributes:n}){const[a]=o();return i(()=>{if(!a.hasNodes([t]))throw new Error("LinkPlugin: LinkNode not registered on editor")}),i(()=>e(a,r({attributes:n,validateUrl:l})),[a,l,n]),null}export{l as LinkPlugin};

package/dist/LexicalListPlugin.d.ts

@@ -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.
+ *
+ */
+export interface ListPluginProps {
+    /**
+     * When `true`, enforces strict indentation rules for list items, ensuring consistent structure.
+     * When `false` (default), indentation is more flexible.
+     */
+    hasStrictIndent?: boolean;
+}
+export declare function ListPlugin({ hasStrictIndent }: ListPluginProps): null;

package/dist/LexicalListPlugin.dev.js

@@ -0,0 +1,56 @@
+/**
+ * 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 list = require('@lexical/list');
+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 useList(editor) {
+  react.useEffect(() => {
+    return list.registerList(editor);
+  }, [editor]);
+}
+
+/**
+ * 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 ListPlugin({
+  hasStrictIndent = false
+}) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  react.useEffect(() => {
+    if (!editor.hasNodes([list.ListNode, list.ListItemNode])) {
+      throw new Error('ListPlugin: ListNode and/or ListItemNode not registered on editor');
+    }
+  }, [editor]);
+  react.useEffect(() => {
+    if (!hasStrictIndent) {
+      return;
+    }
+    return list.registerListStrictIndentTransform(editor);
+  }, [editor, hasStrictIndent]);
+  useList(editor);
+  return null;
+}
+
+exports.ListPlugin = ListPlugin;

package/dist/LexicalListPlugin.dev.mjs

@@ -0,0 +1,54 @@
+/**
+ * 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 { registerList, ListNode, ListItemNode, registerListStrictIndentTransform } from '@lexical/list';
+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 useList(editor) {
+  useEffect(() => {
+    return registerList(editor);
+  }, [editor]);
+}
+
+/**
+ * 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 ListPlugin({
+  hasStrictIndent = false
+}) {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    if (!editor.hasNodes([ListNode, ListItemNode])) {
+      throw new Error('ListPlugin: ListNode and/or ListItemNode not registered on editor');
+    }
+  }, [editor]);
+  useEffect(() => {
+    if (!hasStrictIndent) {
+      return;
+    }
+    return registerListStrictIndentTransform(editor);
+  }, [editor, hasStrictIndent]);
+  useList(editor);
+  return null;
+}
+
+export { ListPlugin };

package/dist/LexicalListPlugin.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 LexicalListPlugin = process.env.NODE_ENV !== 'production' ? require('./LexicalListPlugin.dev.js') : require('./LexicalListPlugin.prod.js');
+module.exports = LexicalListPlugin;

package/dist/LexicalListPlugin.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 './LexicalListPlugin.dev.mjs';
+import * as modProd from './LexicalListPlugin.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const ListPlugin = mod.ListPlugin;

package/dist/LexicalListPlugin.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('./LexicalListPlugin.dev.mjs') : import('./LexicalListPlugin.prod.mjs'));
+export const ListPlugin = mod.ListPlugin;

package/dist/LexicalListPlugin.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/list"),t=require("@lexical/react/LexicalComposerContext"),r=require("react");exports.ListPlugin=function({hasStrictIndent:i=!1}){const[s]=t.useLexicalComposerContext();return r.useEffect(()=>{if(!s.hasNodes([e.ListNode,e.ListItemNode]))throw new Error("ListPlugin: ListNode and/or ListItemNode not registered on editor")},[s]),r.useEffect(()=>{if(i)return e.registerListStrictIndentTransform(s)},[s,i]),function(t){r.useEffect(()=>e.registerList(t),[t])}(s),null};