@etrepum/lexical-builder 0.0.15 → 0.0.16

package/dist/AutoFocusPlan.d.ts

@@ -5,11 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-declare module "@etrepum/lexical-builder" {
-    interface LexicalPlanRegistry {
-        [AutoFocusPlan.name]: typeof AutoFocusPlan;
-    }
-}
 export interface AutoFocusConfig {
     /**
      * Where to move the selection when the editor is focused and there is no
@@ -21,5 +16,5 @@ export interface AutoFocusConfig {
  * A Plan to focus the LexicalEditor when the root element is set
  * (typically only when the editor is first created).
  */
-export declare const AutoFocusPlan: import('@etrepum/lexical-builder').LexicalPlan<AutoFocusConfig, "@etrepum/lexical-builder/AutoFocusPlan", unknown>;
+export declare const AutoFocusPlan: import('./types').LexicalPlan<AutoFocusConfig, "@etrepum/lexical-builder/AutoFocusPlan", unknown>;
 //# sourceMappingURL=AutoFocusPlan.d.ts.map

package/dist/AutoFocusPlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AutoFocusPlan.d.ts","sourceRoot":"","sources":["../src/AutoFocusPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,QAAQ,0BAA0B,CAAC;IACxC,UAAU,mBAAmB;QAC3B,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,OAAO,aAAa,CAAC;KAC5C;CACF;AAED,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CAC5C;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,oHAwBxB,CAAC"}
+{"version":3,"file":"AutoFocusPlan.d.ts","sourceRoot":"","sources":["../src/AutoFocusPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CAC5C;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,mGAwBxB,CAAC"}

package/dist/DragonPlan.d.ts

@@ -9,5 +9,5 @@
  * Add Dragon speech to text input support to the editor, via the
  * @lexical/dragon module.
  */
-export declare const DragonPlan: import('@etrepum/lexical-builder').LexicalPlan<{}, "@lexical/dragon", unknown>;
+export declare const DragonPlan: import('./types').LexicalPlan<{}, "@lexical/dragon", unknown>;
 //# sourceMappingURL=DragonPlan.d.ts.map

package/dist/DragonPlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DragonPlan.d.ts","sourceRoot":"","sources":["../src/DragonPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH;;;GAGG;AACH,eAAO,MAAM,UAAU,gFAIrB,CAAC"}
+{"version":3,"file":"DragonPlan.d.ts","sourceRoot":"","sources":["../src/DragonPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH;;;GAGG;AACH,eAAO,MAAM,UAAU,+DAIrB,CAAC"}

package/dist/HistoryPlan.d.ts

@@ -1,10 +1,5 @@
 import { HistoryState } from '@lexical/history';
 
-declare module "@etrepum/lexical-builder" {
-    interface LexicalPlanRegistry {
-        [HistoryPlan.name]: typeof HistoryPlan;
-    }
-}
 export interface HistoryConfig {
     /**
      * The time (in milliseconds) the editor should delay generating a new history stack,
@@ -20,5 +15,5 @@ export interface HistoryConfig {
  * Registers necessary listeners to manage undo/redo history stack and related
  * editor commands, via the @lexical/history module.
  */
-export declare const HistoryPlan: import('@etrepum/lexical-builder').LexicalPlan<HistoryConfig, "@etrepum/lexical-builder/HistoryPlan", unknown>;
+export declare const HistoryPlan: import('./types').LexicalPlan<HistoryConfig, "@etrepum/lexical-builder/HistoryPlan", unknown>;
 //# sourceMappingURL=HistoryPlan.d.ts.map

package/dist/HistoryPlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HistoryPlan.d.ts","sourceRoot":"","sources":["../src/HistoryPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAEL,KAAK,YAAY,EAElB,MAAM,kBAAkB,CAAC;AAM1B,OAAO,QAAQ,0BAA0B,CAAC;IACxC,UAAU,mBAAmB;QAC3B,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,OAAO,WAAW,CAAC;KACxC;CACF;AAED,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,yBAAyB,EAAE,MAAM,YAAY,CAAC;CAC/C;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,gHAStB,CAAC"}
+{"version":3,"file":"HistoryPlan.d.ts","sourceRoot":"","sources":["../src/HistoryPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAEL,KAAK,YAAY,EAElB,MAAM,kBAAkB,CAAC;AAK1B,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,yBAAyB,EAAE,MAAM,YAAY,CAAC;CAC/C;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,+FAStB,CAAC"}

package/dist/LexicalBuilder.d.ts

@@ -1,4 +1,4 @@
-import { AnyLexicalPlan, AnyLexicalPlanArgument, EditorHandle } from './types';
+import { AnyLexicalPlan, AnyLexicalPlanArgument, EditorHandle, RootPlanArgument } from './types';
 import { LexicalEditor, CreateEditorArgs } from 'lexical';
 import { PlanRep } from './PlanRep';
 
@@ -33,19 +33,23 @@ import { PlanRep } from './PlanRep';
  * );
  * ```
  */
-export declare function buildEditorFromPlans(plan: AnyLexicalPlanArgument, ...plans: AnyLexicalPlanArgument[]): EditorHandle;
+export declare function buildEditorFromPlans(plan: AnyLexicalPlanArgument | RootPlanArgument, ...plans: (AnyLexicalPlanArgument | RootPlanArgument)[]): EditorHandle;
+/** @internal */
+export declare function coerceToPlanArgument(plan: AnyLexicalPlanArgument | RootPlanArgument): AnyLexicalPlanArgument;
 /** @internal */
 export declare class LexicalBuilder {
     phases: Map<AnyLexicalPlan, PlanRep<AnyLexicalPlan>>[];
     planMap: Map<AnyLexicalPlan, [number, PlanRep<AnyLexicalPlan>]>;
     planNameMap: Map<string, PlanRep<AnyLexicalPlan>>;
+    reverseEdges: Map<AnyLexicalPlan, Set<AnyLexicalPlan>>;
+    addStack: Set<AnyLexicalPlan>;
     conflicts: Map<string, string>;
     constructor();
     /** Look up the editor that was created by this LexicalBuilder or undefined */
     static fromEditor(editor: LexicalEditor): LexicalBuilder | undefined;
     buildEditor(): EditorHandle;
     getPlanRep<Plan extends AnyLexicalPlan>(plan: Plan): PlanRep<Plan> | undefined;
-    addPlan(arg: AnyLexicalPlanArgument): number;
+    addPlan(arg: AnyLexicalPlanArgument, parent?: AnyLexicalPlan): number;
     sortedPlanReps(): Generator<PlanRep<AnyLexicalPlan>, void, undefined>;
     registerEditor(editor: LexicalEditor): () => void;
     buildCreateEditorArgs(): Pick<CreateEditorArgs, "disableEvents" | "namespace" | "nodes" | "theme" | "html" | "editable"> & Pick<AnyLexicalPlan, "onError" | "$initialEditorState">;

package/dist/LexicalBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LexicalBuilder.d.ts","sourceRoot":"","sources":["../src/LexicalBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EACV,cAAc,EACd,sBAAsB,EACtB,YAAY,EAEb,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,aAAa,EAEb,KAAK,gBAAgB,EAKtB,MAAM,SAAS,CAAC;AAKjB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,sBAAsB,EAC5B,GAAG,KAAK,EAAE,sBAAsB,EAAE,GACjC,YAAY,CAOd;AA+BD,gBAAgB;AAChB,qBAAa,cAAc;IACzB,MAAM,EAAE,GAAG,CAAC,cAAc,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC;IACvD,OAAO,EAAE,GAAG,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAChE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;IAClD,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;;IAU/B,8EAA8E;IAC9E,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS;IAIpE,WAAW,IAAI,YAAY;IAmB3B,UAAU,CAAC,IAAI,SAAS,cAAc,EACpC,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS;IAQ5B,OAAO,CAAC,GAAG,EAAE,sBAAsB,GAAG,MAAM;IA4E3C,cAAc;IAMf,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,IAAI;IAqBjD,qBAAqB;CAqFtB"}
+{"version":3,"file":"LexicalBuilder.d.ts","sourceRoot":"","sources":["../src/LexicalBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EACV,cAAc,EACd,sBAAsB,EACtB,YAAY,EAEZ,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,aAAa,EAEb,KAAK,gBAAgB,EAKtB,MAAM,SAAS,CAAC;AAKjB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,sBAAsB,GAAG,gBAAgB,EAC/C,GAAG,KAAK,EAAE,CAAC,sBAAsB,GAAG,gBAAgB,CAAC,EAAE,GACtD,YAAY,CAOd;AAED,gBAAgB;AAChB,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,sBAAsB,GAAG,gBAAgB,GAC9C,sBAAsB,CAExB;AA+BD,gBAAgB;AAChB,qBAAa,cAAc;IACzB,MAAM,EAAE,GAAG,CAAC,cAAc,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC;IACvD,OAAO,EAAE,GAAG,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAChE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;IAClD,YAAY,EAAE,GAAG,CAAC,cAAc,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC;IACvD,QAAQ,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;IAC9B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;;IAY/B,8EAA8E;IAC9E,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS;IAIpE,WAAW,IAAI,YAAY;IAmB3B,UAAU,CAAC,IAAI,SAAS,cAAc,EACpC,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS;IAQ5B,OAAO,CAAC,GAAG,EAAE,sBAAsB,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM;IA8FpE,cAAc;IAMf,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,IAAI;IAqBjD,qBAAqB;CAqFtB"}

package/dist/PlainTextPlan.d.ts

@@ -1,5 +1,5 @@
 /**
  * A plan to register @lexical/plain-text behavior
  */
-export declare const PlainTextPlan: import('@etrepum/lexical-builder').LexicalPlan<{}, "@lexical/plain-text", unknown>;
+export declare const PlainTextPlan: import('./types').LexicalPlan<{}, "@lexical/plain-text", unknown>;
 //# sourceMappingURL=PlainTextPlan.d.ts.map

package/dist/PlainTextPlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PlainTextPlan.d.ts","sourceRoot":"","sources":["../src/PlainTextPlan.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,eAAO,MAAM,aAAa,oFAKxB,CAAC"}
+{"version":3,"file":"PlainTextPlan.d.ts","sourceRoot":"","sources":["../src/PlainTextPlan.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,eAAO,MAAM,aAAa,mEAKxB,CAAC"}

package/dist/PlanRep.d.ts

@@ -1,6 +1,5 @@
 import { LexicalBuilder } from './LexicalBuilder';
 import { AnyLexicalPlan, LexicalPlanConfig, LexicalPlanDependency, LexicalPlanOutput } from './types';
-import { LexicalPlanRegistry } from '@etrepum/lexical-builder';
 import { LexicalEditor } from 'lexical';
 
 /**
@@ -15,8 +14,9 @@ export declare class PlanRep<Plan extends AnyLexicalPlan> {
     plan: Plan;
     constructor(builder: LexicalBuilder, plan: Plan);
     register(editor: LexicalEditor, signal: AbortSignal): () => void;
-    getPeer<Name extends keyof LexicalPlanRegistry>(name: string): undefined | LexicalPlanDependency<LexicalPlanRegistry[Name]>;
+    getPeer<PeerPlan extends AnyLexicalPlan = never>(name: PeerPlan["name"]): undefined | LexicalPlanDependency<PeerPlan>;
     getDependency<Dependency extends AnyLexicalPlan>(dep: Dependency): LexicalPlanDependency<Dependency>;
+    getDirectDependentNames(): string[];
     getPlanDependency(): LexicalPlanDependency<Plan>;
     getConfig(): LexicalPlanConfig<Plan>;
 }

package/dist/PlanRep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PlanRep.d.ts","sourceRoot":"","sources":["../src/PlanRep.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EACjB,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAKpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG7C;;GAEG;AACH,qBAAa,OAAO,CAAC,IAAI,SAAS,cAAc;IAC9C,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAClC,WAAW,CAAC,EAAE,qBAAqB,CAAC,IAAI,CAAC,CAAC;IAC1C,OAAO,CAAC,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,EAAE,IAAI,CAAC;gBACC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI;IAK/C,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,GAAG,MAAM,IAAI;IAahE,OAAO,CAAC,IAAI,SAAS,MAAM,mBAAmB,EAC5C,IAAI,EAAE,MAAM,GACX,SAAS,GAAG,qBAAqB,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAQ/D,aAAa,CAAC,UAAU,SAAS,cAAc,EAC7C,GAAG,EAAE,UAAU,GACd,qBAAqB,CAAC,UAAU,CAAC;IAWpC,iBAAiB,IAAI,qBAAqB,CAAC,IAAI,CAAC;IAchD,SAAS,IAAI,iBAAiB,CAAC,IAAI,CAAC;CAarC"}
+{"version":3,"file":"PlanRep.d.ts","sourceRoot":"","sources":["../src/PlanRep.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EACjB,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAKjB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG7C;;GAEG;AACH,qBAAa,OAAO,CAAC,IAAI,SAAS,cAAc;IAC9C,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAClC,WAAW,CAAC,EAAE,qBAAqB,CAAC,IAAI,CAAC,CAAC;IAC1C,OAAO,CAAC,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,EAAE,IAAI,CAAC;gBACC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI;IAK/C,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,GAAG,MAAM,IAAI;IAchE,OAAO,CAAC,QAAQ,SAAS,cAAc,GAAG,KAAK,EAC7C,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,GACrB,SAAS,GAAG,qBAAqB,CAAC,QAAQ,CAAC;IAM9C,aAAa,CAAC,UAAU,SAAS,cAAc,EAC7C,GAAG,EAAE,UAAU,GACd,qBAAqB,CAAC,UAAU,CAAC;IAWpC,uBAAuB,IAAI,MAAM,EAAE;IAOnC,iBAAiB,IAAI,qBAAqB,CAAC,IAAI,CAAC;IAchD,SAAS,IAAI,iBAAiB,CAAC,IAAI,CAAC;CAarC"}

package/dist/RichTextPlan.d.ts

@@ -9,5 +9,5 @@
  * A plan to register @lexical/rich-text behavior and nodes
  * ({@link HeadingNode}, {@link QuoteNode})
  */
-export declare const RichTextPlan: import('@etrepum/lexical-builder').LexicalPlan<{}, "@lexical/rich-text", unknown>;
+export declare const RichTextPlan: import('./types').LexicalPlan<{}, "@lexical/rich-text", unknown>;
 //# sourceMappingURL=RichTextPlan.d.ts.map

package/dist/RichTextPlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RichTextPlan.d.ts","sourceRoot":"","sources":["../src/RichTextPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH;;;GAGG;AACH,eAAO,MAAM,YAAY,mFAMvB,CAAC"}
+{"version":3,"file":"RichTextPlan.d.ts","sourceRoot":"","sources":["../src/RichTextPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH;;;GAGG;AACH,eAAO,MAAM,YAAY,kEAMvB,CAAC"}

package/dist/definePlan.d.ts

@@ -1,4 +1,4 @@
-import { LexicalPlan, NormalizedLexicalPlanArgument, PlanConfigBase, RegisterCleanup } from './types';
+import { AnyLexicalPlan, LexicalPlan, LexicalPlanConfig, NormalizedLexicalPlanArgument, NormalizedPeerDependency, PlanConfigBase, RegisterCleanup, RootPlan, RootPlanArgument } from './types';
 
 /**
  * Define a LexicalPlan from the given object literal. TypeScript will
@@ -39,7 +39,8 @@ export declare function definePlan<Config extends PlanConfigBase, Name extends s
  * Define a LexicalPlan from the given object literal, assigning an
  * empty config and the name "[root]". This plan must only be used
  * at most once per editor, usually as the first argument to
- * {@link buildEditorFromPlans}
+ * {@link buildEditorFromPlans} or the plan argument to
+ * {@link LexicalPlanComposer}.
  *
  * @param rootPlan A plan without the config or name properties
  * @returns The given plan argument, after in-place assignment of config and name
@@ -53,7 +54,7 @@ export declare function definePlan<Config extends PlanConfigBase, Name extends s
  * );
  * ```
  */
-export declare function defineRootPlan(rootPlan: Omit<LexicalPlan<PlanConfigBase, "[root]", unknown>, "config" | "name">): LexicalPlan<PlanConfigBase, "[root]", unknown>;
+export declare function defineRootPlan<Output>(rootPlan: RootPlanArgument<Output>): RootPlan<Output>;
 /**
  * Override a partial of the configuration of a Plan, to be used
  * in the dependencies array of another plan, or as
@@ -80,4 +81,7 @@ export declare function defineRootPlan(rootPlan: Omit<LexicalPlan<PlanConfigBase
  */
 export declare function configPlan<Config extends PlanConfigBase, Name extends string, Output>(...args: NormalizedLexicalPlanArgument<Config, Name, Output>): NormalizedLexicalPlanArgument<Config, Name, Output>;
 export declare function provideOutput<Output>(output: Output, cleanup?: () => void): RegisterCleanup<Output>;
+/** @internal */
+export declare const PeerDependencyBrand: unique symbol;
+export declare function declarePeerDependency<Plan extends AnyLexicalPlan = never>(name: Plan["name"], config?: Partial<LexicalPlanConfig<Plan>>): NormalizedPeerDependency<Plan>;
 //# sourceMappingURL=definePlan.d.ts.map

package/dist/definePlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definePlan.d.ts","sourceRoot":"","sources":["../src/definePlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,6BAA6B,EAC7B,cAAc,EACd,eAAe,EAChB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,UAAU,CACxB,MAAM,SAAS,cAAc,EAC7B,IAAI,SAAS,MAAM,EACnB,MAAM,EACN,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAE5E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,IAAI,CACZ,WAAW,CAAC,cAAc,EAAE,QAAQ,EAAE,OAAO,CAAC,EAC9C,QAAQ,GAAG,MAAM,CAClB,GACA,WAAW,CAAC,cAAc,EAAE,QAAQ,EAAE,OAAO,CAAC,CAEhD;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CACxB,MAAM,SAAS,cAAc,EAC7B,IAAI,SAAS,MAAM,EACnB,MAAM,EAEN,GAAG,IAAI,EAAE,6BAA6B,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAC3D,6BAA6B,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAErD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAClC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,IAAI,GACnB,eAAe,CAAC,MAAM,CAAC,CAEzB"}
+{"version":3,"file":"definePlan.d.ts","sourceRoot":"","sources":["../src/definePlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,6BAA6B,EAC7B,wBAAwB,EACxB,cAAc,EACd,eAAe,EACf,QAAQ,EACR,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,UAAU,CACxB,MAAM,SAAS,cAAc,EAC7B,IAAI,SAAS,MAAM,EACnB,MAAM,EACN,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAE5E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EACnC,QAAQ,EAAE,gBAAgB,CAAC,MAAM,CAAC,GACjC,QAAQ,CAAC,MAAM,CAAC,CAElB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CACxB,MAAM,SAAS,cAAc,EAC7B,IAAI,SAAS,MAAM,EACnB,MAAM,EAEN,GAAG,IAAI,EAAE,6BAA6B,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAC3D,6BAA6B,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAErD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAClC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,IAAI,GACnB,eAAe,CAAC,MAAM,CAAC,CAEzB;AAED,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,EAAE,OAAO,MAExC,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,IAAI,SAAS,cAAc,GAAG,KAAK,EACvE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,EAClB,MAAM,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,GACxC,wBAAwB,CAAC,IAAI,CAAC,CAEhC"}

package/dist/getPeerDependencyFromEditor.d.ts

@@ -1,5 +1,5 @@
 import { LexicalEditor } from 'lexical';
-import { LexicalPeerDependency } from './types';
+import { AnyLexicalPlan, LexicalPlanDependency } from './types';
 
 /**
  * Get the finalized config and output of a Plan that was used to build the
@@ -10,22 +10,36 @@ import { LexicalPeerDependency } from './types';
  * config around. Use this version if you do not have a concrete reference to
  * the Plan for some reason (e.g. it is an optional peer dependency).
  *
+ * Both the explicit Plan type and the name are required.
+ *
+ *  @example
+ * ```tsx
+ * getPeerDependencyFromEditor<typeof import("@some/plan").SomePlan>(editor, "@some/plan");
+ * ```
+
  * @param editor The editor that may have been built using plan
  * @param planName The name of the Plan
  * @returns The config and output of the Plan or undefined
  */
-export declare function getPeerDependencyFromEditor<Name extends string>(editor: LexicalEditor, planName: Name): LexicalPeerDependency<Name> | undefined;
+export declare function getPeerDependencyFromEditor<Plan extends AnyLexicalPlan = never>(editor: LexicalEditor, planName: Plan["name"]): LexicalPlanDependency<Plan> | undefined;
 /**
  * Get the finalized config and output of a Plan that was used to build the
  * editor by name.
  *
+ * Both the explicit Plan type and the name are required.
+ *
  * This can be used from the implementation of a LexicalNode or in other
  * situation where you have an editor reference but it's not easy to pass the
  * config around. Use this version if you do not have a concrete reference to
  * the Plan for some reason (e.g. it is an optional peer dependency).
  *
+ * @example
+ * ```tsx
+ * $getPeerDependency<typeof import("@some/plan").SomePlan>("@some/plan")
+ * ```
+ *
  * @param planName The name of the Plan
  * @returns The config and output of the Plan or undefined
  */
-export declare function $getPeerDependency<Name extends string>(planName: Name): LexicalPeerDependency<Name> | undefined;
+export declare function $getPeerDependency<Plan extends AnyLexicalPlan = never>(planName: Plan["name"]): LexicalPlanDependency<Plan> | undefined;
 //# sourceMappingURL=getPeerDependencyFromEditor.d.ts.map

package/dist/getPeerDependencyFromEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPeerDependencyFromEditor.d.ts","sourceRoot":"","sources":["../src/getPeerDependencyFromEditor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,aAAa,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAKhD;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,SAAS,MAAM,EAC7D,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,IAAI,GACb,qBAAqB,CAAC,IAAI,CAAC,GAAG,SAAS,CAWzC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,SAAS,MAAM,EACpD,QAAQ,EAAE,IAAI,GACb,qBAAqB,CAAC,IAAI,CAAC,GAAG,SAAS,CAEzC"}
+{"version":3,"file":"getPeerDependencyFromEditor.d.ts","sourceRoot":"","sources":["../src/getPeerDependencyFromEditor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,aAAa,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAKhE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,SAAS,cAAc,GAAG,KAAK,EAEnC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,GACrB,qBAAqB,CAAC,IAAI,CAAC,GAAG,SAAS,CAWzC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,SAAS,cAAc,GAAG,KAAK,EACpE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,GACrB,qBAAqB,CAAC,IAAI,CAAC,GAAG,SAAS,CAEzC"}

package/dist/index.d.ts

@@ -7,8 +7,8 @@
  */
 export { PACKAGE_VERSION } from './PACKAGE_VERSION';
 export { configPlan, definePlan, defineRootPlan, provideOutput, } from './definePlan';
-export { LexicalBuilder, buildEditorFromPlans } from './LexicalBuilder';
-export { type AnyLexicalPlan, type AnyLexicalPlanArgument, type EditorHandle, type InitialEditorStateType, type LexicalPlan, type LexicalPlanArgument, type LexicalPlanConfig, type LexicalPlanName, type LexicalPlanOutput, type LexicalPlanDependency, type LexicalPeerConfig, type LexicalPeerDependency, type LexicalPeerPlan, type NormalizedLexicalPlanArgument, type PlanConfigBase, type RegisterState, type RegisterCleanup, } from './types';
+export { LexicalBuilder, buildEditorFromPlans, coerceToPlanArgument, } from './LexicalBuilder';
+export { type AnyLexicalPlan, type AnyLexicalPlanArgument, type EditorHandle, type InitialEditorStateType, type LexicalPlan, type LexicalPlanArgument, type LexicalPlanConfig, type LexicalPlanName, type LexicalPlanOutput, type LexicalPlanDependency, type RootPlan, type RootPlanArgument, type NormalizedLexicalPlanArgument, type PlanConfigBase, type RegisterState, type RegisterCleanup, type NormalizedPeerDependency, } from './types';
 export { safeCast } from './safeCast';
 export { shallowMergeConfig } from './shallowMergeConfig';
 export { $getPlanDependency, getPlanDependencyFromEditor, } from './getPlanDependencyFromEditor';
@@ -18,24 +18,4 @@ export { DragonPlan } from './DragonPlan';
 export { type HistoryConfig, HistoryPlan } from './HistoryPlan';
 export { PlainTextPlan } from './PlainTextPlan';
 export { RichTextPlan } from './RichTextPlan';
-/**
- * An open interface for Name -> Config mappings. If you are defining a
- * plan with non-empty config and it may be used as a peerDependency then
- * you should extend this as follows:
- *
- * @example Extending LexicalPlanRegistry
- * ```ts
- * export const SomePlan = definePlan({
- *   name: "@some/plan",
- *   config: { className: "default" }
- * });
- * declare module '@etrepum/lexical-builder' {
- *   interface LexicalPlanRegistry {
- *     [SomePlan.name]: typeof SomePlan;
- *   }
- * }
- * ```
- */
-export interface LexicalPlanRegistry {
-}
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EACL,UAAU,EACV,UAAU,EACV,cAAc,EACd,aAAa,GACd,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,KAAK,6BAA6B,EAClC,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,eAAe,GACrB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,kBAAkB,EAClB,2BAA2B,GAC5B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,kBAAkB,EAClB,2BAA2B,GAC5B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,KAAK,eAAe,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,KAAK,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,mBAAmB;CAAG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EACL,UAAU,EACV,UAAU,EACV,cAAc,EACd,aAAa,GACd,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,6BAA6B,EAClC,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,wBAAwB,GAC9B,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,kBAAkB,EAClB,2BAA2B,GAC5B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,kBAAkB,EAClB,2BAA2B,GAC5B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,KAAK,eAAe,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,KAAK,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -10,7 +10,7 @@ import { registerDragonSupport } from "@lexical/dragon";
 import { createEmptyHistoryState, registerHistory } from "@lexical/history";
 import { registerPlainText } from "@lexical/plain-text";
 import { HeadingNode, QuoteNode, registerRichText } from "@lexical/rich-text";
-const PACKAGE_VERSION = "0.0.15";
+const PACKAGE_VERSION = "0.0.16";
 function definePlan(plan) {
   return plan;
 }
@@ -101,6 +101,7 @@ class PlanRep {
     const cleanup = this.plan.register(editor, this.getConfig(), {
       getPeer: this.getPeer.bind(this),
       getDependency: this.getDependency.bind(this),
+      getDirectDependentNames: this.getDirectDependentNames.bind(this),
       signal
     });
     this._output = cleanup.output;
@@ -120,6 +121,12 @@ class PlanRep {
     );
     return rep.getPlanDependency();
   }
+  getDirectDependentNames() {
+    return Array.from(
+      this.builder.reverseEdges.get(this.plan) || [],
+      (plan) => plan.name
+    );
+  }
   getPlanDependency() {
     if (!this._dependency) {
       invariant(
@@ -149,12 +156,15 @@ class PlanRep {
 const buildersForEditors = /* @__PURE__ */ new WeakMap();
 function buildEditorFromPlans(plan, ...plans) {
   const builder = new LexicalBuilder();
-  builder.addPlan(plan);
+  builder.addPlan(coerceToPlanArgument(plan));
   for (const otherPlan of plans) {
-    builder.addPlan(otherPlan);
+    builder.addPlan(coerceToPlanArgument(otherPlan));
   }
   return builder.buildEditor();
 }
+function coerceToPlanArgument(plan) {
+  return "name" in plan || Array.isArray(plan) ? plan : defineRootPlan(plan);
+}
 function noop() {
 }
 class DisposableEditorHandle {
@@ -184,11 +194,15 @@ class LexicalBuilder {
     __publicField(this, "phases");
     __publicField(this, "planMap");
     __publicField(this, "planNameMap");
+    __publicField(this, "reverseEdges");
+    __publicField(this, "addStack");
     __publicField(this, "conflicts");
     this.phases = [/* @__PURE__ */ new Map()];
     this.planMap = /* @__PURE__ */ new Map();
     this.planNameMap = /* @__PURE__ */ new Map();
     this.conflicts = /* @__PURE__ */ new Map();
+    this.reverseEdges = /* @__PURE__ */ new Map();
+    this.addStack = /* @__PURE__ */ new Set();
   }
   /** Look up the editor that was created by this LexicalBuilder or undefined */
   static fromEditor(editor) {
@@ -218,7 +232,7 @@ class LexicalBuilder {
       return rep;
     }
   }
-  addPlan(arg) {
+  addPlan(arg, parent) {
     let plan;
     let configs;
     if (Array.isArray(arg)) {
@@ -227,6 +241,14 @@ class LexicalBuilder {
       plan = arg;
       configs = [];
     }
+    if (parent) {
+      let edgeSet = this.reverseEdges.get(plan);
+      if (!edgeSet) {
+        edgeSet = /* @__PURE__ */ new Set();
+        this.reverseEdges.set(plan, edgeSet);
+      }
+      edgeSet.add(parent);
+    }
     let [phase, planRep] = this.planMap.get(plan) || [0, void 0];
     if (!planRep) {
       const hasConflict = this.conflicts.get(plan.name);
@@ -247,8 +269,15 @@ class LexicalBuilder {
         );
         this.conflicts.set(name, plan.name);
       }
+      invariant(
+        !this.addStack.has(plan),
+        "LexicalBuilder: Circular dependency detected for Plan %s from %s",
+        plan.name,
+        (parent == null ? void 0 : parent.name) || "[unknown]"
+      );
+      this.addStack.add(plan);
       for (const dep of plan.dependencies || []) {
-        phase = Math.max(phase, 1 + this.addPlan(dep));
+        phase = Math.max(phase, 1 + this.addPlan(dep, plan));
       }
       for (const [depName, cfg] of Object.entries(
         plan.peerDependencies || {}
@@ -258,7 +287,8 @@ class LexicalBuilder {
           phase = Math.max(
             phase,
             1 + this.addPlan(
-              configPlan(dep.plan, cfg)
+              configPlan(dep.plan, cfg),
+              plan
             )
           );
         }
@@ -285,6 +315,7 @@ class LexicalBuilder {
         String(phase)
       );
       currentPhaseMap.set(plan, planRep);
+      this.addStack.delete(plan);
     }
     for (const config of configs) {
       planRep.configs.add(config);
@@ -485,6 +516,7 @@ export {
   PlainTextPlan,
   RichTextPlan,
   buildEditorFromPlans,
+  coerceToPlanArgument,
   configPlan,
   definePlan,
   defineRootPlan,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/PACKAGE_VERSION.ts","../src/definePlan.ts","../src/shared/invariant.ts","../src/deepThemeMergeInPlace.ts","../src/initializeEditor.ts","../src/shallowMergeConfig.ts","../src/PlanRep.ts","../src/LexicalBuilder.ts","../src/safeCast.ts","../src/getPlanDependencyFromEditor.ts","../src/getPeerDependencyFromEditor.ts","../src/AutoFocusPlan.ts","../src/DragonPlan.ts","../src/HistoryPlan.ts","../src/PlainTextPlan.ts","../src/RichTextPlan.ts"],"sourcesContent":["/** The build version of this package (e.g. \"0.16.0\") */\nexport const PACKAGE_VERSION: string = import.meta.env.PACKAGE_VERSION;\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type {\n  LexicalPlan,\n  NormalizedLexicalPlanArgument,\n  PlanConfigBase,\n  RegisterCleanup,\n} from \"./types\";\n\n/**\n * Define a LexicalPlan from the given object literal. TypeScript will\n * infer Config and Name in most cases, but you may want to use\n * {@link safeCast} for config if there are default fields or varying types.\n *\n * @param plan The LexicalPlan\n * @returns The unmodified plan argument (this is only an inference helper)\n *\n * @example Basic example\n * ```ts\n * export const MyPlan = definePlan({\n *   // Plan names must be unique in an editor\n *   name: \"my\",\n *   // Config must be an object, but an empty object is fine\n *   config: {},\n *   nodes: [MyNode],\n * });\n * ```\n *\n * @example Plan with optional configuration\n * ```ts\n * export interface ConfigurableConfig {\n *   optional?: string;\n *   required: number;\n * }\n * export const ConfigurablePlan = definePlan({\n *   name: \"configurable\",\n *   // The Plan's config must satisfy the full config type,\n *   // but using the Plan as a dependency never requires\n *   // configuration and any partial of the config can be specified\n *   config: safeCast<ConfigurableConfig>({ required: 1 }),\n * });\n * ```\n */\nexport function definePlan<\n  Config extends PlanConfigBase,\n  Name extends string,\n  Output,\n>(plan: LexicalPlan<Config, Name, Output>): LexicalPlan<Config, Name, Output> {\n  return plan;\n}\n\n/**\n * Define a LexicalPlan from the given object literal, assigning an\n * empty config and the name \"[root]\". This plan must only be used\n * at most once per editor, usually as the first argument to\n * {@link buildEditorFromPlans}\n *\n * @param rootPlan A plan without the config or name properties\n * @returns The given plan argument, after in-place assignment of config and name\n *\n * @example\n * ```ts\n * const editorHandle = buildEditorFromPlans(\n *   defineRootPlan({\n *     dependencies: [DragonPlan, RichTextPlan, HistoryPlan],\n *   }),\n * );\n * ```\n */\nexport function defineRootPlan(\n  rootPlan: Omit<\n    LexicalPlan<PlanConfigBase, \"[root]\", unknown>,\n    \"config\" | \"name\"\n  >,\n): LexicalPlan<PlanConfigBase, \"[root]\", unknown> {\n  return Object.assign(rootPlan, { name: \"[root]\", config: {} }) as any;\n}\n\n/**\n * Override a partial of the configuration of a Plan, to be used\n * in the dependencies array of another plan, or as\n * an argument to {@link buildEditorFromPlans}.\n *\n * Before building the editor, configurations will be merged using\n * plan.mergeConfig(plan, config) or {@link shallowMergeConfig} if\n * this is not directly implemented by the Plan.\n *\n * @param args A plan followed by one or more config partials for that plan\n * @returns [plan, config, ...configs]\n *\n * @example\n * ```ts\n * export const ReactDecoratorPlan = definePlan({\n *   name: \"react-decorator\",\n *   dependencies: [\n *     configPlan(ReactPlan, {\n *       decorators: [<ReactDecorator />]\n *     }),\n *   ],\n * });\n * ```\n */\nexport function configPlan<\n  Config extends PlanConfigBase,\n  Name extends string,\n  Output,\n>(\n  ...args: NormalizedLexicalPlanArgument<Config, Name, Output>\n): NormalizedLexicalPlanArgument<Config, Name, Output> {\n  return args;\n}\n\nexport function provideOutput<Output>(\n  output: Output,\n  cleanup?: () => void,\n): RegisterCleanup<Output> {\n  return Object.assign(() => cleanup && cleanup(), { output });\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n// invariant(condition, message) will refine types based on \"condition\", and\n// if \"condition\" is false will throw an error. This function is special-cased\n// in flow itself, so we can't name it anything else.\nexport default function invariant(\n  cond?: boolean,\n  message?: string,\n  ...args: string[]\n): asserts cond {\n  if (cond) {\n    return;\n  }\n\n  throw new Error(\n    args.reduce((msg, arg) => msg.replace(\"%s\", String(arg)), message || \"\"),\n  );\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * Recursively merge the given theme configuration in-place.\n *\n * @returns If `a` and `b` are both objects (and `b` is not an Array) then\n * all keys in `b` are merged into `a` then `a` is returned.\n * Otherwise `b` is returned.\n *\n * @example\n * ```ts\n * const a = { a: \"a\", nested: { a: 1 } };\n * const b = { b: \"b\", nested: { b: 2 } };\n * const rval = deepThemeMergeInPlace(a, b);\n * expect(a).toBe(rval);\n * expect(a).toEqual({ a: \"a\", b: \"b\", nested: { a: 1, b: 2 } });\n * ```\n */\nexport function deepThemeMergeInPlace(a: unknown, b: unknown) {\n  if (\n    a &&\n    b &&\n    !Array.isArray(b) &&\n    typeof a === \"object\" &&\n    typeof b === \"object\"\n  ) {\n    const aObj = a as Record<string, unknown>;\n    const bObj = b as Record<string, unknown>;\n    for (const k in bObj) {\n      aObj[k] = deepThemeMergeInPlace(aObj[k], bObj[k]);\n    }\n    return a;\n  }\n  return b;\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { InitialEditorStateType } from \"./types\";\n\nimport { $createParagraphNode, $getRoot, type LexicalEditor } from \"lexical\";\n\nconst HISTORY_MERGE_OPTIONS = { tag: \"history-merge\" };\n\nfunction $defaultInitializer() {\n  const root = $getRoot();\n  if (root.isEmpty()) {\n    root.append($createParagraphNode());\n  }\n}\n\nexport function initializeEditor(\n  editor: LexicalEditor,\n  $initialEditorState: InitialEditorStateType = $defaultInitializer,\n): void {\n  switch (typeof $initialEditorState) {\n    case \"function\": {\n      editor.update(() => $initialEditorState(editor), HISTORY_MERGE_OPTIONS);\n      break;\n    }\n    case \"string\": {\n      const parsedEditorState = editor.parseEditorState($initialEditorState);\n      editor.setEditorState(parsedEditorState, HISTORY_MERGE_OPTIONS);\n      break;\n    }\n    case \"object\": {\n      if ($initialEditorState) {\n        editor.setEditorState($initialEditorState, HISTORY_MERGE_OPTIONS);\n      }\n      break;\n    }\n  }\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport type { PlanConfigBase } from \"./types\";\n\n/**\n * The default merge strategy for plan configuration is a shallow merge.\n *\n * @param config A full config\n * @param overrides A partial config of overrides\n * @returns config if there are no overrides, otherwise `{...config, ...overrides}`\n */\nexport function shallowMergeConfig<T extends PlanConfigBase>(\n  config: T,\n  overrides?: Partial<T>,\n): T {\n  if (!overrides || config === overrides) {\n    return config;\n  }\n  for (const k in overrides) {\n    if (config[k] !== overrides[k]) {\n      return { ...config, ...overrides };\n    }\n  }\n  return config;\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { LexicalBuilder } from \"./LexicalBuilder\";\nimport type {\n  AnyLexicalPlan,\n  LexicalPlanConfig,\n  LexicalPlanDependency,\n  LexicalPlanOutput,\n} from \"./types\";\nimport type { LexicalPlanRegistry } from \"@etrepum/lexical-builder\";\n\nimport invariant from \"./shared/invariant\";\n\nimport { shallowMergeConfig } from \"./shallowMergeConfig\";\nimport type { LexicalEditor } from \"lexical\";\n\nconst noop = () => {};\n/**\n * @internal\n */\nexport class PlanRep<Plan extends AnyLexicalPlan> {\n  builder: LexicalBuilder;\n  configs: Set<Partial<LexicalPlanConfig<Plan>>>;\n  _config?: LexicalPlanConfig<Plan>;\n  _dependency?: LexicalPlanDependency<Plan>;\n  _output?: LexicalPlanOutput<Plan>;\n  plan: Plan;\n  constructor(builder: LexicalBuilder, plan: Plan) {\n    this.builder = builder;\n    this.plan = plan;\n    this.configs = new Set();\n  }\n  register(editor: LexicalEditor, signal: AbortSignal): () => void {\n    if (!this.plan.register) {\n      this._output = undefined;\n      return noop;\n    }\n    const cleanup = this.plan.register(editor, this.getConfig(), {\n      getPeer: this.getPeer.bind(this),\n      getDependency: this.getDependency.bind(this),\n      signal,\n    });\n    this._output = cleanup.output as LexicalPlanOutput<Plan>;\n    return cleanup;\n  }\n  getPeer<Name extends keyof LexicalPlanRegistry>(\n    name: string,\n  ): undefined | LexicalPlanDependency<LexicalPlanRegistry[Name]> {\n    const rep = this.builder.planNameMap.get(name);\n    return rep\n      ? (rep.getPlanDependency() as LexicalPlanDependency<\n          LexicalPlanRegistry[Name]\n        >)\n      : undefined;\n  }\n  getDependency<Dependency extends AnyLexicalPlan>(\n    dep: Dependency,\n  ): LexicalPlanDependency<Dependency> {\n    const rep = this.builder.getPlanRep(dep);\n    invariant(\n      rep !== undefined,\n      \"LexicalPlanBuilder: Plan %s missing dependency plan %s to be in registry\",\n      this.plan.name,\n      dep.name,\n    );\n    return rep.getPlanDependency();\n  }\n\n  getPlanDependency(): LexicalPlanDependency<Plan> {\n    if (!this._dependency) {\n      invariant(\n        \"_output\" in this,\n        \"Plan %s used as a dependency before registration\",\n        this.plan.name,\n      );\n      this._dependency = {\n        config: this.getConfig(),\n        output: this._output!,\n      };\n    }\n    return this._dependency;\n  }\n  getConfig(): LexicalPlanConfig<Plan> {\n    if (!this._config) {\n      let config = this.plan.config;\n      const mergeConfig = this.plan.mergeConfig\n        ? this.plan.mergeConfig.bind(this.plan)\n        : shallowMergeConfig;\n      for (const cfg of this.configs) {\n        config = mergeConfig(config, cfg);\n      }\n      this._config = config;\n    }\n    return this._config;\n  }\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport type {\n  AnyLexicalPlan,\n  AnyLexicalPlanArgument,\n  EditorHandle,\n  LexicalPlanConfig,\n} from \"./types\";\n\nimport {\n  LexicalEditor,\n  createEditor,\n  type CreateEditorArgs,\n  type EditorThemeClasses,\n  type HTMLConfig,\n  type KlassConstructor,\n  type LexicalNode,\n} from \"lexical\";\nimport invariant from \"./shared/invariant\";\n\nimport { deepThemeMergeInPlace } from \"./deepThemeMergeInPlace\";\nimport { initializeEditor } from \"./initializeEditor\";\nimport { PlanRep } from \"./PlanRep\";\nimport { mergeRegister } from \"@lexical/utils\";\nimport { configPlan } from \"./definePlan\";\n\nconst buildersForEditors = new WeakMap<LexicalEditor, LexicalBuilder>();\n\n/**\n * Build a LexicalEditor by combining together one or more plans, optionally\n * overriding some of their configuration.\n *\n * @param plan A plan argument (a plan, or a plan with config overrides)\n * @param plans Optional additional plan arguments\n * @returns An editor handle\n *\n * @example A single root plan with multiple dependencies\n * ```ts\n * const editorHandle = buildEditorFromPlans(\n *   defineRootPlan({\n *     dependencies: [\n *       RichTextPlan,\n *       configPlan(EmojiPlan, { emojiBaseUrl: \"/assets/emoji\" }),\n *     ],\n *     register: (editor: LexicalEditor) => {\n *       console.log(\"Editor Created\");\n *       return () => console.log(\"Editor Disposed\");\n *     },\n *   }),\n * );\n * ```\n * @example A very similar minimal configuration without the register hook\n * ```ts\n * const editorHandle = buildEditorFromPlans(\n *   RichTextPlan,\n *   configPlan(EmojiPlan, { emojiBaseUrl: \"/assets/emoji\" }),\n * );\n * ```\n */\nexport function buildEditorFromPlans(\n  plan: AnyLexicalPlanArgument,\n  ...plans: AnyLexicalPlanArgument[]\n): EditorHandle {\n  const builder = new LexicalBuilder();\n  builder.addPlan(plan);\n  for (const otherPlan of plans) {\n    builder.addPlan(otherPlan);\n  }\n  return builder.buildEditor();\n}\n\n/** @internal */\nfunction noop() {}\n\n/** @internal */\nclass DisposableEditorHandle implements EditorHandle {\n  editor: LexicalEditor;\n  dispose: () => void;\n  constructor(editor: LexicalEditor, dispose: () => void) {\n    this.editor = editor;\n    this.dispose = () => {\n      try {\n        dispose();\n      } finally {\n        this.dispose = noop;\n      }\n    };\n  }\n  // This should be safe even if the runtime doesn't have Symbol.dispose\n  // because it will just be `handle[undefined] = dispose;`\n  [Symbol.dispose]() {\n    this.dispose();\n  }\n}\n\n/** Throw the given Error */\nfunction defaultOnError(err: Error) {\n  throw err;\n}\n\n/** @internal */\nexport class LexicalBuilder {\n  phases: Map<AnyLexicalPlan, PlanRep<AnyLexicalPlan>>[];\n  planMap: Map<AnyLexicalPlan, [number, PlanRep<AnyLexicalPlan>]>;\n  planNameMap: Map<string, PlanRep<AnyLexicalPlan>>;\n  conflicts: Map<string, string>;\n\n  constructor() {\n    // closure compiler can't handle class initializers\n    this.phases = [new Map()];\n    this.planMap = new Map();\n    this.planNameMap = new Map();\n    this.conflicts = new Map();\n  }\n\n  /** Look up the editor that was created by this LexicalBuilder or undefined */\n  static fromEditor(editor: LexicalEditor): LexicalBuilder | undefined {\n    return buildersForEditors.get(editor);\n  }\n\n  buildEditor(): EditorHandle {\n    const { $initialEditorState, onError, ...editorConfig } =\n      this.buildCreateEditorArgs();\n    const editor = createEditor({\n      ...editorConfig,\n      ...(onError ? { onError: (err) => onError(err, editor) } : {}),\n    });\n    initializeEditor(editor, $initialEditorState);\n    buildersForEditors.set(editor, this);\n    return new DisposableEditorHandle(\n      editor,\n      mergeRegister(\n        () => buildersForEditors.delete(editor),\n        () => editor.setRootElement(null),\n        this.registerEditor(editor),\n      ),\n    );\n  }\n\n  getPlanRep<Plan extends AnyLexicalPlan>(\n    plan: Plan,\n  ): PlanRep<Plan> | undefined {\n    const pair = this.planMap.get(plan);\n    if (pair) {\n      const rep: PlanRep<AnyLexicalPlan> = pair[1];\n      return rep as PlanRep<Plan>;\n    }\n  }\n\n  addPlan(arg: AnyLexicalPlanArgument): number {\n    let plan: AnyLexicalPlan;\n    let configs: unknown[];\n    if (Array.isArray(arg)) {\n      [plan, ...configs] = arg;\n    } else {\n      plan = arg;\n      configs = [];\n    }\n    let [phase, planRep] = this.planMap.get(plan) || [0, undefined];\n    if (!planRep) {\n      const hasConflict = this.conflicts.get(plan.name);\n      if (typeof hasConflict === \"string\") {\n        invariant(\n          false,\n          \"LexicalBuilder: plan %s conflicts with %s\",\n          plan.name,\n          hasConflict,\n        );\n      }\n      for (const name of plan.conflictsWith || []) {\n        invariant(\n          !this.planNameMap.has(name),\n          \"LexicalBuilder: plan %s conflicts with %s\",\n          plan.name,\n          name,\n        );\n        this.conflicts.set(name, plan.name);\n      }\n      // TODO detect circular dependencies\n      for (const dep of plan.dependencies || []) {\n        phase = Math.max(phase, 1 + this.addPlan(dep));\n      }\n      for (const [depName, cfg] of Object.entries(\n        plan.peerDependencies || {},\n      )) {\n        const dep = this.planNameMap.get(depName);\n        if (dep) {\n          phase = Math.max(\n            phase,\n            1 +\n              this.addPlan(\n                configPlan(dep.plan, cfg as LexicalPlanConfig<typeof dep.plan>),\n              ),\n          );\n        }\n      }\n      invariant(\n        this.phases.length >= phase,\n        \"LexicalBuilder: Expected phase to be no greater than phases.length\",\n      );\n      if (this.phases.length === phase) {\n        this.phases.push(new Map());\n      }\n      planRep = new PlanRep(this, plan);\n      invariant(\n        !this.planNameMap.has(plan.name),\n        \"LexicalBuilder: Multiple plans registered with name %s, names must be unique\",\n        plan.name,\n      );\n      this.planMap.set(plan, [phase, planRep]);\n      this.planNameMap.set(plan.name, planRep);\n      const currentPhaseMap = this.phases[phase];\n      invariant(\n        currentPhaseMap !== undefined,\n        \"LexicalBuilder: Expecting phase map for phase %s\",\n        String(phase),\n      );\n      currentPhaseMap.set(plan, planRep);\n    }\n    for (const config of configs) {\n      planRep.configs.add(config as Partial<LexicalPlanConfig<AnyLexicalPlan>>);\n    }\n    return phase;\n  }\n\n  *sortedPlanReps() {\n    for (const phase of this.phases) {\n      yield* phase.values();\n    }\n  }\n\n  registerEditor(editor: LexicalEditor): () => void {\n    const cleanups: (() => void)[] = [];\n    const controller = new AbortController();\n    for (const planRep of this.sortedPlanReps()) {\n      cleanups.push(planRep.register(editor, controller.signal));\n    }\n    return () => {\n      for (let i = cleanups.length - 1; i >= 0; i--) {\n        const cleanupFun = cleanups[i];\n        invariant(\n          cleanupFun !== undefined,\n          \"LexicalBuilder: Expecting cleanups[%s] to be defined\",\n          String(i),\n        );\n        cleanupFun();\n      }\n      cleanups.length = 0;\n      controller.abort();\n    };\n  }\n\n  buildCreateEditorArgs() {\n    const config: Pick<\n      CreateEditorArgs,\n      \"nodes\" | \"html\" | \"theme\" | \"disableEvents\" | \"editable\" | \"namespace\"\n    > &\n      Pick<AnyLexicalPlan, \"$initialEditorState\" | \"onError\"> = {\n      // Prefer throwing errors rather than console.error by default\n      onError: defaultOnError,\n    };\n    const nodes = new Set<NonNullable<CreateEditorArgs[\"nodes\"]>[number]>();\n    const replacedNodes = new Map<\n      KlassConstructor<typeof LexicalNode>,\n      PlanRep<AnyLexicalPlan>\n    >();\n    const htmlExport: NonNullable<HTMLConfig[\"export\"]> = new Map();\n    const htmlImport: NonNullable<HTMLConfig[\"import\"]> = {};\n    const theme: EditorThemeClasses = {};\n    for (const planRep of this.sortedPlanReps()) {\n      const { plan } = planRep;\n      if (plan.onError !== undefined) {\n        config.onError = plan.onError;\n      }\n      if (plan.disableEvents !== undefined) {\n        config.disableEvents = plan.disableEvents;\n      }\n      if (plan.editable !== undefined) {\n        config.editable = plan.editable;\n      }\n      if (plan.namespace !== undefined) {\n        config.namespace = plan.namespace;\n      }\n      if (plan.$initialEditorState !== undefined) {\n        config.$initialEditorState = plan.$initialEditorState;\n      }\n      if (plan.nodes) {\n        for (const node of plan.nodes) {\n          if (typeof node !== \"function\") {\n            const conflictPlan = replacedNodes.get(node.replace);\n            if (conflictPlan) {\n              invariant(\n                false,\n                \"LexicalBuilder: Plan %s can not register replacement for node %s because %s already did\",\n                plan.name,\n                node.replace.name,\n                conflictPlan.plan.name,\n              );\n            }\n            replacedNodes.set(node.replace, planRep);\n          }\n          nodes.add(node);\n        }\n      }\n      if (plan.html) {\n        if (plan.html.export) {\n          for (const [k, v] of plan.html.export.entries()) {\n            htmlExport.set(k, v);\n          }\n        }\n        if (plan.html.import) {\n          Object.assign(htmlImport, plan.html.import);\n        }\n      }\n      if (plan.theme) {\n        deepThemeMergeInPlace(theme, plan.theme);\n      }\n    }\n    if (Object.keys(theme).length > 0) {\n      config.theme = theme;\n    }\n    if (nodes.size) {\n      config.nodes = [...nodes];\n    }\n    const hasImport = Object.keys(htmlImport).length > 0;\n    const hasExport = htmlExport.size > 0;\n    if (hasImport || hasExport) {\n      config.html = {};\n      if (hasImport) {\n        config.html.import = htmlImport;\n      }\n      if (hasExport) {\n        config.html.export = htmlExport;\n      }\n    }\n    return config;\n  }\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * Explicitly and safely cast a value to a specific type when inference or\n * satisfies isn't going to work as expected (often useful for the config\n * property with definePlan)\n */\nexport function safeCast<T>(value: T): T {\n  return value;\n}\n","import { $getEditor, LexicalEditor } from \"lexical\";\nimport { AnyLexicalPlan, LexicalPlanDependency } from \"./types\";\nimport { LexicalBuilder } from \"./LexicalBuilder\";\nimport invariant from \"./shared/invariant\";\nimport { PACKAGE_VERSION } from \"./PACKAGE_VERSION\";\nimport { PlanRep } from \"./PlanRep\";\n\n/**\n * Get the finalized config and output of a Plan that was used to build the editor.\n *\n * This is useful in the implementation of a LexicalNode or in other\n * situations where you have an editor reference but it's not easy to\n * pass the config or {@link RegisterState} around.\n *\n * It will throw if the Editor was not built using this Plan.\n *\n * @param editor The editor that was built using plan\n * @param plan The concrete reference to a Plan used to build this editor\n * @returns The config and output for that Plan\n */\nexport function getPlanDependencyFromEditor<Plan extends AnyLexicalPlan>(\n  editor: LexicalEditor,\n  plan: Plan,\n): LexicalPlanDependency<Plan> {\n  const builder = LexicalBuilder.fromEditor(editor);\n  invariant(\n    builder !== undefined,\n    \"getPlanFromEditor: editor was not created with this build of Lexical Builder %s\",\n    PACKAGE_VERSION,\n  );\n  const rep = builder.getPlanRep(plan);\n  invariant(\n    rep !== undefined,\n    \"getPlanFromEditor: Plan %s was not built when creating this editor\",\n    plan.name,\n  );\n  return rep.getPlanDependency();\n}\n\n/**\n * Get the finalized config and output of a Plan that was used to build the editor.\n *\n * This is useful in the implementation of a LexicalNode or in other\n * situations where you have an editor reference but it's not easy to\n * pass the config or {@link RegisterState} around.\n *\n * It will throw if the Editor was not built using this Plan.\n *\n * @param plan The concrete reference to a Plan used to build this editor\n * @returns The config and outputs for that Plan\n */\nexport function $getPlanDependency<Plan extends AnyLexicalPlan>(\n  plan: Plan,\n): LexicalPlanDependency<Plan> {\n  return getPlanDependencyFromEditor($getEditor(), plan);\n}\n","import { $getEditor, LexicalEditor } from \"lexical\";\nimport { LexicalPeerDependency } from \"./types\";\nimport { LexicalBuilder } from \"./LexicalBuilder\";\nimport invariant from \"./shared/invariant\";\nimport { PACKAGE_VERSION } from \"./PACKAGE_VERSION\";\n\n/**\n * Get the finalized config and output of a Plan that was used to build the\n * editor by name.\n *\n * This can be used from the implementation of a LexicalNode or in other\n * situation where you have an editor reference but it's not easy to pass the\n * config around. Use this version if you do not have a concrete reference to\n * the Plan for some reason (e.g. it is an optional peer dependency).\n *\n * @param editor The editor that may have been built using plan\n * @param planName The name of the Plan\n * @returns The config and output of the Plan or undefined\n */\nexport function getPeerDependencyFromEditor<Name extends string>(\n  editor: LexicalEditor,\n  planName: Name,\n): LexicalPeerDependency<Name> | undefined {\n  const builder = LexicalBuilder.fromEditor(editor);\n  invariant(\n    builder !== undefined,\n    \"getPeerConfigFromEditor: editor was not created with this build of Lexical Builder %s\",\n    PACKAGE_VERSION,\n  );\n  const peer = builder.planNameMap.get(planName);\n  return peer\n    ? (peer.getPlanDependency() as LexicalPeerDependency<Name>)\n    : undefined;\n}\n\n/**\n * Get the finalized config and output of a Plan that was used to build the\n * editor by name.\n *\n * This can be used from the implementation of a LexicalNode or in other\n * situation where you have an editor reference but it's not easy to pass the\n * config around. Use this version if you do not have a concrete reference to\n * the Plan for some reason (e.g. it is an optional peer dependency).\n *\n * @param planName The name of the Plan\n * @returns The config and output of the Plan or undefined\n */\nexport function $getPeerDependency<Name extends string>(\n  planName: Name,\n): LexicalPeerDependency<Name> | undefined {\n  return getPeerDependencyFromEditor($getEditor(), planName);\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { definePlan } from \"./definePlan\";\nimport { safeCast } from \"./safeCast\";\n\nimport type {} from \"@etrepum/lexical-builder\";\ndeclare module \"@etrepum/lexical-builder\" {\n  interface LexicalPlanRegistry {\n    [AutoFocusPlan.name]: typeof AutoFocusPlan;\n  }\n}\n\nexport interface AutoFocusConfig {\n  /**\n   * Where to move the selection when the editor is focused and there is no\n   * existing selection. Can be \"rootStart\" or \"rootEnd\" (the default).\n   */\n  defaultSelection?: \"rootStart\" | \"rootEnd\";\n}\n\n/**\n * A Plan to focus the LexicalEditor when the root element is set\n * (typically only when the editor is first created).\n */\nexport const AutoFocusPlan = definePlan({\n  config: safeCast<AutoFocusConfig>({}),\n  name: \"@etrepum/lexical-builder/AutoFocusPlan\",\n  register(editor, { defaultSelection }) {\n    return editor.registerRootListener((rootElement) => {\n      editor.focus(\n        () => {\n          // If we try and move selection to the same point with setBaseAndExtent, it won't\n          // trigger a re-focus on the element. So in the case this occurs, we'll need to correct it.\n          // Normally this is fine, Selection API !== Focus API, but fore the intents of the naming\n          // of this plugin, which should preserve focus too.\n          const activeElement = document.activeElement;\n          if (\n            rootElement !== null &&\n            (activeElement === null || !rootElement.contains(activeElement))\n          ) {\n            // Note: preventScroll won't work in Webkit.\n            rootElement.focus({ preventScroll: true });\n          }\n        },\n        { defaultSelection },\n      );\n    });\n  },\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { registerDragonSupport } from \"@lexical/dragon\";\n\nimport { definePlan } from \"./definePlan\";\n\n/**\n * Add Dragon speech to text input support to the editor, via the\n * @lexical/dragon module.\n */\nexport const DragonPlan = definePlan({\n  config: {},\n  name: \"@lexical/dragon\",\n  register: registerDragonSupport,\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport {\n  createEmptyHistoryState,\n  type HistoryState,\n  registerHistory,\n} from \"@lexical/history\";\n\nimport { definePlan } from \"./definePlan\";\nimport { safeCast } from \"./safeCast\";\n\nimport type {} from \"@etrepum/lexical-builder\";\ndeclare module \"@etrepum/lexical-builder\" {\n  interface LexicalPlanRegistry {\n    [HistoryPlan.name]: typeof HistoryPlan;\n  }\n}\n\nexport interface HistoryConfig {\n  /**\n   * The time (in milliseconds) the editor should delay generating a new history stack,\n   * instead of merging the current changes with the current stack. The default is 300ms.\n   */\n  delay: number;\n  /**\n   * The initial history state, the default is {@link createEmptyHistoryState}.\n   */\n  createInitialHistoryState: () => HistoryState;\n}\n\n/**\n * Registers necessary listeners to manage undo/redo history stack and related\n * editor commands, via the @lexical/history module.\n */\nexport const HistoryPlan = definePlan({\n  config: safeCast<HistoryConfig>({\n    createInitialHistoryState: createEmptyHistoryState,\n    delay: 300,\n  }),\n  name: \"@etrepum/lexical-builder/HistoryPlan\",\n  register(editor, { delay, createInitialHistoryState }) {\n    return registerHistory(editor, createInitialHistoryState(), delay);\n  },\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport { registerPlainText } from \"@lexical/plain-text\";\n\nimport { definePlan } from \"./definePlan\";\n\n/**\n * A plan to register @lexical/plain-text behavior\n */\nexport const PlainTextPlan = definePlan({\n  config: {},\n  conflictsWith: [\"@lexical/rich-text\"],\n  name: \"@lexical/plain-text\",\n  register: registerPlainText,\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { HeadingNode, QuoteNode, registerRichText } from \"@lexical/rich-text\";\n\nimport { definePlan } from \"./definePlan\";\n\n/**\n * A plan to register @lexical/rich-text behavior and nodes\n * ({@link HeadingNode}, {@link QuoteNode})\n */\nexport const RichTextPlan = definePlan({\n  config: {},\n  conflictsWith: [\"@lexical/plain-text\"],\n  name: \"@lexical/rich-text\",\n  nodes: [HeadingNode, QuoteNode],\n  register: registerRichText,\n});\n"],"names":["noop"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../src/PACKAGE_VERSION.ts","../src/definePlan.ts","../src/shared/invariant.ts","../src/deepThemeMergeInPlace.ts","../src/initializeEditor.ts","../src/shallowMergeConfig.ts","../src/PlanRep.ts","../src/LexicalBuilder.ts","../src/safeCast.ts","../src/getPlanDependencyFromEditor.ts","../src/getPeerDependencyFromEditor.ts","../src/AutoFocusPlan.ts","../src/DragonPlan.ts","../src/HistoryPlan.ts","../src/PlainTextPlan.ts","../src/RichTextPlan.ts"],"sourcesContent":["/** The build version of this package (e.g. \"0.16.0\") */\nexport const PACKAGE_VERSION: string = import.meta.env.PACKAGE_VERSION;\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type {\n  AnyLexicalPlan,\n  LexicalPlan,\n  LexicalPlanConfig,\n  NormalizedLexicalPlanArgument,\n  NormalizedPeerDependency,\n  PlanConfigBase,\n  RegisterCleanup,\n  RootPlan,\n  RootPlanArgument,\n} from \"./types\";\n\n/**\n * Define a LexicalPlan from the given object literal. TypeScript will\n * infer Config and Name in most cases, but you may want to use\n * {@link safeCast} for config if there are default fields or varying types.\n *\n * @param plan The LexicalPlan\n * @returns The unmodified plan argument (this is only an inference helper)\n *\n * @example Basic example\n * ```ts\n * export const MyPlan = definePlan({\n *   // Plan names must be unique in an editor\n *   name: \"my\",\n *   // Config must be an object, but an empty object is fine\n *   config: {},\n *   nodes: [MyNode],\n * });\n * ```\n *\n * @example Plan with optional configuration\n * ```ts\n * export interface ConfigurableConfig {\n *   optional?: string;\n *   required: number;\n * }\n * export const ConfigurablePlan = definePlan({\n *   name: \"configurable\",\n *   // The Plan's config must satisfy the full config type,\n *   // but using the Plan as a dependency never requires\n *   // configuration and any partial of the config can be specified\n *   config: safeCast<ConfigurableConfig>({ required: 1 }),\n * });\n * ```\n */\nexport function definePlan<\n  Config extends PlanConfigBase,\n  Name extends string,\n  Output,\n>(plan: LexicalPlan<Config, Name, Output>): LexicalPlan<Config, Name, Output> {\n  return plan;\n}\n\n/**\n * Define a LexicalPlan from the given object literal, assigning an\n * empty config and the name \"[root]\". This plan must only be used\n * at most once per editor, usually as the first argument to\n * {@link buildEditorFromPlans} or the plan argument to\n * {@link LexicalPlanComposer}.\n *\n * @param rootPlan A plan without the config or name properties\n * @returns The given plan argument, after in-place assignment of config and name\n *\n * @example\n * ```ts\n * const editorHandle = buildEditorFromPlans(\n *   defineRootPlan({\n *     dependencies: [DragonPlan, RichTextPlan, HistoryPlan],\n *   }),\n * );\n * ```\n */\nexport function defineRootPlan<Output>(\n  rootPlan: RootPlanArgument<Output>,\n): RootPlan<Output> {\n  return Object.assign(rootPlan, { name: \"[root]\", config: {} } as const);\n}\n\n/**\n * Override a partial of the configuration of a Plan, to be used\n * in the dependencies array of another plan, or as\n * an argument to {@link buildEditorFromPlans}.\n *\n * Before building the editor, configurations will be merged using\n * plan.mergeConfig(plan, config) or {@link shallowMergeConfig} if\n * this is not directly implemented by the Plan.\n *\n * @param args A plan followed by one or more config partials for that plan\n * @returns [plan, config, ...configs]\n *\n * @example\n * ```ts\n * export const ReactDecoratorPlan = definePlan({\n *   name: \"react-decorator\",\n *   dependencies: [\n *     configPlan(ReactPlan, {\n *       decorators: [<ReactDecorator />]\n *     }),\n *   ],\n * });\n * ```\n */\nexport function configPlan<\n  Config extends PlanConfigBase,\n  Name extends string,\n  Output,\n>(\n  ...args: NormalizedLexicalPlanArgument<Config, Name, Output>\n): NormalizedLexicalPlanArgument<Config, Name, Output> {\n  return args;\n}\n\nexport function provideOutput<Output>(\n  output: Output,\n  cleanup?: () => void,\n): RegisterCleanup<Output> {\n  return Object.assign(() => cleanup && cleanup(), { output } as const);\n}\n\n/** @internal */\nexport const PeerDependencyBrand: unique symbol = Symbol.for(\n  \"@etrepum/lexical-builder/PeerDependency\",\n);\n\nexport function declarePeerDependency<Plan extends AnyLexicalPlan = never>(\n  name: Plan[\"name\"],\n  config?: Partial<LexicalPlanConfig<Plan>>,\n): NormalizedPeerDependency<Plan> {\n  return [name, config] as NormalizedPeerDependency<Plan>;\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n// invariant(condition, message) will refine types based on \"condition\", and\n// if \"condition\" is false will throw an error. This function is special-cased\n// in flow itself, so we can't name it anything else.\nexport default function invariant(\n  cond?: boolean,\n  message?: string,\n  ...args: string[]\n): asserts cond {\n  if (cond) {\n    return;\n  }\n\n  throw new Error(\n    args.reduce((msg, arg) => msg.replace(\"%s\", String(arg)), message || \"\"),\n  );\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * Recursively merge the given theme configuration in-place.\n *\n * @returns If `a` and `b` are both objects (and `b` is not an Array) then\n * all keys in `b` are merged into `a` then `a` is returned.\n * Otherwise `b` is returned.\n *\n * @example\n * ```ts\n * const a = { a: \"a\", nested: { a: 1 } };\n * const b = { b: \"b\", nested: { b: 2 } };\n * const rval = deepThemeMergeInPlace(a, b);\n * expect(a).toBe(rval);\n * expect(a).toEqual({ a: \"a\", b: \"b\", nested: { a: 1, b: 2 } });\n * ```\n */\nexport function deepThemeMergeInPlace(a: unknown, b: unknown) {\n  if (\n    a &&\n    b &&\n    !Array.isArray(b) &&\n    typeof a === \"object\" &&\n    typeof b === \"object\"\n  ) {\n    const aObj = a as Record<string, unknown>;\n    const bObj = b as Record<string, unknown>;\n    for (const k in bObj) {\n      aObj[k] = deepThemeMergeInPlace(aObj[k], bObj[k]);\n    }\n    return a;\n  }\n  return b;\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { InitialEditorStateType } from \"./types\";\n\nimport { $createParagraphNode, $getRoot, type LexicalEditor } from \"lexical\";\n\nconst HISTORY_MERGE_OPTIONS = { tag: \"history-merge\" };\n\nfunction $defaultInitializer() {\n  const root = $getRoot();\n  if (root.isEmpty()) {\n    root.append($createParagraphNode());\n  }\n}\n\nexport function initializeEditor(\n  editor: LexicalEditor,\n  $initialEditorState: InitialEditorStateType = $defaultInitializer,\n): void {\n  switch (typeof $initialEditorState) {\n    case \"function\": {\n      editor.update(() => $initialEditorState(editor), HISTORY_MERGE_OPTIONS);\n      break;\n    }\n    case \"string\": {\n      const parsedEditorState = editor.parseEditorState($initialEditorState);\n      editor.setEditorState(parsedEditorState, HISTORY_MERGE_OPTIONS);\n      break;\n    }\n    case \"object\": {\n      if ($initialEditorState) {\n        editor.setEditorState($initialEditorState, HISTORY_MERGE_OPTIONS);\n      }\n      break;\n    }\n  }\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport type { PlanConfigBase } from \"./types\";\n\n/**\n * The default merge strategy for plan configuration is a shallow merge.\n *\n * @param config A full config\n * @param overrides A partial config of overrides\n * @returns config if there are no overrides, otherwise `{...config, ...overrides}`\n */\nexport function shallowMergeConfig<T extends PlanConfigBase>(\n  config: T,\n  overrides?: Partial<T>,\n): T {\n  if (!overrides || config === overrides) {\n    return config;\n  }\n  for (const k in overrides) {\n    if (config[k] !== overrides[k]) {\n      return { ...config, ...overrides };\n    }\n  }\n  return config;\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { LexicalBuilder } from \"./LexicalBuilder\";\nimport type {\n  AnyLexicalPlan,\n  LexicalPlanConfig,\n  LexicalPlanDependency,\n  LexicalPlanOutput,\n} from \"./types\";\n\nimport invariant from \"./shared/invariant\";\n\nimport { shallowMergeConfig } from \"./shallowMergeConfig\";\nimport type { LexicalEditor } from \"lexical\";\n\nconst noop = () => {};\n/**\n * @internal\n */\nexport class PlanRep<Plan extends AnyLexicalPlan> {\n  builder: LexicalBuilder;\n  configs: Set<Partial<LexicalPlanConfig<Plan>>>;\n  _config?: LexicalPlanConfig<Plan>;\n  _dependency?: LexicalPlanDependency<Plan>;\n  _output?: LexicalPlanOutput<Plan>;\n  plan: Plan;\n  constructor(builder: LexicalBuilder, plan: Plan) {\n    this.builder = builder;\n    this.plan = plan;\n    this.configs = new Set();\n  }\n  register(editor: LexicalEditor, signal: AbortSignal): () => void {\n    if (!this.plan.register) {\n      this._output = undefined;\n      return noop;\n    }\n    const cleanup = this.plan.register(editor, this.getConfig(), {\n      getPeer: this.getPeer.bind(this),\n      getDependency: this.getDependency.bind(this),\n      getDirectDependentNames: this.getDirectDependentNames.bind(this),\n      signal,\n    });\n    this._output = cleanup.output as LexicalPlanOutput<Plan>;\n    return cleanup;\n  }\n  getPeer<PeerPlan extends AnyLexicalPlan = never>(\n    name: PeerPlan[\"name\"],\n  ): undefined | LexicalPlanDependency<PeerPlan> {\n    const rep = this.builder.planNameMap.get(name);\n    return rep\n      ? (rep.getPlanDependency() as LexicalPlanDependency<PeerPlan>)\n      : undefined;\n  }\n  getDependency<Dependency extends AnyLexicalPlan>(\n    dep: Dependency,\n  ): LexicalPlanDependency<Dependency> {\n    const rep = this.builder.getPlanRep(dep);\n    invariant(\n      rep !== undefined,\n      \"LexicalPlanBuilder: Plan %s missing dependency plan %s to be in registry\",\n      this.plan.name,\n      dep.name,\n    );\n    return rep.getPlanDependency();\n  }\n\n  getDirectDependentNames(): string[] {\n    return Array.from(\n      this.builder.reverseEdges.get(this.plan) || [],\n      (plan) => plan.name,\n    );\n  }\n\n  getPlanDependency(): LexicalPlanDependency<Plan> {\n    if (!this._dependency) {\n      invariant(\n        \"_output\" in this,\n        \"Plan %s used as a dependency before registration\",\n        this.plan.name,\n      );\n      this._dependency = {\n        config: this.getConfig(),\n        output: this._output!,\n      };\n    }\n    return this._dependency;\n  }\n  getConfig(): LexicalPlanConfig<Plan> {\n    if (!this._config) {\n      let config = this.plan.config;\n      const mergeConfig = this.plan.mergeConfig\n        ? this.plan.mergeConfig.bind(this.plan)\n        : shallowMergeConfig;\n      for (const cfg of this.configs) {\n        config = mergeConfig(config, cfg);\n      }\n      this._config = config;\n    }\n    return this._config;\n  }\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport type {\n  AnyLexicalPlan,\n  AnyLexicalPlanArgument,\n  EditorHandle,\n  LexicalPlanConfig,\n  RootPlanArgument,\n} from \"./types\";\n\nimport {\n  LexicalEditor,\n  createEditor,\n  type CreateEditorArgs,\n  type EditorThemeClasses,\n  type HTMLConfig,\n  type KlassConstructor,\n  type LexicalNode,\n} from \"lexical\";\nimport invariant from \"./shared/invariant\";\n\nimport { deepThemeMergeInPlace } from \"./deepThemeMergeInPlace\";\nimport { initializeEditor } from \"./initializeEditor\";\nimport { PlanRep } from \"./PlanRep\";\nimport { mergeRegister } from \"@lexical/utils\";\nimport { configPlan, defineRootPlan } from \"./definePlan\";\n\nconst buildersForEditors = new WeakMap<LexicalEditor, LexicalBuilder>();\n\n/**\n * Build a LexicalEditor by combining together one or more plans, optionally\n * overriding some of their configuration.\n *\n * @param plan A plan argument (a plan, or a plan with config overrides)\n * @param plans Optional additional plan arguments\n * @returns An editor handle\n *\n * @example A single root plan with multiple dependencies\n * ```ts\n * const editorHandle = buildEditorFromPlans(\n *   defineRootPlan({\n *     dependencies: [\n *       RichTextPlan,\n *       configPlan(EmojiPlan, { emojiBaseUrl: \"/assets/emoji\" }),\n *     ],\n *     register: (editor: LexicalEditor) => {\n *       console.log(\"Editor Created\");\n *       return () => console.log(\"Editor Disposed\");\n *     },\n *   }),\n * );\n * ```\n * @example A very similar minimal configuration without the register hook\n * ```ts\n * const editorHandle = buildEditorFromPlans(\n *   RichTextPlan,\n *   configPlan(EmojiPlan, { emojiBaseUrl: \"/assets/emoji\" }),\n * );\n * ```\n */\nexport function buildEditorFromPlans(\n  plan: AnyLexicalPlanArgument | RootPlanArgument,\n  ...plans: (AnyLexicalPlanArgument | RootPlanArgument)[]\n): EditorHandle {\n  const builder = new LexicalBuilder();\n  builder.addPlan(coerceToPlanArgument(plan));\n  for (const otherPlan of plans) {\n    builder.addPlan(coerceToPlanArgument(otherPlan));\n  }\n  return builder.buildEditor();\n}\n\n/** @internal */\nexport function coerceToPlanArgument(\n  plan: AnyLexicalPlanArgument | RootPlanArgument,\n): AnyLexicalPlanArgument {\n  return \"name\" in plan || Array.isArray(plan) ? plan : defineRootPlan(plan);\n}\n\n/** @internal */\nfunction noop() {}\n\n/** @internal */\nclass DisposableEditorHandle implements EditorHandle {\n  editor: LexicalEditor;\n  dispose: () => void;\n  constructor(editor: LexicalEditor, dispose: () => void) {\n    this.editor = editor;\n    this.dispose = () => {\n      try {\n        dispose();\n      } finally {\n        this.dispose = noop;\n      }\n    };\n  }\n  // This should be safe even if the runtime doesn't have Symbol.dispose\n  // because it will just be `handle[undefined] = dispose;`\n  [Symbol.dispose]() {\n    this.dispose();\n  }\n}\n\n/** Throw the given Error */\nfunction defaultOnError(err: Error) {\n  throw err;\n}\n\n/** @internal */\nexport class LexicalBuilder {\n  phases: Map<AnyLexicalPlan, PlanRep<AnyLexicalPlan>>[];\n  planMap: Map<AnyLexicalPlan, [number, PlanRep<AnyLexicalPlan>]>;\n  planNameMap: Map<string, PlanRep<AnyLexicalPlan>>;\n  reverseEdges: Map<AnyLexicalPlan, Set<AnyLexicalPlan>>;\n  addStack: Set<AnyLexicalPlan>;\n  conflicts: Map<string, string>;\n\n  constructor() {\n    // closure compiler can't handle class initializers\n    this.phases = [new Map()];\n    this.planMap = new Map();\n    this.planNameMap = new Map();\n    this.conflicts = new Map();\n    this.reverseEdges = new Map();\n    this.addStack = new Set();\n  }\n\n  /** Look up the editor that was created by this LexicalBuilder or undefined */\n  static fromEditor(editor: LexicalEditor): LexicalBuilder | undefined {\n    return buildersForEditors.get(editor);\n  }\n\n  buildEditor(): EditorHandle {\n    const { $initialEditorState, onError, ...editorConfig } =\n      this.buildCreateEditorArgs();\n    const editor = createEditor({\n      ...editorConfig,\n      ...(onError ? { onError: (err) => onError(err, editor) } : {}),\n    });\n    initializeEditor(editor, $initialEditorState);\n    buildersForEditors.set(editor, this);\n    return new DisposableEditorHandle(\n      editor,\n      mergeRegister(\n        () => buildersForEditors.delete(editor),\n        () => editor.setRootElement(null),\n        this.registerEditor(editor),\n      ),\n    );\n  }\n\n  getPlanRep<Plan extends AnyLexicalPlan>(\n    plan: Plan,\n  ): PlanRep<Plan> | undefined {\n    const pair = this.planMap.get(plan);\n    if (pair) {\n      const rep: PlanRep<AnyLexicalPlan> = pair[1];\n      return rep as PlanRep<Plan>;\n    }\n  }\n\n  addPlan(arg: AnyLexicalPlanArgument, parent?: AnyLexicalPlan): number {\n    let plan: AnyLexicalPlan;\n    let configs: unknown[];\n    if (Array.isArray(arg)) {\n      [plan, ...configs] = arg;\n    } else {\n      plan = arg;\n      configs = [];\n    }\n    // Track incoming dependencies\n    if (parent) {\n      let edgeSet = this.reverseEdges.get(plan);\n      if (!edgeSet) {\n        edgeSet = new Set();\n        this.reverseEdges.set(plan, edgeSet);\n      }\n      edgeSet.add(parent);\n    }\n    let [phase, planRep] = this.planMap.get(plan) || [0, undefined];\n    if (!planRep) {\n      const hasConflict = this.conflicts.get(plan.name);\n      if (typeof hasConflict === \"string\") {\n        invariant(\n          false,\n          \"LexicalBuilder: plan %s conflicts with %s\",\n          plan.name,\n          hasConflict,\n        );\n      }\n      for (const name of plan.conflictsWith || []) {\n        invariant(\n          !this.planNameMap.has(name),\n          \"LexicalBuilder: plan %s conflicts with %s\",\n          plan.name,\n          name,\n        );\n        this.conflicts.set(name, plan.name);\n      }\n      invariant(\n        !this.addStack.has(plan),\n        \"LexicalBuilder: Circular dependency detected for Plan %s from %s\",\n        plan.name,\n        parent?.name || \"[unknown]\",\n      );\n      this.addStack.add(plan);\n      // TODO detect circular dependencies\n      for (const dep of plan.dependencies || []) {\n        phase = Math.max(phase, 1 + this.addPlan(dep, plan));\n      }\n      for (const [depName, cfg] of Object.entries(\n        plan.peerDependencies || {},\n      )) {\n        const dep = this.planNameMap.get(depName);\n        if (dep) {\n          phase = Math.max(\n            phase,\n            1 +\n              this.addPlan(\n                configPlan(dep.plan, cfg as LexicalPlanConfig<typeof dep.plan>),\n                plan,\n              ),\n          );\n        }\n      }\n      invariant(\n        this.phases.length >= phase,\n        \"LexicalBuilder: Expected phase to be no greater than phases.length\",\n      );\n      if (this.phases.length === phase) {\n        this.phases.push(new Map());\n      }\n      planRep = new PlanRep(this, plan);\n      invariant(\n        !this.planNameMap.has(plan.name),\n        \"LexicalBuilder: Multiple plans registered with name %s, names must be unique\",\n        plan.name,\n      );\n      this.planMap.set(plan, [phase, planRep]);\n      this.planNameMap.set(plan.name, planRep);\n      const currentPhaseMap = this.phases[phase];\n      invariant(\n        currentPhaseMap !== undefined,\n        \"LexicalBuilder: Expecting phase map for phase %s\",\n        String(phase),\n      );\n      currentPhaseMap.set(plan, planRep);\n      this.addStack.delete(plan);\n    }\n    for (const config of configs) {\n      planRep.configs.add(config as Partial<LexicalPlanConfig<AnyLexicalPlan>>);\n    }\n    return phase;\n  }\n\n  *sortedPlanReps() {\n    for (const phase of this.phases) {\n      yield* phase.values();\n    }\n  }\n\n  registerEditor(editor: LexicalEditor): () => void {\n    const cleanups: (() => void)[] = [];\n    const controller = new AbortController();\n    for (const planRep of this.sortedPlanReps()) {\n      cleanups.push(planRep.register(editor, controller.signal));\n    }\n    return () => {\n      for (let i = cleanups.length - 1; i >= 0; i--) {\n        const cleanupFun = cleanups[i];\n        invariant(\n          cleanupFun !== undefined,\n          \"LexicalBuilder: Expecting cleanups[%s] to be defined\",\n          String(i),\n        );\n        cleanupFun();\n      }\n      cleanups.length = 0;\n      controller.abort();\n    };\n  }\n\n  buildCreateEditorArgs() {\n    const config: Pick<\n      CreateEditorArgs,\n      \"nodes\" | \"html\" | \"theme\" | \"disableEvents\" | \"editable\" | \"namespace\"\n    > &\n      Pick<AnyLexicalPlan, \"$initialEditorState\" | \"onError\"> = {\n      // Prefer throwing errors rather than console.error by default\n      onError: defaultOnError,\n    };\n    const nodes = new Set<NonNullable<CreateEditorArgs[\"nodes\"]>[number]>();\n    const replacedNodes = new Map<\n      KlassConstructor<typeof LexicalNode>,\n      PlanRep<AnyLexicalPlan>\n    >();\n    const htmlExport: NonNullable<HTMLConfig[\"export\"]> = new Map();\n    const htmlImport: NonNullable<HTMLConfig[\"import\"]> = {};\n    const theme: EditorThemeClasses = {};\n    for (const planRep of this.sortedPlanReps()) {\n      const { plan } = planRep;\n      if (plan.onError !== undefined) {\n        config.onError = plan.onError;\n      }\n      if (plan.disableEvents !== undefined) {\n        config.disableEvents = plan.disableEvents;\n      }\n      if (plan.editable !== undefined) {\n        config.editable = plan.editable;\n      }\n      if (plan.namespace !== undefined) {\n        config.namespace = plan.namespace;\n      }\n      if (plan.$initialEditorState !== undefined) {\n        config.$initialEditorState = plan.$initialEditorState;\n      }\n      if (plan.nodes) {\n        for (const node of plan.nodes) {\n          if (typeof node !== \"function\") {\n            const conflictPlan = replacedNodes.get(node.replace);\n            if (conflictPlan) {\n              invariant(\n                false,\n                \"LexicalBuilder: Plan %s can not register replacement for node %s because %s already did\",\n                plan.name,\n                node.replace.name,\n                conflictPlan.plan.name,\n              );\n            }\n            replacedNodes.set(node.replace, planRep);\n          }\n          nodes.add(node);\n        }\n      }\n      if (plan.html) {\n        if (plan.html.export) {\n          for (const [k, v] of plan.html.export.entries()) {\n            htmlExport.set(k, v);\n          }\n        }\n        if (plan.html.import) {\n          Object.assign(htmlImport, plan.html.import);\n        }\n      }\n      if (plan.theme) {\n        deepThemeMergeInPlace(theme, plan.theme);\n      }\n    }\n    if (Object.keys(theme).length > 0) {\n      config.theme = theme;\n    }\n    if (nodes.size) {\n      config.nodes = [...nodes];\n    }\n    const hasImport = Object.keys(htmlImport).length > 0;\n    const hasExport = htmlExport.size > 0;\n    if (hasImport || hasExport) {\n      config.html = {};\n      if (hasImport) {\n        config.html.import = htmlImport;\n      }\n      if (hasExport) {\n        config.html.export = htmlExport;\n      }\n    }\n    return config;\n  }\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * Explicitly and safely cast a value to a specific type when inference or\n * satisfies isn't going to work as expected (often useful for the config\n * property with definePlan)\n */\nexport function safeCast<T>(value: T): T {\n  return value;\n}\n","import { $getEditor, LexicalEditor } from \"lexical\";\nimport { AnyLexicalPlan, LexicalPlanDependency } from \"./types\";\nimport { LexicalBuilder } from \"./LexicalBuilder\";\nimport invariant from \"./shared/invariant\";\nimport { PACKAGE_VERSION } from \"./PACKAGE_VERSION\";\nimport { PlanRep } from \"./PlanRep\";\n\n/**\n * Get the finalized config and output of a Plan that was used to build the editor.\n *\n * This is useful in the implementation of a LexicalNode or in other\n * situations where you have an editor reference but it's not easy to\n * pass the config or {@link RegisterState} around.\n *\n * It will throw if the Editor was not built using this Plan.\n *\n * @param editor The editor that was built using plan\n * @param plan The concrete reference to a Plan used to build this editor\n * @returns The config and output for that Plan\n */\nexport function getPlanDependencyFromEditor<Plan extends AnyLexicalPlan>(\n  editor: LexicalEditor,\n  plan: Plan,\n): LexicalPlanDependency<Plan> {\n  const builder = LexicalBuilder.fromEditor(editor);\n  invariant(\n    builder !== undefined,\n    \"getPlanFromEditor: editor was not created with this build of Lexical Builder %s\",\n    PACKAGE_VERSION,\n  );\n  const rep = builder.getPlanRep(plan);\n  invariant(\n    rep !== undefined,\n    \"getPlanFromEditor: Plan %s was not built when creating this editor\",\n    plan.name,\n  );\n  return rep.getPlanDependency();\n}\n\n/**\n * Get the finalized config and output of a Plan that was used to build the editor.\n *\n * This is useful in the implementation of a LexicalNode or in other\n * situations where you have an editor reference but it's not easy to\n * pass the config or {@link RegisterState} around.\n *\n * It will throw if the Editor was not built using this Plan.\n *\n * @param plan The concrete reference to a Plan used to build this editor\n * @returns The config and outputs for that Plan\n */\nexport function $getPlanDependency<Plan extends AnyLexicalPlan>(\n  plan: Plan,\n): LexicalPlanDependency<Plan> {\n  return getPlanDependencyFromEditor($getEditor(), plan);\n}\n","import { $getEditor, LexicalEditor } from \"lexical\";\nimport { AnyLexicalPlan, LexicalPlanDependency } from \"./types\";\nimport { LexicalBuilder } from \"./LexicalBuilder\";\nimport invariant from \"./shared/invariant\";\nimport { PACKAGE_VERSION } from \"./PACKAGE_VERSION\";\n\n/**\n * Get the finalized config and output of a Plan that was used to build the\n * editor by name.\n *\n * This can be used from the implementation of a LexicalNode or in other\n * situation where you have an editor reference but it's not easy to pass the\n * config around. Use this version if you do not have a concrete reference to\n * the Plan for some reason (e.g. it is an optional peer dependency).\n *\n * Both the explicit Plan type and the name are required.\n *\n *  @example\n * ```tsx\n * getPeerDependencyFromEditor<typeof import(\"@some/plan\").SomePlan>(editor, \"@some/plan\");\n * ```\n\n * @param editor The editor that may have been built using plan\n * @param planName The name of the Plan\n * @returns The config and output of the Plan or undefined\n */\nexport function getPeerDependencyFromEditor<\n  Plan extends AnyLexicalPlan = never,\n>(\n  editor: LexicalEditor,\n  planName: Plan[\"name\"],\n): LexicalPlanDependency<Plan> | undefined {\n  const builder = LexicalBuilder.fromEditor(editor);\n  invariant(\n    builder !== undefined,\n    \"getPeerConfigFromEditor: editor was not created with this build of Lexical Builder %s\",\n    PACKAGE_VERSION,\n  );\n  const peer = builder.planNameMap.get(planName);\n  return peer\n    ? (peer.getPlanDependency() as LexicalPlanDependency<Plan>)\n    : undefined;\n}\n\n/**\n * Get the finalized config and output of a Plan that was used to build the\n * editor by name.\n *\n * Both the explicit Plan type and the name are required.\n *\n * This can be used from the implementation of a LexicalNode or in other\n * situation where you have an editor reference but it's not easy to pass the\n * config around. Use this version if you do not have a concrete reference to\n * the Plan for some reason (e.g. it is an optional peer dependency).\n *\n * @example\n * ```tsx\n * $getPeerDependency<typeof import(\"@some/plan\").SomePlan>(\"@some/plan\")\n * ```\n *\n * @param planName The name of the Plan\n * @returns The config and output of the Plan or undefined\n */\nexport function $getPeerDependency<Plan extends AnyLexicalPlan = never>(\n  planName: Plan[\"name\"],\n): LexicalPlanDependency<Plan> | undefined {\n  return getPeerDependencyFromEditor($getEditor(), planName);\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { definePlan } from \"./definePlan\";\nimport { safeCast } from \"./safeCast\";\n\nexport interface AutoFocusConfig {\n  /**\n   * Where to move the selection when the editor is focused and there is no\n   * existing selection. Can be \"rootStart\" or \"rootEnd\" (the default).\n   */\n  defaultSelection?: \"rootStart\" | \"rootEnd\";\n}\n\n/**\n * A Plan to focus the LexicalEditor when the root element is set\n * (typically only when the editor is first created).\n */\nexport const AutoFocusPlan = definePlan({\n  config: safeCast<AutoFocusConfig>({}),\n  name: \"@etrepum/lexical-builder/AutoFocusPlan\",\n  register(editor, { defaultSelection }) {\n    return editor.registerRootListener((rootElement) => {\n      editor.focus(\n        () => {\n          // If we try and move selection to the same point with setBaseAndExtent, it won't\n          // trigger a re-focus on the element. So in the case this occurs, we'll need to correct it.\n          // Normally this is fine, Selection API !== Focus API, but fore the intents of the naming\n          // of this plugin, which should preserve focus too.\n          const activeElement = document.activeElement;\n          if (\n            rootElement !== null &&\n            (activeElement === null || !rootElement.contains(activeElement))\n          ) {\n            // Note: preventScroll won't work in Webkit.\n            rootElement.focus({ preventScroll: true });\n          }\n        },\n        { defaultSelection },\n      );\n    });\n  },\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { registerDragonSupport } from \"@lexical/dragon\";\n\nimport { definePlan } from \"./definePlan\";\n\n/**\n * Add Dragon speech to text input support to the editor, via the\n * @lexical/dragon module.\n */\nexport const DragonPlan = definePlan({\n  config: {},\n  name: \"@lexical/dragon\",\n  register: registerDragonSupport,\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport {\n  createEmptyHistoryState,\n  type HistoryState,\n  registerHistory,\n} from \"@lexical/history\";\n\nimport { definePlan } from \"./definePlan\";\nimport { safeCast } from \"./safeCast\";\n\nexport interface HistoryConfig {\n  /**\n   * The time (in milliseconds) the editor should delay generating a new history stack,\n   * instead of merging the current changes with the current stack. The default is 300ms.\n   */\n  delay: number;\n  /**\n   * The initial history state, the default is {@link createEmptyHistoryState}.\n   */\n  createInitialHistoryState: () => HistoryState;\n}\n\n/**\n * Registers necessary listeners to manage undo/redo history stack and related\n * editor commands, via the @lexical/history module.\n */\nexport const HistoryPlan = definePlan({\n  config: safeCast<HistoryConfig>({\n    createInitialHistoryState: createEmptyHistoryState,\n    delay: 300,\n  }),\n  name: \"@etrepum/lexical-builder/HistoryPlan\",\n  register(editor, { delay, createInitialHistoryState }) {\n    return registerHistory(editor, createInitialHistoryState(), delay);\n  },\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport { registerPlainText } from \"@lexical/plain-text\";\n\nimport { definePlan } from \"./definePlan\";\n\n/**\n * A plan to register @lexical/plain-text behavior\n */\nexport const PlainTextPlan = definePlan({\n  config: {},\n  conflictsWith: [\"@lexical/rich-text\"],\n  name: \"@lexical/plain-text\",\n  register: registerPlainText,\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { HeadingNode, QuoteNode, registerRichText } from \"@lexical/rich-text\";\n\nimport { definePlan } from \"./definePlan\";\n\n/**\n * A plan to register @lexical/rich-text behavior and nodes\n * ({@link HeadingNode}, {@link QuoteNode})\n */\nexport const RichTextPlan = definePlan({\n  config: {},\n  conflictsWith: [\"@lexical/plain-text\"],\n  name: \"@lexical/rich-text\",\n  nodes: [HeadingNode, QuoteNode],\n  register: registerRichText,\n});\n"],"names":["noop"],"mappings":"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"}

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { CreateEditorArgs, EditorState, LexicalEditor } from 'lexical';
-import { LexicalPlanRegistry } from '@etrepum/lexical-builder';
+import { PeerDependencyBrand } from './definePlan';
 
 /**
  * Any concrete {@link LexicalPlan}
@@ -13,6 +13,14 @@ export type AnyLexicalPlanArgument = LexicalPlanArgument<any, string, any>;
  * The default plan configuration of an empty object
  */
 export type PlanConfigBase = Record<never, never>;
+export type RootPlan<Output> = LexicalPlan<PlanConfigBase, "[root]", Output>;
+export type RootPlanArgument<Output = any> = Omit<RootPlan<Output>, "config" | "name">;
+export type NormalizedPeerDependency<Plan extends AnyLexicalPlan> = [
+    Plan["name"],
+    Partial<LexicalPlanConfig<Plan>> | undefined
+] & {
+    [PeerDependencyBrand]: Plan;
+};
 /**
  * A tuple of [plan, configOverride, ...configOverrides]
  */
@@ -28,12 +36,17 @@ export interface RegisterState {
      * Get the result of a peerDependency by name, if it exists
      * (must be a peerDependency of this plan)
      */
-    getPeer<Name extends keyof LexicalPlanRegistry>(name: string): undefined | LexicalPlanDependency<LexicalPlanRegistry[Name]>;
+    getPeer<Plan extends AnyLexicalPlan = never>(name: Plan["name"]): undefined | LexicalPlanDependency<Plan>;
     /**
      * Get the configuration of a dependency by plan
      * (must be a direct dependency of this plan)
      */
     getDependency<Dependency extends AnyLexicalPlan>(dep: Dependency): LexicalPlanDependency<Dependency>;
+    /**
+     * Get the names of any direct dependents of this
+     * Plan, typically only used for error messages.
+     */
+    getDirectDependentNames(): string[];
 }
 /**
  * A {@link LexicalPlan} or {@link NormalizedLexicalPlanArgument} (plan with config overrides)
@@ -62,9 +75,7 @@ export interface LexicalPlan<Config extends PlanConfigBase = PlanConfigBase, Nam
      * Other Plans, by name, that this Plan can optionally depend on or
      * configure, if they are directly depended on by another Plan
      */
-    peerDependencies?: {
-        [k in keyof LexicalPlanRegistry]?: Partial<LexicalPeerConfig<k>>;
-    };
+    peerDependencies?: NormalizedPeerDependency<AnyLexicalPlan>[];
     /**
      * @internal Disable root element events (for internal Meta use)
      */
@@ -162,23 +173,6 @@ export type RegisterCleanup<Output> = (() => void) & (unknown extends Output ? {
 } : {
     output: Output;
 });
-/**
- * Get the Config type of a peer Plan from {@link LexicalPlanRegistry} by
- * name, or the empty {@link PlanConfigBase} if it is not globally registered.
- */
-export type LexicalPeerConfig<Name extends keyof LexicalPlanRegistry | string> = LexicalPeerPlan<Name>["config"];
-/**
- * Get the Plan type of a peer Plan from {@link LexicalPlanRegistry} by
- * name, or an "default" Plan type if it is not globally registered.
- */
-export type LexicalPeerPlan<Name extends keyof LexicalPlanRegistry | string> = [
-    Name
-] extends [keyof LexicalPlanRegistry] ? LexicalPlanRegistry[Name] : LexicalPlan<PlanConfigBase, Name, unknown>;
-/**
- * Get the Config type of a peer Plan from {@link LexicalPlanRegistry} by
- * name, or the empty {@link PlanConfigBase} if it is not globally registered.
- */
-export type LexicalPeerDependency<Name extends keyof LexicalPlanRegistry | string> = LexicalPlanDependency<LexicalPeerPlan<Name>>;
 /**
  * Extract the Config type from a Plan
  */

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD;;GAEG;AAEH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;AAC3D;;GAEG;AAEH,MAAM,MAAM,sBAAsB,GAAG,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;AAC3E;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAElD,MAAM,MAAM,QAAQ,CAAC,MAAM,IAAI,WAAW,CAAC,cAAc,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;AAC7E,MAAM,MAAM,gBAAgB,CAAC,MAAM,GAAG,GAAG,IAAI,IAAI,CAC/C,QAAQ,CAAC,MAAM,CAAC,EAChB,QAAQ,GAAG,MAAM,CAClB,CAAC;AAEF,MAAM,MAAM,wBAAwB,CAAC,IAAI,SAAS,cAAc,IAAI;IAClE,IAAI,CAAC,MAAM,CAAC;IACZ,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS;CAC7C,GAAG;IAAE,CAAC,mBAAmB,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,6BAA6B,CACvC,MAAM,SAAS,cAAc,EAC7B,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,OAAO,IACpB,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAE/E;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,MAAM,EAAE,WAAW,CAAC;IACpB;;;OAGG;IACH,OAAO,CAAC,IAAI,SAAS,cAAc,GAAG,KAAK,EACzC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,GACjB,SAAS,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;IAC3C;;;OAGG;IACH,aAAa,CAAC,UAAU,SAAS,cAAc,EAC7C,GAAG,EAAE,UAAU,GACd,qBAAqB,CAAC,UAAU,CAAC,CAAC;IACrC;;;OAGG;IACH,uBAAuB,IAAI,MAAM,EAAE,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,CAC7B,MAAM,SAAS,cAAc,EAC7B,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,OAAO,IAEpB,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GACjC,6BAA6B,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAExD,MAAM,WAAW,qBAAqB,CAAC,UAAU,SAAS,cAAc;IACtE,MAAM,EAAE,iBAAiB,CAAC,UAAU,CAAC,CAAC;IACtC,MAAM,EAAE,iBAAiB,CAAC,UAAU,CAAC,CAAC;CACvC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW,CAC1B,MAAM,SAAS,cAAc,GAAG,cAAc,EAC9C,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,MAAM,SAAS,OAAO,GAAG,OAAO;IAEhC,2CAA2C;IAC3C,IAAI,EAAE,IAAI,CAAC;IACX,wDAAwD;IACxD,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,gFAAgF;IAChF,YAAY,CAAC,EAAE,sBAAsB,EAAE,CAAC;IACxC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,wBAAwB,CAAC,cAAc,CAAC,EAAE,CAAC;IAE9D;;OAEG;IACH,aAAa,CAAC,EAAE,gBAAgB,CAAC,eAAe,CAAC,CAAC;IAClD;;OAEG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC,cAAc,CAAC,CAAC;IAChD;;;;OAIG;IACH,SAAS,CAAC,EAAE,gBAAgB,CAAC,WAAW,CAAC,CAAC;IAC1C;;OAEG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAClC;;OAEG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAClC;;;;OAIG;IACH,IAAI,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChC;;OAEG;IACH,QAAQ,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACxC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC;IACxD;;;OAGG;IACH,mBAAmB,CAAC,EAAE,sBAAsB,CAAC;IAC7C;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC;IACrE;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,CACT,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,KACjB,eAAe,CAAC,MAAM,CAAC,CAAC;CAC9B;AAED,MAAM,MAAM,eAAe,CAAC,MAAM,IAAI,CAAC,MAAM,IAAI,CAAC,GAChD,CAAC,OAAO,SAAS,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEtE;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,IAAI,SAAS,cAAc,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC5E;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,IAAI,SAAS,cAAc,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC;AAExE,MAAM,MAAM,iBAAiB,CAAC,IAAI,IAChC,IAAI,SAAS,WAAW,CAAC,MAAM,OAAO,EAAE,MAAM,KAAK,EAAE,MAAM,MAAM,CAAC,GAC9D,MAAM,GACN,OAAO,CAAC;AAEd;;GAEG;AACH,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC9C,yBAAyB;IACzB,MAAM,EAAE,aAAa,CAAC;IACtB;;;OAGG;IACH,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAC9B,IAAI,GACJ,MAAM,GACN,WAAW,GACX,CAAC,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC,CAAC"}

package/package.json

@@ -17,7 +17,7 @@
     "test": "vitest run",
     "test:watch": "vitest"
   },
-  "version": "0.0.15",
+  "version": "0.0.16",
   "license": "MIT",
   "repository": {
     "type": "git",