edytor 1.0.0 → 3.0.0

package/dist/crdt/props.js

@@ -0,0 +1,172 @@
+/**
+ * Properties: the deep proxy behind `block.data`, `atom.data`,
+ * `edytor.data` and `document.data` (SyncedStore's feel, one small module).
+ * It is sugar over the one write path: every mutation is a data patch
+ * handed to `write`, which is the `patchData` operation (dispatched on a
+ * view, raw on a bare document).
+ *
+ * A read goes to `read()` every time (the live source), so a reactive
+ * reader of `block.data.title` re-runs when anyone changes it, and a key a
+ * peer deletes is gone. Plain objects read as nested proxies, arrays as
+ * array proxies, everything else as the raw value; a proxy is cached per
+ * path, so its identity is stable. An object or array held in an array
+ * item is that item's (its path names the item by id, from `ids`): it
+ * stays on its item wherever peers move it, so `{#each list as item (item)}`
+ * keeps a row on its item; once the item is removed, its writes are
+ * refused. A key is a path segment as `keySegment` writes it.
+ *
+ * Writes, each the patch of only what it changes (per-leaf storage, so
+ * concurrent edits of other keys and items merge): `obj.key = v`,
+ * `arr[i] = v` and `delete obj.key` patch that path; `push`, `pop`,
+ * `shift`, `unshift`, `splice` and `length` are one `splice` (the items
+ * kept keep their ids), `sort` and `reverse` one `order` (the items move),
+ * `fill` and `copyWithin` writes of the items they change. Assigning a
+ * value equal to the one there writes nothing. `JSON.stringify` and
+ * `$state.snapshot` read plain JSON through it.
+ */
+import { isObject, keySegment, segmentKey } from './data.js';
+import { jsonEquals } from '../utils/json.js';
+/** A plain JSON copy (proxies included), or `undefined`. */
+const plain = (v) => (v === undefined ? v : JSON.parse(JSON.stringify(v)));
+/** The items of `now` that differ from `was`, as writes of those items. */
+const changed = (_, __, was, now) => now.flatMap((value, i) => JSON.stringify(value) === JSON.stringify(was[i]) ? [] : [{ at: `${i}`, value }]);
+/**
+ * Each array mutator as the patches of the array (or of its items `at`),
+ * from its length `n`, the call's `args`, the array `was` and the result `out`.
+ */
+const MUTATORS = {
+    push: (n, args) => ({ splice: [n, 0, ...args] }),
+    pop: (n) => ({ splice: [Math.max(n - 1, 0), n && 1] }),
+    shift: () => ({ splice: [0, 1] }),
+    unshift: (_, args) => ({ splice: [0, 0, ...args] }),
+    // The start and count `splice` resolved (negative, fractional, past the end).
+    splice: (n, [start, , ...items], _, out) => {
+        const s = Math.trunc(Number(start)) || 0;
+        return { splice: [s < 0 ? Math.max(n + s, 0) : Math.min(s, n), out.length, ...items] };
+    },
+    sort: (n, [compare], was) => ({ order: sorted(n, was, compare) }),
+    reverse: (n) => ({ order: Array.from({ length: n }, (_, i) => n - 1 - i) }),
+    fill: changed,
+    copyWithin: changed
+};
+/** The indexes `Array.prototype.sort` puts `values` in (stable, `undefined` compare: by string). */
+const sorted = (n, values, compare) => {
+    const by = typeof compare === 'function'
+        ? compare
+        : (a, b) => (`${a}` < `${b}` ? -1 : `${a}` > `${b}` ? 1 : 0);
+    return Array.from({ length: n }, (_, i) => i).sort((a, b) => by(values[a], values[b]));
+};
+export const propsProxy = (read, write, 
+/** The ids of the items of the array at a path (`facade.dataItemIds`). */
+ids = () => []) => {
+    const cache = new Map();
+    // Item ids per array path, for the value `read()` last gave.
+    let seen;
+    const known = new Map();
+    const idsOf = (path) => {
+        const now = read();
+        if (now !== seen) {
+            seen = now;
+            known.clear();
+        }
+        const key = JSON.stringify(path);
+        return known.get(key) ?? known.set(key, ids(path)).get(key);
+    };
+    const at = (path) => path.reduce((v, k, n) => /^~[a-z]/.test(k)
+        ? Array.isArray(v)
+            ? v[idsOf(path.slice(0, n)).indexOf(k)]
+            : undefined // its array is gone
+        : v !== null && typeof v === 'object'
+            ? v[segmentKey(k)]
+            : undefined, read());
+    const put = (path, value) => {
+        const next = plain(value);
+        if (jsonEquals(at(path), next))
+            return;
+        write([{ path, ...(next !== undefined && { value: next }) }]);
+    };
+    const wrap = (path, v) => Array.isArray(v) || isObject(v) ? proxy(path, Array.isArray(v)) : v;
+    const proxy = (path, array) => {
+        const key = `${array ? '[' : '{'}${JSON.stringify(path)}`;
+        const cached = cache.get(key);
+        if (cached)
+            return cached;
+        const current = () => {
+            const v = at(path);
+            return array ? (Array.isArray(v) ? v : []) : isObject(v) ? v : {};
+        };
+        /** The path of child `k`: an item by its id, a key as its segment. */
+        const child = (k) => [...path, (array && idsOf(path)[Number(k)]) || keySegment(k)];
+        const items = () => current().map((v, i) => wrap(child(`${i}`), v));
+        const own = (k) => Object.prototype.hasOwnProperty.call(current(), k);
+        const made = new Proxy(array ? [] : {}, {
+            get(target, k) {
+                if (typeof k === 'symbol')
+                    return array && k === Symbol.iterator
+                        ? () => items()[Symbol.iterator]()
+                        : Reflect.get(target, k);
+                if (array && k === 'length')
+                    return current().length;
+                if (own(k))
+                    return wrap(child(k), current()[k]);
+                if (array && Object.hasOwn(MUTATORS, k))
+                    return (...args) => {
+                        const was = plain(current());
+                        const next = [...was];
+                        const fn = Array.prototype[k];
+                        args = args.map((a) => (a !== null && typeof a === 'object' ? plain(a) : a));
+                        const out = fn.apply(next, args);
+                        const ops = [MUTATORS[k](was.length, args, was, out)].flat();
+                        if (!jsonEquals(was, next))
+                            write(ops.map(({ at, ...op }) => ({ ...op, path: at ? [...path, at] : path })));
+                        return out === next ? made : out;
+                    };
+                const method = array ? Array.prototype[k] : undefined;
+                if (typeof method === 'function')
+                    return (...args) => method.apply(items(), args);
+                return Reflect.get(target, k);
+            },
+            set(_, k, value) {
+                if (typeof k === 'symbol')
+                    return false;
+                if (array && k === 'length') {
+                    const n = current().length;
+                    const nulls = Array.from({ length: Math.max(value - n, 0) }, () => null);
+                    write([{ path, splice: [Math.min(value, n), Math.max(n - value, 0), ...nulls] }]);
+                }
+                else
+                    put([...path, keySegment(k)], value);
+                return true;
+            },
+            deleteProperty(_, k) {
+                if (typeof k === 'symbol')
+                    return false;
+                if (own(k))
+                    put([...path, keySegment(k)], undefined);
+                return true;
+            },
+            has: (target, k) => (typeof k === 'string' && own(k)) || Reflect.has(target, k),
+            ownKeys: () => [...Object.keys(current()), ...(array ? ['length'] : [])],
+            getOwnPropertyDescriptor(target, k) {
+                if (array && k === 'length')
+                    return (Reflect.getOwnPropertyDescriptor(target, k) && {
+                        value: current().length,
+                        writable: true,
+                        enumerable: false,
+                        configurable: false
+                    });
+                if (typeof k !== 'string' || !own(k))
+                    return undefined;
+                return {
+                    value: wrap(child(k), current()[k]),
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                };
+            }
+        });
+        cache.set(key, made);
+        return made;
+    };
+    return proxy([], false);
+};

