@particle-academy/react-fancy 5.12.0 → 5.14.0

package/dist/inputs.types-DERzxpe1.d.ts

@@ -0,0 +1,44 @@
+import { ReactNode } from 'react';
+import { S as Size } from './types-8Sv0rCjw.js';
+
+type InputOption<V = string> = string | {
+    value: V;
+    label: string;
+    disabled?: boolean;
+    description?: string;
+};
+type InputOptionGroup<V = string> = {
+    label: string;
+    options: InputOption<V>[];
+};
+/**
+ * Edit vs. read-only display. In `"view"` mode an input renders the bound value
+ * as static text instead of an interactive control — the React/Inertia analog of
+ * Livewire's public/bindable properties. Declared here (rather than in `mode/`)
+ * to keep `InputBaseProps` free of an import cycle. Resolved per input via
+ * {@link useFieldMode}: explicit prop → `<Form>`/`<FormProvider>` context → `"edit"`.
+ */
+type FieldMode = "edit" | "view";
+interface InputBaseProps {
+    size?: Size;
+    dirty?: boolean;
+    error?: string;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    disabled?: boolean;
+    className?: string;
+    id?: string;
+    name?: string;
+    /** `"edit"` (default) renders the control; `"view"` renders the value as text. Overrides the `<Form mode>` context. */
+    mode?: FieldMode;
+}
+type AffixPosition = "inside" | "outside";
+interface InputAffixProps {
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    prefixPosition?: AffixPosition;
+    suffixPosition?: AffixPosition;
+}
+
+export type { AffixPosition as A, FieldMode as F, InputAffixProps as I, InputBaseProps as a, InputOption as b, InputOptionGroup as c };

package/dist/kanban.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var chunkBPBI3WWQ_cjs = require('./chunk-BPBI3WWQ.cjs');
+require('./chunk-3Z6ALUWP.cjs');
+
+
+
+Object.defineProperty(exports, "Kanban", {
+  enumerable: true,
+  get: function () { return chunkBPBI3WWQ_cjs.Kanban; }
+});
+Object.defineProperty(exports, "useKanban", {
+  enumerable: true,
+  get: function () { return chunkBPBI3WWQ_cjs.useKanban; }
+});
+//# sourceMappingURL=kanban.cjs.map
+//# sourceMappingURL=kanban.cjs.map

package/dist/kanban.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"kanban.cjs"}

package/dist/kanban.d.cts

