@etrepum/lexical-builder-core 0.0.23

package/README.md

@@ -0,0 +1,7 @@
+# `@etrepum/lexical-builder-core`
+
+**EXPERIMENTAL** Lexical Builder Core
+
+This is the lightweight part of Lexical Builder that should be adopted
+into the lexical package to make it possible to define plans without
+any overhead of including the builder runtime.

package/dist/definePlan.d.ts

@@ -0,0 +1,153 @@
+import { AnyLexicalPlan, LexicalPlan, LexicalPlanConfig, NormalizedLexicalPlanArgument, NormalizedPeerDependency, PlanConfigBase, RegisterCleanup, RootPlan, RootPlanArgument } from './types';
+
+/**
+ * Define a LexicalPlan from the given object literal. TypeScript will
+ * infer Config and Name in most cases, but you may want to use
+ * {@link safeCast} for config if there are default fields or varying types.
+ *
+ * @param plan The LexicalPlan
+ * @returns The unmodified plan argument (this is only an inference helper)
+ *
+ * @example Basic example
+ * ```ts
+ * export const MyPlan = definePlan({
+ *   // Plan names must be unique in an editor
+ *   name: "my",
+ *   // Config must be an object, but an empty object is fine
+ *   config: {},
+ *   nodes: [MyNode],
+ * });
+ * ```
+ *
+ * @example Plan with optional configuration
+ * ```ts
+ * export interface ConfigurableConfig {
+ *   optional?: string;
+ *   required: number;
+ * }
+ * export const ConfigurablePlan = definePlan({
+ *   name: "configurable",
+ *   // The Plan's config must satisfy the full config type,
+ *   // but using the Plan as a dependency never requires
+ *   // configuration and any partial of the config can be specified
+ *   config: safeCast<ConfigurableConfig>({ required: 1 }),
+ * });
+ * ```
+ */
+export declare function definePlan<Config extends PlanConfigBase, Name extends string, Output>(plan: LexicalPlan<Config, Name, Output>): LexicalPlan<Config, Name, Output>;
+/**
+ * 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} 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
+ *
+ * @example
+ * ```ts
+ * const editorHandle = buildEditorFromPlans(
+ *   defineRootPlan({
+ *     dependencies: [DragonPlan, RichTextPlan, HistoryPlan],
+ *   }),
+ * );
+ * ```
+ */
+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
+ * an argument to {@link buildEditorFromPlans}.
+ *
+ * Before building the editor, configurations will be merged using
+ * plan.mergeConfig(plan, config) or {@link shallowMergeConfig} if
+ * this is not directly implemented by the Plan.
+ *
+ * @param args A plan followed by one or more config partials for that plan
+ * @returns [plan, config, ...configs]
+ *
+ * @example
+ * ```ts
+ * export const ReactDecoratorPlan = definePlan({
+ *   name: "react-decorator",
+ *   dependencies: [
+ *     configPlan(ReactPlan, {
+ *       decorators: [<ReactDecorator />]
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare function configPlan<Config extends PlanConfigBase, Name extends string, Output>(...args: NormalizedLexicalPlanArgument<Config, Name, Output>): NormalizedLexicalPlanArgument<Config, Name, Output>;
+/**
+ * Provide output from the register function of a Plan
+ *
+ * @returns A cleanup function
+ *
+ * @example Provide output with no other cleanup
+ * ```ts
+ * // This is entirely optional and would be inferred correctly, but
+ * // it can be useful for documentation!
+ * export interface RegisteredAtOutput {
+ *   registered_at: number;
+ * }
+ * export const RegisteredAtPlan = definePlan({
+ *   name: "RegisteredAt",
+ *   config: {},
+ *   register(editor) {
+ *     return provideOutput<RegisteredAtOutput>({ registered_at: Date.now() });
+ *   },
+ * });
+ * ```
+ *
+ * @example Provide output with other cleanup
+ * ```ts
+ * export interface UniqueCommandOutput {
+ *   command: LexicalCommand<unknown>;
+ * }
+ * export const UniqueCommandPlan = definePlan({
+ *   name: 'UniqueCommand',
+ *   config: {},
+ *   register(editor) {
+ *     const output: UniqueCommnadOutput = {command: createCommand('UNIQUE_COMMAND')};
+ *     const cleanup = registerCommand(
+ *       command,
+ *       (_payload) => {
+ *         console.log('Unique command received!');
+ *         return true;
+ *       }
+ *       COMMAND_PRIORITY_EDITOR
+ *     );
+ *     return provideOutput(output, cleanup);
+ *   },
+ * });
+ * ```
+ *
+ */
+export declare function provideOutput<Output>(output: Output, cleanup?: () => void): RegisterCleanup<Output>;
+/** @internal */
+export declare const PeerDependencyBrand: unique symbol;
+/**
+ * Used to declare a peer dependency of a plan in a type-safe way,
+ * requires the type parameter. The most common use case for peer dependencies
+ * is to avoid a direct import dependency, so you would want to use a
+ * type import or the import type (shown in below examples).
+ *
+ * @param name The plan's name
+ * @param config An optional config override
+ * @returns NormalizedPeerDependency
+ *
+ * @example
+ * ```ts
+ * export const PeerPlan = definePlan({
+ *   name: 'PeerPlan',
+ *   config: {},
+ *   peerDependencies: [
+ *     declarePeerDependency<typeof import("foo").FooPlan>("foo"),
+ *     declarePeerDependency<typeof import("bar").BarPlan>("bar", {config: "bar"}),
+ *   ],
+ * });
+ */
+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