package/dist/crdt/protocol.d.ts

@@ -27,14 +27,14 @@
 export { bindCrdt, type Crdt, type EngineApi, type EngineDoc, type EngineNode, type EngineTransaction, type EngineItemRef, type YNode, type YItem, type YDoc, type YUndoManager, type YTransaction } from './index.js';
 export { SCHEMA_VERSION, META_KEY } from './edytor-doc.js';
 export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion, type GenerationRecord } from './protocols/envelope.js';
-export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkLimitError, type ChunkReader, CLOSE } from './providers/room.js';
+export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkError, type ChunkReader, CLOSE } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate, type SyncProtocol } from './protocols/sync.js';
 export { messagePermissionDenied, messageReadOnly, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
 export { commentsSubscribe, commentsSnapshot, commentsChange, writeCommentsSubscribe, writeCommentsSnapshot, writeCommentsChange, readCommentsMessage, type CommentChange, type CommentMessage, type CommentSnapshot, type CommentThread, type ThreadComment } from './protocols/comments.js';
 export { applyAwarenessUpdate, encodeAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries, type AwarenessEntry } from './protocols/awareness.js';
 export { createDecoder, readVarUint, readVarUint8Array, type Decoder } from 'lib0-v14/decoding';
 export { writeVarUint8Array, type Encoder } from 'lib0-v14/encoding';
-export { assertAdmission, assertSchema, assertUsableDoc, checkSchema, inspectAdmission, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UndecodableUpdateError, UnsupportedDocError, type AdmissionResult, type AdmissionVerdict, type SchemaProblem } from './admission.js';
+export { assertAdmission, assertSchema, checkSchema, inspectAdmission, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UndecodableUpdateError, type AdmissionResult, type AdmissionVerdict, type SchemaProblem } from './admission.js';
 import type { ProviderStack } from './providers/index.js';
 export declare const IndexeddbPersistence: ProviderStack['IndexeddbPersistence'];
 export declare const WebsocketProvider: ProviderStack['WebsocketProvider'];

package/dist/crdt/protocol.js

@@ -30,7 +30,7 @@ export { bindCrdt } from './index.js';
 export { SCHEMA_VERSION, META_KEY } from './edytor-doc.js';
 export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion } from './protocols/envelope.js';
 // ── Message types, acknowledgements and chunks ─────────────────────────