@@ -0,0 +1,136 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * Fired when a card is dropped into a column. `toIndex` is the position
+ * the card should land at within the destination column (0-based;
+ * `toIndex === current count` means append).
+ *
+ * For a same-column reorder, `fromColumn === toColumn` and `toIndex` is
+ * the new position.
+ */
+type KanbanCardMoveHandler = (cardId: string, fromColumn: string, toColumn: string, toIndex: number) => void;
+/**
+ * Fired when a column is dropped at a new position. `toIndex` is the
+ * new position among registered columns (0-based).
+ */
+type KanbanColumnMoveHandler = (columnId: string, toIndex: number) => void;
+interface KanbanContextValue {
+    draggedCard: string | null;
+    setDraggedCard: (id: string | null) => void;
+    dragSource: string | null;
+    setDragSource: (id: string | null) => void;
+    draggedColumn: string | null;
+    setDraggedColumn: (id: string | null) => void;
+    onCardMove?: KanbanCardMoveHandler;
+    onColumnMove?: KanbanColumnMoveHandler;
+    columnIds: string[];
+    registerColumn: (id: string) => () => void;
+}
+interface KanbanProps {
+    children: ReactNode;
+    /**
+     * Called when a card is dropped into a column. Receives the destination
+     * index so handlers can support within-column reorder.
+     */
+    onCardMove?: KanbanCardMoveHandler;
+    /**
+     * Called when a column is dropped at a new position. Only fires if at
+     * least one column inside the board has a `<Kanban.ColumnHandle>` and
+     * a column was actually dragged.
+     */
+    onColumnMove?: KanbanColumnMoveHandler;
+    className?: string;
+}
+interface KanbanColumnProps {
+    children: ReactNode;
+    id: string;
+    title?: string;
+    className?: string;
+    /**
+     * Skip the column's default visuals (background, padding, min-height,
+     * fixed width). Drop-target wiring and the drag-over ring stay.
+     */
+    unstyled?: boolean;
+    /**
+     * Soft work-in-progress limit. Shown in the column header (when `title`
+     * is provided) as `count/limit`. Turns red over capacity. Drops are
+     * still accepted — enforce hard via the consumer's `onCardMove`.
+     */
+    wipLimit?: number;
+    /**
+     * If true, the column renders nothing when it has zero card children.
+     * Useful for filter UIs that want clean collapse instead of empty
+     * placeholders.
+     */
+    hideWhenEmpty?: boolean;
+}
+interface KanbanCardProps {
+    children: ReactNode;
+    id: string;
+    className?: string;
+    /**
+     * Skip the card's default visuals (border, padding, shadow). Drag
+     * handlers and `draggable` stay.
+     */
+    unstyled?: boolean;
+}
+interface KanbanColumnHandleProps {
+    children: ReactNode;
+    className?: string;
+}
+
+declare function KanbanColumn({ children, id, title, className, unstyled, wipLimit, hideWhenEmpty, }: KanbanColumnProps): react.JSX.Element | null;
+declare namespace KanbanColumn {
+    var displayName: string;
+}
+
+declare function KanbanCard({ children, id, className, unstyled }: KanbanCardProps): react.JSX.Element;
+declare namespace KanbanCard {
+    var displayName: string;
+}
+
+/**
+ * Drag handle for column reordering.
+ *
+ * Mount inside a `Kanban.Column` to make that column draggable. The
+ * column's parent `Kanban` listens for the drop and surfaces the new
+ * position via `onColumnMove`. Without a handle, columns are static.
+ *
+ * Typically wrapped around the column header so users grab the title
+ * to reorder; can also be a small grip icon.
+ */
+declare function KanbanColumnHandle({ children, className, }: KanbanColumnHandleProps): react.JSX.Element;
+declare namespace KanbanColumnHandle {
+    var displayName: string;
+}
+
+/**
+ * Kanban board.
+ *
+ * Compound:
+ *   <Kanban onCardMove={...} onColumnMove={...}>
+ *     <Kanban.Column id="todo" wipLimit={4}>
+ *       <Kanban.ColumnHandle>...header...</Kanban.ColumnHandle>  // optional
+ *       <Kanban.Card id="...">...</Kanban.Card>
+ *     </Kanban.Column>
+ *   </Kanban>
+ *
+ * Cards drag between columns AND within a column. Drop position is
+ * computed from mouse Y at hover time and surfaced via the `toIndex`
+ * argument on `onCardMove`.
+ *
+ * Columns drag horizontally to reorder when a `<Kanban.ColumnHandle>`
+ * is mounted inside them. The root computes the drop index from
+ * mouse X and surfaces it via `onColumnMove`.
+ */
+declare function KanbanRoot({ children, onCardMove, onColumnMove, className, }: KanbanProps): react.JSX.Element;
+declare const Kanban: typeof KanbanRoot & {
+    Column: typeof KanbanColumn;
+    Card: typeof KanbanCard;
+    ColumnHandle: typeof KanbanColumnHandle;
+};
+
+declare function useKanban(): KanbanContextValue;
+
+export { Kanban, type KanbanCardMoveHandler, type KanbanCardProps, type KanbanColumnHandleProps, type KanbanColumnMoveHandler, type KanbanColumnProps, type KanbanContextValue, type KanbanProps, useKanban };

package/dist/kanban.d.ts

