@payloadcms/richtext-lexical 3.0.0-beta.13 → 3.0.0-beta.131

package/dist/field/features/horizontalrule/feature.client.js

@@ -1,53 +0,0 @@
-'use client';
-import { SlashMenuOption } from '../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js';
-import { HorizontalRuleIcon } from '../../lexical/ui/icons/HorizontalRule/index.js';
-import { createClientComponent } from '../createClientComponent.js';
-import { MarkdownTransformer } from './markdownTransformer.js';
-import { HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from './nodes/HorizontalRuleNode.js';
-import { HorizontalRulePlugin } from './plugin/index.js';
-const HorizontalRuleFeatureClient = (props)=>{
-    return {
-        clientFeatureProps: props,
-        feature: ()=>({
-                clientFeatureProps: props,
-                markdownTransformers: [
-                    MarkdownTransformer
-                ],
-                nodes: [
-                    HorizontalRuleNode
-                ],
-                plugins: [
-                    {
-                        Component: HorizontalRulePlugin,
-                        position: 'normal'
-                    }
-                ],
-                slashMenu: {
-                    options: [
-                        {
-                            displayName: 'Basic',
-                            key: 'basic',
-                            options: [
-                                new SlashMenuOption(`horizontalrule`, {
-                                    Icon: HorizontalRuleIcon,
-                                    displayName: `Horizontal Rule`,
-                                    keywords: [
-                                        'hr',
-                                        'horizontal rule',
-                                        'line',
-                                        'separator'
-                                    ],
-                                    onSelect: ({ editor })=>{
-                                        editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined);
-                                    }
-                                })
-                            ]
-                        }
-                    ]
-                }
-            })
-    };
-};
-export const HorizontalRuleFeatureClientComponent = createClientComponent(HorizontalRuleFeatureClient);
-
-//# sourceMappingURL=feature.client.js.map

package/dist/field/features/horizontalrule/feature.client.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/horizontalrule/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from '../types.js'\n\nimport { SlashMenuOption } from '../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nimport { HorizontalRuleIcon } from '../../lexical/ui/icons/HorizontalRule/index.js'\nimport { createClientComponent } from '../createClientComponent.js'\nimport { MarkdownTransformer } from './markdownTransformer.js'\nimport { HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from './nodes/HorizontalRuleNode.js'\nimport { HorizontalRulePlugin } from './plugin/index.js'\n\nconst HorizontalRuleFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => ({\n      clientFeatureProps: props,\n      markdownTransformers: [MarkdownTransformer],\n      nodes: [HorizontalRuleNode],\n      plugins: [\n        {\n          Component: HorizontalRulePlugin,\n          position: 'normal',\n        },\n      ],\n      slashMenu: {\n        options: [\n          {\n            displayName: 'Basic',\n            key: 'basic',\n            options: [\n              new SlashMenuOption(`horizontalrule`, {\n                Icon: HorizontalRuleIcon,\n                displayName: `Horizontal Rule`,\n                keywords: ['hr', 'horizontal rule', 'line', 'separator'],\n                onSelect: ({ editor }) => {\n                  editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined)\n                },\n              }),\n            ],\n          },\n        ],\n      },\n    }),\n  }\n}\n\nexport const HorizontalRuleFeatureClientComponent = createClientComponent(\n  HorizontalRuleFeatureClient,\n)\n"],"names":["SlashMenuOption","HorizontalRuleIcon","createClientComponent","MarkdownTransformer","HorizontalRuleNode","INSERT_HORIZONTAL_RULE_COMMAND","HorizontalRulePlugin","HorizontalRuleFeatureClient","props","clientFeatureProps","feature","markdownTransformers","nodes","plugins","Component","position","slashMenu","options","displayName","key","Icon","keywords","onSelect","editor","dispatchCommand","undefined","HorizontalRuleFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAIA,SAASA,eAAe,QAAQ,sEAAqE;AACrG,SAASC,kBAAkB,QAAQ,iDAAgD;AACnF,SAASC,qBAAqB,QAAQ,8BAA6B;AACnE,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SAASC,kBAAkB,EAAEC,8BAA8B,QAAQ,gCAA+B;AAClG,SAASC,oBAAoB,QAAQ,oBAAmB;AAExD,MAAMC,8BAAwE,CAACC;IAC7E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,IAAO,CAAA;gBACdD,oBAAoBD;gBACpBG,sBAAsB;oBAACR;iBAAoB;gBAC3CS,OAAO;oBAACR;iBAAmB;gBAC3BS,SAAS;oBACP;wBACEC,WAAWR;wBACXS,UAAU;oBACZ;iBACD;gBACDC,WAAW;oBACTC,SAAS;wBACP;4BACEC,aAAa;4BACbC,KAAK;4BACLF,SAAS;gCACP,IAAIjB,gBAAgB,CAAC,cAAc,CAAC,EAAE;oCACpCoB,MAAMnB;oCACNiB,aAAa,CAAC,eAAe,CAAC;oCAC9BG,UAAU;wCAAC;wCAAM;wCAAmB;wCAAQ;qCAAY;oCACxDC,UAAU,CAAC,EAAEC,MAAM,EAAE;wCACnBA,OAAOC,eAAe,CAACnB,gCAAgCoB;oCACzD;gCACF;6BACD;wBACH;qBACD;gBACH;YACF,CAAA;IACF;AACF;AAEA,OAAO,MAAMC,uCAAuCxB,sBAClDK,6BACD"}

package/dist/field/features/horizontalrule/feature.server.d.ts

@@ -1,3 +0,0 @@
-import type { FeatureProviderProviderServer } from '../types.js';
-export declare const HorizontalRuleFeature: FeatureProviderProviderServer<undefined, undefined>;
-//# sourceMappingURL=feature.server.d.ts.map