-export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkLimitError, CLOSE } from './providers/room.js';
+export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkError, CLOSE } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate } from './protocols/sync.js';
 export { messagePermissionDenied, messageReadOnly, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
 export { commentsSubscribe, commentsSnapshot, commentsChange, writeCommentsSubscribe, writeCommentsSnapshot, writeCommentsChange, readCommentsMessage } from './protocols/comments.js';
@@ -46,7 +46,7 @@ export { writeVarUint8Array } from 'lib0-v14/encoding';
 // the matrix and the refusal-preserves-data contract). The errors they
 // throw are also exported from `edytor` and `edytor/crdt/edytor`, where a
 // `loadDocument` caller catches them.
-export { assertAdmission, assertSchema, assertUsableDoc, checkSchema, inspectAdmission, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UndecodableUpdateError, UnsupportedDocError } from './admission.js';
+export { assertAdmission, assertSchema, checkSchema, inspectAdmission, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UndecodableUpdateError } from './admission.js';
 // ── Raw providers ──────────────────────────────────────────────────────
 //
 // The classes `createIndexeddbSync`/`createWebsocketSync` construct, bound

package/dist/crdt/providers/index.d.ts

@@ -280,7 +280,7 @@ export declare const bindProviders: (Y: EngineApi) => {
             off<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
         };
     };