@@ -0,0 +1,136 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * Fired when a card is dropped into a column. `toIndex` is the position
+ * the card should land at within the destination column (0-based;
+ * `toIndex === current count` means append).
+ *
+ * For a same-column reorder, `fromColumn === toColumn` and `toIndex` is
+ * the new position.
+ */
+type KanbanCardMoveHandler = (cardId: string, fromColumn: string, toColumn: string, toIndex: number) => void;
+/**
+ * Fired when a column is dropped at a new position. `toIndex` is the
+ * new position among registered columns (0-based).
+ */
+type KanbanColumnMoveHandler = (columnId: string, toIndex: number) => void;
+interface KanbanContextValue {
+    draggedCard: string | null;
+    setDraggedCard: (id: string | null) => void;
+    dragSource: string | null;
+    setDragSource: (id: string | null) => void;
+    draggedColumn: string | null;
+    setDraggedColumn: (id: string | null) => void;
+    onCardMove?: KanbanCardMoveHandler;
+    onColumnMove?: KanbanColumnMoveHandler;
+    columnIds: string[];
+    registerColumn: (id: string) => () => void;
+}
+interface KanbanProps {
+    children: ReactNode;
+    /**
+     * Called when a card is dropped into a column. Receives the destination
+     * index so handlers can support within-column reorder.
+     */
+    onCardMove?: KanbanCardMoveHandler;
+    /**
+     * Called when a column is dropped at a new position. Only fires if at
+     * least one column inside the board has a `<Kanban.ColumnHandle>` and
+     * a column was actually dragged.
+     */
+    onColumnMove?: KanbanColumnMoveHandler;
+    className?: string;
+}
+interface KanbanColumnProps {
+    children: ReactNode;
+    id: string;
+    title?: string;
+    className?: string;
+    /**
+     * Skip the column's default visuals (background, padding, min-height,
+     * fixed width). Drop-target wiring and the drag-over ring stay.
+     */
+    unstyled?: boolean;
+    /**
+     * Soft work-in-progress limit. Shown in the column header (when `title`
+     * is provided) as `count/limit`. Turns red over capacity. Drops are
+     * still accepted — enforce hard via the consumer's `onCardMove`.
+     */
+    wipLimit?: number;
+    /**
+     * If true, the column renders nothing when it has zero card children.
+     * Useful for filter UIs that want clean collapse instead of empty
+     * placeholders.
+     */
+    hideWhenEmpty?: boolean;
+}
+interface KanbanCardProps {
+    children: ReactNode;
+    id: string;
+    className?: string;
+    /**
+     * Skip the card's default visuals (border, padding, shadow). Drag
+     * handlers and `draggable` stay.
+     */
+    unstyled?: boolean;
+}
+interface KanbanColumnHandleProps {
+    children: ReactNode;
+    className?: string;
+}
+
+declare function KanbanColumn({ children, id, title, className, unstyled, wipLimit, hideWhenEmpty, }: KanbanColumnProps): react.JSX.Element | null;
+declare namespace KanbanColumn {
+    var displayName: string;
+}
+
+declare function KanbanCard({ children, id, className, unstyled }: KanbanCardProps): react.JSX.Element;
+declare namespace KanbanCard {
+    var displayName: string;
+}
+
+/**
+ * Drag handle for column reordering.
+ *
+ * Mount inside a `Kanban.Column` to make that column draggable. The
+ * column's parent `Kanban` listens for the drop and surfaces the new
+ * position via `onColumnMove`. Without a handle, columns are static.
+ *
+ * Typically wrapped around the column header so users grab the title
+ * to reorder; can also be a small grip icon.
+ */
+declare function KanbanColumnHandle({ children, className, }: KanbanColumnHandleProps): react.JSX.Element;
+declare namespace KanbanColumnHandle {
+    var displayName: string;
+}
+
+/**
+ * Kanban board.
+ *
+ * Compound:
+ *   <Kanban onCardMove={...} onColumnMove={...}>
+ *     <Kanban.Column id="todo" wipLimit={4}>
+ *       <Kanban.ColumnHandle>...header...</Kanban.ColumnHandle>  // optional
+ *       <Kanban.Card id="...">...</Kanban.Card>
+ *     </Kanban.Column>
+ *   </Kanban>
+ *
+ * Cards drag between columns AND within a column. Drop position is
+ * computed from mouse Y at hover time and surfaced via the `toIndex`
+ * argument on `onCardMove`.
+ *
+ * Columns drag horizontally to reorder when a `<Kanban.ColumnHandle>`
+ * is mounted inside them. The root computes the drop index from
+ * mouse X and surfaces it via `onColumnMove`.
+ */
+declare function KanbanRoot({ children, onCardMove, onColumnMove, className, }: KanbanProps): react.JSX.Element;
+declare const Kanban: typeof KanbanRoot & {
+    Column: typeof KanbanColumn;
+    Card: typeof KanbanCard;
+    ColumnHandle: typeof KanbanColumnHandle;
+};
+
+declare function useKanban(): KanbanContextValue;
+
+export { Kanban, type KanbanCardMoveHandler, type KanbanCardProps, type KanbanColumnHandleProps, type KanbanColumnMoveHandler, type KanbanColumnProps, type KanbanContextValue, type KanbanProps, useKanban };