package/dist/field/features/horizontalrule/feature.server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/field/features/horizontalrule/feature.server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAOhE,eAAO,MAAM,qBAAqB,EAAE,6BAA6B,CAAC,SAAS,EAAE,SAAS,CA4BrF,CAAA"}

package/dist/field/features/horizontalrule/feature.server.js

@@ -1,36 +0,0 @@
-import { HorizontalRuleFeatureClientComponent } from './feature.client.js';
-import { MarkdownTransformer } from './markdownTransformer.js';
-import { HorizontalRuleNode } from './nodes/HorizontalRuleNode.js';
-export const HorizontalRuleFeature = (props)=>{
-    return {
-        feature: ()=>{
-            return {
-                ClientComponent: HorizontalRuleFeatureClientComponent,
-                clientFeatureProps: null,
-                markdownTransformers: [
-                    MarkdownTransformer
-                ],
-                nodes: [
-                    {
-                        converters: {
-                            html: {
-                                converter: ()=>{
-                                    return `<hr/>`;
-                                },
-                                nodeTypes: [
-                                    HorizontalRuleNode.getType()
-                                ]
-                            }
-                        },
-                        node: HorizontalRuleNode
-                    }
-                ],
-                serverFeatureProps: props
-            };
-        },
-        key: 'horizontalrule',
-        serverFeatureProps: props
-    };
-};
-
-//# sourceMappingURL=feature.server.js.map