@@ -0,0 +1 @@
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,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;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,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/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export declare const PACKAGE_VERSION: string;
+export { configPlan, definePlan, defineRootPlan, provideOutput, declarePeerDependency, } from './definePlan';
+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';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,eAAe,EAAE,MAAwC,CAAC;AAEvE,OAAO,EACL,UAAU,EACV,UAAU,EACV,cAAc,EACd,aAAa,EACb,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,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"}

package/dist/index.js

@@ -0,0 +1,37 @@
+function r(n) {
+  return n;
+}
+function u(n) {
+  return Object.assign(n, { name: "[root]", config: {} });
+}
+function f(...n) {
+  return n;
+}
+function o(n, t) {
+  return Object.assign(() => t && t(), { output: n });
+}
+function c(n, t) {
+  return [n, t];
+}
+function i(n) {
+  return n;
+}
+function a(n, t) {
+  if (!t || n === t)
+    return n;
+  for (const e in t)
+    if (n[e] !== t[e])
+      return { ...n, ...t };
+  return n;
+}
+const l = "0.0.23";
+export {
+  l as PACKAGE_VERSION,
+  f as configPlan,
+  c as declarePeerDependency,
+  r as definePlan,
+  u as defineRootPlan,
+  o as provideOutput,
+  i as safeCast,
+  a as shallowMergeConfig
+};

package/dist/safeCast.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+/**
+ * Explicitly and safely cast a value to a specific type when inference or
+ * satisfies isn't going to work as expected (often useful for the config
+ * property with definePlan)
+ */
+export declare function safeCast<T>(value: T): T;
+//# sourceMappingURL=safeCast.d.ts.map

package/dist/safeCast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeCast.d.ts","sourceRoot":"","sources":["../src/safeCast.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEvC"}

package/dist/shallowMergeConfig.d.ts

@@ -0,0 +1,11 @@
+import { PlanConfigBase } from './types';
+
+/**
+ * The default merge strategy for plan configuration is a shallow merge.
+ *
+ * @param config A full config
+ * @param overrides A partial config of overrides
+ * @returns config if there are no overrides, otherwise `{...config, ...overrides}`
+ */
+export declare function shallowMergeConfig<T extends PlanConfigBase>(config: T, overrides?: Partial<T>): T;
+//# sourceMappingURL=shallowMergeConfig.d.ts.map

package/dist/shallowMergeConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shallowMergeConfig.d.ts","sourceRoot":"","sources":["../src/shallowMergeConfig.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,cAAc,EACzD,MAAM,EAAE,CAAC,EACT,SAAS,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GACrB,CAAC,CAUH"}

package/dist/types.d.ts

