@modufolio/panel 0.1.0

package/dist/Composables/useUnsavedChangesWarning.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Warn before a navigation would discard unsaved edits.
+ *
+ * Hooks Inertia's `before` event, so it covers every ordinary visit —
+ * including Logout, which is a POST visit like any other — plus
+ * `beforeunload` for tab closes and hard refreshes.
+ *
+ * Takes Inertia's form object, or a getter for anything else that knows
+ * whether it is dirty (the nested drawer form's computed, say). Read at
+ * event time either way, never captured.
+ */
+export declare function useUnsavedChangesWarning(form: {
+    isDirty: boolean;
+} | (() => boolean)): {
+    allowNextNavigation: () => void;
+};

package/dist/Primitives/hideOthers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Take everything outside `target` out of the accessibility tree, walking up to
+ * the body and treating each level's siblings. Returns the undo.
+ *
+ * @param exempt Elements to leave alone — the other open overlays. They are
+ *   siblings of `target` under the teleport root, and hiding a dropdown that
+ *   belongs to the dialog on top of it would silence the very control the user
+ *   just opened.
+ */
+export declare function hideOthers(target: Element, exempt?: Element[]): () => void;
+/** Whether `element` sits in a subtree an overlay has taken out of the page. */
+export declare function isHiddenBehindOverlay(element: HTMLElement): boolean;

package/dist/Primitives/teleportTarget.d.ts

@@ -0,0 +1,2 @@
+export declare function setTeleportTarget(value: string | HTMLElement): void;
+export declare function getTeleportTarget(): string | HTMLElement;

package/dist/Primitives/useAnchoredPosition.d.ts

@@ -0,0 +1,32 @@
+import { Placement } from '@floating-ui/vue';
+import { CSSProperties, Ref } from 'vue';
+export interface AnchoredPositionOptions {
+    /** Preferred side; flipped automatically when it does not fit. */
+    placement?: Placement;
+    /** Gap between anchor and panel, in pixels. */
+    offset?: number;
+    /** Keep this much clearance from the viewport edge. */
+    padding?: number;
+    /** Size the panel to the anchor — what a combobox listbox wants. */
+    matchWidth?: boolean;
+    /** Cap the panel's height to the space actually available. */
+    fitViewport?: boolean;
+    /** Never shrink the panel below this, even in a cramped viewport. */
+    minHeight?: number;
+}
+export interface AnchoredPosition {
+    /** Bind to the panel's `style`. */
+    floatingStyles: Readonly<Ref<CSSProperties>>;
+    /** The side finally used, after collision handling. */
+    placement: Readonly<Ref<Placement>>;
+}
+/**
+ * Position a floating panel against its trigger.
+ *
+ * Replaces the hand-rolled `getBoundingClientRect()` + clamp that each dropdown
+ * used to carry: flipping when the panel would run off the bottom, shifting it
+ * back inside the viewport, capping its height, and — via `autoUpdate` —
+ * following the anchor through scrolls, resizes and layout changes without
+ * every component registering its own scroll and resize listeners.
+ */
+export declare function useAnchoredPosition(anchor: Ref<HTMLElement | null>, panel: Ref<HTMLElement | null>, open: Ref<boolean>, options?: AnchoredPositionOptions): AnchoredPosition;

package/dist/Primitives/useArrowNavigation.d.ts

@@ -0,0 +1,30 @@
+import { Ref } from 'vue';
+export type NavigationOrientation = 'vertical' | 'horizontal' | 'both';
+export interface ArrowNavigationOptions {
+    /** Which arrow keys move the selection. @default 'vertical' */
+    orientation?: NavigationOrientation;
+    /** Wrap around at the ends. @default true */
+    loop?: boolean;
+}
+/**
+ * The index an arrow / Home / End press should move to, or -1 when the key is
+ * not a navigation key and the caller should let it through.
+ *
+ * Pure on purpose: a listbox driven by a highlighted index (a combobox) and a
+ * menu driven by DOM focus want the same key model but move different things.
+ */
+export declare function resolveNavigationIndex(key: string, currentIndex: number, count: number, options?: ArrowNavigationOptions): number;
+/**
+ * Roving focus over the items inside a container — the WAI-ARIA menu keyboard
+ * model: arrows move focus between items, Home/End jump to the ends, and typing
+ * jumps to an item by name.
+ */
+export declare function useArrowNavigation(container: Ref<HTMLElement | null>, options?: ArrowNavigationOptions & {
+    itemSelector?: string;
+}): {
+    items: () => HTMLElement[];
+    focusFirst: () => void;
+    focusIndex: (index: number) => void;
+    onKeydown: (event: KeyboardEvent) => boolean;
+    resetTypeahead: () => void;
+};

package/dist/Primitives/useBodyScrollLock.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from 'vue';
+/**
+ * Lock page scroll while an overlay is open.
+ *
+ * Returns a writable ref: set it to `true` to hold the lock, `false` to release.
+ * The page only scrolls again once *every* holder has released, so stacked
+ * overlays can each manage their own lock without fighting over `body.overflow`.
+ */
+export declare function useBodyScrollLock(initialState?: boolean): Ref<boolean>;

package/dist/Primitives/useDismissableLayer.d.ts

@@ -0,0 +1,46 @@
+import { MaybeRefOrGetter } from 'vue';
+export type DismissReason = 'escape' | 'pointer-outside';
+export interface DismissableLayerOptions {
+    /**
+     * Everything that counts as "inside" this layer. A teleported panel and the
+     * trigger that opened it live in different parts of the DOM, and a press on
+     * the trigger must not read as an outside interaction — the trigger's own
+     * click handler is what closes the layer in that case.
+     */
+    elements: () => Array<HTMLElement | null | undefined>;
+    /**
+     * Called when this layer is the top of the stack and the user pressed Escape
+     * or interacted outside it. The layer decides what to do: a non-closable
+     * dialog can ignore it, and Escape still will not reach the layer beneath.
+     */
+    onDismiss: (reason: DismissReason) => void;
+    /** Dismiss on a press outside the layer. @default true */
+    dismissOnOutsidePointer?: boolean;
+    /**
+     * The panel that owns the screen while this layer is on top. Supplying it
+     * marks the layer modal: the rest of the page is hidden from assistive
+     * technology, since `aria-modal="true"` is not reliably honoured on its own.
+     * Only the highest modal layer applies, so stacked overlays cannot each hide
+     * the other and leave the page with nothing announced.
+     */
+    modalElement?: () => HTMLElement | null;
+}
+/** Whether any modal overlay is open. */
+export declare function hasModalLayer(): boolean;
+/**
+ * Whether `element` is (or is inside) the overlay that owns focus.
+ *
+ * A focus trap has to ask: an overlay teleported next to an open drawer sits
+ * outside the drawer's subtree, so the drawer's trap would otherwise drag focus
+ * straight back out of whatever opened on top of it.
+ */
+export declare function isTopmostModalLayer(element: HTMLElement | null): boolean;
+/** `Esc` is what older browsers report, and what Vue's `.esc` modifier sends. */
+export declare function isEscapeKey(event: KeyboardEvent): boolean;
+/**
+ * Register an overlay in the global layer stack for as long as `active` holds.
+ *
+ * The stack is what makes nesting behave: Escape and outside presses go to the
+ * layer the user can actually see, and nothing reaches the layers beneath it.
+ */
+export declare function useDismissableLayer(active: MaybeRefOrGetter<boolean>, options: DismissableLayerOptions): void;

package/dist/Primitives/useId.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A DOM id for wiring ARIA relationships (`aria-labelledby`, `aria-controls`, …).
+ *
+ * Prefers Vue's own `useId()`, which is app-scoped and produces the same value
+ * on a server render and its hydration — `Math.random()` does not, and a panel
+ * page rendered on the server would hydrate with mismatched ids. Vue's version
+ * needs a component instance, so anything called outside one (a bare composable
+ * in a test) falls back to a module counter.
+ *
+ * @param deterministicId Caller-supplied id, returned untouched when present,
+ *   so a component can accept an `id` prop and still have a default.
+ */
+export declare function useId(deterministicId?: string | null, prefix?: string): string;

package/dist/Primitives/useTypeahead.d.ts

@@ -0,0 +1,11 @@
+/** A printable single character, i.e. something a user typed to search by. */
+export declare function isTypeaheadKey(event: KeyboardEvent): boolean;
+/**
+ * Jump to an item by typing its first letters — the keyboard behaviour every
+ * native menu and select has, and the reason a long list is usable without a
+ * mouse. Repeating one character cycles through the items starting with it.
+ */
+export declare function useTypeahead(): {
+    onTypeaheadKey: (key: string, values: string[], currentIndex: number) => number;
+    resetTypeahead: () => void;
+};

package/dist/Utils/apiFetch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Small wrapper around `fetch` for the panel's JSON API calls.
+ *
+ * It centralises the three things every hand-rolled `fetch` in the panel used
+ * to do (inconsistently): attach the CSRF token, send/parse JSON, and turn a
+ * non-2xx response into a thrown error carrying the parsed body. Prefer this
+ * over calling `fetch` directly so CSRF and error handling stay uniform.
+ *
+ *   const data = await apiFetch(panelUrl('/api/media/bulk'), {
+ *     method: 'DELETE',
+ *     body: { media_ids: ids },
+ *   })
+ */
+export interface ApiFetchOptions extends Omit<RequestInit, 'body'> {
+    /** Plain objects are JSON-encoded; strings/FormData/Blob are sent as-is. */
+    body?: unknown;
+}
+/** Thrown on a non-2xx response. `body` holds the parsed error payload. */
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+/**
+ * Perform a JSON API request. Resolves with the parsed response body (or null
+ * for an empty/204 response) and rejects with an {@link ApiError} on non-2xx.
+ */
+export declare function apiFetch<T = unknown>(url: string, options?: ApiFetchOptions): Promise<T>;

package/dist/Utils/csrf.d.ts

@@ -0,0 +1,2 @@
+export declare function setCsrfToken(value: string | null | undefined): void;
+export declare function getCsrfToken(): string | null;

package/dist/Utils/dates.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pure date math for the date picker. No DOM, no timezones beyond "local".
+ *
+ * Every Date produced here is a local-time midnight. Dates are constructed
+ * through setters rather than string or numeric constructor arguments:
+ * `new Date('2026-03-05')` parses as UTC midnight (off by a day west of
+ * Greenwich) and `new Date(26, 2, 5)` maps year 26 to 1926.
+ */
+/** Build a local-midnight Date. Month is 0-based, like the Date API. */
+export declare function makeDate(year: number, month: number, day: number): Date;
+/** Strict `YYYY-MM-DD`. Rejects overflow like 2026-02-31. Null for anything else. */
+export declare function parseISO(value: string): Date | null;
+export declare function formatISO(date: Date): string;
+/** Local midnight of the same calendar day. */
+export declare function atMidnight(date: Date): Date;
+export declare function todayMidnight(): Date;
+/** Same calendar day, ignoring time. Null-safe: two nulls are not equal. */
+export declare function dateEquals(a: Date | null, b: Date | null): boolean;
+export declare function addDays(date: Date, days: number): Date;
+/**
+ * Month arithmetic that clamps instead of overflowing: Jan 31 + 1 month is
+ * Feb 28/29, not Mar 3. `anchorDay` lets a caller keep the originally chosen
+ * day across repeated jumps, so Jan 31 → Feb 28 → Mar 31 rather than Mar 28.
+ */
+export declare function addMonths(date: Date, months: number, anchorDay?: number): Date;
+export declare function startOfMonth(date: Date): Date;
+export declare function daysInMonth(year: number, month: number): number;
+/** Is `date` within [min, max] and not vetoed by the callback? */
+export declare function dateAllowed(date: Date, min: Date | null, max: Date | null, isDisabled?: (date: Date) => boolean): boolean;
+/** Nearest date inside [min, max]; the date itself when already inside. */
+export declare function clampToRange(date: Date, min: Date | null, max: Date | null): Date;
+/**
+ * Resolve a 2-digit year to the century that lands it within ±50 years of
+ * the reference date: "1/1/40" means 2040 next to 2026, 1940 next to 1985.
+ */
+export declare function adjustTwoDigitYear(year: number, reference: Date): number;
+/**
+ * The weeks of one month as rows of 7. Leading/trailing cells outside the
+ * month are null (rendered empty, not as adjacent-month days).
+ * `firstDayOfWeek`: 0 = Sunday, 1 = Monday.
+ */
+export declare function monthMatrix(year: number, month: number, firstDayOfWeek?: number): Array<Array<Date | null>>;
+/**
+ * Lenient user-input parsing: d/m/y, d-m-y, d.m.y, with 2- or 4-digit years
+ * (2-digit resolved near `reference`), plus strict ISO. Day-first, matching
+ * the panel's display format. Null when the text is not a real date.
+ */
+export declare function parseUserInput(text: string, reference?: Date): Date | null;
+/** Display format for the panel: `dd/mm/yyyy`. */
+export declare function formatDisplay(date: Date): string;

package/dist/Utils/moduleSingleton.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Module-level state that survives a duplicated copy of this package.
+ *
+ * A bundler can instantiate the same `.ts` module twice — Vite's dep
+ * pre-bundler, for example, inlines a package's TS modules while leaving its
+ * `.vue` SFCs as external raw-source imports, so a store module imported from
+ * both sides of that boundary splits: `useToast().success()` pushes onto one
+ * copy's array while `<Toast />` renders the other's, and no toast ever
+ * appears. It fails silently, which is what makes it expensive to find.
+ *
+ * Keying the state off `globalThis` with `Symbol.for` hands every copy the
+ * same object, whatever the module graph did. In a single-copy build the cost
+ * is one symbol lookup at module init.
+ *
+ * Only for state that must be process-wide. Anything scoped to a component or
+ * an app instance belongs in provide/inject instead — a global would leak
+ * across SSR requests.
+ *
+ * (Pattern from frappe-ui's moduleSingleton, which exists for the same bug.)
+ */
+export declare function moduleSingleton<T>(key: string, create: () => T): T;

package/dist/Utils/optimistic.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Run an optimistic mutation: apply the local change immediately, fire the
+ * request, and roll back if it rejects. This replaces the hand-rolled
+ * snapshot -> mutate -> catch/rollback pattern duplicated across the media
+ * mutation composables.
+ *
+ *   const ok = await optimistic(
+ *     () => {
+ *       const previous = file.is_favorite
+ *       file.is_favorite = !previous
+ *       return () => { file.is_favorite = previous }   // rollback
+ *     },
+ *     () => apiFetch(panelUrl(`/api/media/${file.id}`), { method: 'PATCH', body: {...} }),
+ *     writeKey('media', file.id, 'is_favorite'),
+ *   )
+ *
+ * `apply` performs the optimistic change and returns a rollback thunk.
+ * Resolves true on success, false if the request failed (rolled back).
+ *
+ * The `key` orders overlapping mutations of the same state: without it, two
+ * quick toggles interleave so that the FIRST one failing rolls state back to
+ * before either ran, erasing the second's applied change. With a key, each
+ * application is recorded on the writeGate at dispatch, and a failure only
+ * rolls back while its own write is still the newest for that key — a stale
+ * failure keeps its hands off state a later mutation now owns. (When every
+ * overlapping write fails, the newest rollback restores the previous
+ * optimistic value rather than the original — the older writes' truth is
+ * unknowable locally at that point, and their toasts already fired.)
+ *
+ * `key` is optional only so unrelated one-shot mutations don't have to mint
+ * one; any state that can be mutated twice concurrently should pass it.
+ */
+export declare function optimistic(apply: () => () => void, request: () => Promise<unknown>, key?: string): Promise<boolean>;

package/dist/Utils/reconcile.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Merge a fresh server payload into existing reactive state *in place*,
+ * preserving object and array identity so only changed leaves update — the
+ * analog of Solid's `reconcile`.
+ *
+ * The panel's recurring pattern is `reactive({ ...props.media })` plus a watch
+ * that throws the local copy away and rebuilds it whenever Inertia re-sends the
+ * prop. That resets identity on every navigation (flicker, lost transient UI
+ * state, full re-render). `reconcile(local, next)` instead diffs `next` into
+ * `local`: matched objects are updated in place, arrays are keyed by `id` so
+ * unchanged rows keep their identity, and only genuinely new/removed entries
+ * move.
+ *
+ * Both arguments must be plain data (objects/arrays/primitives) — call it with
+ * a structured clone of the server data, not a live reference you also mutate.
+ */
+export declare function reconcile<T>(target: T, source: T, key?: string): T;

package/dist/Utils/tagsChanged.d.ts

@@ -0,0 +1,16 @@
+export interface TagsChangedPayload {
+    action?: 'attach' | 'detach';
+    tagId?: string | number;
+}
+/**
+ * Whether a `tags-changed` event (emitted by MediaInspectorContainer after
+ * any tag attach/detach, single-media or bulk) should trigger a refetch on
+ * a page filtered to one specific tag (e.g. Media/Tags.vue).
+ *
+ * Only a detach of THAT exact tag can drop the current item out of such a
+ * view. Attaching a tag must never trigger it, and neither must detaching
+ * some other, unrelated tag from the same item — either would clear the
+ * current selection and kick the user out of whatever they're still
+ * editing, for no reason (this broke twice before landing on this rule).
+ */
+export declare function shouldRefetchOnTagsChanged(payload: TagsChangedPayload | undefined, currentTagId: string | number): boolean;

package/dist/Utils/url.d.ts

@@ -0,0 +1,40 @@
+/**
+ * URL and HTML-escaping helpers shared by the rich-text editors.
+ *
+ * The panel has several hand-rolled contenteditable editors that serialize
+ * their content to HTML strings by hand. These helpers give them one place to
+ * escape attribute values and to reject dangerous URL schemes so a typed or
+ * pasted `javascript:` link can't turn into stored XSS.
+ */
+/**
+ * Escape a string for safe interpolation into a double-quoted HTML attribute
+ * value. Escaping `"` and `<`/`>`/`&` prevents attribute-injection breakouts.
+ */
+export declare function escapeHtml(value: string): string;
+/**
+ * Return `url` if it is safe to use as an href, otherwise ''.
+ *
+ * Safe means one of: a scheme on the allowlist (http/https/mailto/tel), a
+ * relative or same-document reference, or no scheme at all (a bare host like
+ * `example.com`). Everything else — `javascript:`, `data:`, `vbscript:`, and
+ * equally anything we simply do not recognise — is rejected.
+ *
+ * Deliberately an allowlist. A denylist has to name every scheme that can
+ * execute and silently admits the one nobody thought of.
+ */
+export declare function sanitizeUrl(url: string): string;
+/**
+ * Coerce user-typed link input into a safe href value:
+ *   example.com   → https://example.com
+ *   /path, #hash  → unchanged
+ *   mailto:a@b.c  → unchanged
+ *   javascript:…  → '' (rejected)
+ */
+export declare function normalizeUrl(input: string): string;
+export declare function setPanelBaseUrl(base: string): void;
+export declare function getPanelBaseUrl(): string;
+/**
+ * Prefix a panel-relative path with the configured mount path:
+ *   panelUrl('/api/media')  →  '/panel/api/media'   (baseUrl '/panel')
+ */
+export declare function panelUrl(path: string): string;

package/dist/Utils/writeGate.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The stale-write gate: ordering for concurrent writes to the same record.
+ *
+ * Two concurrent writes to one record must leave local state on the newer
+ * one, not on whichever response settled last. The order that matters is the
+ * order the requests were DISPATCHED in: a request dispatched later carries
+ * the newer intent, whatever the network does with it afterwards.
+ *
+ * So every write takes a sequence number when it is dispatched, and presents
+ * that number to `admit` before it lands. A write whose sequence is older
+ * than the newest already applied for that key is rejected. The record is
+ * per key, so writes to different records never gate each other.
+ *
+ * A sequence counter, not a timestamp: clocks move, and two responses can
+ * share a millisecond. The counter is store-wide and only ever incremented —
+ * a per-key counter restarting at 0 would let a number minted for one key
+ * match a later slot's, which is how a deleted record comes back to life.
+ * Comparison is still per key, which is what "per-key sequence" buys.
+ *
+ * Design ported from frappe-ui's writeGate (src/data-fetching/writeGate.ts),
+ * which solves the same bug for its doc/list stores. Here the keys are
+ * caller-composed strings — `writeKey('media', file.id)`, optionally with a
+ * field suffix — because the panel has no doctype registry to derive them.
+ */
+/**
+ * What a dispatched write presents to the gate: the sequence number of the
+ * request that produced it, and whether the write may RECORD that number.
+ *
+ * Only a mutating request records. A later-dispatched request that failed
+ * wrote nothing on the server, so it must not make an older success stale;
+ * and a read is not an ordered write at all. A non-recording stamp is
+ * admitted on its sequence and records nothing — which also makes it the
+ * way to ask "is my write still the newest?" without moving the gate.
+ */
+export type DispatchStamp = {
+    sequence: number;
+    record: boolean;
+};
+/**
+ * A write that did not come from a dispatched request — seeding state in a
+ * test, a value that never went over the wire. There is no order to compare
+ * it against, so it is always admitted and records nothing.
+ *
+ * A value a caller has to name, not an argument they can omit: the
+ * un-ordered case is a decision at the call site rather than the silent
+ * default of a forgotten parameter.
+ */
+export declare const LOCAL_WRITE: unique symbol;
+export type WriteStamp = DispatchStamp | typeof LOCAL_WRITE;
+declare class WriteGate {
+    private counter;
+    private applied;
+    /**
+     * Take the next sequence number. Called when a request is dispatched — not
+     * when it settles — so the number reflects the order the writes were
+     * intended in.
+     */
+    next(record: boolean): DispatchStamp;
+    /**
+     * Whether this write may land on this key.
+     *
+     * Asking is booking: an admitted recording write becomes the newest for
+     * the key, so a later call carrying an older sequence is rejected. An
+     * equal sequence passes — the two halves of one response share a number.
+     */
+    admit(key: string, stamp: WriteStamp): boolean;
+    /**
+     * The record is gone on the server: reject every write in flight for it.
+     *
+     * Stamped with a FRESH number rather than the delete's own, because a
+     * delete becomes true when it SETTLES. Any write still in flight at that
+     * moment must have committed before the delete to have succeeded, so its
+     * response is dead data and must not re-create the record. Anything
+     * dispatched after this point takes a higher number and is admitted again.
+     */
+    seal(key: string): void;
+    clear(): void;
+}
+export declare const writeGate: WriteGate;
+/** One spelling for gate keys, so call sites agree on what "the same record" means. */
+export declare function writeKey(resource: string, id: string | number, field?: string): string;
+export {};

package/dist/index.css

@@ -0,0 +1 @@
+.ui-toggle-button[data-v-5920d123]{display:inline-flex;align-items:center;justify-content:center}.pm-editor .ProseMirror{outline:none;min-height:8rem}.pm-editor .ProseMirror>*+*{margin-top:.75rem}.pm-editor .ProseMirror h2{font-size:1.25rem;font-weight:600}.pm-editor .ProseMirror h3{font-size:1.125rem;font-weight:600}.pm-editor .ProseMirror h4,.pm-editor .ProseMirror h5,.pm-editor .ProseMirror h6,.pm-editor .ProseMirror strong{font-weight:600}.pm-editor .ProseMirror em{font-style:italic}.pm-editor .ProseMirror a{text-decoration:underline;color:inherit}.pm-editor .ProseMirror code{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:.875em;background:#f3f4f6;padding:.1em .3em;border-radius:.25rem}.pm-editor .ProseMirror pre{background:#f3f4f6;padding:.75rem;border-radius:.375rem;overflow-x:auto}.pm-editor .ProseMirror pre code{background:none;padding:0}.pm-editor .ProseMirror blockquote{border-left:3px solid rgb(209 213 219);padding-left:.75rem;color:#4b5563}.pm-editor .ProseMirror ul{list-style:disc;padding-left:1.25rem}.pm-editor .ProseMirror ol{list-style:decimal;padding-left:1.25rem}.pm-editor .ProseMirror li>*+*{margin-top:.25rem}.pm-editor .pm-placeholder:before{content:attr(data-placeholder);color:#d1d5db;float:left;height:0;pointer-events:none}.pm-editor .ProseMirror-selectednode{outline:2px solid rgb(59 130 246);border-radius:.375rem}.pm-editor .pm-dropcursor{background:#3b82f6}.pm-drag-handle{position:absolute;left:.5rem;display:none;align-items:center;justify-content:center;width:1rem;padding:.125rem;border-radius:.25rem;color:#d1d5db;cursor:grab;-webkit-user-select:none;user-select:none}.pm-drag-handle:hover{color:#6b7280;background:#f3f4f6}.pm-drag-handle:active{cursor:grabbing}.pm-drag-handle svg{width:.75rem;height:1.25rem;pointer-events:none}