-    watchComments: (server: string, roomName: string, listener: (message: import("../protocol.js").CommentMessage) => void) => (() => void);
+    watchComments: (server: string | null, roomName: string, listener: (message: import("../protocol.js").CommentMessage) => void) => (() => void);
     storeState: (idbPersistence: {
         db: IDBDatabase | null;
         name: string;

package/dist/crdt/providers/room.d.ts

@@ -69,14 +69,15 @@ export declare const MAX_FRAME_BYTES: number;
  * receiver applies the reassembled frame only once `end` arrives.
  */
 export declare const chunkFrame: (whole: Uint8Array, maxFrameBytes?: number) => Uint8Array[];
-/** A chunk sequence announces a frame larger than its reader takes ({@link createChunkReader}). */
-export declare class ChunkLimitError extends Error {
-    readonly total: number;
-    readonly limit: number;
-    constructor(total: number, limit: number);
-}
-/** A chunk part or end with no sequence started (one lost, or never sent). */
-export declare class ChunkSequenceError extends Error {
+/**
+ * A chunk sequence its reader refuses ({@link createChunkReader}): one
+ * announcing a frame larger than the reader takes (`total` over `limit`),
+ * or a part or end with no sequence started (one lost, or never sent).
+ */
+export declare class ChunkError extends Error {
+    readonly total?: number | undefined;
+    readonly limit?: number | undefined;
+    constructor(total?: number | undefined, limit?: number | undefined);
 }
 /** A chunk reader ({@link createChunkReader}): feed it chunk bodies; `buffered` is what it holds. */
 export type ChunkReader = {
@@ -89,7 +90,7 @@ export type ChunkReader = {
  * each chunk frame's body (after the message type); it returns the whole
  * frame on `end`, `null` before. An out-of-order or oversized sequence
  * throws and resets; a sequence announcing more than `maxBytes` throws
- * {@link ChunkLimitError} at its start, before anything is buffered. A
+ * {@link ChunkError} at its start, before anything is buffered. A
  * sequence is assembled into ONE buffer of its announced size, allocated
  * at its start (`buffered`), never into parts copied at its end.
  * `admit(total)` is asked at each start, before that allocation: it may

package/dist/crdt/providers/room.js

@@ -92,26 +92,29 @@ export const chunkFrame = (whole, maxFrameBytes = MAX_FRAME_BYTES) => {
     frames.push(frame(messageChunk, (e) => encoding.writeVarUint(e, chunkEnd)));
     return frames;
 };
-/** A chunk sequence announces a frame larger than its reader takes ({@link createChunkReader}). */
-export class ChunkLimitError extends Error {
+/**
+ * A chunk sequence its reader refuses ({@link createChunkReader}): one
+ * announcing a frame larger than the reader takes (`total` over `limit`),
+ * or a part or end with no sequence started (one lost, or never sent).
+ */
+export class ChunkError extends Error {
     total;
     limit;
     constructor(total, limit) {
-        super(`chunked frame of ${total} bytes exceeds ${limit}`);
+        super(limit === undefined
+            ? 'chunk without a start'
+            : `chunked frame of ${total} bytes exceeds ${limit}`);
         this.total = total;
         this.limit = limit;
-        this.name = 'ChunkLimitError';
+        this.name = 'ChunkError';
     }
 }
-/** A chunk part or end with no sequence started (one lost, or never sent). */
-export class ChunkSequenceError extends Error {
-}
 /**
  * The receiving half of {@link chunkFrame}, one per connection: feed it
  * each chunk frame's body (after the message type); it returns the whole
  * frame on `end`, `null` before. An out-of-order or oversized sequence
  * throws and resets; a sequence announcing more than `maxBytes` throws
- * {@link ChunkLimitError} at its start, before anything is buffered. A
+ * {@link ChunkError} at its start, before anything is buffered. A
  * sequence is assembled into ONE buffer of its announced size, allocated
  * at its start (`buffered`), never into parts copied at its end.
  * `admit(total)` is asked at each start, before that allocation: it may
@@ -136,14 +139,14 @@ export const createChunkReader = (maxBytes = Infinity, admit = () => true) => {
                 reset();
                 const announced = decoding.readVarUint(decoder);
                 if (announced > maxBytes)
-                    throw new ChunkLimitError(announced, maxBytes);
+                    throw new ChunkError(announced, maxBytes);
                 whole = admit(announced) ? new Uint8Array(announced) : null;
                 total = announced;
                 open = true;
                 return null;
             }
             if (!open)
-                throw new ChunkSequenceError(`chunk ${kind} without a start`);
+                throw new ChunkError();
             if (kind === chunkPart) {
                 const bytes = decoding.readVarUint8Array(decoder);
                 if (received + bytes.length > total)

package/dist/crdt/providers/websocket.d.ts

@@ -228,5 +228,5 @@ export declare const bindWebsocketProvider: (Y: EngineApi) => {
             off<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: WebsocketProviderEvents[NAME]): void;
         };
     };
-    watchComments: (server: string, roomName: string, listener: (message: CommentMessage) => void) => (() => void);
+    watchComments: (server: string | null, roomName: string, listener: (message: CommentMessage) => void) => (() => void);
 };

package/dist/crdt/providers/websocket.js

@@ -142,16 +142,16 @@ export const bindWebsocketProvider = (Y) => {
             provider.synced = true;
         }
     });
-    // A room's comment threads (`watchComments`): the listeners of each room,
-    // by `<serverUrl>/<room>`, and the providers dialing it. A provider asks
-    // the room for them (a subscribe) at every open while a room has a
-    // listener, and hands each message the room sends to every listener.
-    const commentListeners = new Map();
-    const providersOf = new Map();
+    const watchers = new Set();
+    const providers = new Set();
     const subscribeFrame = (on) => frame(messageComments, (e) => writeCommentsSubscribe(e, on));
+    const hears = (watcher, provider) => watcher.room === provider.roomname &&
+        (watcher.channel === null || watcher.channel === provider.bcChannel);
+    const listenersOf = (provider) => [...watchers].filter((watcher) => hears(watcher, provider)).map((watcher) => watcher.listener);
+    const providersFor = (watcher) => [...providers].filter((p) => hears(watcher, p));
     room.messageHandlers[messageComments] = (_encoder, decoder, provider) => {
         const message = readCommentsMessage(decoder);
-        for (const listener of [...(commentListeners.get(provider.bcChannel) ?? [])]) {
+        for (const listener of listenersOf(provider)) {
             try {
                 listener(message);
             }
@@ -162,26 +162,28 @@ export const bindWebsocketProvider = (Y) => {
     };
     /**
      * Hear the comment threads of `room` on `server` (the URL a provider
-     * dials, `ws:`/`wss:`): every provider of that room subscribes now and
-     * at each (re)connect, which the room answers with every thread (a
-     * `snapshot`), then sends each `change`. Answers the unsubscribe; the
-     * last one leaving tells the room to stop.
+     * dials, `ws:`/`wss:`; `null`: every provider of that room on the page,
+     * whatever its server): every such provider subscribes now and at each
+     * (re)connect, which the room answers with every thread (a `snapshot`),
+     * then sends each `change`. Answers the unsubscribe; the last listener
+     * of a provider leaving tells its room to stop.
      */
     const watchComments = (server, roomName, listener) => {
-        const key = `${server.replace(/\/+$/, '')}/${roomName}`;
-        const listeners = commentListeners.get(key) ?? new Set();
-        commentListeners.set(key, listeners);
-        const first = listeners.size === 0;
-        listeners.add(listener);
-        if (first)
-            for (const provider of providersOf.get(key) ?? [])
-                send(provider, subscribeFrame(true));
+        const watcher = {
+            room: roomName,
+            channel: server === null ? null : `${server.replace(/\/+$/, '')}/${roomName}`,
+            listener
+        };
+        const fresh = providersFor(watcher).filter((p) => listenersOf(p).length === 0);
+        watchers.add(watcher);
+        for (const provider of fresh)
+            send(provider, subscribeFrame(true));
         return () => {
-            if (!listeners.delete(listener) || listeners.size > 0)
+            if (!watchers.delete(watcher))
                 return;
-            commentListeners.delete(key);
-            for (const provider of providersOf.get(key) ?? [])
-                send(provider, subscribeFrame(false));
+            for (const provider of providersFor(watcher))
+                if (listenersOf(provider).length === 0)
+                    send(provider, subscribeFrame(false));
         };
     };
     // The room's acknowledgement and its bounded catch-up (a frame too large
@@ -468,7 +470,7 @@ export const bindWebsocketProvider = (Y) => {
                 for (const buf of room.hello(provider))
                     sendOn(provider, websocket, buf);
                 // The room's comment threads, while someone listens (`watchComments`).
-                if (commentListeners.get(provider.bcChannel)?.size)
+                if (listenersOf(provider).length > 0)
                     sendOn(provider, websocket, subscribeFrame(true));
             };
             provider.emit('status', [{ status: 'connecting' }]);
@@ -540,8 +542,7 @@ export const bindWebsocketProvider = (Y) => {
                 this._resync = setInterval(() => send(this, room.step1(this)), resyncInterval);
             }
             this._bcSubscriber = room.bcSubscriber(this);
-            const peers = providersOf.get(this.bcChannel) ?? new Set();
-            providersOf.set(this.bcChannel, peers.add(this));
+            providers.add(this);
             // Local doc updates go to the room; another tab's go to the server
             // only (`broadcastUpdate` quarantines a read-only document). A
             // socket the room made read-only gets this document's own edits
@@ -641,9 +642,7 @@ export const bindWebsocketProvider = (Y) => {
                 return;
             clearInterval(this._resync);
             clearInterval(this._checkInterval);
-            const peers = providersOf.get(this.bcChannel);
-            if (peers?.delete(this) && peers.size === 0)
-                providersOf.delete(this.bcChannel);
+            providers.delete(this);
             this.disconnect();
             this.awareness.off('update', this._awarenessUpdateHandler);
             this.doc.off('update', this._updateHandler);

package/dist/crdt/semantics.js

@@ -40,6 +40,7 @@ export const normalizeRole = (role) => {
     };
 };
 /** Freeze `value` and everything in it: the tables are shared by every document. */
+/* @__NO_SIDE_EFFECTS__ */
 const frozen = (value) => {
     if (value && typeof value === 'object' && !Object.isFrozen(value)) {
         Object.freeze(value);
@@ -294,7 +295,8 @@ export const equationSemantics = /* @__PURE__ */ semanticsOf(equationKinds);
  * plugins are not default plugins of `<Edytor>`, but their roles are here so their
  * blocks read the same on every replica.
  */
-export const defaultSemantics = withMarks(semanticsOf(richTextKinds, codeKinds, imageKinds, mediaKinds, layoutKinds, pageKinds, tocKinds, tableKinds, equationKinds), { ...richTextMarks, ...commentMarks });
+export const defaultSemantics = /* @__PURE__ */ withMarks(semanticsOf(richTextKinds, codeKinds, imageKinds, mediaKinds, layoutKinds, pageKinds, tocKinds, tableKinds, equationKinds), 
+/* @__PURE__ */ Object.assign({}, richTextMarks, commentMarks));
 /**
  * The facade configuration (`EdytorDocConfig`) a document with no view
  * reads `semantics` with — the room's: roles, default children, content-less kinds

package/dist/dnd/autoScroll.d.ts

@@ -1,9 +1,17 @@
+/** One adapter's auto-scroll (Atlassian's auto-scroll package), its drags already chosen. */
+export type Scrollers = {
+    /** The window scrolls as the pointer nears its edges. */
+    window(): () => void;
+    /** `element` scrolls as the pointer nears its edges. */
+    element(element: Element): () => void;
+};
 /**
- * Auto-scroll for one drag (a block's, a table row's or column's; Atlassian's
- * auto-scroll package): the window
- * and every scrolling element from the editor up (the editor included) scroll
- * as the pointer nears their edges, faster the closer and the longer it stays,
- * innermost first. `ours` keeps it to this editor's drags. Registered at the
- * drag's start (the package allows it mid-drag); the answer releases it.
+ * Auto-scroll for one drag (a block's, a table row's or column's, files
+ * dragged from outside): the window and every scrolling element from the
+ * editor up (the editor included) scroll as the pointer nears their edges,
+ * faster the closer and the longer it stays, innermost first. `scrollers`
+ * is the drag's adapter's (`elementScrollers`, `externalScrollers`), kept to
+ * this editor's drags. Registered at the drag's start (the package allows it
+ * mid-drag); the answer releases it.
  */
-export declare const autoScrollFor: (root: HTMLElement, ours: (data: Record<string | symbol, unknown>) => boolean) => (() => void);
+export declare const autoScrollFor: (root: HTMLElement, scrollers: Scrollers) => (() => void);

package/dist/dnd/autoScroll.js

@@ -1,25 +1,20 @@
-import { autoScroll, autoScrollWindow } from './pragmatic.js';
 /**
- * Auto-scroll for one drag (a block's, a table row's or column's; Atlassian's
- * auto-scroll package): the window
- * and every scrolling element from the editor up (the editor included) scroll
- * as the pointer nears their edges, faster the closer and the longer it stays,
- * innermost first. `ours` keeps it to this editor's drags. Registered at the
- * drag's start (the package allows it mid-drag); the answer releases it.
+ * Auto-scroll for one drag (a block's, a table row's or column's, files
+ * dragged from outside): the window and every scrolling element from the
+ * editor up (the editor included) scroll as the pointer nears their edges,
+ * faster the closer and the longer it stays, innermost first. `scrollers`
+ * is the drag's adapter's (`elementScrollers`, `externalScrollers`), kept to
+ * this editor's drags. Registered at the drag's start (the package allows it
+ * mid-drag); the answer releases it.
  */
-export const autoScrollFor = (root, ours) => {
-    // The scroller hit-tests with `elementsFromPoint` every frame (jsdom has none),
-    // so it is created only where that exists.
-    if (typeof root.ownerDocument.elementsFromPoint !== 'function')
-        return () => { };
-    const canScroll = ({ source }) => ours(source.data);
-    const releases = [autoScrollWindow({ canScroll })];
+export const autoScrollFor = (root, scrollers) => {
+    const releases = [scrollers.window()];
     const { body, documentElement, defaultView } = root.ownerDocument;
     // The window is the document's scroller: stop below it.
     for (let element = root; element && element !== body && element !== documentElement; element = element.parentElement) {
         const { overflowX, overflowY } = defaultView.getComputedStyle(element);
         if (/auto|scroll|overlay/.test(`${overflowX} ${overflowY}`))
-            releases.push(autoScroll({ element, canScroll }));
+            releases.push(scrollers.element(element));
     }
     return () => releases.forEach((release) => release());
 };

package/dist/{plugins/blockHandles → dnd}/dropIndicator.d.ts

@@ -5,8 +5,8 @@
  * future parent's own row. Both live in the overlay layer, measured each
  * frame. The controller decides the placement; this draws it.
  */
-import type { Block } from '../../block/block.svelte.js';
-import type { Edytor } from '../../edytor.svelte.js';
+import type { Block } from '../block/block.svelte.js';
+import type { Edytor } from '../edytor.svelte.js';
 import { type DropPlacement } from './geometry.js';
 /** What the indicator reads of the controller: the dragged blocks and the beside resolution. */
 type IndicatorContext = {

package/dist/{plugins/blockHandles → dnd}/dropIndicator.js

@@ -1,4 +1,4 @@
-import { getOwnRowBottom, isBeside, nestIndent, ownRow, ownTextRow } from './geometry.js';
+import { cssVar, getOwnRowBottom, isBeside, nestIndent, ownRow, ownTextRow } from './geometry.js';
 /** Notion's drop bar: 4px (its height in `BlockHandles.svelte`, its look the app's). */
 const BAR = 4;
 /** Place `element` at `box`, relative to the layer (`origin`). */
@@ -14,10 +14,7 @@ const place = (element, box, origin) => Object.assign(element.style, {
  * unset there without one.
  */
 const themed = (from, name) => {
-    const value = from.ownerDocument.defaultView
-        ?.getComputedStyle(from)
-        .getPropertyValue(name)
-        .trim();
+    const value = cssVar(from, name);
     return (element) => value ? element.style.setProperty(name, value) : element.style.removeProperty(name);
 };
 /**

package/dist/dnd/external.d.ts

@@ -0,0 +1,6 @@
+import type { Scrollers } from './autoScroll.js';
+export { dropTargetForExternal } from './vendor/pragmatic/pragmatic-drag-and-drop/adapter/drop-target-for-external.js';
+export { containsFiles } from './vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/contains-files.js';
+export { getFiles } from './vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/get-files.js';
+/** The external adapter's auto-scroll, while `ours()` (the drag is over this editor). */
+export declare const externalScrollers: (ours: () => boolean) => Scrollers;

package/dist/dnd/external.js

@@ -0,0 +1,17 @@
+// Pragmatic drag and drop's external adapter (vendored with the element
+// adapter, on its core, `vendor/pragmatic/UPSTREAM.md`): drags that start
+// outside the window (files from the desktop). Only the media plugins that
+// take an upload import it (`plugins/fileDrop.ts`), so a view without them
+// ships none of it.
+import { autoScrollForExternal, autoScrollWindowForExternal } from './vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/entry-point/external.js';
+export { dropTargetForExternal } from './vendor/pragmatic/pragmatic-drag-and-drop/adapter/drop-target-for-external.js';
+export { containsFiles } from './vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/contains-files.js';
+export { getFiles } from './vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/get-files.js';
+/** The external adapter's auto-scroll, while `ours()` (the drag is over this editor). */
+export const externalScrollers = (ours) => {
+    const canScroll = () => ours();
+    return {
+        window: () => autoScrollWindowForExternal({ canScroll }),
+        element: (element) => autoScrollForExternal({ element, canScroll })
+    };
+};

package/dist/{plugins/blockHandles → dnd}/geometry.d.ts

@@ -4,8 +4,8 @@
  * placement's shape, a block's own row, its first text line and one
  * nesting step.
  */
-import type { Block } from '../../block/block.svelte.js';
-import type { BlockMovePosition } from '../../session/moves.js';
+import type { Block } from '../block/block.svelte.js';
+import type { BlockMovePosition } from '../session/moves.js';
 export type DropPlacement = {
     target: Block;
     node: HTMLElement;
@@ -27,6 +27,8 @@ export declare const ownTextRow: (node: HTMLElement) => DOMRect;
  */
 export declare const NEST_INDENT = 24;
 export declare const nestIndent: (node: HTMLElement) => number;
+/** The theme variable `name` as `node` inherits it, read now (none outside a window). */
+export declare const cssVar: (node: HTMLElement, name: string) => string | undefined;
 /**
  * Whether `y` is over the hint of `node`'s empty body (`body.hint`, a kind's
  * `data-edytor-empty-body` element: an open toggle's, a callout's): a drop

package/dist/{plugins/blockHandles → dnd}/geometry.js

@@ -31,12 +31,11 @@ export const ownTextRow = (node) => {
  */
 export const NEST_INDENT = 24;
 export const nestIndent = (node) => {
-    const value = node.ownerDocument.defaultView
-        ?.getComputedStyle(node)
-        .getPropertyValue('--edytor-nest-indent')
-        .trim();
+    const value = cssVar(node, '--edytor-nest-indent');
     return value?.endsWith('px') ? parseFloat(value) : NEST_INDENT;
 };
+/** The theme variable `name` as `node` inherits it, read now (none outside a window). */
+export const cssVar = (node, name) => node.ownerDocument.defaultView?.getComputedStyle(node).getPropertyValue(name).trim();
 /**
  * Whether `y` is over the hint of `node`'s empty body (`body.hint`, a kind's
  * `data-edytor-empty-body` element: an open toggle's, a callout's): a drop