@@ -0,0 +1,211 @@
+import { CreateEditorArgs, EditorState, LexicalEditor } from 'lexical';
+import { PeerDependencyBrand } from './definePlan';
+
+/**
+ * Any concrete {@link LexicalPlan}
+ */
+export type AnyLexicalPlan = LexicalPlan<any, string, any>;
+/**
+ * Any {@link LexicalPlan} or {@link NormalizedLexicalPlanArgument}
+ */
+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]
+ */
+export type NormalizedLexicalPlanArgument<Config extends PlanConfigBase, Name extends string, Output extends unknown> = [LexicalPlan<Config, Name, Output>, Partial<Config>, ...Partial<Config>[]];
+/**
+ * An object that the register method can use to detect unmount and access the
+ * configuration for plan dependencies
+ */
+export interface RegisterState {
+    /** An AbortSignal that is aborted when the EditorHandle is disposed */
+    signal: AbortSignal;
+    /**
+     * Get the result of a peerDependency by name, if it exists
+     * (must be a peerDependency of this plan)
+     */
+    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[];
+    /**
+     * Get the names of all peer dependencies of this
+     * Plan, even if they do not exist in the builder,
+     * typically only used for devtools.
+     */
+    getPeerNameSet(): Set<string>;
+}
+/**
+ * A {@link LexicalPlan} or {@link NormalizedLexicalPlanArgument} (plan with config overrides)
+ */
+export type LexicalPlanArgument<Config extends PlanConfigBase, Name extends string, Output extends unknown> = LexicalPlan<Config, Name, Output> | NormalizedLexicalPlanArgument<Config, Name, Output>;
+export interface LexicalPlanDependency<Dependency extends AnyLexicalPlan> {
+    config: LexicalPlanConfig<Dependency>;
+    output: LexicalPlanOutput<Dependency>;
+}
+/**
+ * A Plan is a composable unit of LexicalEditor configuration
+ * (nodes, theme, etc) used to create an editor, plus runtime behavior
+ * that is registered after the editor is created.
+ *
+ * A Plan may depend on other Plans, and provide functionality to other
+ * plans through its config.
+ */
+export interface LexicalPlan<Config extends PlanConfigBase = PlanConfigBase, Name extends string = string, Output extends unknown = unknown> {
+    /** The name of the Plan, must be unique */
+    name: Name;
+    /** Plan names that must not be loaded with this Plan */
+    conflictsWith?: string[];
+    /** Other Plans that this Plan depends on, can also be used to configure them */
+    dependencies?: AnyLexicalPlanArgument[];
+    /**
+     * Other Plans, by name, that this Plan can optionally depend on or
+     * configure, if they are directly depended on by another Plan
+     */
+    peerDependencies?: NormalizedPeerDependency<AnyLexicalPlan>[];
+    /**
+     * @internal Disable root element events (for internal Meta use)
+     */
+    disableEvents?: CreateEditorArgs["disableEvents"];
+    /**
+     * Used when this editor is nested inside of another editor
+     */
+    parentEditor?: CreateEditorArgs["parentEditor"];
+    /**
+     * The namespace of this Editor. If two editors share the same
+     * namespace, JSON will be the clipboard interchange format.
+     * Otherwise HTML will be used.
+     */
+    namespace?: CreateEditorArgs["namespace"];
+    /**
+     * The nodes that this Plan adds to the Editor configuration, will be merged with other Plans
+     */
+    nodes?: CreateEditorArgs["nodes"];
+    /**
+     * EditorThemeClasses that will be deep merged with other Plans
+     */
+    theme?: CreateEditorArgs["theme"];
+    /**
+     * Overrides for HTML serialization (exportDOM) and
+     * deserialization (importDOM) that does not require subclassing and node
+     * replacement
+     */
+    html?: CreateEditorArgs["html"];
+    /**
+     * Whether the initial state of the editor is editable or not
+     */
+    editable?: CreateEditorArgs["editable"];
+    /**
+     * The editor will catch errors that happen during updates and
+     * reconciliation and call this. It defaults to
+     * `(error) => { throw error }`.
+     *
+     * @param error The Error object
+     * @param editor The editor that this error came from
+     */
+    onError?: (error: Error, editor: LexicalEditor) => void;
+    /**
+     * The initial EditorState as a JSON string, an EditorState, or a function
+     * to update the editor (once).
+     */
+    $initialEditorState?: InitialEditorStateType;
+    /**
+     * The default configuration specific to this Plan. This Config may be
+     * seen by this Plan, or any Plan that uses it as a dependency.
+     *
+     * The config may be mutated on register, this is particularly useful
+     * for vending functionality to other Plans that depend on this Plan.
+     */
+    config: Config;
+    /**
+     * By default, Config is shallow merged `{...a, ...b}` with
+     * {@link shallowMergeConfig}, if your Plan requires other strategies
+     * (such as concatenating an Array) you can implement it here.
+     *
+     * @example Merging an array
+     * ```js
+     * const plan = definePlan({
+     *   // ...
+     *   mergeConfig(config, overrides) {
+     *     const merged = shallowMergeConfig(config, overrides);
+     *     if (Array.isArray(overrides.decorators)) {
+     *       merged.decorators = [...config.decorators, ...overrides.decorators];
+     *     }
+     *     return merged;
+     *   }
+     * });
+     * ```
+     *
+     * @param config The current configuration
+     * @param overrides The partial configuration to merge
+     * @returns The merged configuration
+     */
+    mergeConfig?: (config: Config, overrides: Partial<Config>) => Config;
+    /**
+     * Add behavior to the editor (register transforms, listeners, etc.) after
+     * the Editor is created. The register function may also mutate the config
+     * in-place to expose data to other plans that use it as a dependency.
+     *
+     * @param editor The editor this Plan is being registered with
+     * @param config The merged configuration specific to this Plan
+     * @param state An object containing an AbortSignal that can be
+     *   used, and methods for accessing the merged configuration of
+     *   dependencies and peerDependencies
+     * @returns A clean-up function
+     */
+    register?: (editor: LexicalEditor, config: Config, state: RegisterState) => RegisterCleanup<Output>;
+}
+export type RegisterCleanup<Output> = (() => void) & (unknown extends Output ? {
+    output?: Output;
+} : {
+    output: Output;
+});
+/**
+ * Extract the Config type from a Plan
+ */
+export type LexicalPlanConfig<Plan extends AnyLexicalPlan> = Plan["config"];
+/**
+ * Extract the Name type from a Plan
+ */
+export type LexicalPlanName<Plan extends AnyLexicalPlan> = Plan["name"];
+export type LexicalPlanOutput<Plan> = Plan extends LexicalPlan<infer _Config, infer _Name, infer Output> ? Output : unknown;
+/**
+ * A handle to the editor and its dispose function
+ */
+export interface EditorHandle extends Disposable {
+    /** The created editor */
+    editor: LexicalEditor;
+    /**
+     * Dispose the editor and perform all clean-up
+     * (also available as Symbol.dispose via Disposable)
+     */
+    dispose: () => void;
+}
+/**
+ * All of the possible ways to initialize $initialEditorState:
+ * - `null` an empty state, the default
+ * - `string` an EditorState serialized to JSON
+ * - `EditorState` an EditorState that has been deserialized already (not just parsed JSON)
+ * - `((editor: LexicalEditor) => void)` A function that is called with the editor for you to mutate it
+ */
+export type InitialEditorStateType = null | string | EditorState | ((editor: LexicalEditor) => void);
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@etrepum/lexical-builder-core",
+  "description": "[EXPERIMENTAL] Lexical Builder @etrepum/lexical-builder-core",
+  "type": "module",
+  "keywords": [
+    "lexical",
+    "lexical-builder",
+    "plug-in",
+    "plan"
+  ],
+  "scripts": {
+    "build": "tsc --noEmit && vite build",
+    "dev": "vite",
+    "test": "vitest run --typecheck",
+    "test:watch": "vitest"
+  },
+  "version": "0.0.23",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/etrepum/lexical-builder.git",
+    "directory": "packages/lexical-builder-core"
+  },
+  "bugs": {
+    "url": "https://github.com/etrepum/lexical-builder/issues"
+  },
+  "homepage": "https://github.com/etrepum/lexical-builder",
+  "dependencies": {},
+  "peerDependencies": {
+    "lexical": ">=0.16.0-0"
+  },
+  "sideEffects": false,
+  "devDependencies": {
+    "@testing-library/dom": "^10.1.0",
+    "@testing-library/jest-dom": "^6.4.5",
+    "@testing-library/user-event": "^14.5.2",
+    "jsdom": "^24.1.0",
+    "tslib": "^2.6.2",
+    "typescript": "^5.4.5",
+    "vite": "^5.2.11",
+    "vite-plugin-dts": "^3.9.1",
+    "vite-plugin-package-version": "^1.1.0",
+    "vitest": "^1.6.0"
+  },
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ]
+}