quoin-editor 0.4.2 → 1.0.1

package/dist/yjs.cjs

@@ -0,0 +1,864 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkMLRAVUFGcjs = require('./chunk-MLRAVUFG.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkHOIDJEVIcjs = require('./chunk-HOIDJEVI.cjs');
+
+
+var _chunkXX5FTPJRcjs = require('./chunk-XX5FTPJR.cjs');
+
+
+
+
+
+
+
+
+var _chunkBTBHHBVRcjs = require('./chunk-BTBHHBVR.cjs');
+
+// src/yjs/read-shared.ts
+var _yjs = require('yjs'); var Y = _interopRequireWildcard(_yjs); var Y2 = _interopRequireWildcard(_yjs); var Y3 = _interopRequireWildcard(_yjs);
+
+// src/yjs/required-regions.ts
+var noRequiredRegions = () => [];
+function requiredRegions(schema) {
+  const known = /* @__PURE__ */ new Map();
+  return (type) => {
+    let names = known.get(type);
+    if (names === void 0) {
+      const spec = schema.blocks.get(type);
+      names = _optionalChain([spec, 'optionalAccess', _2 => _2.flow]) === "text" ? Object.keys(spec.initial().regions) : [];
+      known.set(type, names);
+    }
+    return names;
+  };
+}
+
+// src/yjs/read-shared.ts
+function reader(required) {
+  const spans = [_chunkMLRAVUFGcjs.emptySpan.call(void 0, )];
+  const entries = /* @__PURE__ */ new Map();
+  const markers = /* @__PURE__ */ new Map();
+  const order = [];
+  const held2 = /* @__PURE__ */ new Map();
+  const strays = [];
+  let span = spans[0];
+  let entry = null;
+  let open = null;
+  let stray = null;
+  let clean = true;
+  const segFor = (region2, host, at, ops = []) => {
+    const seg = { host, region: region2, at, length: 0 };
+    host.segs.push(seg);
+    held2.set(seg, ops);
+    return seg;
+  };
+  const opened = (region2) => {
+    const seg = segFor(region2, span, span.length + 1);
+    region2.segs.push(seg);
+    return seg;
+  };
+  function content(op, length) {
+    if (open !== null) {
+      open.length += length;
+      held2.get(open).push(op);
+    } else if (span.index === 0 || span.entry !== null) {
+      clean = false;
+      if (stray === null) {
+        stray = { host: span, at: span.length, length: 0, ops: [], after: _nullishCoalesce(order[order.length - 1], () => ( null)) };
+        strays.push(stray);
+      }
+      stray.length += length;
+      stray.ops.push(op);
+    }
+  }
+  function marker(map) {
+    span = _chunkMLRAVUFGcjs.emptySpan.call(void 0, );
+    span.index = spans.length;
+    spans.push(span);
+    [open, stray] = [null, null];
+    const fields = _chunkMLRAVUFGcjs.readMarker.call(void 0, map);
+    const kept = fields !== null && !entries.has(fields.id);
+    entry = kept ? { id: fields.id, map, span, regions: [], copies: [] } : null;
+    if (entry !== null) {
+      span.entry = entry;
+      entries.set(entry.id, entry);
+      markers.set(entry, fields);
+    } else {
+      clean = false;
+      if (fields !== null) {
+        span.copyOf = entries.get(fields.id);
+        span.copyOf.copies.push(span);
+      }
+    }
+  }
+  function embed(value) {
+    let name = _chunkMLRAVUFGcjs.regionNameOf.call(void 0, value);
+    stray = null;
+    const missing = (one) => !entry.regions.some((region2) => region2.name === one);
+    if (name !== null && entry !== null) {
+      const needed = required(markers.get(entry).type);
+      if (needed.length > 0 && !needed.includes(name)) {
+        clean = false;
+        name = _nullishCoalesce(needed.find(missing), () => ( null));
+      }
+      if (name !== null && missing(name)) {
+        const region2 = { name, entry, segs: [] };
+        entry.regions.push(region2);
+        order.push(region2);
+        open = opened(region2);
+        return;
+      }
+    }
+    clean = false;
+    if (open !== null) open = opened(open.region);
+  }
+  return {
+    read(op) {
+      const { insert } = op;
+      if (typeof insert === "string" || _chunkMLRAVUFGcjs.isAtomEmbed.call(void 0, insert)) {
+        const length = typeof insert === "string" ? insert.length : 1;
+        content(op, length);
+        span.length += length;
+        return;
+      }
+      if (insert instanceof Y.Map) marker(insert);
+      else embed(insert);
+      span.length += 1;
+    },
+    finish() {
+      const leading = [];
+      const read = [];
+      let unread = false;
+      for (const { host, at, length, ops, after } of strays) {
+        const region2 = _nullishCoalesce(after, () => ( order[0]));
+        unread ||= region2 === void 0;
+        if (region2 === void 0) continue;
+        const seg = segFor(region2, host, at, ops);
+        seg.length = length;
+        read.push(seg);
+        if (after === null) leading.push(seg);
+        else region2.segs.push(seg);
+      }
+      _optionalChain([order, 'access', _3 => _3[0], 'optionalAccess', _4 => _4.segs, 'access', _5 => _5.unshift, 'call', _6 => _6(...leading)]);
+      const blocks = [...entries.values()].map((kept) => {
+        const { type, indent, attrs } = markers.get(kept);
+        for (const name of required(type)) {
+          if (!kept.regions.some((region2) => region2.name === name)) kept.regions.push({ name, entry: kept, segs: [] });
+        }
+        const inline = (segs) => _chunkMLRAVUFGcjs.inlineOfOps.call(void 0, segs.flatMap((seg) => held2.get(seg)));
+        const regions = kept.regions.map(({ name, segs }) => [name, inline(segs)]);
+        return { id: kept.id, type, indent, attrs: _nullishCoalesce(_optionalChain([attrs, 'optionalAccess', _7 => _7.toJSON, 'call', _8 => _8()]), () => ( {})), regions: Object.fromEntries(regions) };
+      });
+      const layout = _chunkMLRAVUFGcjs.createLayout.call(void 0, spans, entries, clean, { read, leading: new Set(leading), unread });
+      return { doc: _chunkBTBHHBVRcjs.createDoc.call(void 0, blocks), layout };
+    }
+  };
+}
+function readShared(text2, required = noRequiredRegions) {
+  const read = reader(required);
+  for (const op of text2.toDelta()) read.read(op);
+  return read.finish();
+}
+
+// src/yjs/shared.ts
+function reread(shared) {
+  shared.layout = readShared(shared.text, shared.required).layout;
+  shared.stale = true;
+}
+function insertContent(shared, region2, offset, inline) {
+  if (inline.length === 0) return;
+  if (region2.segs.length === 0) return openRegion(shared, region2, inline);
+  const { seg, rel } = _chunkMLRAVUFGcjs.pointOf.call(void 0, region2, offset);
+  _chunkMLRAVUFGcjs.insertInline.call(void 0, shared.text, _chunkMLRAVUFGcjs.spanStart.call(void 0, shared.layout, seg.host) + rel, inline);
+  _chunkMLRAVUFGcjs.grow.call(void 0, shared.layout, seg, rel, _chunkBTBHHBVRcjs.inlineLength.call(void 0, inline));
+}
+function deleteContent(shared, region2, from, to) {
+  for (const { seg, rel, length } of _chunkMLRAVUFGcjs.piecesOf.call(void 0, region2, from, to).reverse()) {
+    _chunkMLRAVUFGcjs.deleteText.call(void 0, shared.text, _chunkMLRAVUFGcjs.spanStart.call(void 0, shared.layout, seg.host) + rel, length);
+    _chunkMLRAVUFGcjs.grow.call(void 0, shared.layout, seg, rel, -length);
+  }
+}
+function formatContent(shared, region2, from, to, attributes) {
+  for (const { seg, rel, length } of _chunkMLRAVUFGcjs.piecesOf.call(void 0, region2, from, to)) {
+    shared.text.format(_chunkMLRAVUFGcjs.spanStart.call(void 0, shared.layout, seg.host) + rel, length, attributes);
+  }
+}
+function openRegion(shared, { name, entry }, inline) {
+  const at = _chunkMLRAVUFGcjs.spanStart.call(void 0, shared.layout, entry.span) + entry.span.length;
+  shared.text.insertEmbed(at, _chunkMLRAVUFGcjs.regionStart.call(void 0, name), {});
+  _chunkMLRAVUFGcjs.insertInline.call(void 0, shared.text, at + 1, inline);
+  reread(shared);
+}
+
+// src/yjs/inline-span.ts
+var units = (inline) => inline.flatMap(
+  (node) => node.kind === "text" ? Array.from({ length: node.text.length }, (_, i) => _chunkBTBHHBVRcjs.text.call(void 0, node.text[i], node.marks)) : [node]
+);
+function changedSpan(before, after) {
+  const a = units(before);
+  const b = units(after);
+  let start = 0;
+  while (start < a.length && start < b.length && _chunkBTBHHBVRcjs.equalNode.call(void 0, a[start], b[start])) start += 1;
+  let end = 0;
+  const shared = Math.min(a.length, b.length) - start;
+  while (end < shared && _chunkBTBHHBVRcjs.equalNode.call(void 0, a[a.length - 1 - end], b[b.length - 1 - end])) end += 1;
+  return { from: start, to: _chunkBTBHHBVRcjs.inlineLength.call(void 0, before) - end, slice: _chunkBTBHHBVRcjs.sliceInline.call(void 0, after, start, _chunkBTBHHBVRcjs.inlineLength.call(void 0, after) - end) };
+}
+
+// src/yjs/plain.ts
+function isPlain({ span, regions }) {
+  if (span.segs.length !== regions.length) return false;
+  let end = 1;
+  for (const { segs } of regions) {
+    if (segs.length !== 1 || segs[0].host !== span || segs[0].at !== end + 1) return false;
+    end = segs[0].at + segs[0].length;
+  }
+  return span.length === end;
+}
+function rewritten(entry, block, map = entry.map) {
+  const next = _chunkMLRAVUFGcjs.cleanEntry.call(void 0, block, map);
+  next.copies.push(...entry.copies);
+  for (const copy of next.copies) copy.copyOf = next;
+  return next;
+}
+function crossesStray(layout, index) {
+  const { read, leading, unread } = layout.strays;
+  return unread || read.some((seg) => {
+    const region2 = _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, seg.region.entry.span);
+    return leading.has(seg) ? index <= region2 : region2 < index && index <= _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, seg.host);
+  });
+}
+
+// src/yjs/write-blocks.ts
+function insertBlocks(shared, next, blocks) {
+  const { layout, text: text2 } = shared;
+  const span = next === null ? null : layout.entries.get(next).span;
+  const index = span === null ? layout.spans.length : _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, span);
+  const crosses = blocks.some((block) => Object.keys(block.regions).length > 0) && crossesStray(layout, index);
+  const maps = _chunkMLRAVUFGcjs.writeBlocks.call(void 0, text2, span === null ? _chunkMLRAVUFGcjs.textLength.call(void 0, layout) : _chunkMLRAVUFGcjs.spanStart.call(void 0, layout, span), blocks);
+  if (crosses) reread(shared);
+  else _chunkMLRAVUFGcjs.placeEntries.call(void 0, layout, index, 0, blocks.map((block, i) => _chunkMLRAVUFGcjs.cleanEntry.call(void 0, block, maps[i])));
+}
+function ownParts(entry, span) {
+  const parts = [];
+  let at = 0;
+  const foreign = span.segs.filter((seg) => seg.region.entry !== entry).sort((a, b) => a.at - b.at);
+  for (const seg of foreign) {
+    if (seg.at > at) parts.push([at, seg.at - at]);
+    at = seg.at + seg.length;
+  }
+  if (span.length > at) parts.push([at, span.length - at]);
+  return parts;
+}
+function dropSpans(shared, spans) {
+  const { layout, text: text2 } = shared;
+  for (const span of [...spans].sort((a, b) => _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, b) - _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, a))) {
+    const at = _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, span);
+    _chunkMLRAVUFGcjs.deleteText.call(void 0, text2, _chunkMLRAVUFGcjs.spanStart.call(void 0, layout, span), span.length);
+    _chunkMLRAVUFGcjs.placeEntries.call(void 0, layout, at, 1, []);
+  }
+}
+function unreadBefore(layout, span) {
+  const before = [];
+  for (let at = _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, span) - 1; at > 0 && layout.spans[at].entry === null; at--) {
+    before.push(layout.spans[at]);
+  }
+  return before;
+}
+function removeBlock(shared, id) {
+  const { layout, text: text2 } = shared;
+  const entry = layout.entries.get(id);
+  const unread = [...entry.copies, ...unreadBefore(layout, entry.span)];
+  if (isPlain(entry)) return dropSpans(shared, [.../* @__PURE__ */ new Set([entry.span, ...unread])]);
+  dropSpans(shared, [...new Set(unread)]);
+  const ranges = [];
+  const start = _chunkMLRAVUFGcjs.spanStart.call(void 0, layout, entry.span);
+  ranges.push(...ownParts(entry, entry.span).map(([at, length]) => [start + at, length]));
+  for (const seg of entry.regions.flatMap((region2) => region2.segs)) {
+    if (seg.host !== entry.span) ranges.push([_chunkMLRAVUFGcjs.spanStart.call(void 0, layout, seg.host) + seg.at, seg.length]);
+  }
+  for (const [at, length] of ranges.sort((a, b) => b[0] - a[0])) if (length > 0) _chunkMLRAVUFGcjs.deleteText.call(void 0, text2, at, length);
+  reread(shared);
+}
+
+// src/yjs/sync-block.ts
+function syncAttrs(map, before, after) {
+  const current = _chunkMLRAVUFGcjs.attrsMap.call(void 0, map, after);
+  if (current === null) return;
+  const kept = new Map(_chunkMLRAVUFGcjs.definedEntries.call(void 0, after));
+  for (const key of [...current.keys()]) if (!kept.has(key)) current.delete(key);
+  for (const [key, value] of kept) if (!_chunkXX5FTPJRcjs.sameValue.call(void 0, before[key], value)) current.set(key, value);
+}
+function keptNames(before, after) {
+  const kept = /* @__PURE__ */ new Set();
+  let from = 0;
+  for (const name of after) {
+    const at = before.indexOf(name, from);
+    if (at < 0) continue;
+    kept.add(name);
+    from = at + 1;
+  }
+  return kept;
+}
+function syncRegions(shared, entry, before, after) {
+  const { text: text2, layout } = shared;
+  const names = Object.keys(after.regions);
+  const queue = entry.regions.map(({ name }) => [name, before.regions[name]]);
+  const kept = keptNames(queue.map(([name]) => name), names);
+  let at = _chunkMLRAVUFGcjs.spanStart.call(void 0, layout, entry.span) + 1;
+  const dropGone = () => {
+    while (queue.length > 0 && !kept.has(queue[0][0])) _chunkMLRAVUFGcjs.deleteText.call(void 0, text2, at, 1 + _chunkBTBHHBVRcjs.inlineLength.call(void 0, queue.shift()[1]));
+  };
+  for (const name of names) {
+    dropGone();
+    const inline = after.regions[name];
+    if (kept.has(name)) {
+      const { from, to, slice } = changedSpan(queue.shift()[1], inline);
+      if (to > from) _chunkMLRAVUFGcjs.deleteText.call(void 0, text2, at + 1 + from, to - from);
+      _chunkMLRAVUFGcjs.insertInline.call(void 0, text2, at + 1 + from, slice);
+    } else {
+      text2.insertEmbed(at, _chunkMLRAVUFGcjs.regionStart.call(void 0, name), {});
+      _chunkMLRAVUFGcjs.insertInline.call(void 0, text2, at + 1, inline);
+    }
+    at += 1 + _chunkBTBHHBVRcjs.inlineLength.call(void 0, inline);
+  }
+  dropGone();
+  _chunkMLRAVUFGcjs.placeEntries.call(void 0, layout, _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, entry.span), 1, [rewritten(entry, after)]);
+}
+function syncBlock(shared, before, after, next) {
+  if (before === after) return;
+  const entry = shared.layout.entries.get(before.id);
+  const plain = isPlain(entry);
+  if (!plain && !_chunkXX5FTPJRcjs.sameValue.call(void 0, Object.keys(before.regions), Object.keys(after.regions))) {
+    removeBlock(shared, before.id);
+    insertBlocks(shared, next, [after]);
+    return;
+  }
+  if (before.type !== after.type) entry.map.set("type", after.type);
+  if (before.indent !== after.indent) entry.map.set("indent", after.indent);
+  syncAttrs(entry.map, before.attrs, after.attrs);
+  if (plain) {
+    const gains = Object.keys(before.regions).length === 0 && Object.keys(after.regions).length > 0;
+    const crosses = gains && crossesStray(shared.layout, _chunkMLRAVUFGcjs.indexOf.call(void 0, shared.layout, entry.span));
+    syncRegions(shared, entry, before, after);
+    if (crosses) reread(shared);
+    return;
+  }
+  for (const name of entry.regions.map((region2) => region2.name)) {
+    const [was, now] = [before.regions[name], after.regions[name]];
+    if (_chunkBTBHHBVRcjs.equalInline.call(void 0, was, now)) continue;
+    const { from, to, slice } = changedSpan(was, now);
+    const region2 = _chunkMLRAVUFGcjs.regionOf.call(void 0, shared.layout, before.id, name);
+    deleteContent(shared, region2, from, to);
+    insertContent(shared, region2, from, slice);
+  }
+}
+
+// src/yjs/sync-docs.ts
+function syncDocs(shared, before, after) {
+  const order = before.blocks.map((block) => block.id);
+  for (const id of [...order]) {
+    if (after.index.has(id)) continue;
+    removeBlock(shared, id);
+    order.splice(order.indexOf(id), 1);
+  }
+  after.blocks.forEach((block, i) => {
+    if (order[i] === block.id) {
+      syncBlock(shared, before.blocks[before.index.get(block.id)], block, _nullishCoalesce(order[i + 1], () => ( null)));
+      return;
+    }
+    const at = order.indexOf(block.id, i);
+    if (at > i) {
+      removeBlock(shared, block.id);
+      order.splice(at, 1);
+    }
+    insertBlocks(shared, _nullishCoalesce(order[i], () => ( null)), [block]);
+    order.splice(i, 0, block.id);
+  });
+}
+
+// src/yjs/split-join.ts
+var held = (region2) => region2 !== void 0 && region2.segs.length > 0;
+function writeSplit(shared, after, { block, region: region2, offset, created }) {
+  const { layout, text: text2 } = shared;
+  const entry = layout.entries.get(block);
+  const tail = _chunkBTBHHBVRcjs.blockById.call(void 0, after, created.id);
+  const last = entry.regions[entry.regions.length - 1];
+  if (!held(last) || last.name !== region2 || Object.keys(tail.regions).at(-1) !== created.region) return false;
+  const { seg, rel } = _chunkMLRAVUFGcjs.pointOf.call(void 0, last, offset);
+  const map = _chunkMLRAVUFGcjs.markerOf.call(void 0, tail);
+  _chunkMLRAVUFGcjs.writeBlock.call(void 0, text2, _chunkMLRAVUFGcjs.spanStart.call(void 0, layout, seg.host) + rel, tail, map, created.region);
+  if (!isPlain(entry)) {
+    reread(shared);
+    return true;
+  }
+  const head = rewritten(entry, _chunkBTBHHBVRcjs.blockById.call(void 0, after, block));
+  _chunkMLRAVUFGcjs.placeEntries.call(void 0, layout, _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, entry.span), 1, [head, _chunkMLRAVUFGcjs.cleanEntry.call(void 0, tail, map)]);
+  return true;
+}
+function writeJoin(shared, after, join2) {
+  const { target, targetRegion, source, sourceRegion } = join2;
+  const { layout, text: text2 } = shared;
+  const [into, from] = [target, source].map((id) => layout.entries.get(id));
+  const [end, start] = [into.regions.at(-1), from.regions[0]];
+  if (!held(end) || !held(start) || end.name !== targetRegion || start.name !== sourceRegion) return false;
+  const between = layout.spans.slice(_chunkMLRAVUFGcjs.indexOf.call(void 0, layout, into.span) + 1, _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, from.span));
+  dropSpans(shared, [...from.copies, ...between]);
+  const at = _chunkMLRAVUFGcjs.spanStart.call(void 0, layout, from.span);
+  if (!isPlain(into) || !isPlain(from)) {
+    const own = start.segs.find((seg) => seg.host === from.span);
+    _chunkMLRAVUFGcjs.deleteText.call(void 0, text2, at + own.at - 1, 1);
+    _chunkMLRAVUFGcjs.deleteText.call(void 0, text2, at, 1);
+    reread(shared);
+    return true;
+  }
+  const index = _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, into.span);
+  const moved = from.regions[0].segs[0].length;
+  const rest = from.span.length - 2 - moved;
+  if (rest > 0) _chunkMLRAVUFGcjs.deleteText.call(void 0, text2, at + 2 + moved, rest);
+  _chunkMLRAVUFGcjs.deleteText.call(void 0, text2, at, 2);
+  _chunkMLRAVUFGcjs.placeEntries.call(void 0, layout, index, 2, [rewritten(into, _chunkBTBHHBVRcjs.blockById.call(void 0, after, target))]);
+  return true;
+}
+
+// src/yjs/local-to-yjs.ts
+var region = ({ shared, params }) => _chunkMLRAVUFGcjs.regionOf.call(void 0, shared.layout, params.block, params.region);
+var following = (doc, id) => _nullishCoalesce(_optionalChain([doc, 'access', _9 => _9.blocks, 'access', _10 => _10[doc.index.get(id) + 1], 'optionalAccess', _11 => _11.id]), () => ( null));
+function replaceInline(context) {
+  const { from, to, slice } = context.params;
+  const target = region(context);
+  deleteContent(context.shared, target, from, to);
+  insertContent(context.shared, target, from, slice);
+}
+function format(context, keys) {
+  const { block, region: name, from, to } = context.params;
+  if (to === from) return;
+  const inline = _chunkBTBHHBVRcjs.blockById.call(void 0, context.before, block).regions[name];
+  formatContent(context.shared, region(context), from, to, keys(_chunkBTBHHBVRcjs.sliceInline.call(void 0, inline, from, to)));
+}
+function removedKeys(mark, inline) {
+  if (typeof mark !== "string") return { [_chunkMLRAVUFGcjs.markAttribute.call(void 0, mark)[0]]: null };
+  const marks = inline.flatMap((node) => node.marks.filter((candidate) => candidate.type === mark));
+  return Object.fromEntries(marks.map((found) => [_chunkMLRAVUFGcjs.markAttribute.call(void 0, found)[0], null]));
+}
+function setAttrs({ shared, after, params }) {
+  const id = params.block;
+  const { map } = shared.layout.entries.get(id);
+  const next = _chunkBTBHHBVRcjs.blockById.call(void 0, after, id).attrs;
+  const attrs = _chunkMLRAVUFGcjs.attrsMap.call(void 0, map, next);
+  if (attrs === null) return;
+  for (const key of Object.keys(params.patch)) {
+    if (next[key] === void 0) attrs.delete(key);
+    else attrs.set(key, next[key]);
+  }
+}
+function moveBlocks({ shared, before, after, params }) {
+  const { from, count, to } = params;
+  if (count === 0 || from === to) return;
+  const moved = before.blocks.slice(from, from + count);
+  for (const block of moved) removeBlock(shared, block.id);
+  insertBlocks(shared, _nullishCoalesce(_optionalChain([after, 'access', _12 => _12.blocks, 'access', _13 => _13[to + count], 'optionalAccess', _14 => _14.id]), () => ( null)), moved);
+}
+var WRITERS = {
+  replaceInline,
+  addMark: (context) => format(context, () => Object.fromEntries([_chunkMLRAVUFGcjs.markAttribute.call(void 0, context.params.mark)])),
+  removeMark: (context) => format(context, (inline) => removedKeys(context.params.mark, inline)),
+  setAttrs,
+  setIndent: ({ shared, params }) => shared.layout.entries.get(params.block).map.set("indent", params.indent),
+  insertBlocks: ({ shared, before, params }) => insertBlocks(shared, _nullishCoalesce(_optionalChain([before, 'access', _15 => _15.blocks, 'access', _16 => _16[params.index], 'optionalAccess', _17 => _17.id]), () => ( null)), params.blocks),
+  removeBlocks: ({ shared, before, params }) => {
+    const { index, count } = params;
+    for (const block of before.blocks.slice(index, index + count)) removeBlock(shared, block.id);
+  },
+  moveBlocks,
+  splitBlock: (context) => {
+    if (!writeSplit(context.shared, context.after, context.params)) {
+      syncDocs(context.shared, context.before, context.after);
+    }
+  },
+  joinBlocks: (context) => {
+    if (!writeJoin(context.shared, context.after, context.params)) {
+      syncDocs(context.shared, context.before, context.after);
+    }
+  },
+  replaceBlock: ({ shared, before, params }) => {
+    const block = params.block;
+    syncBlock(shared, _chunkBTBHHBVRcjs.blockById.call(void 0, before, block.id), block, following(before, block.id));
+  }
+};
+function writeLocalSteps(shared, steps, docs) {
+  steps.forEach((step, i) => {
+    const [before, after] = [docs[i], docs[i + 1]];
+    const writer = WRITERS[step.stepType];
+    if (writer === void 0) syncDocs(shared, before, after);
+    else writer({ shared, before, after, params: step.toJSON() });
+  });
+}
+
+// src/yjs/seed.ts
+function seedOrLoad(editor, text2, { origin, seed, required }) {
+  const { blocks } = editor.state.doc;
+  if (text2.length === 0 && seed === "if-empty") {
+    let maps = [];
+    text2.doc.transact(() => maps = _chunkMLRAVUFGcjs.writeBlocks.call(void 0, text2, 0, blocks), origin);
+    const entries = blocks.map((block, i) => _chunkMLRAVUFGcjs.cleanEntry.call(void 0, block, maps[i]));
+    const spans = [_chunkMLRAVUFGcjs.emptySpan.call(void 0, ), ...entries.map((entry) => entry.span)];
+    return _chunkMLRAVUFGcjs.createLayout.call(void 0, spans, new Map(entries.map((entry) => [entry.id, entry])), true);
+  }
+  const { doc, layout } = readShared(text2, required);
+  if (!_chunkHOIDJEVIcjs.sameDoc.call(void 0, doc, editor.state.doc)) _chunkMLRAVUFGcjs.applyRemote.call(void 0, editor, [_chunkHOIDJEVIcjs.replaceDocStep.call(void 0, doc)]);
+  return layout;
+}
+
+// src/yjs/read-split-join.ts
+
+var bare = (op) => op === void 0 || op.attributes === void 0;
+function split(layout, delta, required) {
+  const [at, ops] = _optionalChain([delta, 'access', _18 => _18[0], 'optionalAccess', _19 => _19.retain]) === void 0 ? [0, delta] : [delta[0].retain, delta.slice(1)];
+  const map = _optionalChain([ops, 'access', _20 => _20[0], 'optionalAccess', _21 => _21.insert]);
+  const name = _chunkMLRAVUFGcjs.regionNameOf.call(void 0, _optionalChain([ops, 'access', _22 => _22[1], 'optionalAccess', _23 => _23.insert]));
+  if (ops.length !== 2 || !(map instanceof Y2.Map) || name === null || !bare(delta[0])) return null;
+  const marker = _chunkMLRAVUFGcjs.readMarker.call(void 0, map);
+  const span = _chunkMLRAVUFGcjs.spanAt.call(void 0, layout, at);
+  if (span.entry === null || !isPlain(span.entry)) return null;
+  const region2 = span.entry.regions.at(-1);
+  const seg = _optionalChain([region2, 'optionalAccess', _24 => _24.segs, 'access', _25 => _25[0]]);
+  const rel = at - _chunkMLRAVUFGcjs.spanStart.call(void 0, layout, span);
+  if (marker === null || layout.entries.has(marker.id) || seg === void 0) return null;
+  if (rel < seg.at || rel > seg.at + seg.length) return null;
+  if (required(marker.type).some((needed) => needed !== name)) return null;
+  const { id, type, indent, attrs } = marker;
+  const created = { id, type, indent, attrs: _nullishCoalesce(_optionalChain([attrs, 'optionalAccess', _26 => _26.toJSON, 'call', _27 => _27()]), () => ( {})), region: name, regions: {} };
+  return { step: _chunkHOIDJEVIcjs.splitBlockStep.call(void 0, span.entry.id, region2.name, _chunkMLRAVUFGcjs.offsetIn.call(void 0, seg, rel), created), map };
+}
+function join(layout, delta) {
+  const [at, ops] = _optionalChain([delta, 'access', _28 => _28[0], 'optionalAccess', _29 => _29.retain]) === void 0 ? [0, delta] : [delta[0].retain, delta.slice(1)];
+  if (ops.length !== 1 || ops[0].delete !== 2 || !bare(delta[0])) return null;
+  const span = _chunkMLRAVUFGcjs.spanAt.call(void 0, layout, at, true);
+  const source = span.entry;
+  const target = _nullishCoalesce(_optionalChain([layout, 'access', _30 => _30.spans, 'access', _31 => _31[span.index - 1], 'optionalAccess', _32 => _32.entry]), () => ( null));
+  if (_chunkMLRAVUFGcjs.spanStart.call(void 0, layout, span) !== at || source === null || target === null) return null;
+  if (source.regions.length !== 1 || target.regions.length === 0 || source.copies.length > 0) return null;
+  if (!isPlain(source) || !isPlain(target)) return null;
+  return _chunkHOIDJEVIcjs.joinBlocksStep.call(void 0, target.id, target.regions.at(-1).name, source.id, source.regions[0].name);
+}
+function splitOrJoin(layout, delta, doc, required) {
+  const found = split(layout, delta, required);
+  const step = _nullishCoalesce(_optionalChain([found, 'optionalAccess', _33 => _33.step]), () => ( join(layout, delta)));
+  if (step === null) return null;
+  const after = step.apply(doc).doc;
+  const { block, target, created } = step.toJSON();
+  const kept = layout.entries.get(_nullishCoalesce(block, () => ( target)));
+  const entries = [rewritten(kept, _chunkBTBHHBVRcjs.blockById.call(void 0, after, kept.id))];
+  if (found !== null) entries.push(_chunkMLRAVUFGcjs.cleanEntry.call(void 0, _chunkBTBHHBVRcjs.blockById.call(void 0, after, created.id), found.map));
+  _chunkMLRAVUFGcjs.placeEntries.call(void 0, layout, _chunkMLRAVUFGcjs.indexOf.call(void 0, layout, kept.span), found === null ? 2 : 1, entries);
+  return step;
+}
+
+// src/yjs/yjs-to-steps.ts
+var REREAD = new Error("reread");
+function markerSteps(shared, event, doc) {
+  const target = event.target;
+  const marker = target.parent === shared.text ? target : target.parent;
+  const fields = _chunkMLRAVUFGcjs.readMarker.call(void 0, marker);
+  const block = fields === null ? void 0 : _chunkBTBHHBVRcjs.blockById.call(void 0, doc, fields.id);
+  if (block === void 0 || _optionalChain([shared, 'access', _34 => _34.layout, 'access', _35 => _35.entries, 'access', _36 => _36.get, 'call', _37 => _37(block.id), 'optionalAccess', _38 => _38.map]) !== marker) return [];
+  const keys = [...event.keysChanged];
+  if (target !== marker) {
+    if (fields.attrs !== target) return [];
+    return [_chunkHOIDJEVIcjs.setAttrsStep.call(void 0, block.id, Object.fromEntries(keys.map((key) => [key, target.get(key)])))];
+  }
+  if (keys.includes("id") || keys.includes("type")) throw REREAD;
+  const { indent, attrs } = fields;
+  if (keys.every((key) => key === "indent")) return [_chunkHOIDJEVIcjs.setIndentStep.call(void 0, block.id, indent)];
+  return [_chunkHOIDJEVIcjs.replaceBlockStep.call(void 0, { ...block, indent, attrs: _nullishCoalesce(_optionalChain([attrs, 'optionalAccess', _39 => _39.toJSON, 'call', _40 => _40()]), () => ( {})) })];
+}
+function contentSteps(shared, events, doc) {
+  const textEvent = events.find((event) => event.target === shared.text);
+  const delta = _nullishCoalesce(_optionalChain([textEvent, 'optionalAccess', _41 => _41.delta]), () => ( []));
+  const structure = splitOrJoin(shared.layout, delta, doc, shared.required);
+  const steps = structure === null ? _chunkMLRAVUFGcjs.textSteps.call(void 0, shared.layout, delta) : [structure];
+  if (steps === null) throw REREAD;
+  let current = steps.reduce((changed, step) => step.apply(changed).doc, doc);
+  for (const event of events) {
+    if (event === textEvent) continue;
+    for (const step of markerSteps(shared, event, current)) {
+      current = step.apply(current).doc;
+      steps.push(step);
+    }
+  }
+  return steps;
+}
+function readRemote(shared, events, doc) {
+  try {
+    return { steps: contentSteps(shared, events, doc), structural: false };
+  } catch (error) {
+    const read = readShared(shared.text, shared.required);
+    shared.layout = read.layout;
+    const blocks = read.doc.blocks.map((block) => {
+      const held2 = _chunkBTBHHBVRcjs.blockById.call(void 0, doc, block.id);
+      return held2 !== void 0 && _chunkXX5FTPJRcjs.sameValue.call(void 0, held2, block) ? held2 : block;
+    });
+    const next = _chunkBTBHHBVRcjs.createDoc.call(void 0, blocks);
+    const failed = error === REREAD ? void 0 : error;
+    return { steps: _chunkHOIDJEVIcjs.sameDoc.call(void 0, next, doc) ? [] : [_chunkHOIDJEVIcjs.replaceDocStep.call(void 0, next)], structural: true, failed };
+  }
+}
+
+// src/yjs/binding.ts
+function bind(editor, text2, options) {
+  const { origins, seed, onError } = options;
+  const doc = text2.doc;
+  const required = requiredRegions(editor.state.schema);
+  const layout = seedOrLoad(editor, text2, { origin: origins.local, seed, required });
+  const history = options.history();
+  const shared = { text: text2, layout, stale: false, required };
+  const ours = (origin) => origin === origins.local || origin === origins.untracked;
+  let held2 = null;
+  const written = /* @__PURE__ */ new WeakSet();
+  const hold = (transaction) => {
+    if (!ours(transaction.origin)) held2 = _chunkMLRAVUFGcjs.holdSelection.call(void 0, text2, shared.layout, editor.state.selection);
+  };
+  const observer = (events, transaction) => {
+    if (ours(transaction.origin)) return;
+    const { steps, structural, failed } = readRemote(shared, events, editor.state.doc);
+    if (steps.length > 0 && transaction.origin !== history.manager) {
+      _chunkMLRAVUFGcjs.applyRemote.call(void 0, editor, steps, structural ? _chunkMLRAVUFGcjs.restoreSelection.call(void 0, text2, shared.layout, held2) : null);
+    } else if (steps.length > 0) {
+      const tr = _chunkMLRAVUFGcjs.sharedChange.call(void 0, editor, steps, history.hint(), "history");
+      written.add(tr);
+      editor.dispatch(tr);
+    }
+    if (failed) onError(failed);
+  };
+  const settle = () => {
+    shared.stale = false;
+    const read = readShared(text2, required);
+    shared.layout = read.layout;
+    if (!_chunkHOIDJEVIcjs.sameDoc.call(void 0, read.doc, editor.state.doc)) _chunkMLRAVUFGcjs.applyRemote.call(void 0, editor, [_chunkHOIDJEVIcjs.replaceDocStep.call(void 0, read.doc)]);
+  };
+  doc.on("beforeTransaction", hold);
+  text2.observeDeep(observer);
+  return {
+    editor,
+    shared,
+    local(tr) {
+      if (written.has(tr)) return;
+      history.record(tr);
+      if (!tr.docChanged) return;
+      const docs = [...tr.docs, tr.doc];
+      const origin = tr.addToHistory ? origins.local : origins.untracked;
+      doc.transact(() => writeLocalSteps(shared, tr.steps, docs), origin);
+      if (shared.stale) settle();
+    },
+    travel: (direction) => history.travel(direction, editor),
+    stop() {
+      doc.off("beforeTransaction", hold);
+      text2.unobserveDeep(observer);
+    }
+  };
+}
+
+// src/yjs/undo-history.ts
+
+var GROUP_DELAY = 500;
+var SELECTION = "selection";
+function undoHistory(text2, origin) {
+  const manager = new Y3.UndoManager(text2, { trackedOrigins: /* @__PURE__ */ new Set([origin]), captureTimeout: Infinity });
+  let group = null;
+  let time = 0;
+  let before = null;
+  let hint = null;
+  manager.on("stack-item-added", ({ stackItem }) => stackItem.meta.set(SELECTION, before));
+  return {
+    manager,
+    record(tr) {
+      if (!tr.docChanged) {
+        if (tr.getMeta("closeHistory") === true) group = null;
+        return;
+      }
+      const next = _chunkHOIDJEVIcjs.groupOf.call(void 0, tr);
+      if (next === null || next !== group || tr.time - time >= GROUP_DELAY) manager.stopCapturing();
+      group = next;
+      time = tr.time;
+      before = tr.before.selection;
+    },
+    travel(direction, editor) {
+      const stack = direction === "undo" ? manager.undoStack : manager.redoStack;
+      const item = stack.at(-1);
+      if (item === void 0) return false;
+      hint = _nullishCoalesce(item.meta.get(SELECTION), () => ( null));
+      before = editor.state.selection;
+      group = null;
+      try {
+        return (direction === "undo" ? manager.undo() : manager.redo()) !== null;
+      } finally {
+        hint = null;
+      }
+    },
+    hint: () => hint
+  };
+}
+
+// src/yjs/index.ts
+function yjsCollaboration(options) {
+  const { doc, field = "quoin", awareness, user, seed = "if-empty" } = options;
+  const onError = _nullishCoalesce(options.onError, () => ( ((error) => console.error(error))));
+  const text2 = doc.getText(field);
+  const origins = { local: { user }, untracked: {} };
+  let history;
+  let binding = null;
+  let disconnects = 0;
+  const collaboration = {
+    doc,
+    text: text2,
+    awareness,
+    user,
+    origin: origins.local,
+    connect(editor) {
+      if (binding !== null) {
+        onError(new Error("A Yjs collaboration connects one editor at a time; this editor stays unconnected."));
+        return () => void 0;
+      }
+      const current = bind(editor, text2, {
+        origins,
+        seed,
+        onError,
+        history: () => history ??= undoHistory(text2, origins.local)
+      });
+      binding = current;
+      return () => {
+        current.stop();
+        if (binding === current) binding = null;
+        const at = ++disconnects;
+        setTimeout(() => {
+          if (binding !== null || at !== disconnects) return;
+          _optionalChain([history, 'optionalAccess', _42 => _42.manager, 'access', _43 => _43.destroy, 'call', _44 => _44()]);
+          history = void 0;
+        }, 16);
+      };
+    },
+    onLocalTransaction: (tr, state) => {
+      if (_optionalChain([binding, 'optionalAccess', _45 => _45.editor, 'access', _46 => _46.state]) === state) binding.local(tr);
+    },
+    history: {
+      undo: () => _nullishCoalesce(_optionalChain([binding, 'optionalAccess', _47 => _47.travel, 'call', _48 => _48("undo")]), () => ( false)),
+      redo: () => _nullishCoalesce(_optionalChain([binding, 'optionalAccess', _49 => _49.travel, 'call', _50 => _50("redo")]), () => ( false)),
+      canUndo: () => binding !== null && history.manager.canUndo(),
+      canRedo: () => binding !== null && history.manager.canRedo()
+    }
+  };
+  _chunkMLRAVUFGcjs.holdBinding.call(void 0, collaboration, () => binding);
+  return collaboration;
+}
+
+// src/engine/collab/collaboration-link.ts
+var linkKey = _chunkHOIDJEVIcjs.createPluginKey.call(void 0, "collaborationLink");
+var linkPlugin = {
+  key: linkKey,
+  init: () => ({ mounts: 0, disconnect: null, warned: false }),
+  apply: (_tr, link) => link
+};
+var linkOf = (state) => _chunkHOIDJEVIcjs.getPluginState.call(void 0, state, linkKey);
+
+// src/engine/collab/warn-host-blocks.ts
+function warnHostBlocks() {
+  if (typeof process !== "undefined" && _optionalChain([process, 'optionalAccess', _51 => _51.env, 'optionalAccess', _52 => _52.NODE_ENV]) === "production") return;
+  console.warn(
+    "Quoin: blocks were supplied to a collaborative editor and ignored, since the shared document holds its content. Supply its starting blocks once and keep the ones it emits."
+  );
+}
+
+// src/engine/collab/collaboration-extension.ts
+var providerKey = _chunkHOIDJEVIcjs.createPluginKey.call(void 0, _chunkHOIDJEVIcjs.HISTORY_PROVIDER);
+function providing(history) {
+  const provider = {
+    undo: (dryRun) => dryRun ? history.canUndo() : history.undo(),
+    redo: (dryRun) => dryRun ? history.canRedo() : history.redo()
+  };
+  return { key: providerKey, init: () => provider, apply: (_tr, value) => value };
+}
+function collaborationExtension(adapter) {
+  const { history } = adapter;
+  return _chunkHOIDJEVIcjs.defineExtension.call(void 0, {
+    name: "collaboration",
+    plugins: history === void 0 ? [linkPlugin] : [linkPlugin, providing(history)],
+    onMount(editor) {
+      const link = linkOf(editor.state);
+      link.mounts += 1;
+      if (link.mounts === 1) {
+        try {
+          link.disconnect = adapter.connect(editor);
+        } catch (error) {
+          link.mounts = 0;
+          throw error;
+        }
+      }
+      return () => {
+        link.mounts -= 1;
+        if (link.mounts === 0) _optionalChain([link, 'access', _53 => _53.disconnect, 'optionalCall', _54 => _54()]);
+      };
+    },
+    onTransaction(tr, state) {
+      const local = tr.origin !== "remote" && tr.origin !== "reconcile";
+      if (local && linkOf(state).mounts > 0) adapter.onLocalTransaction(tr, state);
+    },
+    filterHostBlocks(_blocks, state) {
+      const link = linkOf(state);
+      if (link.mounts === 0) return true;
+      if (!link.warned) warnHostBlocks();
+      link.warned = true;
+      return false;
+    }
+  });
+}
+
+
+
+
+exports.applyRemote = _chunkMLRAVUFGcjs.applyRemote; exports.collaborationExtension = collaborationExtension; exports.yjsCollaboration = yjsCollaboration;
+//# sourceMappingURL=yjs.cjs.map