@w100n/documents 0.16.4 → 0.17.0

package/dist/{chunk-VNXZVOPN.js → chunk-B7C6NBBQ.js}

@@ -1,7 +1,870 @@
 'use client';
+import {
+  mathml
+} from "./chunk-ZAVXCH7V.js";
+
+// src/editor/pager.ts
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+var a4 = { width: 793.73, height: 1122.53, margins: [96, 96, 96, 96] };
+var letter = { width: 816, height: 1056 };
+var paging = new PluginKey("w100n-pager");
+var skip = (el) => el.classList.contains("w100n-text-gap") || el.classList.contains("ProseMirror-gapcursor");
+function measure(view) {
+  const { page } = paging.getState(view.state);
+  const [top, , bottom] = page.margins;
+  const room = page.height - top - bottom;
+  const els = [...view.dom.children];
+  const gaps = [];
+  const line = page.width - page.margins[1] - page.margins[3];
+  const area = (list) => list.length ? 14 + list.reduce((h, text) => h + 15 * Math.max(1, Math.ceil(text.length * 5.6 / line)), 0) : 0;
+  let notes2 = [];
+  let count = 0;
+  let i = 0;
+  let shift = 0;
+  let start = 0;
+  let last = 0;
+  view.state.doc.forEach((node, offset) => {
+    let el = els[i++];
+    while (el && skip(el)) {
+      if (el.classList.contains("w100n-text-gap")) shift += el.offsetHeight;
+      el = els[i++];
+    }
+    if (!el) return;
+    const y = el.offsetTop - shift;
+    const end = y + el.offsetHeight;
+    const mine = [];
+    node.descendants((d) => {
+      if (d.type.name === "footnote") mine.push(`${count + mine.length + 1} ${d.attrs.text}`);
+    });
+    if (node.type.name === "pageBreak") {
+      gaps.push({ pos: offset + node.nodeSize, height: start + room - end + bottom + 24 + top, page: gaps.length + 1, notes: notes2 });
+      notes2 = [];
+      start = end;
+    } else if (end > start + room - area([...notes2, ...mine]) && y > start) {
+      gaps.push({ pos: offset, height: start + room - y + bottom + 24 + top, page: gaps.length + 1, notes: notes2 });
+      notes2 = [];
+      start = y;
+    }
+    notes2.push(...mine);
+    count += mine.length;
+    while (end > start + room) start += room;
+    last = end;
+  });
+  gaps.push({ pos: view.state.doc.content.size, height: Math.max(0, start + room - last), page: gaps.length + 1, end: true, notes: notes2 });
+  return gaps.map((g) => ({ ...g, height: Math.max(0, Math.round(g.height)) }));
+}
+var Pager = Extension.create({
+  name: "pager",
+  addProseMirrorPlugins: () => [new Plugin({
+    key: paging,
+    state: {
+      init: () => ({ set: DecorationSet.empty, page: a4, marks: { header: "", footer: "" }, flow: false }),
+      apply(tr, value) {
+        const next = tr.getMeta(paging);
+        return { set: next?.set ?? value.set.map(tr.mapping, tr.doc), page: next?.page ?? value.page, marks: next?.marks ?? value.marks, flow: next?.flow ?? value.flow };
+      }
+    },
+    props: { decorations: (state) => paging.getState(state).set },
+    view(view) {
+      let timer = 0;
+      let sig = "";
+      const run = () => {
+        if (!view.dom.isConnected) return;
+        const { marks, flow } = paging.getState(view.state);
+        if (flow) {
+          if (sig !== "flow") view.dispatch(view.state.tr.setMeta(paging, { set: DecorationSet.empty }).setMeta("addToHistory", false));
+          sig = "flow";
+          return;
+        }
+        const gaps = measure(view);
+        const next = gaps.map((g) => `${g.pos}:${g.height}:${g.notes.join("\n")}`).join() + `|${marks.header}|${marks.footer}`;
+        if (next === sig) return;
+        sig = next;
+        const line = (parent, cls, text) => {
+          if (!text) return;
+          const span = document.createElement("span");
+          span.className = cls;
+          span.textContent = text;
+          parent.append(span);
+        };
+        const first = Decoration.widget(0, () => {
+          const el = document.createElement("div");
+          el.className = "w100n-text-first";
+          el.contentEditable = "false";
+          line(el, "w100n-text-head", marks.header);
+          return el;
+        }, { key: `first:${marks.header}`, side: -1, ignoreSelection: true });
+        const set = DecorationSet.create(view.state.doc, [first, ...gaps.map((g) => Decoration.widget(g.pos, () => {
+          const el = document.createElement("div");
+          el.className = g.end ? "w100n-text-gap is-end" : "w100n-text-gap";
+          el.style.height = `${g.height}px`;
+          el.dataset.page = String(g.page);
+          el.contentEditable = "false";
+          line(el, "w100n-text-foot", marks.footer);
+          if (!g.end) line(el, "w100n-text-head", marks.header);
+          if (g.notes.length) {
+            const list = document.createElement("div");
+            list.className = "w100n-text-footnotes";
+            for (const note of g.notes) {
+              const p = document.createElement("p");
+              const n = document.createElement("sup");
+              n.textContent = note.slice(0, note.indexOf(" "));
+              p.append(n, note.slice(note.indexOf(" ")));
+              list.append(p);
+            }
+            el.append(list);
+          }
+          return el;
+        }, { key: `${g.pos}:${g.height}:${g.page}:${marks.header}:${marks.footer}:${g.notes.join("\n")}`, side: -1, ignoreSelection: true }))]);
+        view.dispatch(view.state.tr.setMeta(paging, { set }).setMeta("addToHistory", false));
+      };
+      const later = (ms) => {
+        clearTimeout(timer);
+        timer = window.setTimeout(run, ms);
+      };
+      const watch = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(() => later(200));
+      watch?.observe(view.dom);
+      later(0);
+      return {
+        update: (next, prev) => {
+          const now = paging.getState(next.state), was = paging.getState(prev);
+          if (now.page !== was.page || now.marks !== was.marks || now.flow !== was.flow) later(0);
+          else if (next.state.doc !== prev.doc) later(400);
+        },
+        destroy: () => {
+          clearTimeout(timer);
+          watch?.disconnect();
+        }
+      };
+    }
+  })]
+});
+
+// src/editor/extensions.ts
+import { Extension as Extension2, Mark, Node } from "@tiptap/core";
+import Collaboration from "@tiptap/extension-collaboration";
+import CollaborationCaret from "@tiptap/extension-collaboration-caret";
+import Highlight from "@tiptap/extension-highlight";
+import Image from "@tiptap/extension-image";
+import { TaskItem, TaskList } from "@tiptap/extension-list";
+import { TableKit } from "@tiptap/extension-table";
+import { Color, FontFamily, FontSize, TextStyle } from "@tiptap/extension-text-style";
+import { Plugin as Plugin2, PluginKey as PluginKey2, TextSelection } from "@tiptap/pm/state";
+import { StepMap } from "@tiptap/pm/transform";
+import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "@tiptap/pm/view";
+import StarterKit from "@tiptap/starter-kit";
+import { ySyncPluginKey } from "@tiptap/y-tiptap";
+var notes = new PluginKey2("w100n-notes");
+var blocks = [
+  "paragraph",
+  "heading",
+  "bulletList",
+  "orderedList",
+  "listItem",
+  "taskList",
+  "taskItem",
+  "blockquote",
+  "codeBlock",
+  "horizontalRule",
+  "table",
+  "tableRow",
+  "tableHeader",
+  "tableCell",
+  "pageBreak",
+  "toc"
+];
+var changed = (trs) => {
+  const ranges = [];
+  trs.forEach((tr, n) => tr.steps.forEach((step, i) => {
+    const slice = step.slice;
+    if (!slice || !slice.openStart && !slice.openEnd && !slice.content.firstChild?.isBlock) return;
+    const after = tr.mapping.slice(i + 1);
+    for (const later of trs.slice(n + 1)) after.appendMapping(later.mapping);
+    step.getMap().forEach((_a, _b, from, to) => ranges.push([after.map(from, -1), after.map(to, 1)]));
+  }));
+  return ranges;
+};
+var Cells = Extension2.create({
+  name: "cells",
+  addGlobalAttributes: () => [
+    { types: ["tableCell", "tableHeader"], attributes: { background: { default: null, parseHTML: (el) => el.dataset.fill ?? null, renderHTML: (attrs) => attrs.background ? { "data-fill": attrs.background, style: `background-color: ${attrs.background}` } : {} } } },
+    { types: ["table"], attributes: { borders: { default: null, parseHTML: (el) => el.dataset.borders ?? null, renderHTML: (attrs) => attrs.borders ? { "data-borders": attrs.borders } : {} } } }
+  ]
+});
+var searching = new PluginKey2("w100n-search");
+var lookup = (doc, query, matchCase) => {
+  const hits = [];
+  if (!query) return hits;
+  const needle = matchCase ? query : query.toLowerCase();
+  doc.descendants((node, pos) => {
+    if (!node.isTextblock) return true;
+    let text = "";
+    const at = [];
+    node.forEach((child, offset) => {
+      const part = child.isText ? child.text : "\uFFFC";
+      for (let i = 0; i < part.length; i++) at.push(pos + 1 + offset + i);
+      text += part;
+    });
+    const hay = matchCase ? text : text.toLowerCase();
+    for (let i = hay.indexOf(needle); i >= 0; i = hay.indexOf(needle, i + needle.length)) hits.push({ from: at[i], to: at[i + needle.length - 1] + 1 });
+    return false;
+  });
+  return hits;
+};
+var Search = Extension2.create({
+  name: "search",
+  addProseMirrorPlugins: () => [new Plugin2({
+    key: searching,
+    state: {
+      init: () => ({ query: "", matchCase: false, hits: [], at: 0, set: DecorationSet2.empty }),
+      apply(tr, value) {
+        const meta = tr.getMeta(searching);
+        if (!meta && !tr.docChanged) return value;
+        const next = { ...value, ...meta };
+        const hits = lookup(tr.doc, next.query, next.matchCase);
+        const at = hits.length ? (next.at % hits.length + hits.length) % hits.length : 0;
+        return { ...next, hits, at, set: DecorationSet2.create(tr.doc, hits.map((h, i) => Decoration2.inline(h.from, h.to, { class: i === at ? "w100n-found is-current" : "w100n-found" }))) };
+      }
+    },
+    props: { decorations: (state) => searching.getState(state).set }
+  })]
+});
+var replace = (editor, text, all) => {
+  const { hits, at } = searching.getState(editor.state);
+  if (!hits.length) return 0;
+  const tr = editor.state.tr;
+  for (const hit of all ? [...hits].reverse() : [hits[at]]) tr.insertText(text, hit.from, hit.to);
+  editor.view.dispatch(tr);
+  return all ? hits.length : 1;
+};
+var cleanPaste = (html) => html.replace(/<!--\[if[\s\S]*?<!\[endif\]-->/g, "").replace(/<o:p>[\s\S]*?<\/o:p>/g, "").replace(/\sclass=("|')?Mso[^"'\s>]*\1?/g, "").replace(/<img\b[^>]*\ssrc=("|')file:[^"']*\1[^>]*>/gi, "").replace(/\sstyle=("|')([^"']*)\1/g, (_, q, css) => {
+  const kept = css.split(";").map((x) => x.trim()).filter((x) => x && !/^mso-|^tab-stops|^font-family:\s*["']?(Symbol|Wingdings)/i.test(x)).join("; ");
+  return kept ? ` style=${q}${kept}${q}` : "";
+});
+var Blocks = Extension2.create({
+  name: "blocks",
+  addGlobalAttributes: () => [{
+    types: blocks,
+    attributes: {
+      align: { default: null, parseHTML: (el) => el.style.textAlign || null, renderHTML: (attrs) => attrs.align ? { style: `text-align: ${attrs.align}` } : {} },
+      indent: { default: 0, parseHTML: (el) => Number(el.dataset.indent) || 0, renderHTML: (attrs) => attrs.indent ? { "data-indent": attrs.indent, style: `margin-left: ${attrs.indent * 0.5}in` } : {} },
+      line: { default: null, parseHTML: (el) => Number(el.dataset.line) || null, renderHTML: (attrs) => attrs.line ? { "data-line": attrs.line, style: `line-height: ${attrs.line * 1.15}` } : {} },
+      after: { default: null, parseHTML: (el) => el.dataset.after ? Number(el.dataset.after) : null, renderHTML: (attrs) => attrs.after === null || attrs.after === void 0 ? {} : { "data-after": attrs.after, style: `margin-bottom: ${attrs.after}pt` } },
+      ref: { default: null, rendered: false, keepOnSplit: false }
+    }
+  }],
+  addProseMirrorPlugins: () => [new Plugin2({
+    appendTransaction(trs, _old, state) {
+      const ranges = changed(trs);
+      if (!ranges.length) return null;
+      const seen2 = /* @__PURE__ */ new Map();
+      const drop = [];
+      const visit = (node, pos2) => {
+        const ref = node.attrs.ref;
+        if (!ref) return;
+        const first = seen2.get(ref);
+        if (!first) seen2.set(ref, { pos: pos2, node });
+        else if (!first.node.textContent && node.textContent) {
+          drop.push(first.pos);
+          seen2.set(ref, { pos: pos2, node });
+        } else drop.push(pos2);
+      };
+      const from = Math.max(0, Math.min(...ranges.map((r) => r[0])));
+      const to = Math.min(state.doc.content.size, Math.max(...ranges.map((r) => r[1])));
+      const $from = state.doc.resolve(from);
+      const $to = state.doc.resolve(to);
+      const start = Math.max(0, $from.index(0) - 1);
+      const end = Math.min(state.doc.childCount, $to.index(0) + 2);
+      let pos = 0;
+      for (let i = 0; i < start; i++) pos += state.doc.child(i).nodeSize;
+      for (let i = start; i < end; i++) {
+        const top = state.doc.child(i);
+        visit(top, pos);
+        top.descendants((node, at) => visit(node, pos + 1 + at));
+        pos += top.nodeSize;
+      }
+      if (!drop.length) return null;
+      const tr = state.tr;
+      for (const at of drop) tr.setNodeAttribute(at, "ref", null);
+      return tr;
+    }
+  })]
+});
+var PageBreak = Node.create({
+  name: "pageBreak",
+  group: "block",
+  atom: true,
+  selectable: true,
+  addOptions: () => ({ label: "" }),
+  parseHTML: () => [{ tag: "div[data-page-break]" }],
+  renderHTML() {
+    return ["div", { "data-page-break": "", "data-label": this.options.label, class: "w100n-text-break", contenteditable: "false" }];
+  }
+});
+var Formula = Node.create({
+  name: "math",
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  addAttributes: () => ({ latex: { default: "", parseHTML: (el) => el.getAttribute("data-math") ?? "" } }),
+  parseHTML: () => [{ tag: "span[data-math]" }],
+  renderHTML: ({ node }) => ["span", { "data-math": node.attrs.latex, class: "w100n-math" }],
+  addNodeView: () => ({ node }) => {
+    const dom = document.createElement("span");
+    dom.className = "w100n-math";
+    dom.dataset.math = node.attrs.latex;
+    dom.contentEditable = "false";
+    dom.innerHTML = mathml(node.attrs.latex);
+    return { dom };
+  }
+});
+var Footnote = Node.create({
+  name: "footnote",
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  addAttributes: () => ({
+    id: { default: null, parseHTML: (el) => el.getAttribute("data-note-id") },
+    text: { default: "", parseHTML: (el) => el.getAttribute("title") ?? "" }
+  }),
+  parseHTML: () => [{ tag: "sup[data-footnote]" }],
+  renderHTML: ({ node }) => ["sup", { "data-footnote": "", "data-note-id": node.attrs.id ?? void 0, title: node.attrs.text, class: "w100n-fn", contenteditable: "false" }]
+});
+var wikiName = (target) => target.split("#")[0].trim().replace(/\.md$/i, "");
+var WikiLink = Node.create({
+  name: "wikilink",
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  addOptions: () => ({ known: () => true }),
+  addAttributes: () => ({
+    target: { default: "", parseHTML: (el) => el.getAttribute("data-wiki") ?? "" },
+    alias: { default: null, parseHTML: (el) => el.getAttribute("data-alias") }
+  }),
+  parseHTML: () => [{ tag: "span[data-wiki]" }],
+  renderHTML: ({ node }) => [
+    "span",
+    { "data-wiki": node.attrs.target, "data-alias": node.attrs.alias ?? void 0, class: "w100n-wiki", contenteditable: "false" },
+    node.attrs.alias || wikiName(node.attrs.target) || node.attrs.target
+  ],
+  addProseMirrorPlugins() {
+    const known = this.options.known;
+    return [new Plugin2({
+      props: {
+        decorations(state) {
+          const found = [];
+          state.doc.descendants((node, pos) => {
+            if (node.type.name === "wikilink" && !known(node.attrs.target)) found.push(Decoration2.node(pos, pos + node.nodeSize, { class: "is-missing" }));
+          });
+          return DecorationSet2.create(state.doc, found);
+        }
+      }
+    })];
+  }
+});
+var wikiAsk = new PluginKey2("wikiAsk");
+var WikiAsk = Extension2.create({
+  name: "wikiAsk",
+  addProseMirrorPlugins() {
+    return [new Plugin2({
+      key: wikiAsk,
+      state: {
+        init: () => null,
+        apply(tr, _old, _before, state) {
+          const { $from, empty } = state.selection;
+          if (!empty || !$from.parent.isTextblock || $from.parent.type.spec.code) return null;
+          const before = $from.parent.textBetween(0, $from.parentOffset, void 0, "\uFFFC");
+          const m = /\[\[([^[\]\n|\ufffc]*)$/.exec(before);
+          return m ? { from: $from.pos - m[0].length, query: m[1] } : null;
+        }
+      }
+    })];
+  }
+});
+var signs = { bold: "**", italic: "*", strike: "~~", code: "`" };
+var syntax = (text, pos, side) => Decoration2.widget(pos, () => {
+  const el = document.createElement("span");
+  el.className = "w100n-syntax";
+  el.textContent = text;
+  return el;
+}, { side, key: `${text}:${pos}:${side}` });
+var Reveal = Extension2.create({
+  name: "reveal",
+  addProseMirrorPlugins: () => [new Plugin2({
+    props: {
+      decorations(state) {
+        const { $from, empty } = state.selection;
+        if (!empty || !$from.parent.isTextblock) return null;
+        const found = [];
+        const start = $from.start();
+        if ($from.parent.type.name === "heading") found.push(syntax(`${"#".repeat($from.parent.attrs.level)} `, start, -1));
+        const at = $from.parentOffset;
+        for (const [name, sign] of Object.entries(signs)) {
+          let from = -1;
+          let offset = 0;
+          $from.parent.forEach((child) => {
+            const end = offset + child.nodeSize;
+            if (child.marks.some((m) => m.type.name === name)) {
+              if (from < 0) from = offset;
+              if (from <= at && at <= end && (end === $from.parent.content.size || !$from.parent.childAfter(end).node?.marks.some((m) => m.type.name === name))) {
+                found.push(syntax(sign, start + from, -1), syntax(sign, start + end, 1));
+              }
+            } else from = -1;
+            offset = end;
+          });
+        }
+        return DecorationSet2.create(state.doc, found);
+      }
+    }
+  })]
+});
+var EndNotes = Extension2.create({
+  name: "endNotes",
+  addProseMirrorPlugins: () => [new Plugin2({
+    props: {
+      decorations(state) {
+        const notes2 = [];
+        state.doc.descendants((n) => {
+          if (n.type.name === "footnote") notes2.push(n.attrs.text);
+        });
+        if (!notes2.length) return null;
+        return DecorationSet2.create(state.doc, [Decoration2.widget(state.doc.content.size, () => {
+          const list = document.createElement("div");
+          list.className = "w100n-text-endnotes";
+          list.contentEditable = "false";
+          notes2.forEach((text, i) => {
+            const p = list.appendChild(document.createElement("p"));
+            p.appendChild(document.createElement("sup")).textContent = String(i + 1);
+            p.append(text);
+          });
+          return list;
+        }, { key: notes2.join("\n"), side: 1, ignoreSelection: true })]);
+      }
+    }
+  })]
+});
+var headings = (doc, after) => {
+  const found = [];
+  doc.descendants((node, pos) => {
+    if (pos > after && node.type.name === "heading" && node.attrs.level <= 3 && node.textContent.trim()) found.push({ pos, level: node.attrs.level, text: node.textContent.trim() });
+    return !node.isTextblock;
+  });
+  return found;
+};
+function entries(doc, relative, after) {
+  const list = headings(doc, after).map((h) => [h.level, h.text]);
+  const top = relative && list.length ? Math.min(...list.map(([level]) => level)) - 1 : 0;
+  return list.map(([level, text]) => [level - top, text]);
+}
+var Toc = Node.create({
+  name: "toc",
+  group: "block",
+  atom: true,
+  selectable: true,
+  addOptions: () => ({ relative: false, label: "", empty: "" }),
+  addAttributes: () => ({ entries: { default: "[]" }, title: { default: null } }),
+  parseHTML: () => [{ tag: "nav[data-toc]" }],
+  renderHTML() {
+    return ["nav", { "data-toc": "", class: "w100n-text-toc" }];
+  },
+  addNodeView() {
+    return ({ editor, getPos }) => {
+      const dom = document.createElement("nav");
+      dom.className = "w100n-text-toc";
+      dom.contentEditable = "false";
+      const paint2 = () => {
+        const at = getPos() ?? 0;
+        const list = entries(editor.state.doc, this.options.relative, at);
+        const head = document.createElement("b");
+        head.textContent = this.options.label;
+        const items = list.map(([level, text], i) => {
+          const go = document.createElement("button");
+          go.type = "button";
+          go.textContent = text;
+          go.dataset.level = String(level);
+          go.onclick = () => {
+            const hit = headings(editor.state.doc, getPos() ?? 0)[i];
+            if (hit) editor.view.nodeDOM(hit.pos)?.scrollIntoView({ behavior: "smooth", block: "start" });
+          };
+          return go;
+        });
+        const empty = document.createElement("small");
+        empty.textContent = this.options.empty;
+        dom.replaceChildren(head, ...items.length ? items : [empty]);
+      };
+      paint2();
+      return {
+        dom,
+        update: (node) => {
+          if (node.type.name !== "toc") return false;
+          paint2();
+          return true;
+        },
+        ignoreMutation: () => true
+      };
+    };
+  },
+  addProseMirrorPlugins() {
+    const relative = this.options.relative;
+    return [new Plugin2({
+      appendTransaction(trs, _old, state) {
+        if (!trs.some((tr2) => tr2.docChanged && !tr2.getMeta(ySyncPluginKey))) return null;
+        const at = [];
+        state.doc.forEach((node, pos) => {
+          if (node.type.name === "toc") at.push(pos);
+        });
+        if (!at.length) return null;
+        const tr = state.tr;
+        for (const pos of at) {
+          const fresh = JSON.stringify(entries(state.doc, relative, pos));
+          if (state.doc.nodeAt(pos).attrs.entries !== fresh) tr.setNodeAttribute(pos, "entries", fresh);
+        }
+        return tr.docChanged ? tr : null;
+      }
+    })];
+  }
+});
+var revision = (name, tag) => Mark.create({
+  name,
+  inclusive: false,
+  excludes: "insertion deletion",
+  addAttributes: () => ({ id: { default: null }, author: { default: "" }, date: { default: "" } }),
+  parseHTML: () => [{ tag: `${tag}[data-rev]` }],
+  renderHTML: ({ HTMLAttributes }) => [tag, { "data-rev": HTMLAttributes.id, class: "w100n-text-rev", title: HTMLAttributes.author }, 0]
+});
+var seen = /* @__PURE__ */ new WeakMap();
+function changes(doc) {
+  const hit = seen.get(doc);
+  if (hit) return hit;
+  const out = [];
+  doc.descendants((node, pos) => {
+    if (!node.isText) return;
+    const mark = node.marks.find((m) => m.type.name === "insertion" || m.type.name === "deletion");
+    if (!mark) return;
+    const last = out[out.length - 1];
+    if (last && last.id === mark.attrs.id && last.kind === mark.type.name && last.to === pos) Object.assign(last, { text: last.text + node.text, to: pos + node.nodeSize });
+    else out.push({ id: mark.attrs.id, kind: mark.type.name, author: mark.attrs.author, date: mark.attrs.date, text: node.text, from: pos, to: pos + node.nodeSize });
+  });
+  seen.set(doc, out);
+  return out;
+}
+function decide(editor, accept, id) {
+  const { state } = editor;
+  const tr = state.tr;
+  for (const c of changes(state.doc).filter((c2) => !id || c2.id === id).reverse()) {
+    if (c.kind === "insertion" === accept) tr.removeMark(c.from, c.to, state.schema.marks[c.kind].create({ id: c.id, author: c.author, date: c.date }));
+    else tr.delete(c.from, c.to);
+  }
+  if (tr.docChanged) editor.view.dispatch(tr);
+}
+var suggesting = new PluginKey2("w100n-suggest");
+var Suggest = Extension2.create({
+  name: "suggest",
+  addProseMirrorPlugins() {
+    const stamp = (state, kind, from, to) => {
+      const me = suggesting.getState(state).me;
+      const own = [state.doc.resolve(from).nodeBefore, state.doc.resolve(to).nodeAfter].flatMap((n) => n?.marks ?? []).find((m) => m.type.name === kind && m.attrs.author === me);
+      return state.schema.marks[kind].create(own ? own.attrs : { id: Math.random().toString(36).slice(2, 10), author: me, date: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "Z") });
+    };
+    const strike = (tr, state, from, to) => {
+      const parts = [];
+      state.doc.nodesBetween(from, to, (node, pos) => {
+        if (!node.isText) return;
+        const a = Math.max(from, pos), b = Math.min(to, pos + node.nodeSize);
+        if (b > a && !node.marks.some((m) => m.type.name === "deletion")) parts.push({ from: a, to: b, added: node.marks.some((m) => m.type.name === "insertion") });
+      });
+      const mark = stamp(state, "deletion", from, to);
+      for (const p of parts.reverse()) {
+        if (p.added) tr.delete(p.from, p.to);
+        else tr.addMark(p.from, p.to, mark);
+      }
+    };
+    const type = (view, from, to, text) => {
+      const { state } = view;
+      const tr = state.tr;
+      if (to > from) strike(tr, state, from, to);
+      const at = tr.mapping.map(to);
+      const kept = (state.storedMarks ?? state.doc.resolve(from).marks()).filter((m) => m.type.name !== "insertion" && m.type.name !== "deletion");
+      tr.insert(at, state.schema.text(text, [...kept, stamp(state, "insertion", from, to)]));
+      tr.setSelection(TextSelection.create(tr.doc, at + text.length));
+      view.dispatch(tr.scrollIntoView());
+      return true;
+    };
+    return [new Plugin2({
+      key: suggesting,
+      state: {
+        init: () => ({ on: false, me: "" }),
+        apply: (tr, value) => tr.getMeta(suggesting) ?? value
+      },
+      props: {
+        handleTextInput(view, from, to, text) {
+          return suggesting.getState(view.state).on && type(view, from, to, text);
+        },
+        handlePaste(view, _event, slice) {
+          if (!suggesting.getState(view.state).on) return false;
+          const { from, to } = view.state.selection;
+          return type(view, from, to, slice.content.textBetween(0, slice.content.size, "\n"));
+        },
+        handleKeyDown(view, event) {
+          const { state } = view;
+          if (!suggesting.getState(state).on || event.key !== "Backspace" && event.key !== "Delete" || event.metaKey || event.ctrlKey || event.altKey) return false;
+          const { from, to, empty, $from } = state.selection;
+          const back = event.key === "Backspace";
+          let at = from;
+          if (empty) {
+            const skip2 = (pos) => state.doc.resolve(pos)[back ? "nodeBefore" : "nodeAfter"]?.marks.some((m) => m.type.name === "deletion");
+            while (skip2(at)) at += back ? -1 : 1;
+            if (back ? at <= $from.start() : at >= $from.end()) return false;
+          }
+          const tr = state.tr;
+          if (empty) strike(tr, state, back ? at - 1 : at, back ? at : at + 1);
+          else strike(tr, state, from, to);
+          const caret = empty ? tr.mapping.map(back ? at - 1 : at + 1, back ? -1 : 1) : tr.mapping.map(back ? from : to);
+          tr.setSelection(TextSelection.create(tr.doc, caret));
+          view.dispatch(tr.scrollIntoView());
+          return true;
+        }
+      }
+    })];
+  }
+});
+var Note = Mark.create({
+  name: "comment",
+  inclusive: false,
+  excludes: "",
+  addAttributes: () => ({ id: { default: null, renderHTML: (attrs) => ({ "data-comment": attrs.id }) } }),
+  renderHTML: ({ HTMLAttributes }) => ["span", HTMLAttributes, 0]
+});
+var locks = new PluginKey2("w100n-locks");
+var locked = (node) => node.type.name === "paragraph" && String(node.attrs.ref ?? "").startsWith("lock:");
+var scan = (doc) => {
+  const spans = [];
+  doc.descendants((node, pos) => {
+    if (!locked(node)) return true;
+    spans.push({ from: pos, to: pos + node.nodeSize });
+    return false;
+  });
+  return spans;
+};
+var Locks = Extension2.create({
+  name: "locks",
+  addOptions: () => ({ label: "" }),
+  addProseMirrorPlugins() {
+    const shade = (doc, spans) => DecorationSet2.create(doc, spans.map((s) => Decoration2.node(s.from, s.to, { class: "w100n-text-lock", contenteditable: "false", "data-label": this.options.label })));
+    return [new Plugin2({
+      key: locks,
+      state: {
+        init: (_config, state) => {
+          const spans = scan(state.doc);
+          return { spans, set: shade(state.doc, spans) };
+        },
+        apply(tr, value) {
+          if (!tr.docChanged) return value;
+          const fresh = tr.steps.some((step) => {
+            let found = false;
+            step.slice?.content.descendants((node) => {
+              found || (found = locked(node));
+              return !found;
+            });
+            return found;
+          });
+          const spans = fresh ? scan(tr.doc) : value.spans.map((s) => ({ from: tr.mapping.map(s.from, 1), to: tr.mapping.map(s.to, -1) })).filter((s) => s.to > s.from);
+          return { spans, set: spans.length ? shade(tr.doc, spans) : DecorationSet2.empty };
+        }
+      },
+      filterTransaction(tr, state) {
+        let spans = locks.getState(state).spans;
+        if (!spans.length || !tr.docChanged) return true;
+        return tr.mapping.maps.every((map) => {
+          let ok = true;
+          map.forEach((from, to) => {
+            for (const s of spans) if ((from < s.to && to > s.from || from > s.from && from < s.to) && !(from <= s.from && to >= s.to)) ok = false;
+          });
+          spans = spans.map((s) => ({ from: map.map(s.from, 1), to: map.map(s.to, -1) }));
+          return ok;
+        });
+      },
+      props: {
+        decorations: (state) => locks.getState(state).set,
+        handleKeyDown(view, event) {
+          const back = event.key === "Backspace";
+          const { $from, empty } = view.state.selection;
+          if (!back && event.key !== "Delete" || !empty || $from.depth < 1) return false;
+          if (back ? $from.parentOffset !== 0 : $from.parentOffset !== $from.parent.content.size) return false;
+          const at = back ? $from.before() : $from.after();
+          const node = back ? view.state.doc.resolve(at).nodeBefore : view.state.doc.resolve(at).nodeAfter;
+          if (!node || !locked(node)) return false;
+          view.dispatch(view.state.tr.delete(back ? at - node.nodeSize : at, back ? at : at + node.nodeSize));
+          return true;
+        }
+      }
+    })];
+  }
+});
+var paint = (doc, spots, active, pending) => DecorationSet2.create(doc, [
+  ...spots.filter((s) => s.to > s.from).map((s) => Decoration2.inline(s.from, s.to, { class: s.id === active ? "w100n-text-note is-active" : "w100n-text-note", "data-note": s.id })),
+  ...pending && pending.to > pending.from ? [Decoration2.inline(pending.from, pending.to, { class: "w100n-text-note is-active" })] : []
+]);
+var remap = (tr) => {
+  const start = tr.before.content.findDiffStart(tr.doc.content);
+  if (!tr.getMeta(ySyncPluginKey) || start === null) return tr.mapping;
+  let { a, b } = tr.before.content.findDiffEnd(tr.doc.content);
+  if (a < start) [a, b] = [start, b + start - a];
+  if (b < start) [a, b] = [a + start - b, start];
+  return new StepMap([start, a - start, b - start]);
+};
+var Notes = Extension2.create({
+  name: "notes",
+  addProseMirrorPlugins: () => [new Plugin2({
+    key: notes,
+    state: {
+      init: (_config, state) => ({ spots: [], active: null, pending: null, set: DecorationSet2.create(state.doc, []) }),
+      apply(tr, value) {
+        const next = tr.getMeta(notes);
+        if (!next && (!tr.docChanged || !value.spots.length && !value.pending)) return value;
+        const by = remap(tr);
+        const map = (r) => ({ ...r, from: by.map(r.from, 1), to: by.map(r.to, -1) });
+        const merged = { ...value, spots: value.spots.map(map), pending: value.pending && map(value.pending), ...next };
+        return { ...merged, set: paint(tr.doc, merged.spots, merged.active, merged.pending) };
+      }
+    },
+    props: { decorations: (state) => notes.getState(state).set }
+  })]
+});
+var script = (name, tag, other) => Mark.create({
+  name,
+  excludes: other,
+  parseHTML: () => [{ tag }, { style: `vertical-align=${name === "superscript" ? "super" : "sub"}` }],
+  renderHTML: () => [tag, 0],
+  addKeyboardShortcuts() {
+    return { [name === "superscript" ? "Mod-." : "Mod-,"]: () => this.editor.commands.toggleMark(name) };
+  }
+});
+function kit(kind, t, live, wiki) {
+  return [
+    StarterKit.configure({ trailingNode: false, link: { openOnClick: false, autolink: true, defaultProtocol: "https" }, dropcursor: { color: "#8b5cf6", width: 2 }, ...live ? { undoRedo: false } : {} }),
+    TaskList,
+    TaskItem.configure({ nested: true, a11y: { checkboxLabel: (node) => node.textContent || t.tasks } }),
+    TableKit.configure({ table: { resizable: true, cellMinWidth: 32 } }),
+    Cells,
+    Search,
+    Image.extend({
+      addAttributes() {
+        return { ...this.parent?.(), wrap: { default: null, parseHTML: (el) => el.dataset.wrap ?? null, renderHTML: (attrs) => attrs.wrap ? { "data-wrap": attrs.wrap } : {} } };
+      }
+    }).configure({ inline: true, allowBase64: true, resize: { enabled: true, directions: ["top-left", "top-right", "bottom-left", "bottom-right"], minWidth: 24, minHeight: 24, alwaysPreserveAspectRatio: true } }),
+    Highlight.configure({ multicolor: true }),
+    TextStyle,
+    Color,
+    FontSize,
+    FontFamily,
+    script("superscript", "sup", "subscript"),
+    script("subscript", "sub", "superscript"),
+    Blocks,
+    PageBreak.configure({ label: t.pageBreak }),
+    Toc.configure({ relative: kind === "markdown", label: t.toc, empty: t.tocEmpty }),
+    Note,
+    Notes,
+    Formula,
+    Footnote,
+    EndNotes,
+    WikiLink.configure({ known: wiki?.known ?? (() => true) }),
+    ...kind === "markdown" && wiki ? [WikiAsk, Reveal] : [],
+    ...kind === "docx" ? [Pager, Locks.configure({ label: t.locked }), revision("insertion", "ins"), revision("deletion", "del"), Suggest] : [],
+    ...live ? [Collaboration.configure({ document: live.doc }), CollaborationCaret.configure({ provider: live.link, user: live.user })] : []
+  ];
+}
+var textblocks = (editor, change) => editor.chain().focus().command(({ tr, state }) => {
+  state.doc.nodesBetween(state.selection.from, state.selection.to, (node, pos) => {
+    if (!node.isTextblock) return true;
+    for (const [key, value] of Object.entries(change(node.attrs))) if (node.attrs[key] !== value) tr.setNodeAttribute(pos, key, value);
+    return false;
+  });
+  return true;
+}).run();
+var align = (editor, value) => textblocks(editor, () => ({ align: value === "left" ? null : value }));
+var spacing = (editor, change) => textblocks(editor, () => change);
+var indent = (editor, step) => {
+  const type = editor.isActive("taskItem") ? "taskItem" : editor.isActive("listItem") ? "listItem" : null;
+  if (type) return step > 0 ? editor.chain().focus().sinkListItem(type).run() : editor.chain().focus().liftListItem(type).run();
+  return textblocks(editor, (attrs) => ({ indent: Math.min(8, Math.max(0, Number(attrs.indent) + step)) }));
+};
+var clear = (editor) => {
+  const chain = editor.chain().focus();
+  for (const mark of ["bold", "italic", "underline", "strike", "code", "highlight", "textStyle"]) chain.unsetMark(mark);
+  chain.run();
+  return textblocks(editor, () => ({ align: null, indent: 0 }));
+};
+function locate(doc, list) {
+  if (!list.length) return [];
+  const marked = /* @__PURE__ */ new Map();
+  doc.descendants((node, pos) => {
+    if (!node.isText) return;
+    for (const mark of node.marks) {
+      if (mark.type.name !== "comment") continue;
+      const found = marked.get(mark.attrs.id);
+      if (found) Object.assign(found, { to: pos + node.nodeSize, text: found.text + node.text });
+      else marked.set(mark.attrs.id, { from: pos, to: pos + node.nodeSize, text: node.text });
+    }
+  });
+  const claimed = /* @__PURE__ */ new Set();
+  const search = (quote) => {
+    const line = quote.split("\n").find((part) => part.trim())?.trim();
+    let hit = null;
+    if (line) doc.descendants((node, pos) => {
+      if (hit) return false;
+      if (!node.isTextblock) return true;
+      const at = node.textBetween(0, node.content.size, void 0, "\uFFFC").indexOf(line);
+      if (at >= 0) hit = { from: pos + 1 + at, to: pos + 1 + at + line.length };
+      return false;
+    });
+    return hit;
+  };
+  return list.flatMap((c) => {
+    const own = [c.anchor, c.id].find((id) => id && marked.has(id));
+    let range = own ? marked.get(own) : void 0;
+    if (!range) {
+      const twin = [...marked].find(([id, m]) => !claimed.has(id) && m.text === c.quote);
+      if (twin) {
+        claimed.add(twin[0]);
+        range = twin[1];
+      }
+    }
+    range ?? (range = search(c.quote));
+    return range ? [{ id: c.id, from: range.from, to: range.to }] : [];
+  });
+}
 
 // src/text.ts
 var en = {
+  elsewhere: "Other",
+  wikiCreate: "Create \u201C{name}\u201D",
+  wikiNew: "new note",
+  wikiKeys: "\u2191\u2193 pick \xB7 \u21B5 link \xB7 | alias",
+  tree: "Tree",
+  cards: "Cards",
+  openNote: "Open note",
+  findNote: "Type a note name",
+  createNote: "Create note \u201C{name}\u201D",
+  noNote: "No notes match",
+  keysOpen: "\u2191\u2193 move \xB7 \u21B5 open \xB7 esc close",
+  commands: "Commands",
+  newNote: "New note",
+  searchAll: "Search in all notes",
+  showOutline: "Show outline",
+  showLinks: "Show backlinks",
+  showVersions: "Show versions",
+  showComments: "Show comments",
+  keysRun: "\u2191\u2193 move \xB7 \u21B5 run \xB7 esc close",
+  links: "Links",
+  linked: "Linked mentions",
+  unlinked: "Unlinked mentions",
+  noBacklinks: "Nothing links here yet",
   documents: "Documents",
   hint: "Files of your projects: read, edit and comment in one place",
   loose: "Without a folder",
@@ -355,6 +1218,29 @@ var en = {
   uploadFailed: "Could not upload the file"
 };
 var pl = {
+  elsewhere: "Inne",
+  wikiCreate: "Utw\xF3rz \u201E{name}\u201D",
+  wikiNew: "nowa notatka",
+  wikiKeys: "\u2191\u2193 wyb\xF3r \xB7 \u21B5 link \xB7 | alias",
+  tree: "Drzewo",
+  cards: "Karty",
+  openNote: "Otw\xF3rz notatk\u0119",
+  findNote: "Wpisz nazw\u0119 notatki",
+  createNote: "Utw\xF3rz notatk\u0119 \u201E{name}\u201D",
+  noNote: "Brak pasuj\u0105cych notatek",
+  keysOpen: "\u2191\u2193 ruch \xB7 \u21B5 otw\xF3rz \xB7 esc zamknij",
+  commands: "Polecenia",
+  newNote: "Nowa notatka",
+  searchAll: "Szukaj we wszystkich notatkach",
+  showOutline: "Poka\u017C spis",
+  showLinks: "Poka\u017C odno\u015Bniki",
+  showVersions: "Poka\u017C wersje",
+  showComments: "Poka\u017C komentarze",
+  keysRun: "\u2191\u2193 ruch \xB7 \u21B5 uruchom \xB7 esc zamknij",
+  links: "Odno\u015Bniki",
+  linked: "Linki do tej notatki",
+  unlinked: "Wzmianki bez linku",
+  noBacklinks: "Nic tu jeszcze nie linkuje",
   documents: "Dokumenty",
   hint: "Pliki Twoich projekt\xF3w: czytaj, edytuj i komentuj w jednym miejscu",
   loose: "Bez folderu",
@@ -708,6 +1594,29 @@ var pl = {
   uploadFailed: "Nie uda\u0142o si\u0119 wgra\u0107 pliku"
 };
 var uk = {
+  elsewhere: "\u0406\u043D\u0448\u0435",
+  wikiCreate: "\u0421\u0442\u0432\u043E\u0440\u0438\u0442\u0438 \xAB{name}\xBB",
+  wikiNew: "\u043D\u043E\u0432\u0430 \u043D\u043E\u0442\u0430\u0442\u043A\u0430",
+  wikiKeys: "\u2191\u2193 \u0432\u0438\u0431\u0456\u0440 \xB7 \u21B5 \u043F\u043E\u0441\u0438\u043B\u0430\u043D\u043D\u044F \xB7 | \u043F\u0456\u0434\u043F\u0438\u0441",
+  tree: "\u0414\u0435\u0440\u0435\u0432\u043E",
+  cards: "\u041A\u0430\u0440\u0442\u043A\u0438",
+  openNote: "\u0412\u0456\u0434\u043A\u0440\u0438\u0442\u0438 \u043D\u043E\u0442\u0430\u0442\u043A\u0443",
+  findNote: "\u0412\u0432\u0435\u0434\u0456\u0442\u044C \u043D\u0430\u0437\u0432\u0443 \u043D\u043E\u0442\u0430\u0442\u043A\u0438",
+  createNote: "\u0421\u0442\u0432\u043E\u0440\u0438\u0442\u0438 \u043D\u043E\u0442\u0430\u0442\u043A\u0443 \xAB{name}\xBB",
+  noNote: "\u041D\u0435\u043C\u0430\u0454 \u0442\u0430\u043A\u0438\u0445 \u043D\u043E\u0442\u0430\u0442\u043E\u043A",
+  keysOpen: "\u2191\u2193 \u0440\u0443\u0445 \xB7 \u21B5 \u0432\u0456\u0434\u043A\u0440\u0438\u0442\u0438 \xB7 esc \u0437\u0430\u043A\u0440\u0438\u0442\u0438",
+  commands: "\u041A\u043E\u043C\u0430\u043D\u0434\u0438",
+  newNote: "\u041D\u043E\u0432\u0430 \u043D\u043E\u0442\u0430\u0442\u043A\u0430",
+  searchAll: "\u0428\u0443\u043A\u0430\u0442\u0438 \u0432 \u0443\u0441\u0456\u0445 \u043D\u043E\u0442\u0430\u0442\u043A\u0430\u0445",
+  showOutline: "\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u0438 \u0437\u043C\u0456\u0441\u0442",
+  showLinks: "\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u0438 \u043F\u043E\u0441\u0438\u043B\u0430\u043D\u043D\u044F",
+  showVersions: "\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u0438 \u0432\u0435\u0440\u0441\u0456\u0457",
+  showComments: "\u041F\u043E\u043A\u0430\u0437\u0430\u0442\u0438 \u043A\u043E\u043C\u0435\u043D\u0442\u0430\u0440\u0456",
+  keysRun: "\u2191\u2193 \u0440\u0443\u0445 \xB7 \u21B5 \u0432\u0438\u043A\u043E\u043D\u0430\u0442\u0438 \xB7 esc \u0437\u0430\u043A\u0440\u0438\u0442\u0438",
+  links: "\u041F\u043E\u0441\u0438\u043B\u0430\u043D\u043D\u044F",
+  linked: "\u041F\u043E\u0441\u0438\u043B\u0430\u044E\u0442\u044C\u0441\u044F \u0441\u044E\u0434\u0438",
+  unlinked: "\u0417\u0433\u0430\u0434\u043A\u0438 \u0431\u0435\u0437 \u043F\u043E\u0441\u0438\u043B\u0430\u043D\u043D\u044F",
+  noBacklinks: "\u0421\u044E\u0434\u0438 \u0449\u0435 \u043D\u0456\u0449\u043E \u043D\u0435 \u043F\u043E\u0441\u0438\u043B\u0430\u0454\u0442\u044C\u0441\u044F",
   documents: "\u0414\u043E\u043A\u0443\u043C\u0435\u043D\u0442\u0438",
   hint: "\u0424\u0430\u0439\u043B\u0438 \u0432\u0430\u0448\u0438\u0445 \u043F\u0440\u043E\u0454\u043A\u0442\u0456\u0432: \u0447\u0438\u0442\u0430\u0439\u0442\u0435, \u0440\u0435\u0434\u0430\u0433\u0443\u0439\u0442\u0435 \u0439 \u043A\u043E\u043C\u0435\u043D\u0442\u0443\u0439\u0442\u0435 \u0432 \u043E\u0434\u043D\u043E\u043C\u0443 \u043C\u0456\u0441\u0446\u0456",
   loose: "\u0411\u0435\u0437 \u0442\u0435\u043A\u0438",
@@ -1063,6 +1972,25 @@ var uk = {
 var texts = { en, pl, uk };
 
 export {
+  a4,
+  letter,
+  paging,
+  notes,
+  searching,
+  replace,
+  cleanPaste,
+  wikiName,
+  wikiAsk,
+  entries,
+  changes,
+  decide,
+  suggesting,
+  kit,
+  align,
+  spacing,
+  indent,
+  clear,
+  locate,
   texts
 };
-//# sourceMappingURL=chunk-VNXZVOPN.js.map
+//# sourceMappingURL=chunk-B7C6NBBQ.js.map