package/dist/field/features/horizontalrule/feature.server.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/horizontalrule/feature.server.ts"],"sourcesContent":["import type { HTMLConverter } from '../converters/html/converter/types.js'\nimport type { FeatureProviderProviderServer } from '../types.js'\nimport type { SerializedHorizontalRuleNode } from './nodes/HorizontalRuleNode.js'\n\nimport { HorizontalRuleFeatureClientComponent } from './feature.client.js'\nimport { MarkdownTransformer } from './markdownTransformer.js'\nimport { HorizontalRuleNode } from './nodes/HorizontalRuleNode.js'\n\nexport const HorizontalRuleFeature: FeatureProviderProviderServer<undefined, undefined> = (\n  props,\n) => {\n  return {\n    feature: () => {\n      return {\n        ClientComponent: HorizontalRuleFeatureClientComponent,\n        clientFeatureProps: null,\n        markdownTransformers: [MarkdownTransformer],\n        nodes: [\n          {\n            converters: {\n              html: {\n                converter: () => {\n                  return `<hr/>`\n                },\n                nodeTypes: [HorizontalRuleNode.getType()],\n              } as HTMLConverter<SerializedHorizontalRuleNode>,\n            },\n            node: HorizontalRuleNode,\n          },\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'horizontalrule',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["HorizontalRuleFeatureClientComponent","MarkdownTransformer","HorizontalRuleNode","HorizontalRuleFeature","props","feature","ClientComponent","clientFeatureProps","markdownTransformers","nodes","converters","html","converter","nodeTypes","getType","node","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,oCAAoC,QAAQ,sBAAqB;AAC1E,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SAASC,kBAAkB,QAAQ,gCAA+B;AAElE,OAAO,MAAMC,wBAA6E,CACxFC;IAEA,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,iBAAiBN;gBACjBO,oBAAoB;gBACpBC,sBAAsB;oBAACP;iBAAoB;gBAC3CQ,OAAO;oBACL;wBACEC,YAAY;4BACVC,MAAM;gCACJC,WAAW;oCACT,OAAO,CAAC,KAAK,CAAC;gCAChB;gCACAC,WAAW;oCAACX,mBAAmBY,OAAO;iCAAG;4BAC3C;wBACF;wBACAC,MAAMb;oBACR;iBACD;gBACDc,oBAAoBZ;YACtB;QACF;QACAa,KAAK;QACLD,oBAAoBZ;IACtB;AACF,EAAC"}

package/dist/field/features/horizontalrule/markdownTransformer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../src/field/features/horizontalrule/markdownTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAQ3D,eAAO,MAAM,mBAAmB,EAAE,kBAiBjC,CAAA"}

package/dist/field/features/horizontalrule/markdownTransformer.js

@@ -1,23 +0,0 @@
-import { $createHorizontalRuleNode, $isHorizontalRuleNode, HorizontalRuleNode } from './nodes/HorizontalRuleNode.js';
-export const MarkdownTransformer = {
-    type: 'element',
-    dependencies: [
-        HorizontalRuleNode
-    ],
-    export: (node, exportChildren)=>{
-        if (!$isHorizontalRuleNode(node)) {
-            return null;
-        }
-        return '---';
-    },
-    // match ---
-    regExp: /^---\s*$/,
-    replace: (parentNode)=>{
-        const node = $createHorizontalRuleNode();
-        if (node) {
-            parentNode.replace(node);
-        }
-    }
-};
-
-//# sourceMappingURL=markdownTransformer.js.map

package/dist/field/features/horizontalrule/markdownTransformer.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/horizontalrule/markdownTransformer.ts"],"sourcesContent":["import type { ElementTransformer } from '@lexical/markdown'\n\nimport {\n  $createHorizontalRuleNode,\n  $isHorizontalRuleNode,\n  HorizontalRuleNode,\n} from './nodes/HorizontalRuleNode.js'\n\nexport const MarkdownTransformer: ElementTransformer = {\n  type: 'element',\n  dependencies: [HorizontalRuleNode],\n  export: (node, exportChildren) => {\n    if (!$isHorizontalRuleNode(node)) {\n      return null\n    }\n    return '---'\n  },\n  // match ---\n  regExp: /^---\\s*$/,\n  replace: (parentNode) => {\n    const node = $createHorizontalRuleNode()\n    if (node) {\n      parentNode.replace(node)\n    }\n  },\n}\n"],"names":["$createHorizontalRuleNode","$isHorizontalRuleNode","HorizontalRuleNode","MarkdownTransformer","type","dependencies","export","node","exportChildren","regExp","replace","parentNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SACEA,yBAAyB,EACzBC,qBAAqB,EACrBC,kBAAkB,QACb,gCAA+B;AAEtC,OAAO,MAAMC,sBAA0C;IACrDC,MAAM;IACNC,cAAc;QAACH;KAAmB;IAClCI,QAAQ,CAACC,MAAMC;QACb,IAAI,CAACP,sBAAsBM,OAAO;YAChC,OAAO;QACT;QACA,OAAO;IACT;IACA,YAAY;IACZE,QAAQ;IACRC,SAAS,CAACC;QACR,MAAMJ,OAAOP;QACb,IAAIO,MAAM;YACRI,WAAWD,OAAO,CAACH;QACrB;IACF;AACF,EAAC"}

package/dist/field/features/horizontalrule/nodes/HorizontalRuleNode.d.ts

@@ -1,55 +0,0 @@
-import type { DOMConversionMap, DOMExportOutput, LexicalCommand, LexicalNode, SerializedLexicalNode } from 'lexical';
-import lexicalImport from 'lexical';
-declare const DecoratorNode: typeof lexicalImport.DecoratorNode;
-import * as React from 'react';
-/**
- * Serialized representation of a horizontal rule node. Serialized = converted to JSON. This is what is stored in the database / in the lexical editor state.
- */
-export type SerializedHorizontalRuleNode = SerializedLexicalNode;
-export declare const INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void>;
-/**
- * This node is a DecoratorNode. DecoratorNodes allow you to render React components in the editor.
- *
- * They need both createDom and decorate functions. createDom => outside of the html. decorate => React Component inside of the html.
- *
- * If we used DecoratorBlockNode instead, we would only need a decorate method
- */
-export declare class HorizontalRuleNode extends DecoratorNode<React.ReactElement> {
-    static clone(node: HorizontalRuleNode): HorizontalRuleNode;
-    static getType(): string;
-    /**
-     * Defines what happens if you copy an hr element from another page and paste it into the lexical editor
-     *
-     * This also determines the behavior of lexical's internal HTML -> Lexical converter
-     */
-    static importDOM(): DOMConversionMap | null;
-    /**
-     * The data for this node is stored serialized as JSON. This is the "load function" of that node: it takes the saved data and converts it into a node.
-     */
-    static importJSON(serializedNode: SerializedHorizontalRuleNode): HorizontalRuleNode;
-    /**
-     * Determines how the hr element is rendered in the lexical editor. This is only the "initial" / "outer" HTML element.
-     */
-    createDOM(): HTMLElement;
-    /**
-     * Allows you to render a React component within whatever createDOM returns.
-     */
-    decorate(): React.ReactElement;
-    /**
-     * Opposite of importDOM, this function defines what happens when you copy an hr element from the lexical editor and paste it into another page.
-     *
-     * This also determines the behavior of lexical's internal Lexical -> HTML converter
-     */
-    exportDOM(): DOMExportOutput;
-    /**
-     * Opposite of importJSON. This determines what data is saved in the database / in the lexical editor state.
-     */
-    exportJSON(): SerializedLexicalNode;
-    getTextContent(): string;
-    isInline(): false;
-    updateDOM(): boolean;
-}
-export declare function $createHorizontalRuleNode(): HorizontalRuleNode;
-export declare function $isHorizontalRuleNode(node: LexicalNode | null | undefined): node is HorizontalRuleNode;
-export {};
-//# sourceMappingURL=HorizontalRuleNode.d.ts.map

package/dist/field/features/horizontalrule/nodes/HorizontalRuleNode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HorizontalRuleNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/horizontalrule/nodes/HorizontalRuleNode.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAEhB,eAAe,EACf,cAAc,EACd,WAAW,EACX,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAEhB,OAAO,aAAa,MAAM,SAAS,CAAA;AACnC,QAAA,MAA+B,aAAa,oCAAiC,CAAA;AAC7E,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,qBAAqB,CAAA;AAEhE,eAAO,MAAM,8BAA8B,EAAE,cAAc,CAAC,IAAI,CAE/D,CAAA;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC;IACvE,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,kBAAkB,GAAG,kBAAkB;IAI1D,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB;;;;OAIG;IACH,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAS3C;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,4BAA4B,GAAG,kBAAkB;IAInF;;OAEG;IACH,SAAS,IAAI,WAAW;IAIxB;;OAEG;IACH,QAAQ,IAAI,KAAK,CAAC,YAAY;IAI9B;;;;OAIG;IACH,SAAS,IAAI,eAAe;IAG5B;;OAEG;IACH,UAAU,IAAI,qBAAqB;IAOnC,cAAc,IAAI,MAAM;IAIxB,QAAQ,IAAI,KAAK;IAIjB,SAAS,IAAI,OAAO;CAGrB;AAMD,wBAAgB,yBAAyB,IAAI,kBAAkB,CAE9D;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,kBAAkB,CAE5B"}

package/dist/field/features/horizontalrule/nodes/HorizontalRuleNode.js

@@ -1,89 +0,0 @@
-import lexicalImport from 'lexical';
-const { $applyNodeReplacement, DecoratorNode, createCommand } = lexicalImport;
-import * as React from 'react';
-const HorizontalRuleComponent = /*#__PURE__*/ React.lazy(()=>import('../component/index.js').then((module)=>({
-            default: module.HorizontalRuleComponent
-        })));
-export const INSERT_HORIZONTAL_RULE_COMMAND = createCommand('INSERT_HORIZONTAL_RULE_COMMAND');
-/**
- * This node is a DecoratorNode. DecoratorNodes allow you to render React components in the editor.
- *
- * They need both createDom and decorate functions. createDom => outside of the html. decorate => React Component inside of the html.
- *
- * If we used DecoratorBlockNode instead, we would only need a decorate method
- */ export class HorizontalRuleNode extends DecoratorNode {
-    static clone(node) {
-        return new HorizontalRuleNode(node.__key);
-    }
-    static getType() {
-        return 'horizontalrule';
-    }
-    /**
-   * Defines what happens if you copy an hr element from another page and paste it into the lexical editor
-   *
-   * This also determines the behavior of lexical's internal HTML -> Lexical converter
-   */ static importDOM() {
-        return {
-            hr: ()=>({
-                    conversion: convertHorizontalRuleElement,
-                    priority: 0
-                })
-        };
-    }
-    /**
-   * The data for this node is stored serialized as JSON. This is the "load function" of that node: it takes the saved data and converts it into a node.
-   */ static importJSON(serializedNode) {
-        return $createHorizontalRuleNode();
-    }
-    /**
-   * Determines how the hr element is rendered in the lexical editor. This is only the "initial" / "outer" HTML element.
-   */ createDOM() {
-        return document.createElement('hr');
-    }
-    /**
-   * Allows you to render a React component within whatever createDOM returns.
-   */ decorate() {
-        return /*#__PURE__*/ React.createElement(HorizontalRuleComponent, {
-            nodeKey: this.__key
-        });
-    }
-    /**
-   * Opposite of importDOM, this function defines what happens when you copy an hr element from the lexical editor and paste it into another page.
-   *
-   * This also determines the behavior of lexical's internal Lexical -> HTML converter
-   */ exportDOM() {
-        return {
-            element: document.createElement('hr')
-        };
-    }
-    /**
-   * Opposite of importJSON. This determines what data is saved in the database / in the lexical editor state.
-   */ exportJSON() {
-        return {
-            type: 'horizontalrule',
-            version: 1
-        };
-    }
-    getTextContent() {
-        return '\n';
-    }
-    isInline() {
-        return false;
-    }
-    updateDOM() {
-        return false;
-    }
-}
-function convertHorizontalRuleElement() {
-    return {
-        node: $createHorizontalRuleNode()
-    };
-}
-export function $createHorizontalRuleNode() {
-    return $applyNodeReplacement(new HorizontalRuleNode());
-}
-export function $isHorizontalRuleNode(node) {
-    return node instanceof HorizontalRuleNode;
-}
-
-//# sourceMappingURL=HorizontalRuleNode.js.map

package/dist/field/features/horizontalrule/nodes/HorizontalRuleNode.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/horizontalrule/nodes/HorizontalRuleNode.tsx"],"sourcesContent":["import type {\n  DOMConversionMap,\n  DOMConversionOutput,\n  DOMExportOutput,\n  LexicalCommand,\n  LexicalNode,\n  SerializedLexicalNode,\n} from 'lexical'\n\nimport lexicalImport from 'lexical'\nconst { $applyNodeReplacement, DecoratorNode, createCommand } = lexicalImport\nimport * as React from 'react'\n\nconst HorizontalRuleComponent = React.lazy(() =>\n  import('../component/index.js').then((module) => ({\n    default: module.HorizontalRuleComponent,\n  })),\n)\n\n/**\n * Serialized representation of a horizontal rule node. Serialized = converted to JSON. This is what is stored in the database / in the lexical editor state.\n */\nexport type SerializedHorizontalRuleNode = SerializedLexicalNode\n\nexport const INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void> = createCommand(\n  'INSERT_HORIZONTAL_RULE_COMMAND',\n)\n\n/**\n * This node is a DecoratorNode. DecoratorNodes allow you to render React components in the editor.\n *\n * They need both createDom and decorate functions. createDom => outside of the html. decorate => React Component inside of the html.\n *\n * If we used DecoratorBlockNode instead, we would only need a decorate method\n */\nexport class HorizontalRuleNode extends DecoratorNode<React.ReactElement> {\n  static clone(node: HorizontalRuleNode): HorizontalRuleNode {\n    return new HorizontalRuleNode(node.__key)\n  }\n\n  static getType(): string {\n    return 'horizontalrule'\n  }\n\n  /**\n   * Defines what happens if you copy an hr element from another page and paste it into the lexical editor\n   *\n   * This also determines the behavior of lexical's internal HTML -> Lexical converter\n   */\n  static importDOM(): DOMConversionMap | null {\n    return {\n      hr: () => ({\n        conversion: convertHorizontalRuleElement,\n        priority: 0,\n      }),\n    }\n  }\n\n  /**\n   * The data for this node is stored serialized as JSON. This is the \"load function\" of that node: it takes the saved data and converts it into a node.\n   */\n  static importJSON(serializedNode: SerializedHorizontalRuleNode): HorizontalRuleNode {\n    return $createHorizontalRuleNode()\n  }\n\n  /**\n   * Determines how the hr element is rendered in the lexical editor. This is only the \"initial\" / \"outer\" HTML element.\n   */\n  createDOM(): HTMLElement {\n    return document.createElement('hr')\n  }\n\n  /**\n   * Allows you to render a React component within whatever createDOM returns.\n   */\n  decorate(): React.ReactElement {\n    return <HorizontalRuleComponent nodeKey={this.__key} />\n  }\n\n  /**\n   * Opposite of importDOM, this function defines what happens when you copy an hr element from the lexical editor and paste it into another page.\n   *\n   * This also determines the behavior of lexical's internal Lexical -> HTML converter\n   */\n  exportDOM(): DOMExportOutput {\n    return { element: document.createElement('hr') }\n  }\n  /**\n   * Opposite of importJSON. This determines what data is saved in the database / in the lexical editor state.\n   */\n  exportJSON(): SerializedLexicalNode {\n    return {\n      type: 'horizontalrule',\n      version: 1,\n    }\n  }\n\n  getTextContent(): string {\n    return '\\n'\n  }\n\n  isInline(): false {\n    return false\n  }\n\n  updateDOM(): boolean {\n    return false\n  }\n}\n\nfunction convertHorizontalRuleElement(): DOMConversionOutput {\n  return { node: $createHorizontalRuleNode() }\n}\n\nexport function $createHorizontalRuleNode(): HorizontalRuleNode {\n  return $applyNodeReplacement(new HorizontalRuleNode())\n}\n\nexport function $isHorizontalRuleNode(\n  node: LexicalNode | null | undefined,\n): node is HorizontalRuleNode {\n  return node instanceof HorizontalRuleNode\n}\n"],"names":["lexicalImport","$applyNodeReplacement","DecoratorNode","createCommand","React","HorizontalRuleComponent","lazy","then","module","default","INSERT_HORIZONTAL_RULE_COMMAND","HorizontalRuleNode","clone","node","__key","getType","importDOM","hr","conversion","convertHorizontalRuleElement","priority","importJSON","serializedNode","$createHorizontalRuleNode","createDOM","document","createElement","decorate","nodeKey","exportDOM","element","exportJSON","type","version","getTextContent","isInline","updateDOM","$isHorizontalRuleNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AASA,OAAOA,mBAAmB,UAAS;AACnC,MAAM,EAAEC,qBAAqB,EAAEC,aAAa,EAAEC,aAAa,EAAE,GAAGH;AAChE,YAAYI,WAAW,QAAO;AAE9B,MAAMC,wCAA0BD,MAAME,IAAI,CAAC,IACzC,MAAM,CAAC,yBAAyBC,IAAI,CAAC,CAACC,SAAY,CAAA;YAChDC,SAASD,OAAOH,uBAAuB;QACzC,CAAA;AAQF,OAAO,MAAMK,iCAAuDP,cAClE,kCACD;AAED;;;;;;CAMC,GACD,OAAO,MAAMQ,2BAA2BT;IACtC,OAAOU,MAAMC,IAAwB,EAAsB;QACzD,OAAO,IAAIF,mBAAmBE,KAAKC,KAAK;IAC1C;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA;;;;GAIC,GACD,OAAOC,YAAqC;QAC1C,OAAO;YACLC,IAAI,IAAO,CAAA;oBACTC,YAAYC;oBACZC,UAAU;gBACZ,CAAA;QACF;IACF;IAEA;;GAEC,GACD,OAAOC,WAAWC,cAA4C,EAAsB;QAClF,OAAOC;IACT;IAEA;;GAEC,GACDC,YAAyB;QACvB,OAAOC,SAASC,aAAa,CAAC;IAChC;IAEA;;GAEC,GACDC,WAA+B;QAC7B,qBAAO,oBAACtB;YAAwBuB,SAAS,IAAI,CAACd,KAAK;;IACrD;IAEA;;;;GAIC,GACDe,YAA6B;QAC3B,OAAO;YAAEC,SAASL,SAASC,aAAa,CAAC;QAAM;IACjD;IACA;;GAEC,GACDK,aAAoC;QAClC,OAAO;YACLC,MAAM;YACNC,SAAS;QACX;IACF;IAEAC,iBAAyB;QACvB,OAAO;IACT;IAEAC,WAAkB;QAChB,OAAO;IACT;IAEAC,YAAqB;QACnB,OAAO;IACT;AACF;AAEA,SAASjB;IACP,OAAO;QAAEN,MAAMU;IAA4B;AAC7C;AAEA,OAAO,SAASA;IACd,OAAOtB,sBAAsB,IAAIU;AACnC;AAEA,OAAO,SAAS0B,sBACdxB,IAAoC;IAEpC,OAAOA,gBAAgBF;AACzB"}

package/dist/field/features/horizontalrule/plugin/index.d.ts

@@ -1,6 +0,0 @@
-import './index.scss';
-/**
- * Registers the INSERT_HORIZONTAL_RULE_COMMAND lexical command and defines the behavior for when it is called.
- */
-export declare function HorizontalRulePlugin(): null;
-//# sourceMappingURL=index.d.ts.map

package/dist/field/features/horizontalrule/plugin/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/horizontalrule/plugin/index.tsx"],"names":[],"mappings":"AAeA,OAAO,cAAc,CAAA;AAErB;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CA2B3C"}

package/dist/field/features/horizontalrule/plugin/index.js

@@ -1,34 +0,0 @@
-'use client';
-import lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js';
-const { useLexicalComposerContext } = lexicalComposerContextImport;
-import lexicalUtilsImport from '@lexical/utils';
-const { $insertNodeToNearestRoot } = lexicalUtilsImport;
-import lexicalImport from 'lexical';
-const { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } = lexicalImport;
-import { useEffect } from 'react';
-import { $createHorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from '../nodes/HorizontalRuleNode.js';
-import './index.scss';
-/**
- * Registers the INSERT_HORIZONTAL_RULE_COMMAND lexical command and defines the behavior for when it is called.
- */ export 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;
-}
-
-//# sourceMappingURL=index.js.map

package/dist/field/features/horizontalrule/plugin/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/horizontalrule/plugin/index.tsx"],"sourcesContent":["'use client'\n\nimport lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js'\nconst { useLexicalComposerContext } = lexicalComposerContextImport\nimport lexicalUtilsImport from '@lexical/utils'\nconst { $insertNodeToNearestRoot } = lexicalUtilsImport\n\nimport lexicalImport from 'lexical'\nconst { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR } = lexicalImport\nimport { useEffect } from 'react'\n\nimport {\n  $createHorizontalRuleNode,\n  INSERT_HORIZONTAL_RULE_COMMAND,\n} from '../nodes/HorizontalRuleNode.js'\nimport './index.scss'\n\n/**\n * Registers the INSERT_HORIZONTAL_RULE_COMMAND lexical command and defines the behavior for when it is called.\n */\nexport function HorizontalRulePlugin(): null {\n  const [editor] = useLexicalComposerContext()\n\n  useEffect(() => {\n    return editor.registerCommand(\n      INSERT_HORIZONTAL_RULE_COMMAND,\n      (type) => {\n        const selection = $getSelection()\n\n        if (!$isRangeSelection(selection)) {\n          return false\n        }\n\n        const focusNode = selection.focus.getNode()\n\n        if (focusNode !== null) {\n          const horizontalRuleNode = $createHorizontalRuleNode()\n          $insertNodeToNearestRoot(horizontalRuleNode)\n        }\n\n        return true\n      },\n      COMMAND_PRIORITY_EDITOR,\n    )\n  }, [editor])\n\n  return null\n}\n"],"names":["lexicalComposerContextImport","useLexicalComposerContext","lexicalUtilsImport","$insertNodeToNearestRoot","lexicalImport","$getSelection","$isRangeSelection","COMMAND_PRIORITY_EDITOR","useEffect","$createHorizontalRuleNode","INSERT_HORIZONTAL_RULE_COMMAND","HorizontalRulePlugin","editor","registerCommand","type","selection","focusNode","focus","getNode","horizontalRuleNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAEA,OAAOA,kCAAkC,2CAA0C;AACnF,MAAM,EAAEC,yBAAyB,EAAE,GAAGD;AACtC,OAAOE,wBAAwB,iBAAgB;AAC/C,MAAM,EAAEC,wBAAwB,EAAE,GAAGD;AAErC,OAAOE,mBAAmB,UAAS;AACnC,MAAM,EAAEC,aAAa,EAAEC,iBAAiB,EAAEC,uBAAuB,EAAE,GAAGH;AACtE,SAASI,SAAS,QAAQ,QAAO;AAEjC,SACEC,yBAAyB,EACzBC,8BAA8B,QACzB,iCAAgC;AACvC,OAAO,eAAc;AAErB;;CAEC,GACD,OAAO,SAASC;IACd,MAAM,CAACC,OAAO,GAAGX;IAEjBO,UAAU;QACR,OAAOI,OAAOC,eAAe,CAC3BH,gCACA,CAACI;YACC,MAAMC,YAAYV;YAElB,IAAI,CAACC,kBAAkBS,YAAY;gBACjC,OAAO;YACT;YAEA,MAAMC,YAAYD,UAAUE,KAAK,CAACC,OAAO;YAEzC,IAAIF,cAAc,MAAM;gBACtB,MAAMG,qBAAqBV;gBAC3BN,yBAAyBgB;YAC3B;YAEA,OAAO;QACT,GACAZ;IAEJ,GAAG;QAACK;KAAO;IAEX,OAAO;AACT"}

package/dist/field/features/horizontalrule/plugin/index.scss

@@ -1,20 +0,0 @@
-@import '../../../../scss/styles.scss';
-
-hr {
-  padding: 2px 2px;
-  border: none;
-  margin: 1rem 0;
-  cursor: pointer;
-}
-
-hr:after {
-  content: '';
-  display: block;
-  height: 2px;
-  background-color: var(--theme-elevation-250);
-}
-
-hr.selected {
-  outline: 2px solid var(--theme-success-500);
-  user-select: none;
-}

package/dist/field/features/indent/feature.client.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-export declare const IndentFeatureClientComponent: import("react").FC<undefined>;
-//# sourceMappingURL=feature.client.d.ts.map

package/dist/field/features/indent/feature.client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/field/features/indent/feature.client.tsx"],"names":[],"mappings":";AAkEA,eAAO,MAAM,4BAA4B,+BAA6C,CAAA"}

package/dist/field/features/indent/feature.client.js

@@ -1,58 +0,0 @@
-'use client';
-import lexicalImport from 'lexical';
-const { INDENT_CONTENT_COMMAND, OUTDENT_CONTENT_COMMAND } = lexicalImport;
-import { IndentDecreaseIcon } from '../../lexical/ui/icons/IndentDecrease/index.js';
-import { IndentIncreaseIcon } from '../../lexical/ui/icons/IndentIncrease/index.js';
-import { createClientComponent } from '../createClientComponent.js';
-import { IndentSectionWithEntries } from './floatingSelectToolbarIndentSection.js';
-const IndentFeatureClient = (props)=>{
-    return {
-        clientFeatureProps: props,
-        feature: ()=>({
-                clientFeatureProps: props,
-                floatingSelectToolbar: {
-                    sections: [
-                        IndentSectionWithEntries([
-                            {
-                                ChildComponent: IndentDecreaseIcon,
-                                isActive: ()=>false,
-                                isEnabled: ({ selection })=>{
-                                    if (!selection || !selection?.getNodes()?.length) {
-                                        return false;
-                                    }
-                                    for (const node of selection.getNodes()){
-                                        // If at least one node is indented, this should be active
-                                        if ('__indent' in node && node.__indent > 0 || node.getParent() && '__indent' in node.getParent() && node.getParent().__indent > 0) {
-                                            return true;
-                                        }
-                                    }
-                                    return false;
-                                },
-                                key: 'indent-decrease',
-                                label: `Decrease Indent`,
-                                onClick: ({ editor })=>{
-                                    editor.dispatchCommand(OUTDENT_CONTENT_COMMAND, undefined);
-                                },
-                                order: 1
-                            }
-                        ]),
-                        IndentSectionWithEntries([
-                            {
-                                ChildComponent: IndentIncreaseIcon,
-                                isActive: ()=>false,
-                                key: 'indent-increase',
-                                label: `Increase Indent`,
-                                onClick: ({ editor })=>{
-                                    editor.dispatchCommand(INDENT_CONTENT_COMMAND, undefined);
-                                },
-                                order: 2
-                            }
-                        ])
-                    ]
-                }
-            })
-    };
-};
-export const IndentFeatureClientComponent = createClientComponent(IndentFeatureClient);
-
-//# sourceMappingURL=feature.client.js.map

package/dist/field/features/indent/feature.client.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/indent/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport lexicalImport from 'lexical'\nconst { INDENT_CONTENT_COMMAND, OUTDENT_CONTENT_COMMAND } = lexicalImport\n\nimport type { FeatureProviderProviderClient } from '../types.js'\n\nimport { IndentDecreaseIcon } from '../../lexical/ui/icons/IndentDecrease/index.js'\nimport { IndentIncreaseIcon } from '../../lexical/ui/icons/IndentIncrease/index.js'\nimport { createClientComponent } from '../createClientComponent.js'\nimport { IndentSectionWithEntries } from './floatingSelectToolbarIndentSection.js'\n\nconst IndentFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => ({\n      clientFeatureProps: props,\n      floatingSelectToolbar: {\n        sections: [\n          IndentSectionWithEntries([\n            {\n              ChildComponent: IndentDecreaseIcon,\n              isActive: () => false,\n              isEnabled: ({ selection }) => {\n                if (!selection || !selection?.getNodes()?.length) {\n                  return false\n                }\n                for (const node of selection.getNodes()) {\n                  // If at least one node is indented, this should be active\n                  if (\n                    ('__indent' in node && (node.__indent as number) > 0) ||\n                    (node.getParent() &&\n                      '__indent' in node.getParent() &&\n                      node.getParent().__indent > 0)\n                  ) {\n                    return true\n                  }\n                }\n                return false\n              },\n              key: 'indent-decrease',\n              label: `Decrease Indent`,\n              onClick: ({ editor }) => {\n                editor.dispatchCommand(OUTDENT_CONTENT_COMMAND, undefined)\n              },\n              order: 1,\n            },\n          ]),\n          IndentSectionWithEntries([\n            {\n              ChildComponent: IndentIncreaseIcon,\n              isActive: () => false,\n              key: 'indent-increase',\n              label: `Increase Indent`,\n              onClick: ({ editor }) => {\n                editor.dispatchCommand(INDENT_CONTENT_COMMAND, undefined)\n              },\n              order: 2,\n            },\n          ]),\n        ],\n      },\n    }),\n  }\n}\n\nexport const IndentFeatureClientComponent = createClientComponent(IndentFeatureClient)\n"],"names":["lexicalImport","INDENT_CONTENT_COMMAND","OUTDENT_CONTENT_COMMAND","IndentDecreaseIcon","IndentIncreaseIcon","createClientComponent","IndentSectionWithEntries","IndentFeatureClient","props","clientFeatureProps","feature","floatingSelectToolbar","sections","ChildComponent","isActive","isEnabled","selection","getNodes","length","node","__indent","getParent","key","label","onClick","editor","dispatchCommand","undefined","order","IndentFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAEA,OAAOA,mBAAmB,UAAS;AACnC,MAAM,EAAEC,sBAAsB,EAAEC,uBAAuB,EAAE,GAAGF;AAI5D,SAASG,kBAAkB,QAAQ,iDAAgD;AACnF,SAASC,kBAAkB,QAAQ,iDAAgD;AACnF,SAASC,qBAAqB,QAAQ,8BAA6B;AACnE,SAASC,wBAAwB,QAAQ,0CAAyC;AAElF,MAAMC,sBAAgE,CAACC;IACrE,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,IAAO,CAAA;gBACdD,oBAAoBD;gBACpBG,uBAAuB;oBACrBC,UAAU;wBACRN,yBAAyB;4BACvB;gCACEO,gBAAgBV;gCAChBW,UAAU,IAAM;gCAChBC,WAAW,CAAC,EAAEC,SAAS,EAAE;oCACvB,IAAI,CAACA,aAAa,CAACA,WAAWC,YAAYC,QAAQ;wCAChD,OAAO;oCACT;oCACA,KAAK,MAAMC,QAAQH,UAAUC,QAAQ,GAAI;wCACvC,0DAA0D;wCAC1D,IACE,AAAC,cAAcE,QAAQ,AAACA,KAAKC,QAAQ,GAAc,KAClDD,KAAKE,SAAS,MACb,cAAcF,KAAKE,SAAS,MAC5BF,KAAKE,SAAS,GAAGD,QAAQ,GAAG,GAC9B;4CACA,OAAO;wCACT;oCACF;oCACA,OAAO;gCACT;gCACAE,KAAK;gCACLC,OAAO,CAAC,eAAe,CAAC;gCACxBC,SAAS,CAAC,EAAEC,MAAM,EAAE;oCAClBA,OAAOC,eAAe,CAACxB,yBAAyByB;gCAClD;gCACAC,OAAO;4BACT;yBACD;wBACDtB,yBAAyB;4BACvB;gCACEO,gBAAgBT;gCAChBU,UAAU,IAAM;gCAChBQ,KAAK;gCACLC,OAAO,CAAC,eAAe,CAAC;gCACxBC,SAAS,CAAC,EAAEC,MAAM,EAAE;oCAClBA,OAAOC,eAAe,CAACzB,wBAAwB0B;gCACjD;gCACAC,OAAO;4BACT;yBACD;qBACF;gBACH;YACF,CAAA;IACF;AACF;AAEA,OAAO,MAAMC,+BAA+BxB,sBAAsBE,qBAAoB"}

package/dist/field/features/indent/feature.server.d.ts

@@ -1,3 +0,0 @@
-import type { FeatureProviderProviderServer } from '../types.js';
-export declare const IndentFeature: FeatureProviderProviderServer<undefined, undefined>;
-//# sourceMappingURL=feature.server.d.ts.map

package/dist/field/features/indent/feature.server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/field/features/indent/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAIhE,eAAO,MAAM,aAAa,EAAE,6BAA6B,CAAC,SAAS,EAAE,SAAS,CAY7E,CAAA"}

package/dist/field/features/indent/feature.server.js

@@ -1,16 +0,0 @@
-import { IndentFeatureClientComponent } from './feature.client.js';
-export const IndentFeature = (props)=>{
-    return {
-        feature: ()=>{
-            return {
-                ClientComponent: IndentFeatureClientComponent,
-                clientFeatureProps: null,
-                serverFeatureProps: props
-            };
-        },
-        key: 'indent',
-        serverFeatureProps: props
-    };
-};
-
-//# sourceMappingURL=feature.server.js.map

package/dist/field/features/indent/feature.server.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/indent/feature.server.ts"],"sourcesContent":["import type { FeatureProviderProviderServer } from '../types.js'\n\nimport { IndentFeatureClientComponent } from './feature.client.js'\n\nexport const IndentFeature: FeatureProviderProviderServer<undefined, undefined> = (props) => {\n  return {\n    feature: () => {\n      return {\n        ClientComponent: IndentFeatureClientComponent,\n        clientFeatureProps: null,\n        serverFeatureProps: props,\n      }\n    },\n    key: 'indent',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["IndentFeatureClientComponent","IndentFeature","props","feature","ClientComponent","clientFeatureProps","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;","mappings":"AAEA,SAASA,4BAA4B,QAAQ,sBAAqB;AAElE,OAAO,MAAMC,gBAAqE,CAACC;IACjF,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,iBAAiBJ;gBACjBK,oBAAoB;gBACpBC,oBAAoBJ;YACtB;QACF;QACAK,KAAK;QACLD,oBAAoBJ;IACtB;AACF,EAAC"}

package/dist/field/features/indent/floatingSelectToolbarIndentSection.d.ts

@@ -1,3 +0,0 @@
-import type { FloatingToolbarSection, FloatingToolbarSectionEntry } from '../../lexical/plugins/FloatingSelectToolbar/types.js';
-export declare const IndentSectionWithEntries: (entries: FloatingToolbarSectionEntry[]) => FloatingToolbarSection;
-//# sourceMappingURL=floatingSelectToolbarIndentSection.d.ts.map

package/dist/field/features/indent/floatingSelectToolbarIndentSection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"floatingSelectToolbarIndentSection.d.ts","sourceRoot":"","sources":["../../../../src/field/features/indent/floatingSelectToolbarIndentSection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC5B,MAAM,sDAAsD,CAAA;AAE7D,eAAO,MAAM,wBAAwB,YAC1B,2BAA2B,EAAE,KACrC,sBAOF,CAAA"}

package/dist/field/features/indent/floatingSelectToolbarIndentSection.js

@@ -1,10 +0,0 @@
-export const IndentSectionWithEntries = (entries)=>{
-    return {
-        type: 'buttons',
-        entries,
-        key: 'indent',
-        order: 3
-    };
-};
-
-//# sourceMappingURL=floatingSelectToolbarIndentSection.js.map

package/dist/field/features/indent/floatingSelectToolbarIndentSection.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/indent/floatingSelectToolbarIndentSection.ts"],"sourcesContent":["import type {\n  FloatingToolbarSection,\n  FloatingToolbarSectionEntry,\n} from '../../lexical/plugins/FloatingSelectToolbar/types.js'\n\nexport const IndentSectionWithEntries = (\n  entries: FloatingToolbarSectionEntry[],\n): FloatingToolbarSection => {\n  return {\n    type: 'buttons',\n    entries,\n    key: 'indent',\n    order: 3,\n  }\n}\n"],"names":["IndentSectionWithEntries","entries","type","key","order"],"rangeMappings":";;;;;;;","mappings":"AAKA,OAAO,MAAMA,2BAA2B,CACtCC;IAEA,OAAO;QACLC,MAAM;QACND;QACAE,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/indent/index.scss

@@ -1,4 +0,0 @@
-.floating-select-toolbar-popup__section-indent {
-  display: flex;
-  gap: 2px;
-}

package/dist/field/features/link/drawer/baseFields.d.ts

@@ -1,4 +0,0 @@
-import type { Config } from 'payload/config';
-import type { Field } from 'payload/types';
-export declare const getBaseFields: (config: Config, enabledCollections: false | string[], disabledCollections: false | string[]) => Field[];
-//# sourceMappingURL=baseFields.d.ts.map

package/dist/field/features/link/drawer/baseFields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"baseFields.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/link/drawer/baseFields.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAyB,MAAM,eAAe,CAAA;AAIjE,eAAO,MAAM,aAAa,WAChB,MAAM,sBACM,KAAK,GAAG,MAAM,EAAE,uBACf,KAAK,GAAG,MAAM,EAAE,KACpC,KAAK,EAmHP,CAAA"}