package/dist/kanban.js

@@ -0,0 +1,4 @@
+export { Kanban, useKanban } from './chunk-YT42J4VQ.js';
+import './chunk-DSUHZO6T.js';
+//# sourceMappingURL=kanban.js.map
+//# sourceMappingURL=kanban.js.map

package/dist/kanban.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"kanban.js"}

package/dist/kbd.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var chunkMGZE2QEM_cjs = require('./chunk-MGZE2QEM.cjs');
+require('./chunk-3Z6ALUWP.cjs');
+
+
+
+Object.defineProperty(exports, "Kbd", {
+  enumerable: true,
+  get: function () { return chunkMGZE2QEM_cjs.Kbd; }
+});
+//# sourceMappingURL=kbd.cjs.map
+//# sourceMappingURL=kbd.cjs.map

package/dist/kbd.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"kbd.cjs"}

package/dist/kbd.d.cts

@@ -0,0 +1,30 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode } from 'react';
+
+interface KbdProps extends HTMLAttributes<HTMLElement> {
+    /**
+     * Render a chord as separate keys — `keys={["Cmd", "K"]}` renders two caps
+     * with a separator between them, rather than one wide cap reading "Cmd K".
+     */
+    keys?: ReactNode[];
+    /** Separator drawn between chord keys. Default `"+"`. */
+    separator?: ReactNode;
+    size?: "xs" | "sm" | "md";
+    children?: ReactNode;
+}
+
+/**
+ * A keyboard key cap — `<Kbd>K</Kbd>`, or a chord via `<Kbd keys={["Cmd","K"]} />`.
+ *
+ * Twenty `<kbd>` elements across this suite's own showcase carried six
+ * different className recipes for the same thing: rounded, bordered, mono,
+ * small, with a dark-mode counterpart. None of them disagreed on intent; they
+ * disagreed on which greys.
+ *
+ * `min-w` is the detail worth having in one place: without it a `K` cap is
+ * visibly narrower than an `Esc` cap beside it, and a row of single letters
+ * reads as ragged rather than as keys.
+ */
+declare const Kbd: react.ForwardRefExoticComponent<KbdProps & react.RefAttributes<HTMLElement>>;
+
+export { Kbd, type KbdProps };

package/dist/kbd.d.ts

@@ -0,0 +1,30 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode } from 'react';
+
+interface KbdProps extends HTMLAttributes<HTMLElement> {
+    /**
+     * Render a chord as separate keys — `keys={["Cmd", "K"]}` renders two caps
+     * with a separator between them, rather than one wide cap reading "Cmd K".
+     */
+    keys?: ReactNode[];
+    /** Separator drawn between chord keys. Default `"+"`. */
+    separator?: ReactNode;
+    size?: "xs" | "sm" | "md";
+    children?: ReactNode;
+}
+
+/**
+ * A keyboard key cap — `<Kbd>K</Kbd>`, or a chord via `<Kbd keys={["Cmd","K"]} />`.
+ *
+ * Twenty `<kbd>` elements across this suite's own showcase carried six
+ * different className recipes for the same thing: rounded, bordered, mono,
+ * small, with a dark-mode counterpart. None of them disagreed on intent; they
+ * disagreed on which greys.
+ *
+ * `min-w` is the detail worth having in one place: without it a `K` cap is
+ * visibly narrower than an `Esc` cap beside it, and a row of single letters
+ * reads as ragged rather than as keys.
+ */
+declare const Kbd: react.ForwardRefExoticComponent<KbdProps & react.RefAttributes<HTMLElement>>;
+
+export { Kbd, type KbdProps };

