@nexo-labs/payload-lexical-blocks-builder 1.6.1

package/dist/renderer-Y62qi9KC.d.mts

@@ -0,0 +1,678 @@
+import { o as SerializedEditorState } from "./LexicalDecoratorNode-C9hMKfgk.mjs";
+import { ReactNode } from "react";
+
+//#region ../../node_modules/.pnpm/@storybook+core@8.6.11_prettier@3.5.3_storybook@8.6.11_prettier@3.5.3_/node_modules/@storybook/core/dist/csf/index.d.ts
+declare global {
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
+
+/**
+@see Simplify
+*/
+interface SimplifyOptions {
+  /**
+  Do the simplification recursively.
+  	@default false
+  */
+  deep?: boolean;
+}
+
+// Flatten a type without worrying about the result.
+type Flatten<AnyType, Options extends SimplifyOptions = {}> = Options['deep'] extends true ? { [KeyType in keyof AnyType]: Simplify<AnyType[KeyType], Options> } : { [KeyType in keyof AnyType]: AnyType[KeyType] };
+
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+
+@category Object
+*/
+type Simplify<AnyType, Options extends SimplifyOptions = {}> = Flatten<AnyType> extends AnyType ? Flatten<AnyType, Options> : AnyType;
+
+/**
+Remove any index signatures from the given object type, so that only explicitly defined properties remain.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+const keyed: Record<'foo', unknown> = {}; // Error
+// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+// => '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
+	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `RemoveIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		// Is `{}` assignable to `Record<KeyType, unknown>`?
+		as {} extends Record<KeyType, unknown>
+			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+type RemoveIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		as {} extends Record<KeyType, unknown>
+			? never // => Remove this `KeyType`.
+			: KeyType // => Keep this `KeyType` as it is.
+	]: ObjectType[KeyType];
+};
+```
+
+@example
+```
+import type {RemoveIndexSignature} from 'type-fest';
+
+interface Example {
+	// These index signatures will be removed.
+	[x: string]: any
+	[x: number]: any
+	[x: symbol]: any
+	[x: `head-${string}`]: string
+	[x: `${string}-tail`]: string
+	[x: `head-${string}-tail`]: string
+	[x: `${bigint}`]: string
+	[x: `embedded-${number}`]: string
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+}
+
+type ExampleWithoutIndexSignatures = RemoveIndexSignature<Example>;
+// => { foo: 'bar'; qux?: 'baz' | undefined; }
+```
+
+@category Object
+*/
+
+interface SBBaseType {
+  required?: boolean;
+  raw?: string;
+}
+type SBScalarType = SBBaseType & {
+  name: 'boolean' | 'string' | 'number' | 'function' | 'symbol';
+};
+type SBArrayType = SBBaseType & {
+  name: 'array';
+  value: SBType;
+};
+type SBObjectType = SBBaseType & {
+  name: 'object';
+  value: Record<string, SBType>;
+};
+type SBEnumType = SBBaseType & {
+  name: 'enum';
+  value: (string | number)[];
+};
+type SBIntersectionType = SBBaseType & {
+  name: 'intersection';
+  value: SBType[];
+};
+type SBUnionType = SBBaseType & {
+  name: 'union';
+  value: SBType[];
+};
+type SBOtherType = SBBaseType & {
+  name: 'other';
+  value: string;
+};
+type SBType = SBScalarType | SBEnumType | SBArrayType | SBObjectType | SBIntersectionType | SBUnionType | SBOtherType;
+type StoryId = string;
+type ComponentId = string;
+type ComponentTitle = string;
+type StoryName = string;
+/** @deprecated */
+
+type Tag = string;
+interface StoryIdentifier {
+  componentId: ComponentId;
+  title: ComponentTitle;
+  /** @deprecated */
+  kind: ComponentTitle;
+  id: StoryId;
+  name: StoryName;
+  /** @deprecated */
+  story: StoryName;
+  tags: Tag[];
+}
+interface Parameters {
+  [name: string]: any;
+}
+type ControlType = 'object' | 'boolean' | 'check' | 'inline-check' | 'radio' | 'inline-radio' | 'select' | 'multi-select' | 'number' | 'range' | 'file' | 'color' | 'date' | 'text';
+type ConditionalTest = {
+  truthy?: boolean;
+} | {
+  exists: boolean;
+} | {
+  eq: any;
+} | {
+  neq: any;
+};
+type ConditionalValue = {
+  arg: string;
+} | {
+  global: string;
+};
+type Conditional = ConditionalValue & ConditionalTest;
+interface ControlBase {
+  [key: string]: any;
+  /** @see https://storybook.js.org/docs/api/arg-types#controltype */
+  type?: ControlType;
+  disable?: boolean;
+}
+interface Report$1 {
+  type: string;
+  version?: number;
+  result: unknown;
+  status: 'failed' | 'passed' | 'warning';
+}
+interface ReportingAPI {
+  reports: Report$1[];
+  addReport: (report: Report$1) => void;
+}
+type Control = ControlType | false | (ControlBase & (ControlBase | {
+  type: 'color';
+  /** @see https://storybook.js.org/docs/api/arg-types#controlpresetcolors */
+  presetColors?: string[];
+} | {
+  type: 'file';
+  /** @see https://storybook.js.org/docs/api/arg-types#controlaccept */
+  accept?: string;
+} | {
+  type: 'inline-check' | 'radio' | 'inline-radio' | 'select' | 'multi-select';
+  /** @see https://storybook.js.org/docs/api/arg-types#controllabels */
+  labels?: {
+    [options: string]: string;
+  };
+} | {
+  type: 'number' | 'range';
+  /** @see https://storybook.js.org/docs/api/arg-types#controlmax */
+  max?: number;
+  /** @see https://storybook.js.org/docs/api/arg-types#controlmin */
+  min?: number;
+  /** @see https://storybook.js.org/docs/api/arg-types#controlstep */
+  step?: number;
+}));
+interface InputType {
+  /** @see https://storybook.js.org/docs/api/arg-types#control */
+  control?: Control;
+  /** @see https://storybook.js.org/docs/api/arg-types#description */
+  description?: string;
+  /** @see https://storybook.js.org/docs/api/arg-types#if */
+  if?: Conditional;
+  /** @see https://storybook.js.org/docs/api/arg-types#mapping */
+  mapping?: {
+    [key: string]: any;
+  };
+  /** @see https://storybook.js.org/docs/api/arg-types#name */
+  name?: string;
+  /** @see https://storybook.js.org/docs/api/arg-types#options */
+  options?: readonly any[];
+  /** @see https://storybook.js.org/docs/api/arg-types#table */
+  table?: {
+    [key: string]: unknown;
+    /** @see https://storybook.js.org/docs/api/arg-types#tablecategory */
+    category?: string;
+    /** @see https://storybook.js.org/docs/api/arg-types#tabledefaultvalue */
+    defaultValue?: {
+      summary?: string;
+      detail?: string;
+    };
+    /** @see https://storybook.js.org/docs/api/arg-types#tabledisable */
+    disable?: boolean;
+    /** @see https://storybook.js.org/docs/api/arg-types#tablesubcategory */
+    subcategory?: string;
+    /** @see https://storybook.js.org/docs/api/arg-types#tabletype */
+    type?: {
+      summary?: string;
+      detail?: string;
+    };
+  };
+  /** @see https://storybook.js.org/docs/api/arg-types#type */
+  type?: SBType | SBScalarType['name'];
+  /**
+   * @deprecated Use `table.defaultValue.summary` instead.
+   * @see https://storybook.js.org/docs/api/arg-types#defaultvalue
+   */
+  defaultValue?: any;
+  [key: string]: any;
+}
+interface StrictInputType extends InputType {
+  name: string;
+  type?: SBType;
+}
+interface Args {
+  [name: string]: any;
+}
+/** @see https://storybook.js.org/docs/api/arg-types#argtypes */
+type ArgTypes<TArgs$1 = Args> = { [name in keyof TArgs$1]: InputType };
+type StrictArgTypes<TArgs$1 = Args> = { [name in keyof TArgs$1]: StrictInputType };
+interface Globals {
+  [name: string]: any;
+}
+interface GlobalTypes {
+  [name: string]: InputType;
+}
+interface StrictGlobalTypes {
+  [name: string]: StrictInputType;
+}
+interface Renderer {
+  /** What is the type of the `component` annotation in this renderer? */
+  component: any;
+  /** What does the story function return in this renderer? */
+  storyResult: any;
+  /** What type of element does this renderer render to? */
+  canvasElement: any;
+  mount(): Promise<Canvas>;
+  T?: any;
+}
+/** @deprecated - Use `Renderer` */
+
+interface StoryContextForEnhancers<TRenderer extends Renderer = Renderer, TArgs$1 = Args> extends StoryIdentifier {
+  component?: (TRenderer & {
+    T: any;
+  })['component'];
+  subcomponents?: Record<string, (TRenderer & {
+    T: any;
+  })['component']>;
+  parameters: Parameters;
+  initialArgs: TArgs$1;
+  argTypes: StrictArgTypes<TArgs$1>;
+}
+type ArgsEnhancer<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (context: StoryContextForEnhancers<TRenderer, TArgs$1>) => TArgs$1;
+type ArgTypesEnhancer<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = ((context: StoryContextForEnhancers<TRenderer, TArgs$1>) => StrictArgTypes<TArgs$1>) & {
+  secondPass?: boolean;
+};
+interface StoryContextUpdate<TArgs$1 = Args> {
+  args?: TArgs$1;
+  globals?: Globals;
+  [key: string]: any;
+}
+type ViewMode = 'story' | 'docs';
+type LoaderFunction<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (context: StoryContextForLoaders<TRenderer, TArgs$1>) => Promise<Record<string, any> | void> | Record<string, any> | void;
+type Awaitable<T$1> = T$1 | PromiseLike<T$1>;
+type CleanupCallback = () => Awaitable<unknown>;
+type BeforeAll = () => Awaitable<CleanupCallback | void>;
+type BeforeEach<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (context: StoryContext<TRenderer, TArgs$1>) => Awaitable<CleanupCallback | void>;
+type AfterEach<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (context: StoryContext<TRenderer, TArgs$1>) => Awaitable<void>;
+interface Canvas {}
+interface StoryContext<TRenderer extends Renderer = Renderer, TArgs$1 = Args> extends StoryContextForEnhancers<TRenderer, TArgs$1>, Required<StoryContextUpdate<TArgs$1>> {
+  loaded: Record<string, any>;
+  abortSignal: AbortSignal;
+  canvasElement: TRenderer['canvasElement'];
+  hooks: unknown;
+  originalStoryFn: StoryFn<TRenderer>;
+  viewMode: ViewMode;
+  step: StepFunction<TRenderer, TArgs$1>;
+  context: this;
+  canvas: Canvas;
+  mount: TRenderer['mount'];
+  reporting: ReportingAPI;
+}
+/** @deprecated Use {@link StoryContext} instead. */
+interface StoryContextForLoaders<TRenderer extends Renderer = Renderer, TArgs$1 = Args> extends StoryContext<TRenderer, TArgs$1> {}
+/** @deprecated Use {@link StoryContext} instead. */
+interface PlayFunctionContext<TRenderer extends Renderer = Renderer, TArgs$1 = Args> extends StoryContext<TRenderer, TArgs$1> {}
+type StepLabel = string;
+type StepFunction<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (label: StepLabel, play: PlayFunction<TRenderer, TArgs$1>) => Promise<void> | void;
+type PlayFunction<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (context: PlayFunctionContext<TRenderer, TArgs$1>) => Promise<void> | void;
+type PartialStoryFn<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (update?: StoryContextUpdate<Partial<TArgs$1>>) => TRenderer['storyResult'];
+type LegacyStoryFn<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (context: StoryContext<TRenderer, TArgs$1>) => TRenderer['storyResult'];
+type ArgsStoryFn<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (args: TArgs$1, context: StoryContext<TRenderer, TArgs$1>) => (TRenderer & {
+  T: TArgs$1;
+})['storyResult'];
+type StoryFn<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = LegacyStoryFn<TRenderer, TArgs$1> | ArgsStoryFn<TRenderer, TArgs$1>;
+type DecoratorFunction<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (fn: PartialStoryFn<TRenderer, TArgs$1>, c: StoryContext<TRenderer, TArgs$1>) => TRenderer['storyResult'];
+type DecoratorApplicator<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (storyFn: LegacyStoryFn<TRenderer, TArgs$1>, decorators: DecoratorFunction<TRenderer, TArgs$1>[]) => LegacyStoryFn<TRenderer, TArgs$1>;
+type StepRunner<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (label: StepLabel, play: PlayFunction<TRenderer, TArgs$1>, context: StoryContext<TRenderer, TArgs$1>) => Promise<void>;
+interface BaseAnnotations<TRenderer extends Renderer = Renderer, TArgs$1 = Args> {
+  /**
+   * Wrapper components or Storybook decorators that wrap a story.
+   *
+   * Decorators defined in Meta will be applied to every story variation.
+   *
+   * @see [Decorators](https://storybook.js.org/docs/writing-stories/decorators)
+   */
+  decorators?: DecoratorFunction<TRenderer, Simplify<TArgs$1>>[] | DecoratorFunction<TRenderer, Simplify<TArgs$1>>;
+  /**
+   * Custom metadata for a story.
+   *
+   * @see [Parameters](https://storybook.js.org/docs/writing-stories/parameters)
+   */
+  parameters?: Parameters;
+  /**
+   * Dynamic data that are provided (and possibly updated by) Storybook and its addons.
+   *
+   * @see [Args](https://storybook.js.org/docs/writing-stories/args)
+   */
+  args?: Partial<TArgs$1>;
+  /**
+   * ArgTypes encode basic metadata for args, such as `name`, `description`, `defaultValue` for an
+   * arg. These get automatically filled in by Storybook Docs.
+   *
+   * @see [ArgTypes](https://storybook.js.org/docs/api/arg-types)
+   */
+  argTypes?: Partial<ArgTypes<TArgs$1>>;
+  /**
+   * Asynchronous functions which provide data for a story.
+   *
+   * @see [Loaders](https://storybook.js.org/docs/writing-stories/loaders)
+   */
+  loaders?: LoaderFunction<TRenderer, TArgs$1>[] | LoaderFunction<TRenderer, TArgs$1>;
+  /**
+   * Function to be called before each story. When the function is async, it will be awaited.
+   *
+   * `beforeEach` can be added to preview, the default export and to a specific story. They are run
+   * (and awaited) in the order: preview, default export, story
+   *
+   * A cleanup function can be returned.
+   */
+  beforeEach?: BeforeEach<TRenderer, TArgs$1>[] | BeforeEach<TRenderer, TArgs$1>;
+  /**
+   * Function to be called after each play function for post-test assertions. Don't use this
+   * function for cleaning up state. You can use the return callback of `beforeEach` for that, which
+   * is run when switching stories. When the function is async, it will be awaited.
+   *
+   * `afterEach` can be added to preview, the default export and to a specific story. They are run
+   * (and awaited) reverse order: preview, default export, story
+   */
+  experimental_afterEach?: AfterEach<TRenderer, TArgs$1>[] | AfterEach<TRenderer, TArgs$1>;
+  /**
+   * Define a custom render function for the story(ies). If not passed, a default render function by
+   * the renderer will be used.
+   */
+  render?: ArgsStoryFn<TRenderer, TArgs$1>;
+  /** Named tags for a story, used to filter stories in different contexts. */
+  tags?: Tag[];
+  mount?: (context: StoryContext<TRenderer, TArgs$1>) => TRenderer['mount'];
+}
+interface ProjectAnnotations<TRenderer extends Renderer = Renderer, TArgs$1 = Args> extends BaseAnnotations<TRenderer, TArgs$1> {
+  argsEnhancers?: ArgsEnhancer<TRenderer, Args>[];
+  argTypesEnhancers?: ArgTypesEnhancer<TRenderer, Args>[];
+  /**
+   * Lifecycle hook which runs once, before any loaders, decorators or stories, and may rerun when
+   * configuration changes or when reinitializing (e.g. between test runs). The function may be
+   * synchronous or asynchronous, and may return a cleanup function which may also be synchronous or
+   * asynchronous. The cleanup function is not guaranteed to run (e.g. when the browser closes), but
+   * runs when configuration changes or when reinitializing. This hook may only be defined globally
+   * (i.e. not on component or story level). When multiple hooks are specified, they are to be
+   * executed sequentially (and awaited) in the following order:
+   *
+   * - Addon hooks (in order of addons array in e.g. .storybook/main.js)
+   * - Annotation hooks (in order of previewAnnotations array in e.g. .storybook/main.js)
+   * - Preview hook (via e.g. .storybook/preview.js) Cleanup functions are executed sequentially in
+   *   reverse order of initialization.
+   */
+  beforeAll?: BeforeAll;
+  /** @deprecated Project `globals` renamed to `initiaGlobals` */
+  globals?: Globals;
+  initialGlobals?: Globals;
+  globalTypes?: GlobalTypes;
+  applyDecorators?: DecoratorApplicator<TRenderer, Args>;
+  runStep?: StepRunner<TRenderer, TArgs$1>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@storybook+core@8.6.11_prettier@3.5.3_storybook@8.6.11_prettier@3.5.3_/node_modules/@storybook/core/dist/types/index.d.ts
+declare global {
+  var globalProjectAnnotations: NormalizedProjectAnnotations<any>;
+  var defaultProjectAnnotations: ProjectAnnotations$1<any>;
+}
+type WrappedStoryRef = {
+  __pw_type: 'jsx' | 'importRef';
+};
+type UnwrappedJSXStoryRef = {
+  __pw_type: 'jsx';
+  type: UnwrappedImportStoryRef;
+};
+type UnwrappedImportStoryRef = ComposedStoryFn;
+declare global {
+  function __pwUnwrapObject(storyRef: WrappedStoryRef): Promise<UnwrappedJSXStoryRef | UnwrappedImportStoryRef>;
+}
+interface Report<T$1 = unknown> {
+  type: string;
+  version?: number;
+  result: T$1;
+  status: 'failed' | 'passed' | 'warning';
+}
+declare class ReporterAPI {
+  reports: Report[];
+  addReport(report: Report): Promise<void>;
+}
+
+/**
+ * A URL pathname, beginning with a /.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#location.pathname
+ */
+
+declare global {
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
+
+/**
+Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
+
+Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
+
+This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
+
+@example
+```
+import type {LiteralUnion} from 'type-fest';
+
+// Before
+
+type Pet = 'dog' | 'cat' | string;
+
+const pet: Pet = '';
+// Start typing in your TypeScript-enabled IDE.
+// You **will not** get auto-completion for `dog` and `cat` literals.
+
+// After
+
+type Pet2 = LiteralUnion<'dog' | 'cat', string>;
+
+const pet: Pet2 = '';
+// You **will** get auto-completion for `dog` and `cat` literals.
+```
+
+@category Type
+*/
+
+interface Renderer$1 extends Renderer {}
+type MaybePromise<T$1> = Promise<T$1> | T$1;
+type TeardownRenderToCanvas = () => MaybePromise<void>;
+type RenderToCanvas<TRenderer extends Renderer$1> = (context: RenderContext<TRenderer>, element: TRenderer['canvasElement']) => MaybePromise<void | TeardownRenderToCanvas>;
+interface ProjectAnnotations$1<TRenderer extends Renderer$1> extends ProjectAnnotations<TRenderer> {
+  addons?: ProjectAnnotations$1<TRenderer>[];
+  testingLibraryRender?: (...args: never[]) => {
+    unmount: () => void;
+  };
+  renderToCanvas?: RenderToCanvas<TRenderer>;
+  renderToDOM?: RenderToCanvas<TRenderer>;
+}
+type NormalizedProjectAnnotations<TRenderer extends Renderer$1 = Renderer$1> = Omit<ProjectAnnotations$1<TRenderer>, 'decorators' | 'loaders' | 'runStep' | 'beforeAll'> & {
+  argTypes?: StrictArgTypes;
+  globalTypes?: StrictGlobalTypes;
+  decorators?: DecoratorFunction<TRenderer>[];
+  loaders?: LoaderFunction<TRenderer>[];
+  runStep: StepRunner<TRenderer>;
+  beforeAll: BeforeAll;
+};
+declare type RenderContext<TRenderer extends Renderer$1 = Renderer$1> = StoryIdentifier & {
+  showMain: () => void;
+  showError: (error: {
+    title: string;
+    description: string;
+  }) => void;
+  showException: (err: Error) => void;
+  forceRemount: boolean;
+  storyContext: StoryContext<TRenderer>;
+  storyFn: PartialStoryFn<TRenderer>;
+  unboundStoryFn: LegacyStoryFn<TRenderer>;
+};
+/** A story function with partial args, used internally by composeStory */
+type PartialArgsStoryFn<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = (args?: TArgs$1) => (TRenderer & {
+  T: TArgs$1;
+})['storyResult'];
+/**
+ * A story that got recomposed for portable stories, containing all the necessary data to be
+ * rendered in external environments
+ */
+type ComposedStoryFn<TRenderer extends Renderer = Renderer, TArgs$1 = Args> = PartialArgsStoryFn<TRenderer, TArgs$1> & {
+  args: TArgs$1;
+  id: StoryId;
+  play?: (context?: Partial<StoryContext<TRenderer, Partial<TArgs$1>>>) => Promise<void>;
+  run: (context?: Partial<StoryContext<TRenderer, Partial<TArgs$1>>>) => Promise<void>;
+  load: () => Promise<void>;
+  storyName: string;
+  parameters: Parameters;
+  argTypes: StrictArgTypes<TArgs$1>;
+  reporting: ReporterAPI;
+  tags: Tag[];
+  globals: Globals;
+};
+/**
+ * Based on a module of stories, it returns all stories within it, filtering non-stories Each story
+ * will have partial props, as their props should be handled when composing stories
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/@storybook+react@8.6.11_@storybook+test@8.6.11_storybook@8.6.11_prettier@3.5.3___react-_eab940b44d3237e7dadfcaf195cb715a/node_modules/@storybook/react/dist/public-types-f2c70f25.d.ts
+declare global {
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
+
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+*/
+//#endregion
+//#region src/renderer.d.ts
+interface LexicalBlockProps<T$1> {
+  node: {
+    fields: T$1;
+  };
+}
+type BlockRendererFunction = ({
+  node
+}: LexicalBlockProps<any>) => Promise<any> | any;
+type BlocksRendererFunctions<T$1 extends string> = Record<T$1, BlockRendererFunction>;
+interface GenericStory<P$1> {
+  argTypes?: Partial<ArgTypes<{
+    node: {
+      fields: P$1;
+    };
+  }>>;
+}
+type StoryArgs<T$1> = T$1 extends GenericStory<infer P> ? P : never;
+declare const generateStoryForLexicalBlock: <T$1 extends GenericStory<any>>(args: StoryArgs<T$1>) => {
+  args: LexicalBlockProps<StoryArgs<T$1>>;
+};
+type ExtendedSerializedEditorState = SerializedEditorState & {
+  [k: string]: unknown;
+};
+//#endregion
+export { LexicalBlockProps as a, GenericStory as i, BlocksRendererFunctions as n, StoryArgs as o, ExtendedSerializedEditorState as r, generateStoryForLexicalBlock as s, BlockRendererFunction as t };
+//# sourceMappingURL=renderer-Y62qi9KC.d.mts.map