package/dist/kbd.js

@@ -0,0 +1,4 @@
+export { Kbd } from './chunk-PYRMH34E.js';
+import './chunk-DSUHZO6T.js';
+//# sourceMappingURL=kbd.js.map
+//# sourceMappingURL=kbd.js.map

package/dist/kbd.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"kbd.js"}

package/dist/magic-wand.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var chunkW2Q4OWHX_cjs = require('./chunk-W2Q4OWHX.cjs');
+require('./chunk-5I4PR2KV.cjs');
+require('./chunk-7NLKXBZ2.cjs');
+require('./chunk-6BW5BQMN.cjs');
+require('./chunk-PPLR2DNC.cjs');
+require('./chunk-YLGTDBB2.cjs');
+require('./chunk-2S7WRR5P.cjs');
+require('./chunk-XZYKPGSK.cjs');
+require('./chunk-XCZZVRBY.cjs');
+require('./chunk-JXIBUIEY.cjs');
+require('./chunk-BFKCVSNK.cjs');
+require('./chunk-KJ22KE56.cjs');
+require('./chunk-L3V3BYVS.cjs');
+require('./chunk-3Z6ALUWP.cjs');
+
+
+
+Object.defineProperty(exports, "MagicWand", {
+  enumerable: true,
+  get: function () { return chunkW2Q4OWHX_cjs.MagicWand; }
+});
+//# sourceMappingURL=magic-wand.cjs.map
+//# sourceMappingURL=magic-wand.cjs.map

package/dist/magic-wand.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"magic-wand.cjs"}

package/dist/magic-wand.d.cts

@@ -0,0 +1,62 @@
+import * as react from 'react';
+
+/**
+ * MagicWand — selection-anchored floating toolbar for text inputs.
+ *
+ * When the user highlights text inside the wrapped <Textarea>, a small
+ * pill of AI quick-actions floats above the selection. Clicking an
+ * action invokes the host callback with the selected substring + range;
+ * the host returns a replacement string and MagicWand swaps it in-place.
+ *
+ *   <MagicWand
+ *     value={body}
+ *     onValueChange={setBody}
+ *     actions={[
+ *       { id: "rephrase", label: "Rephrase", hint: "same meaning, different words",
+ *         run: async (s) => await ai.rephrase(s) },
+ *       …
+ *     ]}
+ *   />
+ *
+ * Two appearances: `"floating"` (default — full labels) and `"pill"`
+ * (icon-only, compact). Auto-hides on click-away or scroll by default.
+ */
+type MagicWandSelection = {
+    start: number;
+    end: number;
+    text: string;
+};
+type MagicWandAction = {
+    /** Stable id, also shown as the busy-state key. */
+    id: string;
+    /** Display label (first character used in `pill` mode). */
+    label: string;
+    /** Tooltip body. */
+    hint?: string;
+    /** Optional kind chip rendered next to the label. */
+    tag?: string;
+    /** Returns the replacement text for the selection. */
+    run: (selection: string, range: MagicWandSelection) => Promise<string> | string;
+};
+type MagicWandAppearance = "pill" | "floating";
+interface MagicWandProps {
+    /** Controlled textarea value. */
+    value: string;
+    /** Called on every edit. */
+    onValueChange: (v: string) => void;
+    /** Action list. */
+    actions: MagicWandAction[];
+    /** Visual treatment. Defaults to "floating". */
+    appearance?: MagicWandAppearance;
+    /** Auto-hide the wand on click-away or scroll. Defaults to true. */
+    autoHide?: boolean;
+    /** Textarea rows. */
+    rows?: number;
+    /** Placeholder. */
+    placeholder?: string;
+    /** Called after an action runs successfully. */
+    onAction?: (action: MagicWandAction, selection: MagicWandSelection, replacement: string) => void;
+}
+declare function MagicWand({ value, onValueChange, actions, appearance, autoHide, rows, placeholder, onAction, }: MagicWandProps): react.JSX.Element;
+
+export { MagicWand, type MagicWandAction, type MagicWandAppearance, type MagicWandProps, type MagicWandSelection };

package/dist/magic-wand.d.ts

@@ -0,0 +1,62 @@
+import * as react from 'react';
+
+/**
+ * MagicWand — selection-anchored floating toolbar for text inputs.
+ *
+ * When the user highlights text inside the wrapped <Textarea>, a small
+ * pill of AI quick-actions floats above the selection. Clicking an
+ * action invokes the host callback with the selected substring + range;
+ * the host returns a replacement string and MagicWand swaps it in-place.
+ *
+ *   <MagicWand
+ *     value={body}
+ *     onValueChange={setBody}
+ *     actions={[
+ *       { id: "rephrase", label: "Rephrase", hint: "same meaning, different words",
+ *         run: async (s) => await ai.rephrase(s) },
+ *       …
+ *     ]}
+ *   />
+ *
+ * Two appearances: `"floating"` (default — full labels) and `"pill"`
+ * (icon-only, compact). Auto-hides on click-away or scroll by default.
+ */
+type MagicWandSelection = {
+    start: number;
+    end: number;
+    text: string;
+};
+type MagicWandAction = {
+    /** Stable id, also shown as the busy-state key. */
+    id: string;
+    /** Display label (first character used in `pill` mode). */
+    label: string;
+    /** Tooltip body. */
+    hint?: string;
+    /** Optional kind chip rendered next to the label. */
+    tag?: string;
+    /** Returns the replacement text for the selection. */
+    run: (selection: string, range: MagicWandSelection) => Promise<string> | string;
+};
+type MagicWandAppearance = "pill" | "floating";
+interface MagicWandProps {
+    /** Controlled textarea value. */
+    value: string;
+    /** Called on every edit. */
+    onValueChange: (v: string) => void;
+    /** Action list. */
+    actions: MagicWandAction[];
+    /** Visual treatment. Defaults to "floating". */
+    appearance?: MagicWandAppearance;
+    /** Auto-hide the wand on click-away or scroll. Defaults to true. */
+    autoHide?: boolean;
+    /** Textarea rows. */
+    rows?: number;
+    /** Placeholder. */
+    placeholder?: string;
+    /** Called after an action runs successfully. */
+    onAction?: (action: MagicWandAction, selection: MagicWandSelection, replacement: string) => void;
+}
+declare function MagicWand({ value, onValueChange, actions, appearance, autoHide, rows, placeholder, onAction, }: MagicWandProps): react.JSX.Element;
+
+export { MagicWand, type MagicWandAction, type MagicWandAppearance, type MagicWandProps, type MagicWandSelection };

package/dist/magic-wand.js

@@ -0,0 +1,16 @@
+export { MagicWand } from './chunk-7AFEKDUS.js';
+import './chunk-4UA45GB4.js';
+import './chunk-D7NAXQ2N.js';
+import './chunk-K7JGOQJG.js';
+import './chunk-3DJGPNUI.js';
+import './chunk-GFYSELJF.js';
+import './chunk-NPKE2IX6.js';
+import './chunk-WEGL4S52.js';
+import './chunk-45BBNJQD.js';
+import './chunk-M7EEQPE7.js';
+import './chunk-XJXQG34J.js';
+import './chunk-OL53XYHF.js';
+import './chunk-NRXK42LO.js';
+import './chunk-DSUHZO6T.js';
+//# sourceMappingURL=magic-wand.js.map
+//# sourceMappingURL=magic-wand.js.map

package/dist/magic-wand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"magic-wand.js"}

package/dist/marquee.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var chunkORPYY2MO_cjs = require('./chunk-ORPYY2MO.cjs');
+require('./chunk-3Z6ALUWP.cjs');
+
+
+
+Object.defineProperty(exports, "Marquee", {
+  enumerable: true,
+  get: function () { return chunkORPYY2MO_cjs.Marquee; }
+});
+//# sourceMappingURL=marquee.cjs.map
+//# sourceMappingURL=marquee.cjs.map

package/dist/marquee.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"marquee.cjs"}