@w100n/documents 0.4.0 → 0.10.0

package/dist/chunk-CE3AADY6.js

@@ -0,0 +1,3447 @@
+'use client';
+import {
+  attr,
+  attrs,
+  entry,
+  escape,
+  inflate,
+  parse,
+  readDocx,
+  texts,
+  unescape,
+  unzip,
+  writeDocx,
+  zip
+} from "./chunk-TNSN4ZQ5.js";
+import {
+  a1,
+  box,
+  boxes,
+  cell,
+  plain,
+  quoted,
+  remapped,
+  renamed,
+  shifted,
+  span,
+  squeeze,
+  stored
+} from "./chunk-ISOOUYLI.js";
+
+// src/collab.ts
+import { getSchema } from "@tiptap/core";
+import { Transform } from "@tiptap/pm/transform";
+import { prosemirrorJSONToYXmlFragment, updateYFragment, yXmlFragmentToProseMirrorRootNode } from "@tiptap/y-tiptap";
+import * as Y2 from "yjs";
+
+// package.json
+var version = "0.10.0";
+
+// 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";
+
+// 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 = [];
+  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;
+    if (node.type.name === "pageBreak") {
+      gaps.push({ pos: offset + node.nodeSize, height: start + room - end + bottom + 24 + top, page: gaps.length + 1 });
+      start = end;
+    } else if (end > start + room && y > start) {
+      gaps.push({ pos: offset, height: start + room - y + bottom + 24 + top, page: gaps.length + 1 });
+      start = y;
+    }
+    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 });
+  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 }),
+      apply(tr, value2) {
+        const next = tr.getMeta(paging);
+        return { set: next?.set ?? value2.set.map(tr.mapping, tr.doc), page: next?.page ?? value2.page };
+      }
+    },
+    props: { decorations: (state) => paging.getState(state).set },
+    view(view) {
+      let timer = 0;
+      let sig = "";
+      const run = () => {
+        if (!view.dom.isConnected) return;
+        const gaps = measure(view);
+        const next = gaps.map((g) => `${g.pos}:${g.height}`).join();
+        if (next === sig) return;
+        sig = next;
+        const set = DecorationSet.create(view.state.doc, 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";
+          return el;
+        }, { key: `${g.pos}:${g.height}:${g.page}`, 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) => {
+          if (paging.getState(next.state).page !== paging.getState(prev).page) later(0);
+          else if (next.state.doc !== prev.doc) later(400);
+        },
+        destroy: () => {
+          clearTimeout(timer);
+          watch?.disconnect();
+        }
+      };
+    }
+  })]
+});
+
+// src/editor/extensions.ts
+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 Blocks = Extension2.create({
+  name: "blocks",
+  addGlobalAttributes: () => [{
+    types: blocks,
+    attributes: {
+      align: { default: null, parseHTML: (el) => el.style.textAlign || null, renderHTML: (attrs2) => attrs2.align ? { style: `text-align: ${attrs2.align}` } : {} },
+      indent: { default: 0, parseHTML: (el) => Number(el.dataset.indent) || 0, renderHTML: (attrs2) => attrs2.indent ? { "data-indent": attrs2.indent, style: `margin-left: ${attrs2.indent * 0.5}in` } : {} },
+      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 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, relative2, after) {
+  const list = headings(doc, after).map((h) => [h.level, h.text]);
+  const top = relative2 && 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 relative2 = 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 fresh2 = JSON.stringify(entries(state.doc, relative2, pos));
+          if (state.doc.nodeAt(pos).attrs.entries !== fresh2) tr.setNodeAttribute(pos, "entries", fresh2);
+        }
+        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 parts2 = [];
+      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")) parts2.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 parts2.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, value2) => tr.getMeta(suggesting) ?? value2
+      },
+      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: (attrs2) => ({ "data-comment": attrs2.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, value2) {
+          if (!tr.docChanged) return value2;
+          const fresh2 = tr.steps.some((step) => {
+            let found = false;
+            step.slice?.content.descendants((node) => {
+              found || (found = locked(node));
+              return !found;
+            });
+            return found;
+          });
+          const spans = fresh2 ? scan(tr.doc) : value2.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, pending2) => 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 })),
+  ...pending2 && pending2.to > pending2.from ? [Decoration2.inline(pending2.from, pending2.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, value2) {
+        const next = tr.getMeta(notes);
+        if (!next && (!tr.docChanged || !value2.spots.length && !value2.pending)) return value2;
+        const by = remap(tr);
+        const map = (r) => ({ ...r, from: by.map(r.from, 1), to: by.map(r.to, -1) });
+        const merged = { ...value2, spots: value2.spots.map(map), pending: value2.pending && map(value2.pending), ...next };
+        return { ...merged, set: paint(tr.doc, merged.spots, merged.active, merged.pending) };
+      }
+    },
+    props: { decorations: (state) => notes.getState(state).set }
+  })]
+});
+function kit(kind, t, live) {
+  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: false } }),
+    Image.configure({ inline: true, allowBase64: true }),
+    Highlight.configure({ multicolor: true }),
+    TextStyle,
+    Color,
+    FontSize,
+    FontFamily,
+    Blocks,
+    PageBreak.configure({ label: t.pageBreak }),
+    Toc.configure({ relative: kind === "markdown", label: t.toc, empty: t.tocEmpty }),
+    Note,
+    Notes,
+    ...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 [key2, value2] of Object.entries(change(node.attrs))) if (node.attrs[key2] !== value2) tr.setNodeAttribute(pos, key2, value2);
+    return false;
+  });
+  return true;
+}).run();
+var align = (editor, value2) => textblocks(editor, () => ({ align: value2 === "left" ? null : value2 }));
+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, (attrs2) => ({ indent: Math.min(8, Math.max(0, Number(attrs2.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 marked2 = /* @__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 = marked2.get(mark.attrs.id);
+      if (found) Object.assign(found, { to: pos + node.nodeSize, text: found.text + node.text });
+      else marked2.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 && marked2.has(id));
+    let range = own ? marked2.get(own) : void 0;
+    if (!range) {
+      const twin = [...marked2].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/editor/markdown.ts
+import { marked } from "marked";
+import { MarkdownSerializer } from "prosemirror-markdown";
+var tags = { u: "underline", ins: "underline", mark: "highlight", s: "strike", del: "strike", b: "bold", strong: "bold", i: "italic", em: "italic" };
+var decode = (text) => text.includes("&") ? new DOMParser().parseFromString(`<p>${text.replace(/</g, "&lt;")}</p>`, "text/html").body.textContent ?? text : text;
+var unique = (marks) => [...new Map(marks.map((m) => [m.type, m])).values()];
+function inline(tokens = [], outer = []) {
+  const out = [];
+  let open = [];
+  const marks = () => unique([...outer, ...open]);
+  const text = (value2, extra = []) => {
+    const set = unique([...marks(), ...extra]);
+    const clean = out[out.length - 1]?.type === "hardBreak" ? value2.replace(/^\n/, "") : value2;
+    if (clean) out.push({ type: "text", text: clean, ...set.length ? { marks: set } : {} });
+  };
+  const wrap = (children, mark) => out.push(...inline(children, [...marks(), mark]));
+  for (const token of tokens) {
+    if (token.type === "text") {
+      if (token.tokens) out.push(...inline(token.tokens, marks()));
+      else text(decode(token.text));
+    } else if (token.type === "escape") text(decode(token.text));
+    else if (token.type === "strong") wrap(token.tokens, { type: "bold" });
+    else if (token.type === "em") wrap(token.tokens, { type: "italic" });
+    else if (token.type === "del") wrap(token.tokens, { type: "strike" });
+    else if (token.type === "codespan") text(token.text, [{ type: "code" }]);
+    else if (token.type === "br") out.push({ type: "hardBreak" });
+    else if (token.type === "link") wrap(token.tokens, { type: "link", attrs: { href: token.href } });
+    else if (token.type === "image") out.push({ type: "image", attrs: { src: token.href, alt: token.text || null, title: token.title || null }, ...marks().length ? { marks: marks() } : {} });
+    else if (token.type === "html") {
+      const tag = /^<(\/?)([a-z]+)\s*\/?>$/i.exec(token.raw.trim());
+      const name = tag?.[2].toLowerCase() ?? "";
+      if (name === "br") out.push({ type: "hardBreak" });
+      else if (!tags[name]) text(token.raw);
+      else open = tag[1] ? open.filter((m) => m.type !== tags[name]) : [...open, { type: tags[name] }];
+    } else if (token.type !== "checkbox") text(token.raw);
+  }
+  return out;
+}
+var fill = (content) => content.length ? content : [{ type: "paragraph" }];
+function block(token, hints) {
+  const ref = (hint) => {
+    const id = `md${Object.keys(hints).length + 1}`;
+    hints[id] = hint;
+    return id;
+  };
+  switch (token.type) {
+    case "space":
+    case "def":
+    case "checkbox":
+      return [];
+    case "heading":
+      return [{ type: "heading", attrs: { level: token.depth }, content: inline(token.tokens) }];
+    case "paragraph":
+    case "text":
+      return [{ type: "paragraph", content: token.tokens ? inline(token.tokens) : inline([{ type: "text", raw: token.text, text: token.text }]) }];
+    case "blockquote":
+      return [{ type: "blockquote", content: fill(token.tokens.flatMap((t) => block(t, hints))) }];
+    case "code": {
+      const fence = /^ {0,3}(`{3,}|~{3,})/.exec(token.raw)?.[1][0];
+      return [{ type: "codeBlock", attrs: { language: token.lang || null, ref: fence ? ref({ fence: fence.repeat(3) }) : null }, content: token.text ? [{ type: "text", text: token.text }] : [] }];
+    }
+    case "html":
+      return [{ type: "codeBlock", attrs: { language: "html" }, content: [{ type: "text", text: token.raw.replace(/\n+$/, "") }] }];
+    case "hr":
+      return [{ type: "horizontalRule" }];
+    case "list": {
+      const list = token;
+      const tasks = list.items.every((entry2) => entry2.task);
+      const marker = /^\s*(?:([-*+])|\d+([.)]))/.exec(list.raw);
+      const id = ref({ bullet: marker?.[1], delim: marker?.[2], loose: list.loose });
+      return [{
+        type: tasks ? "taskList" : list.ordered ? "orderedList" : "bulletList",
+        attrs: list.ordered && !tasks ? { start: list.start === "" ? 1 : Number(list.start), ref: id } : { ref: id },
+        content: list.items.map((entry2) => {
+          const content = fill(entry2.tokens.flatMap((t) => block(t, hints)));
+          if (!tasks && entry2.task) content[0].content = [{ type: "text", text: entry2.checked ? "[x] " : "[ ] " }, ...content[0].content ?? []];
+          return tasks ? { type: "taskItem", attrs: { checked: !!entry2.checked }, content } : { type: "listItem", content };
+        })
+      }];
+    }
+    case "table": {
+      const table = token;
+      const cell2 = (type) => (c, i) => ({ type, attrs: { align: table.align[i] }, content: [{ type: "paragraph", content: inline(c.tokens) }] });
+      return [{ type: "table", content: [
+        { type: "tableRow", content: table.header.map(cell2("tableHeader")) },
+        ...table.rows.map((row2) => ({ type: "tableRow", content: row2.map(cell2("tableCell")) }))
+      ] }];
+    }
+    default:
+      return [{ type: "paragraph", content: inline([{ type: "text", raw: token.raw, text: token.raw }]) }];
+  }
+}
+var opens = /^\s*<!--\s*toc\s*-->\s*$/i;
+var shuts = /^\s*<!--\s*\/toc\s*-->\s*$/i;
+var row = /^(\s*)[-*+]\s+\[((?:\\.|[^\]\\])*)\]\(#[^)\s]*\)\s*$/;
+function contents(tokens, i) {
+  if (tokens[i].type !== "html" || !opens.test(tokens[i].raw)) return null;
+  let j = i + 1;
+  const skip2 = () => {
+    while (tokens[j]?.type === "space") j++;
+  };
+  skip2();
+  const list = tokens[j]?.type === "list" ? tokens[j++] : null;
+  skip2();
+  if (tokens[j]?.type !== "html" || !shuts.test(tokens[j].raw)) return null;
+  const rows = list ? list.raw.split("\n").filter((line) => line.trim()).map((line) => row.exec(line)) : [];
+  if (rows.some((r) => !r)) return null;
+  const steps = [...new Set(rows.map((r) => r[1].length))].sort((a, b) => a - b);
+  return { end: j, entries: rows.map((r) => [steps.indexOf(r[1].length) + 1, r[2].replace(/\\(.)/g, "$1")]) };
+}
+var slug = (text, seen2) => {
+  const base = text.toLowerCase().replace(/[^\p{L}\p{N}\s_-]/gu, "").trim().replace(/\s/g, "-");
+  const n = seen2.get(base) ?? 0;
+  seen2.set(base, n + 1);
+  return n ? `${base}-${n}` : base;
+};
+function sniff(tokens) {
+  const style = { bullet: "-", delim: ".", em: "*", strong: "**", fence: "```", br: "\\\n", loose: false };
+  const seen2 = /* @__PURE__ */ new Set();
+  const note = (key2, value2) => {
+    if (seen2.has(key2)) return;
+    seen2.add(key2);
+    style[key2] = value2;
+  };
+  let loose = 0;
+  marked.walkTokens(tokens, (token) => {
+    if (token.type === "list") {
+      const marker = /^\s*(?:([-*+])|\d+([.)]))/.exec(token.raw);
+      if (token.ordered) note("delim", marker?.[2] ?? ".");
+      else note("bullet", marker?.[1] ?? "-");
+      loose += token.loose ? 1 : -1;
+    } else if (token.type === "em") note("em", token.raw[0]);
+    else if (token.type === "strong") note("strong", token.raw.slice(0, 2));
+    else if (token.type === "code" && /^ {0,3}(```|~~~)/.test(token.raw)) note("fence", token.raw.trimStart().slice(0, 3));
+    else if (token.type === "br" && token.raw !== "<br>") note("br", token.raw.startsWith("\\") ? "\\\n" : "  \n");
+  });
+  style.loose = loose > 0;
+  return style;
+}
+function fromMarkdown(source) {
+  const bom = source.startsWith("\uFEFF");
+  const crlf = source.includes("\r\n");
+  const tokens = marked.lexer(source.slice(bom ? 1 : 0).replace(/\r\n?/g, "\n"));
+  const hints = {};
+  const content = [];
+  const raws = [];
+  let head = "";
+  let gap = "";
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const toc = contents(tokens, i);
+    const made2 = toc ? [{ type: "toc", attrs: { entries: JSON.stringify(toc.entries) } }] : block(token, hints);
+    if (!made2.length) {
+      gap += token.raw;
+      continue;
+    }
+    if (raws.length) raws[raws.length - 1] += gap;
+    else head = gap;
+    gap = "";
+    content.push(...made2);
+    raws.push(toc ? tokens.slice(i, toc.end + 1).map((t) => t.raw).join("") : token.raw);
+    if (toc) i = toc.end;
+  }
+  if (!content.length) {
+    content.push({ type: "paragraph" });
+    raws.push("");
+    head = "";
+  }
+  return { doc: { type: "doc", content }, raws, head, tail: gap, style: sniff(tokens), hints, crlf, bom };
+}
+var track = ({ doc: _json, ...parsed }, doc) => {
+  const nodes = [];
+  doc.forEach((node) => nodes.push(node));
+  return nodes.length === parsed.raws.length ? { ...parsed, nodes } : { ...parsed, nodes: [], raws: [], head: "", tail: "\n" };
+};
+var ticks = (node, side) => {
+  const len = Math.max(0, ...(node.isText ? node.text.match(/`+/g) ?? [] : []).map((run) => run.length));
+  return len ? side > 0 ? ` ${"`".repeat(len + 1)}` : `${"`".repeat(len + 1)} ` : "`";
+};
+var plain2 = (mark, parent, index) => {
+  const node = parent.child(index);
+  const href = mark.attrs.href;
+  if (!node.isText || node.marks.length !== 1 || index + 1 < parent.childCount && mark.isInSet(parent.child(index + 1).marks)) return null;
+  const text = node.text;
+  if (text !== href && `mailto:${text}` !== href && !(text.startsWith("www.") && `http://${text}` === href)) return null;
+  const before = index ? parent.child(index - 1) : null;
+  const after = index + 1 < parent.childCount ? parent.child(index + 1) : null;
+  const left = before ? before.isText ? before.text.slice(-1) : "x" : "";
+  const right = after ? after.isText ? after.text : "x" : "";
+  return /^[\s(*_~]?$/.test(left) && /^([\s)]|[.,:;!?]+(\s|$)|$)/.test(right) ? "bare" : text === href || href.startsWith("mailto:") ? "angle" : null;
+};
+function serializer(style, hints, before, cell2 = false) {
+  let form = null;
+  const hint = (node) => hints[node.attrs.ref] ?? {};
+  const run = (parent, index, types) => {
+    let n = 0;
+    for (let i = index - 1; i >= 0 && types.includes(parent.child(i).type.name); i--) n++;
+    if (!index && before && types.includes(before.type.name)) n++;
+    return n % 2;
+  };
+  const tight = (state, node, render) => {
+    const deep = node.content.content.some((entry2) => entry2.content.content.filter((child) => !child.type.name.endsWith("List")).length > 1);
+    const was = state.options.tightLists;
+    state.options.tightLists = !deep && !(hint(node).loose ?? style.loose);
+    render();
+    state.options.tightLists = was;
+  };
+  const list = (state, node, parent, index) => {
+    const bullet = hint(node).bullet ?? (run(parent, index, ["bulletList", "taskList"]) ? style.bullet === "-" ? "*" : "-" : style.bullet);
+    tight(state, node, () => state.renderList(node, "  ", () => `${bullet} `));
+  };
+  const blank2 = { open: "", close: "", mixable: true };
+  const wrap = (open, close = open) => ({ open, close, mixable: true, expelEnclosingWhitespace: true });
+  return new MarkdownSerializer({
+    paragraph(state, node) {
+      state.renderInline(node);
+      state.closeBlock(node);
+    },
+    heading(state, node) {
+      state.write(`${"#".repeat(node.attrs.level)} `);
+      state.renderInline(node, false);
+      state.closeBlock(node);
+    },
+    blockquote(state, node) {
+      state.wrapBlock("> ", null, node, () => state.renderContent(node));
+    },
+    codeBlock(state, node) {
+      const mark = (hint(node).fence ?? style.fence)[0];
+      const longest = Math.max(2, ...(node.textContent.match(new RegExp(`${mark}{3,}`, "g")) ?? []).map((r) => r.length));
+      const fence = mark.repeat(longest + 1);
+      state.write(`${fence}${node.attrs.language ?? ""}
+`);
+      state.text(node.textContent, false);
+      state.ensureNewLine();
+      state.write(fence);
+      state.closeBlock(node);
+    },
+    horizontalRule(state, node) {
+      state.write("---");
+      state.closeBlock(node);
+    },
+    pageBreak(state, node) {
+      state.closeBlock(node);
+    },
+    toc(state, node) {
+      const seen2 = /* @__PURE__ */ new Map();
+      const lines2 = JSON.parse(node.attrs.entries).map(([level, text]) => `${"  ".repeat(level - 1)}${style.bullet} [${text.replace(/[[\]\\]/g, "\\$&")}](#${slug(text, seen2)})
+`);
+      state.write(`<!-- toc -->
+${lines2.join("")}<!-- /toc -->`);
+      state.closeBlock(node);
+    },
+    bulletList: list,
+    taskList: list,
+    orderedList(state, node, parent, index) {
+      const start = node.attrs.start ?? 1;
+      const delim = hint(node).delim ?? (run(parent, index, ["orderedList"]) ? style.delim === "." ? ")" : "." : style.delim);
+      const width = String(start + node.childCount - 1).length;
+      tight(state, node, () => state.renderList(node, " ".repeat(width + 2), (i) => `${start + i}${delim} `));
+    },
+    listItem(state, node) {
+      state.renderContent(node);
+    },
+    taskItem(state, node) {
+      state.write(node.attrs.checked ? "[x] " : "[ ] ");
+      state.renderContent(node);
+    },
+    table(state, node) {
+      const rows = [];
+      const aligns = [];
+      node.forEach((row2, _, r) => {
+        const cells = [];
+        row2.forEach((c) => {
+          const span2 = c.attrs.colspan || 1;
+          const text = [];
+          c.forEach((child) => text.push(serializer(style, hints, null, true).serialize(c.type.schema.topNodeType.create(null, child)).replace(/\n+/g, " ")));
+          if (!r) aligns.push(c.attrs.align, ...Array(span2 - 1).fill(null));
+          cells.push(text.join("<br>").replace(/\|/g, "\\|"), ...Array(span2 - 1).fill(""));
+        });
+        rows.push(cells);
+      });
+      const width = Math.max(...rows.map((r) => r.length));
+      const line = (cells) => `| ${[...cells, ...Array(width - cells.length).fill("")].join(" | ")} |`;
+      const rule = Array.from({ length: width }, (_, i) => ({ left: ":---", center: ":---:", right: "---:" })[aligns[i] ?? ""] ?? "---");
+      [line(rows[0]), `| ${rule.join(" | ")} |`, ...rows.slice(1).map(line)].forEach((text, i) => {
+        if (i) state.ensureNewLine();
+        state.write(text);
+      });
+      state.closeBlock(node);
+    },
+    image(state, node) {
+      const src = String(node.attrs.src ?? "");
+      const title = node.attrs.title ? ` "${String(node.attrs.title).replace(/"/g, '\\"')}"` : "";
+      state.write(`![${state.esc(String(node.attrs.alt ?? ""))}](${/\s/.test(src) ? `<${src}>` : src.replace(/[()]/g, "\\$&")}${title})`);
+    },
+    hardBreak(state, node, parent, index) {
+      for (let i = index + 1; i < parent.childCount; i++) {
+        if (parent.child(i).type === node.type) continue;
+        state.write(cell2 ? "<br>" : style.br);
+        return;
+      }
+    },
+    text(state, node) {
+      state.text(node.text, !state.inAutolink);
+    }
+  }, {
+    italic: wrap(style.em),
+    bold: wrap(style.strong),
+    strike: wrap("~~"),
+    underline: wrap("<u>", "</u>"),
+    highlight: wrap("<mark>", "</mark>"),
+    textStyle: blank2,
+    comment: blank2,
+    link: {
+      open(state, mark, parent, index) {
+        form = plain2(mark, parent, index);
+        state.inAutolink = !!form;
+        return form === "bare" ? "" : form === "angle" ? "<" : "[";
+      },
+      close(state, mark) {
+        state.inAutolink = void 0;
+        const was = form;
+        form = null;
+        return was === "bare" ? "" : was === "angle" ? ">" : `](${String(mark.attrs.href).replace(/[()"]/g, "\\$&")})`;
+      },
+      mixable: true
+    },
+    code: { open: (_s, _m, parent, index) => ticks(parent.child(index), -1), close: (_s, _m, parent, index) => ticks(parent.child(index - 1), 1), escape: false }
+  }, { hardBreakNodeName: "hardBreak", strict: false, escapeExtraCharacters: /<(?=[A-Za-z/!?])/g });
+}
+var one = (node, before, base) => serializer(base.style, base.hints, before).serialize(node.type.schema.topNodeType.create(null, node)).replace(/\n+$/, "");
+function toMarkdown(doc, base) {
+  const nodes = [];
+  const found = [];
+  let j = 0;
+  doc.forEach((node) => {
+    let k = -1;
+    for (let m = j; m < Math.min(base.nodes.length, j + 64) && k < 0; m++) if (base.nodes[m] === node || base.nodes[m].eq(node)) k = m;
+    if (k >= 0) j = k + 1;
+    nodes.push(node);
+    found.push(k);
+  });
+  let out = base.head;
+  const starts = [];
+  nodes.forEach((node, i) => {
+    const k = found[i];
+    if (i && !(k >= 0 && found[i - 1] === k - 1)) out = out.replace(/\n*$/, "\n\n");
+    starts.push(out.length);
+    out += k >= 0 ? base.raws[k] : one(node, i ? nodes[i - 1] : null, base);
+  });
+  const last = found[found.length - 1];
+  const end = last >= 0 && last === base.nodes.length - 1;
+  if (!end) out = out.replace(/\n*$/, "\n");
+  const cut = out.length;
+  out += end ? base.tail : base.tail.trim() ? `
+${base.tail.replace(/^\n+/, "")}` : "";
+  const at = starts.map((s) => Math.min(s, cut));
+  const raws = at.map((s, i) => out.slice(s, i + 1 < at.length ? at[i + 1] : cut));
+  const text = base.crlf ? out.replace(/\n/g, "\r\n") : out;
+  return { text: base.bom ? `\uFEFF${text}` : text, base: { ...base, nodes, raws, tail: out.slice(cut) } };
+}
+
+// src/sheets/model.ts
+var SheetRefusal = class extends Error {
+  constructor(code, sheet = "") {
+    super(code);
+    this.code = code;
+    this.sheet = sheet;
+  }
+};
+var counter = 0;
+var fresh = (prefix) => `${prefix}${Date.now().toString(36)}${(counter++).toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+var numbered = (prefix, count) => Array.from({ length: count }, (_, i) => `${prefix}${i}`);
+function insert(list, at, count, prefix) {
+  list.splice(at, 0, ...Array.from({ length: count }, () => fresh(prefix)));
+}
+function move(list, from, count, to) {
+  const taken = list.splice(from, count);
+  list.splice(to > from ? to - count : to, 0, ...taken);
+}
+function resize(list, count, prefix) {
+  if (list.length > count) list.length = count;
+  else insert(list, list.length, count - list.length, prefix);
+}
+function rebase(model, lines2, sheets) {
+  model.origin = { sheets, lines: Object.fromEntries(Object.entries(lines2).map(([id, l]) => [id, { rows: [...l.rows], cols: [...l.cols] }])) };
+}
+
+// src/sheets/csv.ts
+function decode2(bytes) {
+  if (bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) return { text: new TextDecoder("utf-8").decode(bytes.subarray(3)), encoding: "utf-8", bom: true };
+  if (bytes[0] === 255 && bytes[1] === 254) return { text: new TextDecoder("utf-16le").decode(bytes.subarray(2)), encoding: "utf-16le", bom: true };
+  if (bytes[0] === 254 && bytes[1] === 255) return { text: new TextDecoder("utf-16be").decode(bytes.subarray(2)), encoding: "utf-16be", bom: true };
+  try {
+    return { text: new TextDecoder("utf-8", { fatal: true }).decode(bytes), encoding: "utf-8", bom: false };
+  } catch {
+    const scored = ["windows-1252", "windows-1250", "windows-1251"].map((encoding) => {
+      const text = new TextDecoder(encoding).decode(bytes);
+      let score = 0;
+      for (const [word] of text.matchAll(/\p{L}+/gu)) {
+        const cyrillic = (word.match(/\p{Script=Cyrillic}/gu) ?? []).length;
+        const accented = (word.match(/[^\x00-\x7f\p{Script=Cyrillic}]/gu) ?? []).length;
+        if (cyrillic === word.length || !cyrillic && accented * 2 <= word.length) score += 1;
+        else score -= 1;
+      }
+      score -= 3 * (text.match(/\p{L}[^\p{L}\x00-\x7f]|[^\p{L}\x00-\x7f]\p{L}/gu) ?? []).length;
+      return { text, encoding, score };
+    });
+    const best = scored.reduce((a, b) => b.score > a.score ? b : a);
+    return { text: best.text, encoding: best.encoding, bom: false };
+  }
+}
+function encode(text, encoding, bom) {
+  if (encoding === "utf-8") {
+    const body = new TextEncoder().encode(text);
+    if (!bom) return body;
+    const out2 = new Uint8Array(body.length + 3);
+    out2.set([239, 187, 191]);
+    out2.set(body, 3);
+    return out2;
+  }
+  if (encoding === "utf-16le" || encoding === "utf-16be") {
+    const out2 = new Uint8Array(text.length * 2 + (bom ? 2 : 0));
+    const view = new DataView(out2.buffer);
+    let at = 0;
+    if (bom) {
+      view.setUint16(0, 65279, encoding === "utf-16le");
+      at = 2;
+    }
+    for (let i = 0; i < text.length; i++) view.setUint16(at + i * 2, text.charCodeAt(i), encoding === "utf-16le");
+    return out2;
+  }
+  const table = /* @__PURE__ */ new Map();
+  const decoder2 = new TextDecoder(encoding);
+  for (let b = 255; b >= 0; b--) table.set(decoder2.decode(new Uint8Array([b])), b);
+  const out = new Uint8Array(text.length);
+  for (let i = 0; i < text.length; i++) out[i] = table.get(text[i]) ?? 63;
+  return out;
+}
+function split(text, delimiter, limit = Infinity) {
+  const rows = [];
+  let row2 = [];
+  let i = 0;
+  const n = text.length;
+  while (i <= n && rows.length < limit) {
+    const start = i;
+    let value2 = "";
+    if (text[i] === '"') {
+      i++;
+      while (i < n) {
+        if (text[i] === '"') {
+          if (text[i + 1] === '"') {
+            value2 += '"';
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        value2 += text[i++];
+      }
+      while (i < n && text[i] !== delimiter && text[i] !== "\n" && text[i] !== "\r") value2 += text[i++];
+    } else {
+      while (i < n && text[i] !== delimiter && text[i] !== "\n" && text[i] !== "\r") i++;
+      value2 = text.slice(start, i);
+    }
+    row2.push({ text: value2, raw: text.slice(start, i) });
+    if (i >= n) {
+      rows.push(row2);
+      break;
+    }
+    if (text[i] === delimiter) {
+      i++;
+      continue;
+    }
+    i += text[i] === "\r" && text[i + 1] === "\n" ? 2 : 1;
+    rows.push(row2);
+    row2 = [];
+    if (i >= n) break;
+  }
+  return rows;
+}
+function sniff2(text) {
+  let best = ",", score = -1;
+  for (const d of [",", ";", "	", "|"]) {
+    const rows = split(text, d, 30).filter((r) => r.length > 1 || r[0]?.text);
+    if (!rows.length) continue;
+    const counts = /* @__PURE__ */ new Map();
+    for (const r of rows) counts.set(r.length, (counts.get(r.length) ?? 0) + 1);
+    const [width, often] = [...counts].sort((a, b) => b[1] - a[1] || b[0] - a[0])[0];
+    const s = width > 1 ? often * 100 + width : 0;
+    if (s > score) {
+      score = s;
+      best = d;
+    }
+  }
+  return best;
+}
+var numeric = (s, decimal) => decimal === "," ? /^-?(0|[1-9]\d*)(,\d+)?$/.test(s) : /^-?(0|[1-9]\d*)(\.\d+)?([eE][-+]?\d+)?$/.test(s);
+function readCsv(bytes) {
+  const { text, encoding, bom } = decode2(new Uint8Array(bytes));
+  const delimiter = sniff2(text);
+  const eol = /\r\n/.test(text) ? "\r\n" : /\r(?!\n)/.test(text) && !text.includes("\n") ? "\r" : "\n";
+  const rows = split(text, delimiter);
+  const end = /[\r\n]$/.test(text);
+  if (end && rows.length && rows[rows.length - 1].length === 1 && rows[rows.length - 1][0].raw === "") rows.pop();
+  let commas = 0, dots = 0;
+  if (delimiter !== ",") for (const r of rows) for (const f of r) {
+    if (/^-?\d+,\d+$/.test(f.text)) commas++;
+    else if (/^-?\d+\.\d+$/.test(f.text)) dots++;
+  }
+  const decimal = commas > dots ? "," : ".";
+  const cellData = {};
+  let width = 0;
+  rows.forEach((r, i) => {
+    width = Math.max(width, r.length);
+    r.forEach((f, c) => {
+      if (f.text === "") return;
+      (cellData[i] ?? (cellData[i] = {}))[c] = numeric(f.text, decimal) ? { v: Number(decimal === "," ? f.text.replace(",", ".") : f.text), t: 2 } : { v: f.text, t: 1 };
+    });
+  });
+  const height = Math.max(rows.length + 100, 1e3);
+  const cols = Math.max(width + 4, 26);
+  const format = { delimiter, encoding, bom, eol, decimal, end };
+  const book = {
+    id: "book",
+    name: "",
+    appVersion: "",
+    locale: "enUS",
+    styles: {},
+    sheetOrder: ["s1"],
+    sheets: { s1: { id: "s1", name: "Sheet1", rowCount: height, columnCount: cols, cellData, defaultColumnWidth: 88, defaultRowHeight: 24 } }
+  };
+  return { book, csv: format, lines: { s1: { rows: numbered("r", height), cols: numbered("c", cols) } }, origin: { sheets: { s1: 1 }, lines: { s1: { rows: numbered("r", height), cols: numbered("c", cols) } } } };
+}
+function value(x) {
+  if (!x) return null;
+  const stream = x.p?.body?.dataStream;
+  if (stream !== void 0 && (x.v === void 0 || x.v === null || x.v === "")) return stream.replace(/\r?\n$/, "").replace(/\r\n?/g, "\n");
+  if (x.t === 3 && typeof x.v === "number") return x.v === 1;
+  return x.v ?? null;
+}
+function writeCsv(original, model) {
+  const { text } = decode2(new Uint8Array(original));
+  const format = model.csv ?? readCsv(original).csv;
+  const old = split(text, format.delimiter);
+  if (format.end && old.length && old[old.length - 1].length === 1 && old[old.length - 1][0].raw === "") old.pop();
+  const sid = model.book.sheetOrder[0];
+  const sheet = model.book.sheets[sid];
+  const cells = sheet.cellData ?? {};
+  const lines2 = model.lines[sid], origin = model.origin.lines[sid] ?? lines2;
+  const rowFrom = new Map(origin.rows.map((id, i) => [id, i])), colFrom = new Map(origin.cols.map((id, i) => [id, i]));
+  const quote = (s) => s.includes(format.delimiter) || s.includes('"') || s.includes("\n") || s.includes("\r") ? `"${s.replace(/"/g, '""')}"` : s;
+  const show = (v) => {
+    if (v === null || v === void 0) return "";
+    if (typeof v === "boolean") return v ? "TRUE" : "FALSE";
+    if (typeof v === "number") return format.decimal === "," ? String(v).replace(".", ",") : String(v);
+    return String(v);
+  };
+  const last = Math.max(-1, ...Object.keys(cells).map(Number).filter((r) => Object.values(cells[r] ?? {}).some((x) => show(value(x)) !== "")));
+  const out = [];
+  for (let r = 0; r <= last; r++) {
+    const r0 = rowFrom.get(lines2.rows[r]) ?? -1;
+    const was = r0 >= 0 ? old[r0] : void 0;
+    const line = cells[r] ?? {};
+    const filled2 = Object.keys(line).map(Number).filter((c) => show(value(line[c])) !== "");
+    let count = filled2.length ? Math.max(...filled2) + 1 : 0;
+    if (was) for (let c0 = 0; c0 < was.length; c0++) count = Math.max(count, lines2.cols.indexOf(origin.cols[c0]) + 1);
+    const fields = [];
+    for (let c = 0; c < count; c++) {
+      const c0 = colFrom.get(lines2.cols[c]) ?? -1;
+      const before = was && c0 >= 0 ? was[c0] : void 0;
+      const now = show(value(line[c]));
+      if (before && now === before.text) fields.push(before.raw);
+      else if (before && before.text !== "" && now !== "" && numeric(before.text, format.decimal) && Number(before.text.replace(",", ".")) === Number(now.replace(",", "."))) fields.push(before.raw);
+      else fields.push(quote(now));
+    }
+    out.push(fields.join(format.delimiter));
+  }
+  const body = out.join(format.eol) + (format.end && out.length ? format.eol : "");
+  const bytes = encode(body, format.encoding, format.bom);
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+
+// src/sheets/pack.ts
+var decoder = new TextDecoder();
+var Pack = class {
+  constructor(bytes) {
+    this.names = /* @__PURE__ */ new Map();
+    this.changed = /* @__PURE__ */ new Map();
+    this.entries = unzip(new Uint8Array(bytes));
+    this.entries.forEach((e, i) => this.names.set(e.name.replace(/^\//, ""), i));
+  }
+  bytes(name) {
+    const next = this.changed.get(name);
+    if (next !== void 0) return typeof next === "string" ? new TextEncoder().encode(next) : next;
+    const i = this.names.get(name);
+    return i === void 0 ? null : inflate(this.entries[i]);
+  }
+  text(name) {
+    const next = this.changed.get(name);
+    if (typeof next === "string") return next;
+    const bytes = this.bytes(name);
+    return bytes && decoder.decode(bytes);
+  }
+  put(name, value2) {
+    this.changed.set(name, value2);
+  }
+  rels(part) {
+    const xml = this.text(relsOf(part));
+    if (!xml) return [];
+    const base = part.includes("/") ? part.slice(0, part.lastIndexOf("/") + 1) : "";
+    return [...xml.matchAll(/<(?:\w+:)?Relationship\b[^>]*>/g)].map((m) => {
+      const a = Object.fromEntries(attrs(m[0]));
+      const external = a.TargetMode === "External";
+      return { id: a.Id, type: a.Type.slice(a.Type.lastIndexOf("/") + 1), target: external ? a.Target : resolve(base, a.Target), external };
+    });
+  }
+  build() {
+    const out = [];
+    const seen2 = /* @__PURE__ */ new Set();
+    for (const e of this.entries) {
+      const name = e.name.replace(/^\//, "");
+      seen2.add(name);
+      const next = this.changed.get(name);
+      if (next === null) continue;
+      out.push(next === void 0 ? e : entry(e.name, typeof next === "string" ? new TextEncoder().encode(next) : next, e));
+    }
+    const like = this.entries[0];
+    for (const [name, next] of this.changed) if (!seen2.has(name) && next !== null) out.push(entry(name, typeof next === "string" ? new TextEncoder().encode(next) : next, like));
+    return zip(out);
+  }
+};
+var relsOf = (part) => {
+  const i = part.lastIndexOf("/");
+  return `${part.slice(0, i + 1)}_rels/${part.slice(i + 1)}.rels`;
+};
+function resolve(base, target) {
+  if (target.startsWith("/")) return target.slice(1);
+  const parts2 = (base + target).split("/");
+  const out = [];
+  for (const p of parts2) {
+    if (p === "..") out.pop();
+    else if (p !== "." && p !== "") out.push(p);
+  }
+  return out.join("/");
+}
+function relative(from, to) {
+  const a = from.split("/").slice(0, -1), b = to.split("/");
+  let i = 0;
+  while (i < a.length && a[i] === b[i]) i++;
+  return [...a.slice(i).map(() => ".."), ...b.slice(i)].join("/");
+}
+
+// src/sheets/styles.ts
+var builtin = {
+  1: "0",
+  2: "0.00",
+  3: "#,##0",
+  4: "#,##0.00",
+  5: '"$"#,##0_);("$"#,##0)',
+  6: '"$"#,##0_);[Red]("$"#,##0)',
+  7: '"$"#,##0.00_);("$"#,##0.00)',
+  8: '"$"#,##0.00_);[Red]("$"#,##0.00)',
+  9: "0%",
+  10: "0.00%",
+  11: "0.00E+00",
+  12: "# ?/?",
+  13: "# ??/??",
+  14: "yyyy-mm-dd",
+  15: "d-mmm-yy",
+  16: "d-mmm",
+  17: "mmm-yy",
+  18: "h:mm AM/PM",
+  19: "h:mm:ss AM/PM",
+  20: "h:mm",
+  21: "h:mm:ss",
+  22: "yyyy-mm-dd h:mm",
+  37: "#,##0 ;(#,##0)",
+  38: "#,##0 ;[Red](#,##0)",
+  39: "#,##0.00;(#,##0.00)",
+  40: "#,##0.00;[Red](#,##0.00)",
+  45: "mm:ss",
+  46: "[h]:mm:ss",
+  47: "mmss.0",
+  48: "##0.0E+0",
+  49: "@"
+};
+var indexed = [
+  "000000",
+  "FFFFFF",
+  "FF0000",
+  "00FF00",
+  "0000FF",
+  "FFFF00",
+  "FF00FF",
+  "00FFFF",
+  "000000",
+  "FFFFFF",
+  "FF0000",
+  "00FF00",
+  "0000FF",
+  "FFFF00",
+  "FF00FF",
+  "00FFFF",
+  "800000",
+  "008000",
+  "000080",
+  "808000",
+  "800080",
+  "008080",
+  "C0C0C0",
+  "808080",
+  "9999FF",
+  "993366",
+  "FFFFCC",
+  "CCFFFF",
+  "660066",
+  "FF8080",
+  "0066CC",
+  "CCCCFF",
+  "000080",
+  "FF00FF",
+  "FFFF00",
+  "00FFFF",
+  "800080",
+  "800000",
+  "008080",
+  "0000FF",
+  "00CCFF",
+  "CCFFFF",
+  "CCFFCC",
+  "FFFF99",
+  "99CCFF",
+  "FF99CC",
+  "CC99FF",
+  "FFCC99",
+  "3366FF",
+  "33CCCC",
+  "99CC00",
+  "FFCC00",
+  "FF9900",
+  "FF6600",
+  "666699",
+  "969696",
+  "003366",
+  "339966",
+  "003300",
+  "333300",
+  "993300",
+  "993366",
+  "333399",
+  "333333",
+  "000000",
+  "FFFFFF"
+];
+var lines = ["", "thin", "hair", "dotted", "dashed", "dashDot", "dashDotDot", "double", "medium", "mediumDashed", "mediumDashDot", "mediumDashDotDot", "slantDashDot", "thick"];
+var across = ["", "left", "center", "right", "justify", "justify", "distributed"];
+var down = ["", "top", "center", "bottom"];
+var sides = [["l", "left"], ["r", "right"], ["t", "top"], ["b", "bottom"]];
+var fontOrder = ["b", "i", "strike", "condense", "extend", "outline", "shadow", "u", "vertAlign", "sz", "color", "name", "family", "charset", "scheme"];
+function tinted(hex2, tint) {
+  if (!tint) return hex2;
+  const [r, g, b] = [0, 2, 4].map((i) => parseInt(hex2.slice(i, i + 2), 16) / 255);
+  const max = Math.max(r, g, b), min = Math.min(r, g, b);
+  let h = 0, s = 0, l = (max + min) / 2;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
+    h /= 6;
+  }
+  l = tint < 0 ? l * (1 + tint) : l * (1 - tint) + tint;
+  const hue = (p2, q2, t) => {
+    if (t < 0) t += 1;
+    if (t > 1) t -= 1;
+    return t < 1 / 6 ? p2 + (q2 - p2) * 6 * t : t < 1 / 2 ? q2 : t < 2 / 3 ? p2 + (q2 - p2) * (2 / 3 - t) * 6 : p2;
+  };
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s, p = 2 * l - q;
+  const out = s === 0 ? [l, l, l] : [hue(p, q, h + 1 / 3), hue(p, q, h), hue(p, q, h - 1 / 3)];
+  return out.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("").toUpperCase();
+}
+function palette(theme) {
+  if (!theme) return ["FFFFFF", "000000", "E7E6E6", "44546A", "4472C4", "ED7D31", "A5A5A5", "FFC000", "5B9BD5", "70AD47", "0563C1", "954F72"];
+  const scheme = /<(?:\w+:)?clrScheme\b[^>]*>([\s\S]*?)<\/(?:\w+:)?clrScheme>/.exec(theme)?.[1] ?? "";
+  const pick = (name) => {
+    const m = new RegExp(`<(?:\\w+:)?${name}>([\\s\\S]*?)</(?:\\w+:)?${name}>`).exec(scheme)?.[1] ?? "";
+    return /(?:val|lastClr)="([0-9A-Fa-f]{6})"/.exec(m.includes("lastClr") ? m.replace(/val="\w+"/, "") : m)?.[1]?.toUpperCase() ?? "000000";
+  };
+  const [dk1, lt1, dk2, lt2] = ["dk1", "lt1", "dk2", "lt2"].map(pick);
+  return [lt1, dk1, lt2, dk2, ...["accent1", "accent2", "accent3", "accent4", "accent5", "accent6", "hlink", "folHlink"].map(pick)];
+}
+var hex = (c) => {
+  const s = String(c ?? "").trim();
+  let m = /^#?([0-9a-f]{6})$/i.exec(s);
+  if (m) return "#" + m[1].toUpperCase();
+  m = /^#?([0-9a-f]{3})$/i.exec(s);
+  if (m) return "#" + m[1].split("").map((x) => x + x).join("").toUpperCase();
+  m = /^rgba?\((\d+),\s*(\d+),\s*(\d+)/i.exec(s);
+  return m ? "#" + [m[1], m[2], m[3]].map((v) => Number(v).toString(16).padStart(2, "0")).join("").toUpperCase() : null;
+};
+function norm(l) {
+  const out = {};
+  if (l.bl) out.bl = 1;
+  if (l.it) out.it = 1;
+  if (l.ul?.s) out.ul = { s: 1 };
+  if (l.st?.s) out.st = { s: 1 };
+  if (l.va === 2 || l.va === 3) out.va = l.va;
+  if (l.fs) out.fs = Number(l.fs);
+  if (l.ff) out.ff = l.ff;
+  const cl = hex(l.cl?.rgb);
+  if (cl) out.cl = { rgb: cl };
+  const bg = hex(l.bg?.rgb);
+  if (bg) out.bg = { rgb: bg };
+  if (l.bd) {
+    const bd = {};
+    for (const k of ["t", "b", "l", "r", "tl_br", "bl_tr"]) {
+      const b = l.bd[k];
+      if (b && b.s) bd[k] = { s: b.s, cl: { rgb: hex(b.cl?.rgb) ?? "#000000" } };
+    }
+    if (Object.keys(bd).length) out.bd = bd;
+  }
+  if (l.ht) out.ht = l.ht;
+  if (l.vt) out.vt = l.vt;
+  if (l.tb === 3) out.tb = 3;
+  if (l.tr && (l.tr.a || l.tr.v)) out.tr = { a: l.tr.a ?? 0, v: l.tr.v ? 1 : 0 };
+  if (l.n?.pattern && l.n.pattern !== "General") out.n = { pattern: l.n.pattern };
+  return out;
+}
+var Styles = class {
+  constructor(xml, theme) {
+    this.formats = /* @__PURE__ */ new Map();
+    this.fonts = [];
+    this.fills = [];
+    this.borders = [];
+    this.xfs = [];
+    this.looks = [];
+    this.index = /* @__PURE__ */ new Map();
+    this.added = false;
+    this.custom = null;
+    this.prefix = () => this.root?.name.includes(":") ? this.root.name.slice(0, this.root.name.indexOf(":") + 1) : "";
+    this.bare = (name) => name.slice(name.indexOf(":") + 1);
+    this.child = (el, name) => el.kids.find((k) => this.bare(k.name) === name);
+    this.xml = xml;
+    this.theme = palette(theme);
+    this.root = xml ? parse(xml).kids.find((k) => !k.name.startsWith("?")) ?? null : null;
+    const s = xml ?? "";
+    const list = (name, tag) => {
+      const el = this.root && this.child(this.root, name);
+      return el ? el.kids.filter((k) => this.bare(k.name) === tag).map((k) => s.slice(k.start, k.end)) : [];
+    };
+    for (const f of list("numFmts", "numFmt")) {
+      const a = Object.fromEntries(attrs(f));
+      this.formats.set(Number(a.numFmtId), a.formatCode);
+    }
+    const colours = this.root && this.child(this.root, "colors");
+    const custom = colours && this.child(colours, "indexedColors");
+    if (custom) this.custom = custom.kids.map((k) => (attr(s, k, "rgb") ?? "FF000000").slice(-6).toUpperCase());
+    this.fonts = list("fonts", "font");
+    this.fills = list("fills", "fill");
+    this.borders = list("borders", "border");
+    this.xfs = list("cellXfs", "xf");
+    if (!this.fonts.length) this.fonts = ['<font><sz val="11"/><name val="Calibri"/></font>'];
+    if (!this.fills.length) this.fills = ['<fill><patternFill patternType="none"/></fill>', '<fill><patternFill patternType="gray125"/></fill>'];
+    if (!this.borders.length) this.borders = ["<border><left/><right/><top/><bottom/><diagonal/></border>"];
+    if (!this.xfs.length) this.xfs = ['<xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>'];
+    const raw = this.xfs.map((x) => this.look(x));
+    this.looks = raw.map((l) => norm({ ...raw[0], ...l }));
+    this.looks.forEach((l, i) => {
+      const k = JSON.stringify(l);
+      if (!this.index.has(k)) this.index.set(k, i);
+    });
+  }
+  color(tag) {
+    if (!tag) return void 0;
+    const a = Object.fromEntries(attrs(tag));
+    if (a.auto === "1" || a.auto === "true") return void 0;
+    let hex2;
+    if (a.rgb) hex2 = a.rgb.slice(-6).toUpperCase();
+    else if (a.theme !== void 0) hex2 = this.theme[Number(a.theme)];
+    else if (a.indexed !== void 0) hex2 = (this.custom ?? indexed)[Number(a.indexed)] ?? (Number(a.indexed) === 64 ? "000000" : void 0);
+    return hex2 && "#" + tinted(hex2, Number(a.tint ?? 0));
+  }
+  parts(xml) {
+    const root = parse(xml).kids[0];
+    const out = /* @__PURE__ */ new Map();
+    if (root) for (const k of root.kids) out.set(this.bare(k.name), xml.slice(k.start, k.end));
+    return { root, out, open: root ? xml.slice(root.start, root.open) : "" };
+  }
+  pattern(id) {
+    return this.formats.get(id) ?? builtin[id] ?? (id === 0 ? "General" : "General");
+  }
+  look(xf) {
+    const a = Object.fromEntries(attrs(xf.slice(0, xf.indexOf(">") + 1)));
+    const s = {};
+    const font = this.parts(this.fonts[Number(a.fontId ?? 0)] ?? this.fonts[0]).out;
+    const val = (tag) => tag && Object.fromEntries(attrs(tag)).val;
+    const on = (tag) => tag !== void 0 && !/^(0|false)$/.test(val(tag) ?? "1");
+    if (on(font.get("b"))) s.bl = 1;
+    if (on(font.get("i"))) s.it = 1;
+    if (on(font.get("strike"))) s.st = { s: 1 };
+    if (font.has("u") && val(font.get("u")) !== "none") s.ul = { s: 1 };
+    const va = val(font.get("vertAlign"));
+    if (va === "superscript") s.va = 3;
+    if (va === "subscript") s.va = 2;
+    if (font.has("sz")) s.fs = Number(val(font.get("sz")));
+    if (font.has("name")) s.ff = val(font.get("name"));
+    const cl = this.color(font.get("color"));
+    if (cl) s.cl = { rgb: cl };
+    const fill3 = this.fills[Number(a.fillId ?? 0)];
+    const pattern = fill3 && /patternType="(\w+)"/.exec(fill3)?.[1];
+    if (fill3 && pattern && pattern !== "none" && pattern !== "gray125") {
+      const fg = this.color(/<(?:\w+:)?fgColor\b[^>]*>/.exec(fill3)?.[0]);
+      if (fg) s.bg = { rgb: fg };
+    }
+    const border = this.parts(this.borders[Number(a.borderId ?? 0)] ?? "<border/>");
+    const bd = {};
+    for (const [key2, name] of sides) {
+      const el = border.out.get(name) ?? border.out.get(name === "left" ? "start" : name === "right" ? "end" : name);
+      const style = el && /style="(\w+)"/.exec(el)?.[1];
+      if (!style || style === "none") continue;
+      bd[key2] = { s: Math.max(1, lines.indexOf(style)), cl: { rgb: this.color(/<(?:\w+:)?color\b[^>]*>/.exec(el)?.[0]) ?? "#000000" } };
+    }
+    const diagonal = border.out.get("diagonal");
+    const dstyle = diagonal && /style="(\w+)"/.exec(diagonal)?.[1];
+    if (dstyle && dstyle !== "none") {
+      const line = { s: Math.max(1, lines.indexOf(dstyle)), cl: { rgb: this.color(/<(?:\w+:)?color\b[^>]*>/.exec(diagonal)?.[0]) ?? "#000000" } };
+      const flags = Object.fromEntries(attrs(border.open));
+      if (flags.diagonalDown === "1" || flags.diagonalDown === "true") bd.tl_br = line;
+      if (flags.diagonalUp === "1" || flags.diagonalUp === "true") bd.bl_tr = line;
+    }
+    if (Object.keys(bd).length) s.bd = bd;
+    const align2 = /<(?:\w+:)?alignment\b[^>]*>/.exec(xf)?.[0];
+    if (align2) {
+      const al = Object.fromEntries(attrs(align2));
+      const ht = across.indexOf(al.horizontal === "centerContinuous" ? "center" : al.horizontal);
+      if (ht > 0) s.ht = ht;
+      const vt = down.indexOf(al.vertical);
+      if (vt > 0) s.vt = vt;
+      if (al.wrapText === "1" || al.wrapText === "true") s.tb = 3;
+      const turn = Number(al.textRotation ?? 0);
+      if (turn === 255) s.tr = { a: 0, v: 1 };
+      else if (turn) s.tr = { a: turn <= 90 ? turn : 90 - turn, v: 0 };
+    }
+    const id = Number(a.numFmtId ?? 0);
+    if (id) s.n = { pattern: this.pattern(id) };
+    return s;
+  }
+  find(look) {
+    return this.index.get(JSON.stringify(norm(look)));
+  }
+  derive(base, look) {
+    look = norm(look);
+    const key2 = JSON.stringify(look);
+    const known = this.index.get(key2);
+    if (known !== void 0) return known;
+    const was = this.looks[base] ?? {};
+    const xf = this.xfs[base] ?? this.xfs[0];
+    const head = xf.slice(0, xf.indexOf(">") + 1);
+    const a = new Map(attrs(head));
+    const same3 = (keys) => keys.every((k) => JSON.stringify(was[k]) === JSON.stringify(look[k]));
+    const p = this.prefix();
+    if (!same3(["bl", "it", "st", "ul", "va", "fs", "ff", "cl"])) {
+      a.set("fontId", String(this.add("fonts", this.font(Number(a.get("fontId") ?? 0), was, look))));
+      a.set("applyFont", "1");
+    }
+    if (!same3(["bg"])) {
+      a.set("fillId", String(look.bg?.rgb ? this.add("fills", `<${p}fill><${p}patternFill patternType="solid"><${p}fgColor rgb="${argb(look.bg.rgb)}"/><${p}bgColor indexed="64"/></${p}patternFill></${p}fill>`) : 0));
+      a.set("applyFill", "1");
+    }
+    if (!same3(["bd"])) {
+      a.set("borderId", String(this.add("borders", this.border(Number(a.get("borderId") ?? 0), was, look))));
+      a.set("applyBorder", "1");
+    }
+    if (!same3(["n"])) {
+      a.set("numFmtId", String(this.format(look.n?.pattern ?? "General")));
+      a.set("applyNumberFormat", "1");
+    }
+    let inner = xf.endsWith("/>") && xf.indexOf(">") === xf.length - 1 ? "" : xf.slice(head.length, xf.lastIndexOf("<"));
+    if (!same3(["ht", "vt", "tb", "tr"])) {
+      const old = /<(?:\w+:)?alignment\b[^>]*>/.exec(inner)?.[0];
+      const al = new Map(old ? attrs(old) : []);
+      const put = (name2, value2) => value2 === null ? al.delete(name2) : al.set(name2, value2);
+      put("horizontal", look.ht ? across[look.ht] : null);
+      put("vertical", look.vt ? down[look.vt] : null);
+      put("wrapText", look.tb === 3 ? "1" : null);
+      put("textRotation", look.tr?.v ? "255" : look.tr?.a ? String(look.tr.a > 0 ? look.tr.a : 90 - look.tr.a) : null);
+      const tag = al.size ? `<${p}alignment ${[...al].map(([k, v]) => `${k}="${escape(v)}"`).join(" ")}/>` : "";
+      inner = old ? inner.replace(old, tag) : tag + inner;
+      a.set("applyAlignment", "1");
+    }
+    const name = head.slice(1, head.search(/[\s/>]/));
+    const open = `<${name} ${[...a].map(([k, v]) => `${k}="${escape(v)}"`).join(" ")}`;
+    const next = inner ? `${open}>${inner}</${name}>` : `${open}/>`;
+    this.xfs.push(next);
+    this.added = true;
+    const index = this.xfs.length - 1;
+    this.looks.push(norm({ ...this.looks[0], ...this.look(next) }));
+    this.index.set(key2, index);
+    return index;
+  }
+  add(list, xml) {
+    const at = this[list].indexOf(xml);
+    if (at >= 0) return at;
+    this[list].push(xml);
+    this.added = true;
+    return this[list].length - 1;
+  }
+  font(id, was, look) {
+    const p = this.prefix();
+    const { out } = this.parts(this.fonts[id] ?? this.fonts[0]);
+    const set = (name, xml) => xml === null ? out.delete(name) : out.set(name, xml);
+    const diff = (k) => JSON.stringify(was[k]) !== JSON.stringify(look[k]);
+    if (diff("bl")) set("b", look.bl ? `<${p}b/>` : null);
+    if (diff("it")) set("i", look.it ? `<${p}i/>` : null);
+    if (diff("st")) set("strike", look.st?.s ? `<${p}strike/>` : null);
+    if (diff("ul")) set("u", look.ul?.s ? `<${p}u/>` : null);
+    if (diff("va")) set("vertAlign", look.va === 3 ? `<${p}vertAlign val="superscript"/>` : look.va === 2 ? `<${p}vertAlign val="subscript"/>` : null);
+    if (diff("fs")) set("sz", `<${p}sz val="${look.fs ?? 11}"/>`);
+    if (diff("cl")) set("color", look.cl?.rgb ? `<${p}color rgb="${argb(look.cl.rgb)}"/>` : null);
+    if (diff("ff")) {
+      set("name", `<${p}name val="${escape(look.ff ?? "Calibri")}"/>`);
+      set("scheme", null);
+    }
+    return `<${p}font>${fontOrder.filter((k) => out.has(k)).map((k) => out.get(k)).join("")}</${p}font>`;
+  }
+  border(id, was, look) {
+    const p = this.prefix();
+    const { out, open } = this.parts(this.borders[id] ?? this.borders[0]);
+    const flags = new Map(open ? attrs(open) : []);
+    const line = (name, b) => b ? `<${p}${name} style="${lines[b.s] || "thin"}"><${p}color rgb="${argb(b.cl?.rgb ?? "#000000")}"/></${p}${name}>` : `<${p}${name}/>`;
+    const before = was.bd ?? {}, after = look.bd ?? {};
+    const parts2 = [];
+    for (const [key2, name] of sides) {
+      const old = out.get(name) ?? out.get(name === "left" ? "start" : name === "right" ? "end" : name);
+      parts2.push(JSON.stringify(before[key2]) === JSON.stringify(after[key2]) && old ? old : line(name, after[key2]));
+    }
+    const diagonal = after.tl_br ?? after.bl_tr;
+    if (JSON.stringify(before.tl_br) === JSON.stringify(after.tl_br) && JSON.stringify(before.bl_tr) === JSON.stringify(after.bl_tr)) parts2.push(out.get("diagonal") ?? `<${p}diagonal/>`);
+    else {
+      parts2.push(line("diagonal", diagonal));
+      if (after.tl_br) flags.set("diagonalDown", "1");
+      else flags.delete("diagonalDown");
+      if (after.bl_tr) flags.set("diagonalUp", "1");
+      else flags.delete("diagonalUp");
+    }
+    for (const extra of ["vertical", "horizontal"]) if (out.has(extra)) parts2.push(out.get(extra));
+    const attributes = [...flags].map(([k, v]) => ` ${k}="${escape(v)}"`).join("");
+    return `<${p}border${attributes}>${parts2.join("")}</${p}border>`;
+  }
+  format(pattern) {
+    if (pattern === "General") return 0;
+    for (const [id2, code] of this.formats) if (code === pattern) return id2;
+    for (const [id2, code] of Object.entries(builtin)) if (code === pattern) return Number(id2);
+    const id = Math.max(163, ...this.formats.keys()) + 1;
+    this.formats.set(id, pattern);
+    this.added = true;
+    return id;
+  }
+  build() {
+    if (!this.added) return null;
+    const p = this.prefix();
+    const s = this.xml ?? `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"></styleSheet>`;
+    const root = parse(s).kids.find((k) => !k.name.startsWith("?"));
+    const order2 = ["numFmts", "fonts", "fills", "borders", "cellStyleXfs", "cellXfs", "cellStyles", "dxfs", "tableStyles", "colors", "extLst"];
+    const lists = {
+      numFmts: [...this.formats].map(([id, code]) => `<${p}numFmt numFmtId="${id}" formatCode="${escape(code)}"/>`),
+      fonts: this.fonts,
+      fills: this.fills,
+      borders: this.borders,
+      cellXfs: this.xfs
+    };
+    const edits2 = [];
+    for (const name of Object.keys(lists)) {
+      if (!lists[name].length) continue;
+      const el = root.kids.find((k) => this.bare(k.name) === name);
+      if (el) {
+        const open = s.slice(el.start, el.open).replace(/\s*\/?>$/, "").replace(/\scount="\d*"/, "");
+        edits2.push([el.start, el.end, `${open} count="${lists[name].length}">${lists[name].join("")}</${el.name}>`]);
+      } else {
+        const after = root.kids.find((k) => order2.indexOf(this.bare(k.name)) > order2.indexOf(name));
+        const at = after ? after.start : root.close;
+        edits2.push([at, at, `<${p}${name} count="${lists[name].length}">${lists[name].join("")}</${p}${name}>`]);
+      }
+    }
+    edits2.sort((x, y) => y[0] - x[0]);
+    let out = s;
+    for (const [from, to, xml] of edits2) out = out.slice(0, from) + xml + out.slice(to);
+    return out;
+  }
+};
+var argb = (hex2) => "FF" + hex2.replace("#", "").toUpperCase().padStart(6, "0").slice(-6);
+
+// src/sheets/xlsx.ts
+var key = (r, c) => r * 16384 + c;
+var px = { row: (pt2) => Math.round(pt2 * 4 / 3 * 100) / 100, col: (w) => Math.round(w * 7 + 5) };
+var pt = { row: (h) => Math.round(h * 3 / 4 * 100) / 100, col: (w) => Math.max(0, Math.round((w - 5) / 7 * 100) / 100) };
+var decodeX = (s) => s.includes("_x") ? s.replace(/_x([0-9A-Fa-f]{4})_/g, (_, h) => String.fromCharCode(parseInt(h, 16))) : s;
+function runs(xml) {
+  const clean = xml.includes("rPh") ? xml.replace(/<(\w+:)?rPh\b[\s\S]*?<\/(\w+:)?rPh>/g, "") : xml;
+  let out = "";
+  for (const m of clean.matchAll(/<(?:\w+:)?t(?:\s[^>]*)?(?:\/>|>([\s\S]*?)<\/(?:\w+:)?t>)/g)) out += m[1] ?? "";
+  return decodeX(unescape(out));
+}
+var patterns = /* @__PURE__ */ new Map();
+var attr2 = (tag, name) => {
+  let re = patterns.get(name);
+  if (!re) patterns.set(name, re = new RegExp(`\\s${name}="([^"]*)"`));
+  const m = re.exec(tag);
+  return m ? unescape(m[1]) : null;
+};
+var element = (xml, name) => {
+  const m = new RegExp(`<((?:\\w+:)?${name})\\b[^>]*?(\\/?)>`).exec(xml);
+  if (!m) return null;
+  if (m[2]) return { start: m.index, open: m.index + m[0].length, close: m.index + m[0].length, end: m.index + m[0].length, tag: m[0] };
+  const close = xml.indexOf(`</${m[1]}>`, m.index);
+  return { start: m.index, open: m.index + m[0].length, close, end: close + m[1].length + 3, tag: m[0] };
+};
+function worksheets(bytes) {
+  const pack = new Pack(bytes);
+  const part = pack.rels("").find((r) => r.type === "officeDocument")?.target ?? "xl/workbook.xml";
+  const rels = pack.rels(part);
+  return [...(pack.text(part) ?? "").matchAll(/<(?:\w+:)?sheet\b[^>]*\/?>/g)].filter((m) => rels.find((r) => r.id === /\s[\w]+:id="([^"]*)"/.exec(m[0])?.[1])?.type === "worksheet").map((m) => Number(attr2(m[0], "sheetId")));
+}
+function load(bytes) {
+  var _a, _b;
+  const pack = new Pack(bytes);
+  const office = pack.rels("").find((r) => r.type === "officeDocument");
+  const part = office?.target ?? "xl/workbook.xml";
+  const xml = pack.text(part);
+  if (!xml) throw new Error("No workbook");
+  const rels = pack.rels(part);
+  const target = (type) => rels.find((r) => r.type === type)?.target;
+  const themePart = target("theme");
+  const stylesPart = target("styles");
+  const styles = new Styles(stylesPart ? pack.text(stylesPart) : null, themePart ? pack.text(themePart) : null);
+  const stringsPart = target("sharedStrings");
+  const strings = [];
+  const sst = stringsPart ? pack.text(stringsPart) : null;
+  if (sst) for (const m of sst.matchAll(/<(?:\w+:)?si\b[^>]*?(?:\/>|>([\s\S]*?)<\/(?:\w+:)?si>)/g)) strings.push(m[1] ? runs(m[1]) : "");
+  const date1904 = /<(?:\w+:)?workbookPr\b[^>]*\bdate1904="(1|true)"/.test(xml);
+  const entries2 = [];
+  for (const m of xml.matchAll(/<(?:\w+:)?sheet\b[^>]*\/?>/g)) {
+    const tag = m[0];
+    const rid = /\s[\w]+:id="([^"]*)"/.exec(tag)?.[1] ?? "";
+    const rel = rels.find((r) => r.id === rid);
+    entries2.push({ name: attr2(tag, "name") ?? "", sheetId: Number(attr2(tag, "sheetId")), rid, xml: tag, sheet: rel?.type === "worksheet" });
+  }
+  const book = {
+    id: "book",
+    name: "",
+    appVersion: "",
+    locale: "enUS",
+    styles: {},
+    sheetOrder: [],
+    sheets: {},
+    resources: [],
+    defaultStyle: styles.looks[0]
+  };
+  if (date1904) book.dateSystem = "date1904";
+  const notes2 = {};
+  const validations = {};
+  const filters = {};
+  const model = { book, lines: {}, origin: { sheets: {}, lines: {} } };
+  const sheets = [];
+  const active = Number(/<(?:\w+:)?workbookView\b[^>]*\bactiveTab="(\d+)"/.exec(xml)?.[1] ?? 0);
+  const useStyle = (xf) => {
+    const id = `x${xf}`;
+    if (!(id in book.styles)) book.styles[id] = styles.looks[xf] ?? {};
+    return id;
+  };
+  for (const entry2 of entries2) {
+    if (!entry2.sheet) continue;
+    const rel = rels.find((r) => r.id === entry2.rid);
+    const sxml = pack.text(rel.target);
+    if (sxml === null) continue;
+    const sid = `s${entry2.sheetId}`;
+    const p = /<(\w+:)?worksheet\b/.exec(sxml)?.[1] ?? "";
+    const srels = pack.rels(rel.target);
+    const sheet = { id: sid, name: entry2.name, cellData: {}, rowData: {}, columnData: {}, mergeData: [] };
+    const state = attr2(entry2.xml, "state");
+    if (state === "hidden") sheet.hidden = 1;
+    if (state === "veryHidden") sheet.hidden = 2;
+    const open = element(sxml, `${p}sheetData`);
+    const bounds = open ? [open.start, open.open, open.close, open.end] : [sxml.length, sxml.length, sxml.length, sxml.length];
+    const head = open ? sxml.slice(0, open.start) : sxml;
+    const tail = open ? sxml.slice(open.end) : "";
+    const format = /<(?:\w+:)?sheetFormatPr\b[^>]*>/.exec(head)?.[0];
+    const defaultRow = format && attr2(format, "defaultRowHeight") ? px.row(Number(attr2(format, "defaultRowHeight"))) : 20;
+    const defaultCol = format && attr2(format, "defaultColWidth") ? px.col(Number(attr2(format, "defaultColWidth"))) : format && attr2(format, "baseColWidth") ? px.col(Number(attr2(format, "baseColWidth")) + 0.71) : 64;
+    sheet.defaultRowHeight = defaultRow;
+    sheet.defaultColumnWidth = defaultCol;
+    const view = /<(?:\w+:)?sheetView\b[^>]*>/.exec(head)?.[0];
+    if (view && attr2(view, "showGridLines") === "0") sheet.showGridlines = 0;
+    if (view && attr2(view, "rightToLeft") === "1") sheet.rightToLeft = 1;
+    if (view && attr2(view, "zoomScale")) sheet.zoomRatio = Number(attr2(view, "zoomScale")) / 100;
+    const pane = /<(?:\w+:)?pane\b[^>]*>/.exec(head)?.[0];
+    if (pane && /^frozen/.test(attr2(pane, "state") ?? "")) {
+      const x = Number(attr2(pane, "xSplit") ?? 0), y = Number(attr2(pane, "ySplit") ?? 0);
+      sheet.freeze = { xSplit: x, ySplit: y, startRow: y, startColumn: x };
+    }
+    const tab = /<(?:\w+:)?tabColor\b[^>]*>/.exec(head)?.[0];
+    if (tab) {
+      const c = styles.color(tab);
+      if (c) sheet.tabColor = c;
+    }
+    const cols = [];
+    for (const m of head.matchAll(/<(?:\w+:)?col\b[^>]*\/?>/g)) {
+      const t = m[0];
+      const spec = { min: Number(attr2(t, "min")), max: Number(attr2(t, "max")), xml: t, hidden: /^(1|true)$/.test(attr2(t, "hidden") ?? "") };
+      if (attr2(t, "width") !== null && /^(1|true)$/.test(attr2(t, "customWidth") ?? "1")) spec.width = px.col(Number(attr2(t, "width")));
+      if (attr2(t, "style") !== null && attr2(t, "style") !== "0") spec.style = Number(attr2(t, "style"));
+      cols.push(spec);
+    }
+    const cellData = {};
+    const rowData = {};
+    const rows = /* @__PURE__ */ new Map();
+    const cells = /* @__PURE__ */ new Map();
+    const masters = /* @__PURE__ */ new Map();
+    const children = [];
+    const rowStyles = /* @__PURE__ */ new Map();
+    let maxRow = -1, maxCol = -1;
+    if (open && open.close > open.open) {
+      const end = open.close;
+      let at = open.open, row2 = -1, col = -1;
+      while (at < end) {
+        const lt = sxml.indexOf("<", at);
+        if (lt < 0 || lt >= end) break;
+        const gt = sxml.indexOf(">", lt);
+        if (sxml.charCodeAt(lt + 1) === 47) {
+          at = gt + 1;
+          continue;
+        }
+        let j = lt + 1;
+        while (j < gt) {
+          const ch = sxml.charCodeAt(j);
+          if (ch === 32 || ch === 47 || ch === 9 || ch === 10 || ch === 13) break;
+          j++;
+        }
+        const name = sxml.slice(lt + 1 + p.length, j);
+        const tag = sxml.slice(lt, gt + 1);
+        if (name === "row") {
+          const r = attr2(tag, "r");
+          row2 = r ? Number(r) - 1 : row2 + 1;
+          col = -1;
+          rows.set(row2, { open: tag });
+          const rd = {};
+          const ht = attr2(tag, "ht");
+          if (ht !== null) rd.h = px.row(Number(ht));
+          if (ht !== null && /^(1|true)$/.test(attr2(tag, "customHeight") ?? "")) rd.ia = 0;
+          if (/^(1|true)$/.test(attr2(tag, "hidden") ?? "")) rd.hd = 1;
+          const rs = attr2(tag, "s");
+          if (rs !== null && /^(1|true)$/.test(attr2(tag, "customFormat") ?? "")) {
+            rowStyles.set(row2, Number(rs));
+            rd.s = useStyle(Number(rs));
+          }
+          if (Object.keys(rd).length) rowData[row2] = rd;
+          if (rd.h !== void 0 || rd.hd || rd.s) maxRow = Math.max(maxRow, row2);
+          at = gt + 1;
+          continue;
+        }
+        if (name !== "c") {
+          at = gt + 1;
+          continue;
+        }
+        const ref = attr2(tag, "r");
+        if (ref) [, col] = cell(ref);
+        else col += 1;
+        const self = sxml.charCodeAt(gt - 1) === 47;
+        const close = self ? gt + 1 : sxml.indexOf(`</${p}c>`, gt);
+        const stop = self ? gt + 1 : close + p.length + 4;
+        const inner = self ? "" : sxml.slice(gt + 1, close);
+        const t = attr2(tag, "t");
+        const s = Number(attr2(tag, "s") ?? 0);
+        const out = {};
+        let shared = false;
+        if (inner) {
+          const f = /<(?:\w+:)?f\b([^>]*?)(?:\/>|>([\s\S]*?)<\/(?:\w+:)?f>)/.exec(inner);
+          if (f) {
+            const kind = attr2(f[0], "t");
+            const formula = f[2] === void 0 ? "" : unescape(f[2]);
+            if (kind === "shared") {
+              shared = true;
+              const si = attr2(f[0], "si") ?? "";
+              if (formula) masters.set(si, { f: formula, r: row2, c: col });
+              else children.push([row2, col, si]);
+              if (formula) out.f = "=" + plain(formula);
+            } else if (kind !== "dataTable" && formula) out.f = "=" + plain(formula);
+          }
+          const v = /<(?:\w+:)?v>([\s\S]*?)<\/(?:\w+:)?v>/.exec(inner)?.[1];
+          if (t === "inlineStr") {
+            const is = /<(?:\w+:)?is>([\s\S]*?)<\/(?:\w+:)?is>/.exec(inner)?.[1];
+            if (is !== void 0) {
+              out.v = runs(is);
+              out.t = 1;
+            }
+          } else if (v !== void 0) {
+            if (t === "s") {
+              out.v = strings[Number(v)] ?? "";
+              out.t = 1;
+            } else if (t === "str" || t === "e") {
+              out.v = decodeX(unescape(v));
+              out.t = 1;
+            } else if (t === "b") {
+              out.v = v === "1" || v === "true";
+              out.t = 3;
+            } else if (t === "d") {
+              const d = Date.parse(v);
+              out.v = Number.isNaN(d) ? v : (d - Date.UTC(1899, 11, 30)) / 864e5;
+              out.t = Number.isNaN(d) ? 1 : 2;
+            } else {
+              out.v = Number(v);
+              out.t = 2;
+            }
+          }
+        }
+        const styled = s || rowStyles.has(row2) || cols.some((spec) => spec.style !== void 0 && col + 1 >= spec.min && col + 1 <= spec.max);
+        if (styled) out.s = useStyle(s);
+        if (out.v !== void 0 || out.f || out.s || shared) {
+          (cellData[row2] ?? (cellData[row2] = {}))[col] = out;
+          if (out.v !== void 0 || out.f || s) {
+            maxRow = Math.max(maxRow, row2);
+            maxCol = Math.max(maxCol, col);
+          }
+        }
+        cells.set(key(row2, col), { start: lt, end: stop, shared });
+        at = stop;
+      }
+    }
+    for (const [r, c, si] of children) {
+      const m = masters.get(si);
+      const target2 = (_a = cellData[r] ?? (cellData[r] = {}))[c] ?? (_a[c] = {});
+      if (m) target2.f = "=" + plain(shifted(m.f, r - m.r, c - m.c));
+    }
+    for (const spec of cols) if (spec.max <= 1024) maxCol = Math.max(maxCol, spec.max - 1);
+    const merges = [];
+    for (const m of tail.matchAll(/<(?:\w+:)?mergeCell\b[^>]*\/?>/g)) {
+      const ref = attr2(m[0], "ref");
+      if (!ref) continue;
+      merges.push(ref);
+      for (const b of boxes(ref)) {
+        sheet.mergeData.push({ startRow: b.startRow, startColumn: b.startColumn, endRow: b.endRow, endColumn: b.endColumn });
+        maxRow = Math.max(maxRow, b.endRow);
+        maxCol = Math.max(maxCol, b.endColumn);
+      }
+    }
+    const rules = [];
+    const dvs = [];
+    const dvBlock = element(tail, `${p}dataValidations`);
+    if (dvBlock) for (const m of tail.slice(dvBlock.open, dvBlock.close).matchAll(/<(?:\w+:)?dataValidation\b[^>]*?(?:\/>|>[\s\S]*?<\/(?:\w+:)?dataValidation>)/g)) {
+      const rule = validation(m[0], `dv${dvs.length}`);
+      dvs.push(m[0]);
+      if (rule) rules.push(rule);
+    }
+    if (rules.length) validations[sid] = rules;
+    const af = /<(?:\w+:)?autoFilter\b[^>]*?(?:\/>|>[\s\S]*?<\/(?:\w+:)?autoFilter>)/.exec(tail)?.[0] ?? null;
+    if (af) {
+      const [b] = boxes(attr2(af, "ref") ?? "");
+      if (b) filters[sid] = { ref: { ...b, rangeType: 0 }, filterColumns: criteria(af), cachedFilteredOut: [] };
+    }
+    const sheetNotes = [];
+    const commentsRel = srels.find((r) => r.type === "comments");
+    const vmlRel = srels.find((r) => r.type === "vmlDrawing");
+    const authors = [];
+    if (commentsRel) {
+      const cx = pack.text(commentsRel.target) ?? "";
+      for (const m of cx.matchAll(/<(?:\w+:)?author>([\s\S]*?)<\/(?:\w+:)?author>|<(?:\w+:)?author\/>/g)) authors.push(unescape(m[1] ?? ""));
+      for (const m of cx.matchAll(/<(?:\w+:)?comment\b[^>]*>[\s\S]*?<\/(?:\w+:)?comment>/g)) {
+        const ref = attr2(m[0], "ref") ?? "";
+        const textXml = /<(?:\w+:)?text>([\s\S]*?)<\/(?:\w+:)?text>/.exec(m[0])?.[1] ?? "";
+        const note = { ref, xml: m[0], text: runs(textXml) };
+        sheetNotes.push(note);
+        const [r, c] = cell(ref);
+        if (r < 0) continue;
+        ((_b = notes2[sid] ?? (notes2[sid] = {}))[r] ?? (_b[r] = {}))[c] = { note: note.text, width: 160, height: 72, show: false, id: `n${sheetNotes.length - 1}`, row: r, col: c };
+        maxRow = Math.max(maxRow, r);
+        maxCol = Math.max(maxCol, c);
+      }
+    }
+    const height = Math.max(maxRow + 1 + 100, 1e3);
+    const width = Math.max(maxCol + 1 + 4, 26);
+    for (const spec of cols) {
+      for (let c = spec.min - 1; c < Math.min(spec.max, width); c++) {
+        const cd = {};
+        if (spec.width !== void 0) cd.w = spec.width;
+        if (spec.hidden) cd.hd = 1;
+        if (spec.style !== void 0) cd.s = useStyle(spec.style);
+        if (Object.keys(cd).length) sheet.columnData[c] = cd;
+      }
+    }
+    sheet.rowCount = height;
+    sheet.columnCount = width;
+    sheet.cellData = cellData;
+    sheet.rowData = rowData;
+    book.sheets[sid] = sheet;
+    book.sheetOrder.push(sid);
+    model.lines[sid] = { rows: numbered("r", height), cols: numbered("c", width) };
+    model.origin.lines[sid] = { rows: numbered("r", height), cols: numbered("c", width) };
+    model.origin.sheets[sid] = entry2.sheetId;
+    sheets.push({
+      sid,
+      name: entry2.name,
+      sheetId: entry2.sheetId,
+      part: rel.target,
+      xml: sxml,
+      p,
+      rels: srels,
+      bounds,
+      rows,
+      cells,
+      cols,
+      merges,
+      validations: dvs,
+      notes: sheetNotes,
+      comments: commentsRel?.target ?? null,
+      vml: vmlRel?.target ?? null,
+      authors,
+      width
+    });
+  }
+  const names = {};
+  for (const m of xml.matchAll(/<(?:\w+:)?definedName\b([^>]*)>([\s\S]*?)<\/(?:\w+:)?definedName>/g)) {
+    const name = attr2(m[0], "name") ?? "";
+    if (name.startsWith("_xlnm.") || /^(1|true)$/.test(attr2(m[0], "hidden") ?? "")) continue;
+    const local = attr2(m[0], "localSheetId");
+    const scoped = local === null ? null : entries2[Number(local)];
+    const id = `d${Object.keys(names).length}`;
+    names[id] = { id, name, formulaOrRefString: plain(unescape(m[2])), localSheetId: scoped ? `s${scoped.sheetId}` : "AllDefaultWorkbook" };
+  }
+  const resources = book.resources;
+  if (Object.keys(names).length) resources.push({ name: "SHEET_DEFINED_NAME_PLUGIN", data: JSON.stringify(names) });
+  if (Object.keys(notes2).length) resources.push({ name: "SHEET_NOTE_PLUGIN", data: JSON.stringify(notes2) });
+  if (Object.keys(validations).length) resources.push({ name: "SHEET_DATA_VALIDATION_PLUGIN", data: JSON.stringify(validations) });
+  if (Object.keys(filters).length) resources.push({ name: "SHEET_FILTER_PLUGIN", data: JSON.stringify(filters) });
+  const shown = entries2[active];
+  if (shown?.sheet && book.sheetOrder.includes(`s${shown.sheetId}`)) model.active = `s${shown.sheetId}`;
+  return { model, book: { pack, part, xml, rels, styles, stylesPart: stylesPart ?? null, sheets, entries: entries2 } };
+}
+var kinds = { whole: "whole", decimal: "decimal", list: "list", textLength: "textLength", custom: "custom" };
+var stops = { information: 0, stop: 1, warning: 2 };
+function validation(xml, uid) {
+  const type = attr2(xml, "type") ?? "none";
+  const kind = kinds[type];
+  const ranges = boxes(attr2(xml, "sqref") ?? "");
+  if (!kind || !ranges.length) return null;
+  const f = (n) => {
+    const m = new RegExp(`<(?:\\w+:)?formula${n}>([\\s\\S]*?)</(?:\\w+:)?formula${n}>`).exec(xml)?.[1];
+    return m === void 0 ? void 0 : plain(unescape(m));
+  };
+  let formula1 = f(1), formula2 = f(2);
+  if (kind === "list" && formula1 !== void 0) formula1 = /^".*"$/.test(formula1) ? formula1.slice(1, -1).replace(/""/g, '"') : "=" + formula1;
+  else if (kind === "custom" && formula1 !== void 0) formula1 = "=" + formula1;
+  else if (formula1 !== void 0 && !/^-?[\d.]+$/.test(formula1)) formula1 = "=" + formula1;
+  if (formula2 !== void 0 && !/^-?[\d.]+$/.test(formula2)) formula2 = "=" + formula2;
+  const flag = (name) => /^(1|true)$/.test(attr2(xml, name) ?? "");
+  const rule = { uid, type: kind, ranges: ranges.map((b) => ({ ...b, rangeType: 0 })) };
+  const operator = attr2(xml, "operator");
+  if (kind !== "list" && kind !== "custom") rule.operator = operator ?? "between";
+  if (formula1 !== void 0) rule.formula1 = formula1;
+  if (formula2 !== void 0) rule.formula2 = formula2;
+  if (flag("allowBlank")) rule.allowBlank = true;
+  if (kind === "list") rule.showDropDown = !flag("showDropDown");
+  if (flag("showErrorMessage")) rule.showErrorMessage = true;
+  if (flag("showInputMessage")) rule.showInputMessage = true;
+  const style = attr2(xml, "errorStyle");
+  if (style && style in stops) rule.errorStyle = stops[style];
+  for (const name of ["error", "errorTitle", "prompt", "promptTitle"]) if (attr2(xml, name) !== null) rule[name] = attr2(xml, name);
+  return rule;
+}
+function criteria(xml) {
+  const out = [];
+  for (const m of xml.matchAll(/<(?:\w+:)?filterColumn\b[^>]*>([\s\S]*?)<\/(?:\w+:)?filterColumn>/g)) {
+    const colId = Number(attr2(m[0], "colId") ?? 0);
+    const inner = m[1];
+    if (/<(?:\w+:)?filters\b/.test(inner)) {
+      const values = [...inner.matchAll(/<(?:\w+:)?filter\b[^>]*\/?>/g)].map((f) => attr2(f[0], "val") ?? "");
+      const blank2 = /<(?:\w+:)?filters\b[^>]*\bblank="(1|true)"/.test(inner);
+      out.push({ colId, filters: { ...values.length && { filters: values }, ...blank2 && { blank: true } } });
+    } else if (/<(?:\w+:)?customFilters\b/.test(inner)) {
+      const and = /<(?:\w+:)?customFilters\b[^>]*\band="(1|true)"/.test(inner);
+      const list = [...inner.matchAll(/<(?:\w+:)?customFilter\b[^>]*\/?>/g)].map((f) => ({ ...attr2(f[0], "operator") && { operator: attr2(f[0], "operator") }, val: attr2(f[0], "val") ?? "" }));
+      out.push({ colId, customFilters: { ...and && { and: 1 }, customFilters: list } });
+    }
+  }
+  return out;
+}
+
+// src/sheets/write.ts
+var order = [
+  "sheetPr",
+  "dimension",
+  "sheetViews",
+  "sheetFormatPr",
+  "cols",
+  "sheetData",
+  "sheetCalcPr",
+  "sheetProtection",
+  "protectedRanges",
+  "scenarios",
+  "autoFilter",
+  "sortState",
+  "dataConsolidate",
+  "customSheetViews",
+  "mergeCells",
+  "phoneticPr",
+  "conditionalFormatting",
+  "dataValidations",
+  "hyperlinks",
+  "printOptions",
+  "pageMargins",
+  "pageSetup",
+  "headerFooter",
+  "rowBreaks",
+  "colBreaks",
+  "customProperties",
+  "cellWatches",
+  "ignoredErrors",
+  "smartTags",
+  "drawing",
+  "legacyDrawing",
+  "legacyDrawingHF",
+  "drawingHF",
+  "picture",
+  "oleObjects",
+  "controls",
+  "webPublishItems",
+  "tableParts",
+  "extLst"
+];
+var errors = /^#(NULL!|DIV\/0!|VALUE!|REF!|NAME\?|NUM!|N\/A|GETTING_DATA|SPILL!|CALC!)$/;
+var REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var blankSheet = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><dimension ref="A1"/><sheetViews><sheetView workbookViewId="0"/></sheetViews><sheetFormatPr defaultRowHeight="15"/><sheetData/><pageMargins left="0.7" right="0.7" top="0.75" bottom="0.75" header="0.3" footer="0.3"/></worksheet>';
+var same = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+var blank = (v) => v === void 0 || v === null || v === "";
+var patterns2 = /* @__PURE__ */ new Map();
+var setAttr = (tag, name, value2) => {
+  let re = patterns2.get(name);
+  if (!re) patterns2.set(name, re = new RegExp(`\\s${name}="[^"]*"`));
+  if (value2 === null) return tag.replace(re, "");
+  if (re.test(tag)) return tag.replace(re, () => ` ${name}="${escape(value2)}"`);
+  return tag.replace(/\s*(\/?>)$/, (end) => ` ${name}="${escape(value2)}"${end.trim()}`);
+};
+var literal = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function resource(book, name) {
+  const found = book.resources?.find((r) => r.name === name);
+  return found ? JSON.parse(found.data || "{}") : null;
+}
+function textOf(c) {
+  if (!c) return null;
+  const stream = c.p?.body?.dataStream;
+  if (stream !== void 0 && blank(c.v)) return stream.replace(/\r?\n$/, "").replace(/\r\n?/g, "\n");
+  if (c.t === 3 && typeof c.v === "number") return c.v === 1;
+  return c.v ?? null;
+}
+function formulas(cells) {
+  const masters = /* @__PURE__ */ new Map();
+  for (const [r, line] of Object.entries(cells)) for (const [c, x] of Object.entries(line ?? {})) if (x?.si && x.f) masters.set(x.si, { f: x.f, r: +r, c: +c });
+  return (r, c, x) => {
+    if (x.f) return x.f;
+    if (!x.si) return null;
+    const m = masters.get(x.si);
+    return m ? "=" + shifted(m.f.replace(/^=/, ""), r - m.r, c - m.c) : null;
+  };
+}
+function equalValue(a, b) {
+  if (blank(a) && blank(b)) return true;
+  if (typeof a === "number" && typeof b === "number") return a === b || Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b));
+  return a === b;
+}
+function lookup(book, s) {
+  if (!s) return {};
+  return (typeof s === "string" ? book.styles[s] : s) ?? {};
+}
+var Axis = class {
+  constructor(old, now) {
+    this.old = old;
+    this.now = now;
+    this.map = (i) => i < this.old.length ? this.at.get(this.old[i]) ?? -1 : i + this.shift;
+    this.from = (i) => i < this.now.length ? this.back.get(this.now[i]) ?? -1 : i - this.shift;
+    this.near = (i) => {
+      for (let j = i; j < this.old.length; j++) if (this.map(j) >= 0) return this.map(j);
+      for (let j = i; j >= 0; j--) if (this.map(j) >= 0) return this.map(j);
+      return 0;
+    };
+    this.at = new Map(now.map((id, i) => [id, i]));
+    this.back = new Map(old.map((id, i) => [id, i]));
+    this.moved = old.some((id, i) => this.at.get(id) !== i);
+    const last = old.length ? this.at.get(old[old.length - 1]) : void 0;
+    this.shift = last === void 0 ? now.length - old.length : last - (old.length - 1);
+  }
+};
+function find(xml, name) {
+  const m = new RegExp(`<((?:\\w+:)?${name})\\b[^>]*?(\\/?)>`).exec(xml);
+  if (!m) return null;
+  if (m[2]) return { start: m.index, end: m.index + m[0].length, tag: m[0] };
+  const close = xml.indexOf(`</${m[1]}>`, m.index);
+  return { start: m.index, end: close + m[1].length + 3, tag: m[0] };
+}
+function place(xml, name, value2) {
+  const found = find(xml, name);
+  if (found) return xml.slice(0, found.start) + (value2 ?? "") + xml.slice(found.end);
+  if (value2 === null) return xml;
+  const rank = order.indexOf(name);
+  let at = -1;
+  for (const later of order.slice(rank + 1)) {
+    const f = find(xml, later);
+    if (f && (at < 0 || f.start < at)) at = f.start;
+  }
+  if (at < 0) at = xml.search(/<\/(?:\w+:)?worksheet>\s*$/);
+  if (at < 0) at = xml.length;
+  return xml.slice(0, at) + value2 + xml.slice(at);
+}
+function remapZone(xml, mine, rows, cols) {
+  const ranges = (sqref) => boxes(sqref).map((b) => squeeze(b, rows.map, cols.map)).filter((b) => b !== null).map(span).join(" ");
+  const formula = (f) => remapped(f, mine, rows.map, cols.map);
+  let out = xml.replace(/<((?:\w+:)?)(conditionalFormatting|dataValidation|hyperlink|ignoredError|protectedRange)\b[^>]*?(?:\/>|>[\s\S]*?<\/\1\2>)/g, (all) => {
+    const sq = attr2(all, "sqref");
+    const ref = attr2(all, "ref");
+    let next = all;
+    if (sq !== null) {
+      const s = ranges(sq);
+      if (!s) return "";
+      next = setAttr(next.slice(0, next.indexOf(">") + 1), "sqref", s) + next.slice(next.indexOf(">") + 1);
+    }
+    if (ref !== null) {
+      const s = ranges(ref);
+      if (!s) return "";
+      next = setAttr(next.slice(0, next.indexOf(">") + 1), "ref", s) + next.slice(next.indexOf(">") + 1);
+    }
+    return next.replace(/<((?:\w+:)?)(formula|formula1|formula2)>([\s\S]*?)<\/\1\2>/g, (_, p, n, f) => `<${p}${n}>${escape(formula(unescape(f)))}</${p}${n}>`);
+  });
+  out = out.replace(/<((?:\w+:)?)(autoFilter|sortState|sortCondition)\b[^>]*?>/g, (tag) => {
+    const ref = attr2(tag, "ref");
+    return ref === null ? tag : setAttr(tag, "ref", ranges(ref) || ref);
+  });
+  out = out.replace(/<(xm:sqref)>([\s\S]*?)<\/xm:sqref>/g, (_, n, s) => `<${n}>${ranges(s)}</${n}>`);
+  out = out.replace(/<(xm:f)>([\s\S]*?)<\/xm:f>/g, (_, n, f) => `<${n}>${escape(formula(unescape(f)))}</${n}>`);
+  out = out.replace(/<((?:\w+:)?)(selection|pane)\b[^>]*?>/g, (tag) => {
+    let next = tag;
+    for (const name of ["activeCell", "topLeftCell"]) {
+      const v = attr2(next, name);
+      if (v === null) continue;
+      const [r, c] = cell(v);
+      if (r >= 0) next = setAttr(next, name, a1(rows.near(r), cols.near(c)));
+    }
+    const sq = attr2(next, "sqref");
+    return sq === null ? next : setAttr(next, "sqref", ranges(sq) || "A1");
+  });
+  return out;
+}
+function anchors(xml, rows, cols) {
+  return xml.replace(/<((?:\w+:)?)(from|to)>([\s\S]*?)<\/\1\2>/g, (all, p, n, inner) => {
+    const next = inner.replace(/<((?:\w+:)?)col>(\d+)<\/\1col>/, (_, q, v) => `<${q}col>${cols.near(Number(v))}</${q}col>`).replace(/<((?:\w+:)?)row>(\d+)<\/\1row>/, (_, q, v) => `<${q}row>${rows.near(Number(v))}</${q}row>`);
+    return `<${p}${n}>${next}</${p}${n}>`;
+  });
+}
+function writeXlsx(original, model) {
+  const { model: base, book } = load(original);
+  const { pack, styles } = book;
+  const cur = model.book;
+  const defaults = norm(styles.looks[0] ?? {});
+  const bySheetId = new Map(book.sheets.map((s) => [s.sheetId, s]));
+  const kept = new Set(cur.sheetOrder.map((sid) => model.origin.sheets[sid]).filter((id) => bySheetId.has(id)));
+  const removed = book.sheets.filter((s) => !kept.has(s.sheetId));
+  const charts = [...pack.names.keys()].filter((n) => /^xl\/charts\/chart[^/]*\.xml$/.test(n));
+  const caches = book.rels.filter((r) => r.type === "pivotCacheDefinition").map((r) => r.target);
+  for (const gone of removed) {
+    const pattern = new RegExp(`(^|[^\\w.])(${literal(gone.name)}|'${literal(gone.name.replace(/'/g, "''"))}')!`);
+    const own = new Set(gone.rels.filter((r) => r.type === "drawing").flatMap((r) => pack.rels(r.target)).filter((r) => r.type === "chart").map((r) => r.target));
+    if (charts.some((c) => !own.has(c) && [...(pack.text(c) ?? "").matchAll(/<(?:\w+:)?f>([\s\S]*?)<\/(?:\w+:)?f>/g)].some((m) => pattern.test(unescape(m[1]))))) throw new SheetRefusal("chartSource", gone.name);
+    if (caches.some((c) => new RegExp(`<(?:\\w+:)?worksheetSource\\b[^>]*\\bsheet="${literal(escape(gone.name))}"`).test(pack.text(c) ?? ""))) throw new SheetRefusal("pivotSheet", gone.name);
+  }
+  const names = /* @__PURE__ */ new Map();
+  const axes = /* @__PURE__ */ new Map();
+  let touched = false;
+  const sheetParts = [];
+  let nextSheetId = Math.max(0, ...book.entries.map((e) => e.sheetId)) + 1;
+  let nextRid = Math.max(0, ...book.rels.map((r) => Number(/\d+$/.exec(r.id)?.[0] ?? 0))) + 1;
+  const used = new Set(pack.names.keys());
+  const fresh2 = (pattern) => {
+    let n = 1;
+    while (used.has(pattern(n)) || pack.changed.has(pattern(n))) n++;
+    used.add(pattern(n));
+    return pattern(n);
+  };
+  const types = [];
+  const defaultsNeeded = /* @__PURE__ */ new Set();
+  for (const sid of cur.sheetOrder) {
+    const id = model.origin.sheets[sid];
+    const rec = id !== void 0 ? bySheetId.get(id) ?? null : null;
+    if (rec && [...axes.values()].every((a) => a.rec !== rec)) {
+      const lines2 = model.lines[sid], old = model.origin.lines[sid] ?? base.lines[rec.sid];
+      axes.set(sid, { rows: new Axis(old.rows, lines2.rows), cols: new Axis(old.cols, lines2.cols), rec });
+      sheetParts.push({ sid, rec, part: rec.part, rid: book.entries.find((e) => e.sheetId === rec.sheetId).rid, sheetId: rec.sheetId });
+      if (cur.sheets[sid].name !== rec.name) names.set(rec.name, cur.sheets[sid].name);
+    } else {
+      const part = fresh2((n) => `xl/worksheets/sheet${n}.xml`);
+      sheetParts.push({ sid, rec: null, part, rid: `rId${nextRid++}`, sheetId: nextSheetId++ });
+      types.push([`/${part}`, "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"]);
+    }
+  }
+  const curNotes = resource(cur, "SHEET_NOTE_PLUGIN");
+  const curRules = resource(cur, "SHEET_DATA_VALIDATION_PLUGIN");
+  const curFilters = resource(cur, "SHEET_FILTER_PLUGIN");
+  const baseRules = resource(base.book, "SHEET_DATA_VALIDATION_PLUGIN") ?? {};
+  const baseFilters = resource(base.book, "SHEET_FILTER_PLUGIN") ?? {};
+  const filterNames = /* @__PURE__ */ new Map();
+  for (const entry2 of sheetParts) {
+    const { sid, rec } = entry2;
+    const sheet = cur.sheets[sid];
+    const ax = axes.get(sid);
+    const rows = ax?.rows ?? new Axis([], model.lines[sid]?.rows ?? []);
+    const cols = ax?.cols ?? new Axis([], model.lines[sid]?.cols ?? []);
+    const old = rec ? base.book.sheets[rec.sid] : {};
+    const xml = rec?.xml ?? blankSheet;
+    const p = rec?.p ?? "";
+    const cells = sheet.cellData ?? {};
+    const oldCells = old.cellData ?? {};
+    const fOf = formulas(cells);
+    const rowStyle = (sh, r) => sh.rowData?.[r]?.s;
+    const colStyle = (sh, c) => sh.columnData?.[c]?.s;
+    const seen2 = /* @__PURE__ */ new Map();
+    const looks = (bk, sh, r, c, x) => {
+      const s = x?.s ?? colStyle(sh, c) ?? rowStyle(sh, r);
+      const id = typeof s === "string" ? (bk === cur ? "c" : "b") + s : "";
+      const known = id && seen2.get(id);
+      if (known) return known;
+      const look = norm({ ...defaults, ...lookup(bk, s) });
+      const made2 = { look, json: JSON.stringify(look) };
+      if (id) seen2.set(id, made2);
+      return made2;
+    };
+    const xfOf = (s) => typeof s === "string" && /^x\d+$/.test(s) ? Number(s.slice(1)) : 0;
+    const xfFor = (look, was) => {
+      if (same(norm(styles.looks[was] ?? {}), look) || was === 0 && same(defaults, look)) return was;
+      return styles.find(look) ?? styles.derive(was, look);
+    };
+    let changed2 = !rec || rows.moved || cols.moved;
+    let reused = 0, total = 0;
+    for (const [r, line] of Object.entries(oldCells)) for (const c of Object.keys(line ?? {})) if (rows.map(+r) >= 0 && cols.map(+c) >= 0) total++;
+    const body = [];
+    const filtered = new Set(curFilters?.[sid]?.cachedFilteredOut ?? []);
+    const indices = /* @__PURE__ */ new Set();
+    for (const [r, line] of Object.entries(cells)) if (line && Object.keys(line).length) indices.add(+r);
+    for (const [r, rd] of Object.entries(sheet.rowData ?? {})) if (rd && (rd.h !== void 0 || rd.hd || rd.s)) indices.add(+r);
+    if (rec) for (const r0 of rec.rows.keys()) {
+      const r = rows.map(r0);
+      if (r >= 0) indices.add(r);
+    }
+    for (const r of filtered) indices.add(r);
+    let minR = Infinity, minC = Infinity, maxR = -1, maxC = -1;
+    for (const r of [...indices].sort((a, b) => a - b)) {
+      const r0 = rows.from(r);
+      const orow = r0 >= 0 ? rec?.rows.get(r0) : void 0;
+      const rd = sheet.rowData?.[r] ?? {};
+      const od = r0 >= 0 ? old.rowData?.[r0] ?? {} : {};
+      let tag = orow ? orow.open.replace(/\s*\/>$/, ">") : `<${p}row>`;
+      tag = setAttr(tag, "r", String(r + 1));
+      if (orow && (rows.moved || cols.moved)) tag = setAttr(tag, "spans", null);
+      if (Math.abs((rd.h ?? -1) - (od.h ?? -1)) > 0.5) {
+        changed2 = true;
+        tag = setAttr(setAttr(tag, "ht", rd.h === void 0 ? null : String(pt.row(rd.h))), "customHeight", rd.h === void 0 ? null : "1");
+      }
+      const hidden = !!rd.hd || filtered.has(r);
+      if (hidden !== !!od.hd) {
+        changed2 = true;
+        tag = setAttr(tag, "hidden", hidden ? "1" : null);
+      }
+      const look = rd.s ? norm({ ...defaults, ...lookup(cur, rd.s) }) : null;
+      const was = od.s ? norm({ ...defaults, ...lookup(base.book, od.s) }) : null;
+      if (!same(look, was)) {
+        changed2 = true;
+        tag = setAttr(setAttr(tag, "s", look ? String(xfFor(look, xfOf(od.s))) : null), "customFormat", look ? "1" : null);
+      }
+      const line = cells[r] ?? {};
+      const parts2 = [];
+      for (const c of Object.keys(line).map(Number).sort((a, b) => a - b)) {
+        const x = line[c];
+        if (!x) continue;
+        const c0 = cols.from(c);
+        const ox = r0 >= 0 && c0 >= 0 ? oldCells[r0]?.[c0] : void 0;
+        const f = fOf(r, c, x);
+        const v = textOf(x);
+        const look2 = looks(cur, sheet, r, c, x);
+        const orec = r0 >= 0 && c0 >= 0 ? rec?.cells.get(key(r0, c0)) : void 0;
+        const unchanged = !!ox && (ox.f ?? null) === f && equalValue(textOf(ox), v) && looks(base.book, old, r0, c0, ox).json === look2.json;
+        if (unchanged) reused++;
+        if (blank(v) && !f && !x.s) continue;
+        if (unchanged && orec && !orec.shared) {
+          const raw = xml.slice(orec.start, orec.end);
+          parts2.push(rows.moved || cols.moved ? raw.replace(/^<[^>]*>/, (t) => setAttr(t, "r", a1(r, c))) : raw);
+        } else {
+          if (!unchanged) changed2 = true;
+          const xf = xfFor(look2.look, xfOf(ox?.s ?? colStyle(sheet, c) ?? rowStyle(sheet, r)));
+          const out = cellXml(p, a1(r, c), xf, x, f, v);
+          if (!out) continue;
+          parts2.push(out);
+        }
+        minR = Math.min(minR, r);
+        maxR = Math.max(maxR, r);
+        minC = Math.min(minC, c);
+        maxC = Math.max(maxC, c);
+      }
+      if (!parts2.length && !orow && !rd.h && !hidden && !look) continue;
+      body.push(parts2.length ? `${tag}${parts2.join("")}</${p}row>` : tag.replace(/>$/, "/>"));
+    }
+    if (rec && reused !== total) changed2 = true;
+    let head = xml.slice(0, rec ? rec.bounds[0] : xml.indexOf("<sheetData"));
+    let tail = xml.slice(rec ? rec.bounds[3] : xml.indexOf("<sheetData/>") + 12);
+    const mine = (s) => s === null || s === rec?.name;
+    if (rec && (rows.moved || cols.moved)) {
+      head = remapZone(head, mine, rows, cols);
+      tail = remapZone(tail, mine, rows, cols);
+    }
+    const colXml = columns(p, rec, sheet, old, cols, defaults, cur, base.book, xfFor, xfOf);
+    if (colXml !== void 0) {
+      changed2 = true;
+      head = place(head, "cols", colXml);
+    }
+    const merges = (sheet.mergeData ?? []).map((m) => span(m)).sort();
+    const oldMerges = [...rec?.merges ?? []].map((m) => span(box(m))).sort();
+    if (!same(merges, oldMerges)) {
+      changed2 = true;
+      tail = place(tail, "mergeCells", merges.length ? `<${p}mergeCells count="${merges.length}">${merges.map((m) => `<${p}mergeCell ref="${m}"/>`).join("")}</${p}mergeCells>` : null);
+    }
+    const freeze = sheet.freeze && (sheet.freeze.xSplit > 0 || sheet.freeze.ySplit > 0) ? [sheet.freeze.xSplit, sheet.freeze.ySplit] : [0, 0];
+    const oldFreeze = old.freeze ? [old.freeze.xSplit, old.freeze.ySplit] : [0, 0];
+    if (!same(freeze, oldFreeze)) {
+      changed2 = true;
+      head = frozen(head, p, freeze[0], freeze[1]);
+    }
+    if ((sheet.showGridlines ?? 1) !== (old.showGridlines ?? 1)) {
+      changed2 = true;
+      head = head.replace(/<(?:\w+:)?sheetView\b[^>]*?>/, (t) => setAttr(t, "showGridLines", sheet.showGridlines === 0 ? "0" : null));
+    }
+    if ((sheet.tabColor ?? "") !== (old.tabColor ?? "")) {
+      changed2 = true;
+      head = tabColour(head, p, sheet.tabColor ?? "");
+    }
+    const rules = (curRules ? curRules[sid] ?? [] : rec ? baseRules[rec.sid] ?? [] : []).map((r) => ({ ...r, ranges: r.ranges.map((b) => ({ startRow: b.startRow, startColumn: b.startColumn, endRow: b.endRow, endColumn: b.endColumn })) }));
+    const oldRules = (rec ? baseRules[rec.sid] ?? [] : []).map((r) => ({ ...r, ranges: r.ranges.map((b) => squeeze(b, rows.map, cols.map)).filter(Boolean) }));
+    if (curRules && !same(rules.map(canonRule), oldRules.map(canonRule))) {
+      changed2 = true;
+      const known = new Map((rec?.validations ?? []).map((v, i) => [`dv${i}`, v]));
+      const shown = new Set(rules.map((r) => r.uid));
+      const hiddenRules = [...known].filter(([uid, v]) => !shown.has(uid) && !(rec && baseRules[rec.sid]?.some((r) => r.uid === uid)) && v).map(([, v]) => rows.moved || cols.moved ? remapZone(v, mine, rows, cols) : v);
+      const list = [...hiddenRules, ...rules.map((r) => validationXml(p, r, known.get(r.uid)))].filter(Boolean);
+      tail = place(tail, "dataValidations", list.length ? `<${p}dataValidations count="${list.length}">${list.join("")}</${p}dataValidations>` : null);
+    }
+    const oldFilter = rec ? baseFilters[rec.sid] ?? null : null;
+    const filter = curFilters ? curFilters[sid] ?? null : oldFilter;
+    const fref = filter?.ref ? span(filter.ref) : null;
+    const oref = oldFilter?.ref ? (() => {
+      const b = squeeze(oldFilter.ref, rows.map, cols.map);
+      return b && span(b);
+    })() : null;
+    if (curFilters && (fref !== oref || !same(filter?.filterColumns ?? [], oldFilter?.filterColumns ?? []))) {
+      changed2 = true;
+      tail = place(tail, "autoFilter", filter?.ref ? filterXml(p, filter.ref, filter.filterColumns ?? []) : null);
+      filterNames.set(entry2.sheetId, filter?.ref ? `${quoted(sheet.name)}!${span(filter.ref).split(":").map((s) => s.replace(/([A-Z]+)(\d+)/, "$$$1$$$2")).join(":")}` : null);
+    }
+    const notes2 = Object.values(curNotes?.[sid] ?? {}).flatMap((line) => Object.values(line ?? {})).filter((n) => n && !blank(n.note));
+    const oldNotes = (rec?.notes ?? []).map((n) => ({ ref: n.ref, text: n.text }));
+    const nowNotes = notes2.map((n) => ({ ref: a1(n.row, n.col), text: n.note })).sort((a, b) => a.ref.localeCompare(b.ref));
+    if (curNotes && !same(nowNotes, [...oldNotes].sort((a, b) => a.ref.localeCompare(b.ref)))) {
+      changed2 = true;
+      tail = writeNotes(book, entry2, tail, p, notes2, rows, cols, types, defaultsNeeded, fresh2);
+    }
+    const rename = (s) => names.size ? s.replace(/<(xm:f|(?:\w+:)?formula\d?)>([\s\S]*?)<\/\1>/g, (_, n, f) => `<${n}>${escape([...names].reduce((g, [from, to]) => renamed(g, from, to), unescape(f)))}</${n}>`) : s;
+    if (!changed2) {
+      if (rec && rename(xml) !== xml) pack.put(entry2.part, rename(xml));
+      continue;
+    }
+    touched = true;
+    head = rename(head);
+    tail = rename(tail);
+    if (/\sr:id="/.test(tail) && !/xmlns:r=/.test(head)) head = head.replace(/<((?:\w+:)?worksheet)\b/, `<$1 xmlns:r="${REL}"`);
+    const dim = maxR < 0 ? "A1" : span({ startRow: minR, startColumn: minC, endRow: maxR, endColumn: maxC });
+    head = /<(?:\w+:)?dimension\b/.test(head) ? head.replace(/<((?:\w+:)?)dimension\b[^>]*\/?>/, `<$1dimension ref="${dim}"/>`) : place(head, "dimension", `<${p}dimension ref="${dim}"/>`);
+    pack.put(entry2.part, head + (body.length ? `<${p}sheetData>${body.join("")}</${p}sheetData>` : `<${p}sheetData/>`) + tail);
+    if (rec && (rows.moved || cols.moved)) {
+      for (const rel of rec.rels) {
+        if (rel.external) continue;
+        if (rel.type === "drawing") {
+          const d = pack.text(rel.target);
+          if (d) pack.put(rel.target, anchors(d, rows, cols));
+        }
+        if (rel.type === "table") {
+          const t = pack.text(rel.target);
+          if (!t) continue;
+          const ref = attr2(/<(?:\w+:)?table\b[^>]*>/.exec(t)?.[0] ?? "", "ref");
+          const b = ref && box(ref);
+          const moved = b && squeeze(b, rows.map, cols.map);
+          if (b && moved && moved.endColumn - moved.startColumn !== b.endColumn - b.startColumn) throw new SheetRefusal("tableColumns", rec.name);
+          if (moved) pack.put(rel.target, t.replace(/(<(?:\w+:)?(?:table|autoFilter)\b[^>]*?\sref=")([^"]*)"/g, (_, a, r) => `${a}${span(squeeze(box(r), rows.map, cols.map) ?? box(r))}"`));
+        }
+      }
+    }
+  }
+  const sheetStyles = styles.build();
+  if (sheetStyles) {
+    const target = book.stylesPart ?? "xl/styles.xml";
+    pack.put(target, sheetStyles);
+    if (!book.stylesPart) {
+      types.push([`/${target}`, "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"]);
+      pack.put(relsOf(book.part), (pack.text(relsOf(book.part)) ?? "").replace(/<\/(?:\w+:)?Relationships>/, (end) => `<Relationship Id="rId${nextRid++}" Type="${REL}/styles" Target="${relative(book.part, target)}"/>${end}`));
+    }
+    touched = true;
+  }
+  for (const [sid, ax] of axes) {
+    if (!ax.rows.moved && !ax.cols.moved) continue;
+    const name = ax.rec.name;
+    const mine = (s) => s === name;
+    for (const c of charts) {
+      const t = pack.text(c);
+      if (t && t.includes(name)) pack.put(c, t.replace(/<((?:\w+:)?)f>([\s\S]*?)<\/\1f>/g, (_, p, f) => `<${p}f>${escape(remapped(unescape(f), mine, ax.rows.map, ax.cols.map))}</${p}f>`));
+    }
+    for (const c of caches) {
+      const t = pack.text(c);
+      if (t) pack.put(c, t.replace(/<(?:\w+:)?worksheetSource\b[^>]*>/g, (tag) => attr2(tag, "sheet") === name && attr2(tag, "ref") ? setAttr(tag, "ref", span(squeeze(box(attr2(tag, "ref")), ax.rows.map, ax.cols.map) ?? box(attr2(tag, "ref")))) : tag));
+    }
+    for (const other of sheetParts) {
+      if (other.sid === sid || !other.rec) continue;
+      const t = pack.text(other.part);
+      if (t && t.includes(name)) pack.put(other.part, t.replace(/<(xm:f|(?:\w+:)?formula\d?)>([\s\S]*?)<\/\1>/g, (_, n, f) => `<${n}>${escape(remapped(unescape(f), mine, ax.rows.map, ax.cols.map))}</${n}>`));
+    }
+  }
+  for (const [from, to] of names) {
+    for (const c of charts) {
+      const t = pack.text(c);
+      if (t && t.includes(from)) pack.put(c, t.replace(/<((?:\w+:)?)f>([\s\S]*?)<\/\1f>/g, (_, p, f) => `<${p}f>${escape(renamed(unescape(f), from, to))}</${p}f>`));
+    }
+    for (const c of caches) {
+      const t = pack.text(c);
+      if (t) pack.put(c, t.replace(/(<(?:\w+:)?worksheetSource\b[^>]*\ssheet=")([^"]*)"/g, (all, a, s) => unescape(s) === from ? `${a}${escape(to)}"` : all));
+    }
+  }
+  const sheetsChanged = removed.length > 0 || names.size > 0 || sheetParts.some((s) => !s.rec) || sheetParts.map((s) => s.sheetId).join() !== book.entries.filter((e) => e.sheet && kept.has(e.sheetId)).map((e) => e.sheetId).join() || cur.sheetOrder.some((sid) => {
+    const rec = axes.get(sid)?.rec;
+    return !!rec && (cur.sheets[sid].hidden ?? 0) !== (base.book.sheets[rec.sid].hidden ?? 0);
+  });
+  if (!touched && !sheetsChanged && !filterNames.size) return original;
+  let wb = book.xml;
+  const listed = [];
+  const nonSheets = book.entries.map((e, i) => ({ e, i })).filter((x) => !x.e.sheet);
+  const indexOf = new Map(book.entries.map((e, i) => [e.sheetId, i]));
+  const wp = /<(\w+:)?workbook\b/.exec(wb)?.[1] ?? "";
+  const relPrefix = /xmlns:(\w+)="http:\/\/schemas\.openxmlformats\.org\/officeDocument\/2006\/relationships"/.exec(wb)?.[1] ?? "r";
+  for (const s of sheetParts) {
+    const sheet = cur.sheets[s.sid];
+    const state = sheet.hidden === 2 ? "veryHidden" : sheet.hidden ? "hidden" : null;
+    let tag = s.rec ? book.entries.find((e) => e.sheetId === s.sheetId).xml : `<${wp}sheet name="" sheetId="${s.sheetId}" ${relPrefix}:id="${s.rid}"/>`;
+    tag = setAttr(setAttr(tag, "name", sheet.name ?? `Sheet${s.sheetId}`), "state", state);
+    listed.push({ xml: tag, sheetId: s.sheetId, oldIndex: s.rec ? indexOf.get(s.sheetId) : -1 });
+  }
+  for (const { e, i } of nonSheets) {
+    let at = listed.findIndex((x) => x.oldIndex > i);
+    if (at < 0) at = listed.length;
+    listed.splice(at, 0, { xml: e.xml, sheetId: e.sheetId, oldIndex: i });
+  }
+  wb = wb.replace(/(<(?:\w+:)?sheets\b[^>]*>)[\s\S]*?(<\/(?:\w+:)?sheets>)/, (_, a, b) => a + listed.map((x) => x.xml).join("") + b);
+  const newIndex = new Map(listed.map((x, i) => [x.oldIndex, i]));
+  const sheetIndex = new Map(listed.map((x, i) => [x.sheetId, i]));
+  const removedNames = new Set(removed.map((r) => r.name));
+  wb = wb.replace(/<((?:\w+:)?)definedName\b([^>]*)>([\s\S]*?)<\/\1definedName>/g, (all, p, attrs0, body) => {
+    let tag = `<${p}definedName${attrs0}>`;
+    const local = attr2(tag, "localSheetId");
+    if (local !== null) {
+      const next = newIndex.get(Number(local));
+      if (next === void 0) return "";
+      tag = setAttr(tag, "localSheetId", String(next));
+      const owner = listed[next];
+      if (attr2(tag, "name") === "_xlnm._FilterDatabase" && filterNames.has(owner.sheetId)) {
+        const f2 = filterNames.get(owner.sheetId);
+        filterNames.delete(owner.sheetId);
+        return f2 ? `${tag}${escape(f2)}</${p}definedName>` : "";
+      }
+    }
+    let f = unescape(body);
+    for (const gone of removedNames) f = f.replace(new RegExp(`(?:'${literal(gone.replace(/'/g, "''"))}'|${literal(gone)})![$A-Z0-9:]+`, "g"), "#REF!");
+    for (const [, ax] of axes) if (ax.rows.moved || ax.cols.moved) f = remapped(f, (s) => s === ax.rec.name, ax.rows.map, ax.cols.map);
+    for (const [from, to] of names) f = renamed(f, from, to);
+    return `${tag}${escape(f)}</${p}definedName>`;
+  });
+  for (const [sheetId, f] of filterNames) {
+    if (!f) continue;
+    const def = `<${wp}definedName name="_xlnm._FilterDatabase" localSheetId="${sheetIndex.get(sheetId)}" hidden="1">${escape(f)}</${wp}definedName>`;
+    wb = /<(?:\w+:)?definedNames\b/.test(wb) ? wb.replace(/<\/(?:\w+:)?definedNames>/, (end) => def + end) : wb.replace(/<\/(?:\w+:)?sheets>/, (end) => `${end}<${wp}definedNames>${def}</${wp}definedNames>`);
+  }
+  wb = wb.replace(/<((?:\w+:)?)definedNames>\s*<\/\1definedNames>/, "");
+  wb = wb.replace(/<(?:\w+:)?workbookView\b[^>]*>/g, (tag) => {
+    const total = listed.length;
+    let next = tag;
+    const tab = attr2(next, "activeTab");
+    if (tab !== null) next = setAttr(next, "activeTab", String(Math.min(newIndex.get(Number(tab)) ?? 0, total - 1)));
+    const first = attr2(next, "firstSheet");
+    if (first !== null) next = setAttr(next, "firstSheet", String(Math.min(newIndex.get(Number(first)) ?? 0, total - 1)));
+    return next;
+  });
+  if (touched) {
+    wb = /<(?:\w+:)?calcPr\b/.test(wb) ? wb.replace(/<(?:\w+:)?calcPr\b[^>]*?\/?>/, (tag) => setAttr(tag, "fullCalcOnLoad", "1")) : wb.replace(/(<\/(?:\w+:)?sheets>(?:\s*<(?:\w+:)?(?:functionGroups|externalReferences|definedNames)\b[\s\S]*?<\/(?:\w+:)?(?:functionGroups|externalReferences|definedNames)>)*)/, `$1<${wp}calcPr fullCalcOnLoad="1"/>`);
+  }
+  pack.put(book.part, wb);
+  let rels = pack.text(relsOf(book.part)) ?? "";
+  for (const gone of removed) {
+    const entry2 = book.entries.find((e) => e.sheetId === gone.sheetId);
+    rels = rels.replace(new RegExp(`<(?:\\w+:)?Relationship\\b[^>]*\\bId="${entry2.rid}"[^>]*\\/>`), "");
+    pack.put(gone.part, null);
+    pack.put(relsOf(gone.part), null);
+    types.push([`/${gone.part}`, null]);
+  }
+  const calc = book.rels.find((r) => r.type === "calcChain");
+  if (calc && touched) {
+    rels = rels.replace(new RegExp(`<(?:\\w+:)?Relationship\\b[^>]*\\bId="${calc.id}"[^>]*\\/>`), "");
+    pack.put(calc.target, null);
+    types.push([`/${calc.target}`, null]);
+  }
+  for (const s of sheetParts) if (!s.rec) rels = rels.replace(/<\/(?:\w+:)?Relationships>/, (end) => `<Relationship Id="${s.rid}" Type="${REL}/worksheet" Target="${relative(book.part, s.part)}"/>${end}`);
+  pack.put(relsOf(book.part), rels);
+  contentTypes(pack, types, defaultsNeeded);
+  return copy(pack.build());
+}
+var copy = (u) => u.buffer.slice(u.byteOffset, u.byteOffset + u.byteLength);
+function contentTypes(pack, types, defaults) {
+  if (!types.length && !defaults.size) return;
+  let ct = pack.text("[Content_Types].xml") ?? "";
+  for (const [name, type] of types) {
+    ct = ct.replace(new RegExp(`<Override\\b[^>]*PartName="${literal(name)}"[^>]*\\/>`), "");
+    if (type) ct = ct.replace("</Types>", () => `<Override PartName="${name}" ContentType="${type}"/></Types>`);
+  }
+  for (const ext of defaults) if (!new RegExp(`Extension="${ext}"`, "i").test(ct)) ct = ct.replace(/(<Types\b[^>]*>)/, `$1<Default Extension="${ext}" ContentType="application/vnd.openxmlformats-officedocument.vmlDrawing"/>`);
+  pack.put("[Content_Types].xml", ct);
+}
+function cellXml(p, ref, xf, x, f, v) {
+  const s = xf ? ` s="${xf}"` : "";
+  if (f) {
+    const body = escape(stored(f.replace(/^=/, "")));
+    let t = "", val = "";
+    if (typeof v === "number" && Number.isFinite(v)) val = `<${p}v>${v}</${p}v>`;
+    else if (typeof v === "boolean" || x.t === 3) {
+      t = ' t="b"';
+      val = `<${p}v>${v === true || v === 1 ? 1 : 0}</${p}v>`;
+    } else if (typeof v === "string" && v !== "") {
+      t = errors.test(v) ? ' t="e"' : ' t="str"';
+      val = `<${p}v>${escape(v)}</${p}v>`;
+    }
+    return `<${p}c r="${ref}"${s}${t}><${p}f>${body}</${p}f>${val}</${p}c>`;
+  }
+  if (blank(v)) return xf ? `<${p}c r="${ref}"${s}/>` : "";
+  if (typeof v === "boolean") return `<${p}c r="${ref}"${s} t="b"><${p}v>${v ? 1 : 0}</${p}v></${p}c>`;
+  if (typeof v === "number") return Number.isFinite(v) ? `<${p}c r="${ref}"${s}><${p}v>${v}</${p}v></${p}c>` : `<${p}c r="${ref}"${s} t="e"><${p}v>#NUM!</${p}v></${p}c>`;
+  const str = String(v);
+  if (x.t === 2 && str.trim() !== "" && Number.isFinite(Number(str))) return `<${p}c r="${ref}"${s}><${p}v>${Number(str)}</${p}v></${p}c>`;
+  if (x.t !== 4 && errors.test(str)) return `<${p}c r="${ref}"${s} t="e"><${p}v>${escape(str)}</${p}v></${p}c>`;
+  const space = /^\s|\s$|\n/.test(str) ? ' xml:space="preserve"' : "";
+  return `<${p}c r="${ref}"${s} t="inlineStr"><${p}is><${p}t${space}>${escape(str)}</${p}t></${p}is></${p}c>`;
+}
+function columns(p, rec, sheet, old, cols, defaults, cur, baseBook, xfFor, xfOf) {
+  const now = sheet.columnData ?? {}, was = old.columnData ?? {};
+  const count = sheet.columnCount ?? 26;
+  const look = (bk, s) => s ? norm({ ...defaults, ...lookup(bk, s) }) : null;
+  let differs = cols.moved;
+  for (let c = 0; c < count && !differs; c++) {
+    const c0 = cols.from(c);
+    const a = now[c] ?? {}, b = c0 >= 0 ? was[c0] ?? {} : {};
+    if (Math.abs((a.w ?? -1) - (b.w ?? -1)) > 0.5 || !!a.hd !== !!b.hd || !same(look(cur, a.s), look(baseBook, b.s))) differs = true;
+  }
+  if (!differs) return void 0;
+  const specs = rec?.cols ?? [];
+  const specAt = (c0) => specs.find((s) => c0 + 1 >= s.min && c0 + 1 <= s.max);
+  const out = [];
+  for (let c = 0; c < count; c++) {
+    const c0 = cols.from(c);
+    const spec = c0 >= 0 ? specAt(c0) : void 0;
+    const a = new Map(spec ? [...spec.xml.matchAll(/([\w:]+)="([^"]*)"/g)].map((m) => [m[1], m[2]]) : []);
+    a.delete("min");
+    a.delete("max");
+    const n = now[c] ?? {}, o = c0 >= 0 ? was[c0] ?? {} : {};
+    if (Math.abs((n.w ?? -1) - (o.w ?? -1)) > 0.5) {
+      if (n.w === void 0) {
+        a.delete("width");
+        a.delete("customWidth");
+      } else {
+        a.set("width", String(pt.col(n.w)));
+        a.set("customWidth", "1");
+      }
+    }
+    if (!!n.hd !== !!o.hd) n.hd ? a.set("hidden", "1") : a.delete("hidden");
+    const ln = look(cur, n.s), lo = look(baseBook, o.s);
+    if (!same(ln, lo)) ln ? a.set("style", String(xfFor(ln, xfOf(o.s)))) : a.delete("style");
+    if (!a.size) continue;
+    if (!a.has("width")) a.set("width", String(pt.col(sheet.defaultColumnWidth ?? 64)));
+    out.push({ c, attrs: a });
+  }
+  const runs2 = [];
+  for (let i = 0; i < out.length; i++) {
+    let j = i;
+    const k = JSON.stringify([...out[i].attrs]);
+    while (j + 1 < out.length && out[j + 1].c === out[j].c + 1 && JSON.stringify([...out[j + 1].attrs]) === k) j++;
+    runs2.push(`<${p}col min="${out[i].c + 1}" max="${out[j].c + 1}"${[...out[i].attrs].map(([n, v]) => ` ${n}="${v}"`).join("")}/>`);
+    i = j;
+  }
+  const shift = count - (rec?.width ?? count);
+  for (const spec of specs) {
+    if (spec.max <= (rec?.width ?? 0)) continue;
+    const min = Math.max(count + 1, spec.min + shift), max = Math.min(16384, spec.max + shift);
+    if (min <= max) runs2.push(spec.xml.replace(/\smin="\d+"/, ` min="${min}"`).replace(/\smax="\d+"/, ` max="${max}"`));
+  }
+  return runs2.length ? `<${p}cols>${runs2.join("")}</${p}cols>` : null;
+}
+function frozen(head, p, x, y) {
+  const pane = x || y ? `<${p}pane${x ? ` xSplit="${x}"` : ""}${y ? ` ySplit="${y}"` : ""} topLeftCell="${a1(y, x)}" activePane="${x && y ? "bottomRight" : y ? "bottomLeft" : "topRight"}" state="frozen"/>` : "";
+  const selection = x || y ? `<${p}selection pane="${x && y ? "bottomRight" : y ? "bottomLeft" : "topRight"}" activeCell="${a1(y, x)}" sqref="${a1(y, x)}"/>` : `<${p}selection activeCell="A1" sqref="A1"/>`;
+  const view = /<((?:\w+:)?)sheetView\b[^>]*?(\/?)>/.exec(head);
+  if (!view) return place(head, "sheetViews", `<${p}sheetViews><${p}sheetView workbookViewId="0">${pane}${selection}</${p}sheetView></${p}sheetViews>`);
+  if (view[2]) return head.slice(0, view.index) + view[0].replace(/\s*\/>$/, ">") + pane + selection + `</${view[1]}sheetView>` + head.slice(view.index + view[0].length);
+  const close = head.indexOf(`</${view[1]}sheetView>`, view.index);
+  const inner = head.slice(view.index + view[0].length, close).replace(/<(?:\w+:)?pane\b[^>]*\/>/g, "").replace(/<(?:\w+:)?selection\b[^>]*\/>/g, "");
+  return head.slice(0, view.index) + view[0] + pane + selection + inner + head.slice(close);
+}
+function tabColour(head, p, colour) {
+  const tag = colour ? `<${p}tabColor rgb="FF${colour.replace("#", "").toUpperCase()}"/>` : "";
+  if (/<(?:\w+:)?tabColor\b/.test(head)) return head.replace(/<(?:\w+:)?tabColor\b[^>]*\/>/, tag);
+  if (!colour) return head;
+  const pr = /<((?:\w+:)?)sheetPr\b[^>]*?(\/?)>/.exec(head);
+  if (!pr) return place(head, "sheetPr", `<${p}sheetPr>${tag}</${p}sheetPr>`);
+  if (pr[2]) return head.slice(0, pr.index) + pr[0].replace(/\s*\/>$/, ">") + tag + `</${pr[1]}sheetPr>` + head.slice(pr.index + pr[0].length);
+  return head.slice(0, pr.index + pr[0].length) + tag + head.slice(pr.index + pr[0].length);
+}
+function canonRule(r) {
+  const out = {};
+  for (const k of ["uid", "type", "operator", "formula1", "formula2", "allowBlank", "showDropDown", "showErrorMessage", "showInputMessage", "errorStyle", "error", "errorTitle", "prompt", "promptTitle"]) {
+    const v = r[k];
+    if (v !== void 0 && v !== null && v !== false && v !== "") out[k] = v;
+  }
+  if (out.type === "list" && out.showDropDown === void 0) out.showDropDown = true;
+  out.ranges = r.ranges.map((b) => span(b)).sort();
+  return out;
+}
+function validationXml(p, r, was) {
+  if (!["whole", "decimal", "list", "textLength", "custom", "date"].includes(String(r.type))) return "";
+  let tag = was ? was.slice(0, was.indexOf(">") + 1).replace(/\s*\/>$/, ">") : `<${p}dataValidation>`;
+  const bool = (name, on) => {
+    tag = setAttr(tag, name, on ? "1" : null);
+  };
+  tag = setAttr(tag, "type", String(r.type));
+  tag = setAttr(tag, "operator", r.type === "list" || r.type === "custom" || !r.operator || r.operator === "between" ? null : String(r.operator));
+  bool("allowBlank", r.allowBlank);
+  bool("showDropDown", r.type === "list" && r.showDropDown === false);
+  bool("showInputMessage", r.showInputMessage);
+  bool("showErrorMessage", r.showErrorMessage);
+  const style = Object.entries(stops).find(([, v]) => v === r.errorStyle)?.[0];
+  tag = setAttr(tag, "errorStyle", style && style !== "stop" ? style : null);
+  for (const name of ["errorTitle", "error", "promptTitle", "prompt"]) tag = setAttr(tag, name, blank(r[name]) ? null : String(r[name]));
+  tag = setAttr(tag, "sqref", r.ranges.map(span).join(" "));
+  const f1 = r.formula1 === void 0 ? "" : r.type === "list" && !String(r.formula1).startsWith("=") ? `"${listText(String(r.formula1)).replace(/"/g, '""')}"` : stored(String(r.formula1).replace(/^=/, ""));
+  const f2 = r.formula2 === void 0 ? "" : stored(String(r.formula2).replace(/^=/, ""));
+  return `${tag}${f1 ? `<${p}formula1>${escape(f1)}</${p}formula1>` : ""}${f2 ? `<${p}formula2>${escape(f2)}</${p}formula2>` : ""}</${p}dataValidation>`;
+}
+function listText(f) {
+  try {
+    const list = JSON.parse(f);
+    if (Array.isArray(list)) return list.join(",");
+  } catch {
+    return f;
+  }
+  return f;
+}
+function filterXml(p, ref, columns2) {
+  const body = columns2.map((c) => {
+    if (c.filters) return `<${p}filterColumn colId="${c.colId}"><${p}filters${c.filters.blank ? ' blank="1"' : ""}>${(c.filters.filters ?? []).map((v) => `<${p}filter val="${escape(String(v))}"/>`).join("")}</${p}filters></${p}filterColumn>`;
+    if (c.customFilters) return `<${p}filterColumn colId="${c.colId}"><${p}customFilters${c.customFilters.and ? ' and="1"' : ""}>${c.customFilters.customFilters.map((f) => `<${p}customFilter${f.operator ? ` operator="${f.operator}"` : ""} val="${escape(String(f.val))}"/>`).join("")}</${p}customFilters></${p}filterColumn>`;
+    return "";
+  }).join("");
+  return body ? `<${p}autoFilter ref="${span(ref)}">${body}</${p}autoFilter>` : `<${p}autoFilter ref="${span(ref)}"/>`;
+}
+function writeNotes(book, entry2, tail, p, notes2, rows, cols, types, defaults, fresh2) {
+  const { pack } = book;
+  const rec = entry2.rec;
+  const relsPart = relsOf(entry2.part);
+  let rels = pack.text(relsPart) ?? '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>';
+  let nextRid = Math.max(0, ...[...rels.matchAll(/\bId="rId(\d+)"/g)].map((m) => Number(m[1]))) + 1;
+  let commentsPart = rec?.comments ?? null;
+  let vmlPart = rec?.vml ?? null;
+  if (!commentsPart) {
+    commentsPart = fresh2((n) => `xl/comments${n}.xml`);
+    rels = rels.replace("</Relationships>", () => `<Relationship Id="rId${nextRid++}" Type="${REL}/comments" Target="${relative(entry2.part, commentsPart)}"/></Relationships>`);
+    types.push([`/${commentsPart}`, "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml"]);
+  }
+  if (!vmlPart) {
+    vmlPart = fresh2((n) => `xl/drawings/vmlDrawing${n}.vml`);
+    const rid = `rId${nextRid++}`;
+    rels = rels.replace("</Relationships>", () => `<Relationship Id="${rid}" Type="${REL}/vmlDrawing" Target="${relative(entry2.part, vmlPart)}"/></Relationships>`);
+    defaults.add("vml");
+    const relNs = /xmlns:(\w+)="http:\/\/schemas\.openxmlformats\.org\/officeDocument\/2006\/relationships"/.exec(rec?.xml ?? "")?.[1];
+    tail = place(tail, "legacyDrawing", `<${p}legacyDrawing ${relNs ?? "r"}:id="${rid}"/>`);
+  }
+  pack.put(relsPart, rels);
+  const authors = rec?.authors.length ? [...rec.authors] : ["Author"];
+  const byOld = new Map((rec?.notes ?? []).map((n) => {
+    const [r, c] = cell(n.ref);
+    return [a1(rows.map(r), cols.map(c)), n];
+  }));
+  const list = [...notes2].sort((a, b) => a.row - b.row || a.col - b.col).map((n) => {
+    const ref = a1(n.row, n.col);
+    const was = byOld.get(ref);
+    if (was && was.text === n.note) return setAttr(was.xml.slice(0, was.xml.indexOf(">") + 1), "ref", ref) + was.xml.slice(was.xml.indexOf(">") + 1);
+    const authorId = was ? attr2(was.xml, "authorId") ?? "0" : "0";
+    return `<${p}comment ref="${ref}" authorId="${authorId}"><${p}text><${p}r><${p}t xml:space="preserve">${escape(n.note)}</${p}t></${p}r></${p}text></${p}comment>`;
+  });
+  const existing = pack.text(commentsPart);
+  const authorsXml = `<${p}authors>${authors.map((a) => `<${p}author>${escape(a)}</${p}author>`).join("")}</${p}authors>`;
+  const commentsXml = existing ? existing.replace(/<((?:\w+:)?)commentList\b[^>]*?(?:\/>|>[\s\S]*?<\/\1commentList>)/, () => `<${p}commentList>${list.join("")}</${p}commentList>`) : `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<comments xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">${authorsXml}<commentList>${list.join("")}</commentList></comments>`;
+  pack.put(commentsPart, commentsXml);
+  const vml = pack.text(vmlPart) ?? '<xml xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:x="urn:schemas-microsoft-com:office:excel"><o:shapelayout v:ext="edit"><o:idmap v:ext="edit" data="1"/></o:shapelayout><v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" path="m,l,21600r21600,l21600,xe"><v:stroke joinstyle="miter"/><v:path gradientshapeok="t" o:connecttype="rect"/></v:shapetype></xml>';
+  const shapes = /* @__PURE__ */ new Map();
+  let rest = vml.replace(/<v:shape\b[^>]*>[\s\S]*?<\/v:shape>/g, (shape) => {
+    if (!/ObjectType="Note"/.test(shape)) return shape;
+    const r = Number(/<x:Row>(\d+)<\/x:Row>/.exec(shape)?.[1] ?? -1), c = Number(/<x:Column>(\d+)<\/x:Column>/.exec(shape)?.[1] ?? -1);
+    if (r >= 0 && c >= 0) shapes.set(a1(rows.map(r), cols.map(c)), shape);
+    return "";
+  });
+  let id = Math.max(1024, ...[...vml.matchAll(/_x0000_s(\d+)/g)].map((m) => Number(m[1])));
+  const out = notes2.map((n) => {
+    const ref = a1(n.row, n.col);
+    const was = shapes.get(ref);
+    if (was) return was.replace(/<x:Row>\d+<\/x:Row>/, `<x:Row>${n.row}</x:Row>`).replace(/<x:Column>\d+<\/x:Column>/, `<x:Column>${n.col}</x:Column>`).replace(/<x:Anchor>([^<]*)<\/x:Anchor>/, `<x:Anchor>${n.col + 1}, 15, ${n.row}, 2, ${n.col + 3}, 15, ${n.row + 4}, 16</x:Anchor>`);
+    return `<v:shape id="_x0000_s${++id}" type="#_x0000_t202" style="position:absolute;margin-left:59.25pt;margin-top:1.5pt;width:108pt;height:59.25pt;z-index:1;visibility:hidden" fillcolor="#ffffe1" o:insetmode="auto"><v:fill color2="#ffffe1"/><v:shadow on="t" color="black" obscured="t"/><v:path o:connecttype="none"/><v:textbox style="mso-direction-alt:auto"><div style="text-align:left"></div></v:textbox><x:ClientData ObjectType="Note"><x:MoveWithCells/><x:SizeWithCells/><x:Anchor>${n.col + 1}, 15, ${n.row}, 2, ${n.col + 3}, 15, ${n.row + 4}, 16</x:Anchor><x:AutoFill>False</x:AutoFill><x:Row>${n.row}</x:Row><x:Column>${n.col}</x:Column></x:ClientData></v:shape>`;
+  }).join("");
+  rest = rest.replace(/<\/xml>\s*$/, () => `${out}</xml>`);
+  pack.put(vmlPart, rest);
+  return tail;
+}
+
+// src/sheets/book.ts
+function readSheet(bytes, kind) {
+  return kind === "csv" ? readCsv(bytes) : load(bytes).model;
+}
+function writeSheet(original, model, kind) {
+  return kind === "csv" ? writeCsv(original, model) : writeXlsx(original, model);
+}
+
+// src/sheets/shared.ts
+import * as Y from "yjs";
+var props = ["name", "hidden", "tabColor", "freeze", "showGridlines", "rightToLeft"];
+var spot = (row2, col) => `${row2}:${col}`;
+var canon = (x) => x === null || typeof x !== "object" ? JSON.stringify(x ?? null) : Array.isArray(x) ? `[${x.map(canon).join(",")}]` : `{${Object.keys(x).filter((k) => x[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canon(x[k])}`).join(",")}}`;
+var strip = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0 && v !== null));
+var fnv = (bytes, h = 2166136261) => {
+  for (const b of bytes) h = Math.imul(h ^ b, 16777619) >>> 0;
+  return h;
+};
+function parts(doc) {
+  const book = doc.getMap("book");
+  return {
+    book,
+    values: doc.getMap("values"),
+    origin: doc.getMap("origin"),
+    order: book.get("order"),
+    sheets: book.get("sheets"),
+    styles: book.get("styles")
+  };
+}
+var pieces = (m) => ({
+  rows: m.get("rows"),
+  cols: m.get("cols"),
+  cells: m.get("cells"),
+  rowData: m.get("rowData"),
+  colData: m.get("colData"),
+  merges: m.get("merges"),
+  notes: m.get("notes")
+});
+function made(config, lines2) {
+  const m = new Y.Map();
+  for (const name of props) if (config[name] !== void 0) m.set(name, config[name]);
+  m.set("look", strip({ defaultRowHeight: config.defaultRowHeight, defaultColumnWidth: config.defaultColumnWidth, zoomRatio: config.zoomRatio }));
+  m.set("rows", Y.Array.from(lines2.rows));
+  m.set("cols", Y.Array.from(lines2.cols));
+  for (const name of ["cells", "rowData", "colData", "merges", "notes"]) m.set(name, new Y.Map());
+  return m;
+}
+function fill2(doc, model) {
+  const { book: wb, lines: lines2 } = model;
+  const book = doc.getMap("book");
+  const notes2 = JSON.parse(wb.resources?.find((r) => r.name === "SHEET_NOTE_PLUGIN")?.data ?? "{}");
+  doc.transact(() => {
+    book.set("head", strip({ id: wb.id, name: wb.name, appVersion: wb.appVersion, locale: wb.locale, defaultStyle: wb.defaultStyle, dateSystem: wb.dateSystem }));
+    book.set("extras", (wb.resources ?? []).filter((r) => r.name !== "SHEET_NOTE_PLUGIN"));
+    book.set("active", model.active ?? null);
+    book.set("styles", new Y.Map());
+    book.set("order", Y.Array.from(wb.sheetOrder));
+    book.set("sheets", new Y.Map());
+    const { sheets, styles, values, origin } = parts(doc);
+    for (const [id, look] of Object.entries(wb.styles)) if (look) styles.set(id, look);
+    for (const sid of wb.sheetOrder) {
+      const sheet = wb.sheets[sid];
+      const l = lines2[sid];
+      sheets.set(sid, made(sheet, l));
+      origin.set(sid, { id: model.origin.sheets[sid], name: sheet.name ?? "", rows: l.rows.length, cols: l.cols.length });
+      const { cells, rowData, colData, merges, notes: kept } = pieces(sheets.get(sid));
+      for (const [r, line] of Object.entries(sheet.cellData ?? {})) for (const [c, x] of Object.entries(line ?? {})) {
+        if (!x) continue;
+        const at = spot(l.rows[+r], l.cols[+c]);
+        const out = {};
+        if (x.f) {
+          out.f = x.f;
+          values.set(`${sid}:${at}`, { v: x.v ?? null, t: x.t ?? null });
+        } else {
+          if (x.v !== void 0 && x.v !== null) out.v = x.v;
+          if (x.t) out.t = x.t;
+        }
+        if (x.p) out.p = x.p;
+        if (typeof x.s === "string") out.s = x.s;
+        cells.set(at, out);
+      }
+      for (const [r, rd] of Object.entries(sheet.rowData ?? {})) if (rd) rowData.set(l.rows[+r], strip({ h: rd.h, hd: rd.hd, ia: rd.ia, s: typeof rd.s === "string" ? rd.s : void 0 }));
+      for (const [c, cd] of Object.entries(sheet.columnData ?? {})) if (cd) colData.set(l.cols[+c], strip({ w: cd.w, hd: cd.hd, s: typeof cd.s === "string" ? cd.s : void 0 }));
+      for (const b of sheet.mergeData ?? []) merges.set([l.rows[b.startRow], l.cols[b.startColumn], l.rows[b.endRow], l.cols[b.endColumn]].join(":"), 1);
+      for (const [r, line] of Object.entries(notes2[sid] ?? {})) for (const [c, n] of Object.entries(line)) kept.set(spot(l.rows[+r], l.cols[+c]), { note: n.note, width: n.width, height: n.height });
+    }
+  });
+}
+function sheetOf(doc, sid, l) {
+  const { sheets, values } = parts(doc);
+  const m = sheets.get(sid);
+  const { cells, rowData, colData, merges } = pieces(m);
+  const rows = new Map(l.rows.map((id, i) => [id, i])), cols = new Map(l.cols.map((id, i) => [id, i]));
+  const cellData = {};
+  for (const [at, x] of cells) {
+    const [row2, col] = at.split(":");
+    const r = rows.get(row2), c = cols.get(col);
+    if (r === void 0 || c === void 0) continue;
+    const kept = x.f ? values.get(`${sid}:${at}`) : void 0;
+    (cellData[r] ?? (cellData[r] = {}))[c] = kept ? { ...x, v: kept.v, t: kept.t } : { ...x };
+  }
+  const rowsOut = {}, colsOut = {};
+  for (const [id, x] of rowData) if (rows.has(id)) rowsOut[rows.get(id)] = { ...x };
+  for (const [id, x] of colData) if (cols.has(id)) colsOut[cols.get(id)] = { ...x };
+  const mergeData = [...merges.keys()].map((k) => k.split(":")).map(([r0, c0, r1, c1]) => ({ startRow: rows.get(r0), startColumn: cols.get(c0), endRow: rows.get(r1), endColumn: cols.get(c1) })).filter((b) => [b.startRow, b.startColumn, b.endRow, b.endColumn].every((n) => n !== void 0));
+  const out = { ...m.get("look"), id: sid, rowCount: l.rows.length, columnCount: l.cols.length, cellData, rowData: rowsOut, columnData: colsOut, mergeData };
+  for (const name of props) if (m.has(name)) Object.assign(out, { [name]: m.get(name) });
+  return out;
+}
+var notesOf = (m, l) => {
+  const rows = new Map(l.rows.map((id, i) => [id, i])), cols = new Map(l.cols.map((id, i) => [id, i]));
+  return [...pieces(m).notes].map(([at, n]) => ({ ...n, row: rows.get(at.split(":")[0]), col: cols.get(at.split(":")[1]) })).filter((n) => n.row !== void 0 && n.col !== void 0);
+};
+function build(doc) {
+  const { book, order: order2, sheets, styles, origin } = parts(doc);
+  const sheetOrder = [...new Set(order2.toArray())].filter((sid) => sheets.has(sid));
+  const wb = { ...book.get("head"), styles: styles.toJSON(), sheetOrder, sheets: {}, resources: [] };
+  const model = { book: wb, lines: {}, origin: { sheets: {}, lines: {} } };
+  const notes2 = {};
+  for (const sid of sheetOrder) {
+    const { rows, cols } = pieces(sheets.get(sid));
+    const l = { rows: rows.toArray(), cols: cols.toArray() };
+    model.lines[sid] = l;
+    wb.sheets[sid] = sheetOf(doc, sid, l);
+    notesOf(sheets.get(sid), l).forEach((n, i) => {
+      var _a, _b;
+      ((_a = notes2[sid] ?? (notes2[sid] = {}))[_b = n.row] ?? (_a[_b] = {}))[n.col] = { ...n, show: false, id: `n${i}` };
+    });
+    const o = origin.get(sid);
+    if (!o) continue;
+    model.origin.sheets[sid] = o.id;
+    model.origin.lines[sid] = { rows: typeof o.rows === "number" ? numbered("r", o.rows) : o.rows, cols: typeof o.cols === "number" ? numbered("c", o.cols) : o.cols };
+  }
+  wb.resources.push({ name: "SHEET_NOTE_PLUGIN", data: JSON.stringify(notes2) });
+  const active = book.get("active");
+  if (active && sheetOrder.includes(active)) model.active = active;
+  return model;
+}
+function extras(doc, model) {
+  const { book, origin } = parts(doc);
+  const own = new Map([...origin.entries()].filter(([sid]) => model.lines[sid]).map(([sid, o]) => {
+    const old = model.origin.lines[sid], now = model.lines[sid];
+    return [`s${o.id}`, { sid, name: o.name, rows: new Axis(old.rows, now.rows), cols: new Axis(old.cols, now.cols) }];
+  }));
+  const fix = (b, sid) => {
+    const a = own.get(sid);
+    return squeeze(b, a.rows.map, a.cols.map);
+  };
+  for (const r of book.get("extras")) {
+    const parsed = JSON.parse(r.data);
+    let out = {};
+    if (r.name === "SHEET_DEFINED_NAME_PLUGIN") out = Object.fromEntries(Object.entries(parsed).map(([id, n]) => {
+      let f = n.formulaOrRefString;
+      for (const a of own.values()) {
+        f = remapped(f, (s) => s === a.name, a.rows.map, a.cols.map);
+        if (a.name !== model.book.sheets[a.sid].name) f = renamed(f, a.name, model.book.sheets[a.sid].name);
+      }
+      return [id, { ...n, formulaOrRefString: f, localSheetId: own.get(n.localSheetId)?.sid ?? n.localSheetId }];
+    }));
+    else for (const [base, x] of Object.entries(parsed)) {
+      const a = own.get(base);
+      if (!a) continue;
+      if (r.name === "SHEET_DATA_VALIDATION_PLUGIN") out[a.sid] = x.map((rule) => ({ ...rule, ranges: rule.ranges.map((b) => fix(b, base)).filter(Boolean) })).filter((rule) => rule.ranges.length);
+      else if (r.name === "SHEET_FILTER_PLUGIN") {
+        const f = x;
+        const ref = fix(f.ref, base);
+        if (ref) out[a.sid] = { ...f, ref: { ...f.ref, ...ref }, cachedFilteredOut: (f.cachedFilteredOut ?? []).map(a.rows.map).filter((n) => n >= 0) };
+      } else out[a.sid] = x;
+    }
+    model.book.resources.push({ name: r.name, data: JSON.stringify(out) });
+  }
+  return model;
+}
+function settle(doc, model, bytes, kind) {
+  const { book, origin } = parts(doc);
+  const ids = kind === "csv" ? [] : worksheets(bytes);
+  const saved = readSheet(bytes, kind);
+  const back = /* @__PURE__ */ new Map();
+  model.book.sheetOrder.forEach((sid, i) => {
+    const id = ids[i] ?? i + 1;
+    back.set(`s${id}`, sid);
+    origin.set(sid, { id, name: model.book.sheets[sid].name ?? "", rows: model.lines[sid].rows, cols: model.lines[sid].cols });
+  });
+  for (const sid of [...origin.keys()]) if (!model.lines[sid]) origin.delete(sid);
+  book.set("extras", (saved.book.resources ?? []).filter((r) => r.name !== "SHEET_NOTE_PLUGIN"));
+}
+function applyCells(doc, list, origin) {
+  const { order: order2, sheets, values } = parts(doc);
+  let done = 0;
+  doc.transact(() => {
+    for (const x of list) {
+      const sid = order2.toArray().find((id) => sheets.get(id)?.get("name") === x.sheet);
+      const [r, c] = cell(x.ref);
+      if (!sid || r < 0) continue;
+      const { rows, cols, cells } = pieces(sheets.get(sid));
+      if (r >= rows.length || c >= cols.length) continue;
+      const at = spot(rows.get(r), cols.get(c));
+      const next = {};
+      if (x.formula !== void 0) next.f = x.formula.startsWith("=") ? x.formula : `=${x.formula}`;
+      else if (typeof x.value === "boolean") Object.assign(next, { v: x.value ? 1 : 0, t: 3 });
+      else if (x.value !== void 0 && x.value !== null && x.value !== "") Object.assign(next, { v: x.value, t: typeof x.value === "number" ? 2 : 1 });
+      const s = cells.get(at)?.s;
+      if (s) next.s = s;
+      values.delete(`${sid}:${at}`);
+      if (Object.keys(next).length) cells.set(at, next);
+      else cells.delete(at);
+      done++;
+    }
+  }, origin);
+  return done;
+}
+
+// src/sheets/text.ts
+var en = {
+  tools: "Sheet tools",
+  loading: "Opening the sheet",
+  failed: "This sheet could not be opened",
+  retry: "Try again",
+  undo: "Undo",
+  redo: "Redo",
+  bold: "Bold",
+  italic: "Italic",
+  underline: "Underline",
+  strike: "Strike out",
+  textColour: "Text colour",
+  fill: "Fill colour",
+  automatic: "Automatic",
+  noFill: "No fill",
+  borders: "Borders",
+  borderAll: "All borders",
+  borderOuter: "Outer border",
+  borderBottom: "Bottom border",
+  borderNone: "No borders",
+  alignLeft: "Align left",
+  alignCenter: "Centre",
+  alignRight: "Align right",
+  wrap: "Wrap text",
+  merge: "Merge cells",
+  unmerge: "Split cells",
+  format: "Number format",
+  general: "General",
+  number: "Number",
+  percent: "Percent",
+  currency: "Currency",
+  date: "Date",
+  time: "Time",
+  text: "Text",
+  rowAbove: "Row above",
+  rowBelow: "Row below",
+  columnLeft: "Column on the left",
+  columnRight: "Column on the right",
+  deleteRows: "Delete rows",
+  deleteColumns: "Delete columns",
+  freeze: "Freeze",
+  freezeNone: "Unfreeze",
+  freezeRow: "First row",
+  freezeColumn: "First column",
+  freezeHere: "Up to the selected cell",
+  sortUp: "Sort A to Z",
+  sortDown: "Sort Z to A",
+  filter: "Filter",
+  find: "Find and replace",
+  note: "Note",
+  save: "Save",
+  saving: "Saving",
+  saved: "Saved",
+  saveFailed: "Could not save",
+  editedNote: "Sheet edited",
+  viewOnly: "View only",
+  notesOnly: "You can add notes",
+  offline: "Offline",
+  offlineHint: "Your changes stay here and sync when the connection is back",
+  liveOff: "Live editing is unavailable",
+  people: "People in this sheet",
+  you: "you",
+  refused: {
+    chartSource: "A chart on another sheet uses data from \u201C{sheet}\u201D. Bring that sheet back to save.",
+    pivotSheet: "A pivot table reads its data from \u201C{sheet}\u201D. Bring that sheet back to save.",
+    tableColumns: "Columns changed inside a table on \u201C{sheet}\u201D. Undo that change to save."
+  }
+};
+var pl = {
+  tools: "Narz\u0119dzia arkusza",
+  loading: "Otwieranie arkusza",
+  failed: "Nie uda\u0142o si\u0119 otworzy\u0107 tego arkusza",
+  retry: "Spr\xF3buj ponownie",
+  undo: "Cofnij",
+  redo: "Pon\xF3w",
+  bold: "Pogrubienie",
+  italic: "Kursywa",
+  underline: "Podkre\u015Blenie",
+  strike: "Przekre\u015Blenie",
+  textColour: "Kolor tekstu",
+  fill: "Kolor wype\u0142nienia",
+  automatic: "Automatyczny",
+  noFill: "Bez wype\u0142nienia",
+  borders: "Obramowanie",
+  borderAll: "Wszystkie kraw\u0119dzie",
+  borderOuter: "Kraw\u0119dzie zewn\u0119trzne",
+  borderBottom: "Dolna kraw\u0119d\u017A",
+  borderNone: "Bez kraw\u0119dzi",
+  alignLeft: "Do lewej",
+  alignCenter: "Wy\u015Brodkuj",
+  alignRight: "Do prawej",
+  wrap: "Zawijaj tekst",
+  merge: "Scal kom\xF3rki",
+  unmerge: "Rozdziel kom\xF3rki",
+  format: "Format liczb",
+  general: "Og\xF3lny",
+  number: "Liczba",
+  percent: "Procent",
+  currency: "Waluta",
+  date: "Data",
+  time: "Godzina",
+  text: "Tekst",
+  rowAbove: "Wiersz powy\u017Cej",
+  rowBelow: "Wiersz poni\u017Cej",
+  columnLeft: "Kolumna po lewej",
+  columnRight: "Kolumna po prawej",
+  deleteRows: "Usu\u0144 wiersze",
+  deleteColumns: "Usu\u0144 kolumny",
+  freeze: "Zablokuj",
+  freezeNone: "Odblokuj",
+  freezeRow: "Pierwszy wiersz",
+  freezeColumn: "Pierwsza kolumna",
+  freezeHere: "Do zaznaczonej kom\xF3rki",
+  sortUp: "Sortuj od A do Z",
+  sortDown: "Sortuj od Z do A",
+  filter: "Filtr",
+  find: "Znajd\u017A i zamie\u0144",
+  note: "Notatka",
+  save: "Zapisz",
+  saving: "Zapisywanie",
+  saved: "Zapisano",
+  saveFailed: "Nie uda\u0142o si\u0119 zapisa\u0107",
+  editedNote: "Edycja arkusza",
+  viewOnly: "Tylko podgl\u0105d",
+  notesOnly: "Mo\u017Cesz dodawa\u0107 notatki",
+  offline: "Offline",
+  offlineHint: "Zmiany zostaj\u0105 tutaj i zsynchronizuj\u0105 si\u0119 po powrocie po\u0142\u0105czenia",
+  liveOff: "Wsp\xF3lna edycja jest niedost\u0119pna",
+  people: "Osoby w tym arkuszu",
+  you: "ty",
+  refused: {
+    chartSource: "Wykres na innym arkuszu korzysta z danych arkusza \u201E{sheet}\u201D. Przywr\xF3\u0107 ten arkusz, aby zapisa\u0107.",
+    pivotSheet: "Tabela przestawna pobiera dane z arkusza \u201E{sheet}\u201D. Przywr\xF3\u0107 ten arkusz, aby zapisa\u0107.",
+    tableColumns: "Kolumny zmieni\u0142y si\u0119 wewn\u0105trz tabeli na arkuszu \u201E{sheet}\u201D. Cofnij t\u0119 zmian\u0119, aby zapisa\u0107."
+  }
+};
+var uk = {
+  tools: "\u0406\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u0438 \u0442\u0430\u0431\u043B\u0438\u0446\u0456",
+  loading: "\u0412\u0456\u0434\u043A\u0440\u0438\u0432\u0430\u0454\u043C\u043E \u0442\u0430\u0431\u043B\u0438\u0446\u044E",
+  failed: "\u041D\u0435 \u0432\u0434\u0430\u043B\u043E\u0441\u044F \u0432\u0456\u0434\u043A\u0440\u0438\u0442\u0438 \u0446\u044E \u0442\u0430\u0431\u043B\u0438\u0446\u044E",
+  retry: "\u0421\u043F\u0440\u043E\u0431\u0443\u0432\u0430\u0442\u0438 \u0449\u0435",
+  undo: "\u0412\u0456\u0434\u043C\u0456\u043D\u0438\u0442\u0438",
+  redo: "\u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0438",
+  bold: "\u0416\u0438\u0440\u043D\u0438\u0439",
+  italic: "\u041A\u0443\u0440\u0441\u0438\u0432",
+  underline: "\u041F\u0456\u0434\u043A\u0440\u0435\u0441\u043B\u0435\u043D\u0438\u0439",
+  strike: "\u0417\u0430\u043A\u0440\u0435\u0441\u043B\u0435\u043D\u0438\u0439",
+  textColour: "\u041A\u043E\u043B\u0456\u0440 \u0442\u0435\u043A\u0441\u0442\u0443",
+  fill: "\u041A\u043E\u043B\u0456\u0440 \u0437\u0430\u043B\u0438\u0432\u043A\u0438",
+  automatic: "\u0410\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u043D\u0438\u0439",
+  noFill: "\u0411\u0435\u0437 \u0437\u0430\u043B\u0438\u0432\u043A\u0438",
+  borders: "\u041C\u0435\u0436\u0456",
+  borderAll: "\u0423\u0441\u0456 \u043C\u0435\u0436\u0456",
+  borderOuter: "\u0417\u043E\u0432\u043D\u0456\u0448\u043D\u0456 \u043C\u0435\u0436\u0456",
+  borderBottom: "\u041D\u0438\u0436\u043D\u044F \u043C\u0435\u0436\u0430",
+  borderNone: "\u0411\u0435\u0437 \u043C\u0435\u0436",
+  alignLeft: "\u041B\u0456\u0432\u043E\u0440\u0443\u0447",
+  alignCenter: "\u041F\u043E \u0446\u0435\u043D\u0442\u0440\u0443",
+  alignRight: "\u041F\u0440\u0430\u0432\u043E\u0440\u0443\u0447",
+  wrap: "\u041F\u0435\u0440\u0435\u043D\u043E\u0441\u0438\u0442\u0438 \u0442\u0435\u043A\u0441\u0442",
+  merge: "\u041E\u0431\u2019\u0454\u0434\u043D\u0430\u0442\u0438 \u043A\u043B\u0456\u0442\u0438\u043D\u043A\u0438",
+  unmerge: "\u0420\u043E\u0437\u2019\u0454\u0434\u043D\u0430\u0442\u0438 \u043A\u043B\u0456\u0442\u0438\u043D\u043A\u0438",
+  format: "\u0424\u043E\u0440\u043C\u0430\u0442 \u0447\u0438\u0441\u0435\u043B",
+  general: "\u0417\u0430\u0433\u0430\u043B\u044C\u043D\u0438\u0439",
+  number: "\u0427\u0438\u0441\u043B\u043E",
+  percent: "\u0412\u0456\u0434\u0441\u043E\u0442\u043E\u043A",
+  currency: "\u0412\u0430\u043B\u044E\u0442\u0430",
+  date: "\u0414\u0430\u0442\u0430",
+  time: "\u0427\u0430\u0441",
+  text: "\u0422\u0435\u043A\u0441\u0442",
+  rowAbove: "\u0420\u044F\u0434\u043E\u043A \u0432\u0438\u0449\u0435",
+  rowBelow: "\u0420\u044F\u0434\u043E\u043A \u043D\u0438\u0436\u0447\u0435",
+  columnLeft: "\u0421\u0442\u043E\u0432\u043F\u0435\u0446\u044C \u043B\u0456\u0432\u043E\u0440\u0443\u0447",
+  columnRight: "\u0421\u0442\u043E\u0432\u043F\u0435\u0446\u044C \u043F\u0440\u0430\u0432\u043E\u0440\u0443\u0447",
+  deleteRows: "\u0412\u0438\u0434\u0430\u043B\u0438\u0442\u0438 \u0440\u044F\u0434\u043A\u0438",
+  deleteColumns: "\u0412\u0438\u0434\u0430\u043B\u0438\u0442\u0438 \u0441\u0442\u043E\u0432\u043F\u0446\u0456",
+  freeze: "\u0417\u0430\u043A\u0440\u0456\u043F\u0438\u0442\u0438",
+  freezeNone: "\u0412\u0456\u0434\u043A\u0440\u0456\u043F\u0438\u0442\u0438",
+  freezeRow: "\u041F\u0435\u0440\u0448\u0438\u0439 \u0440\u044F\u0434\u043E\u043A",
+  freezeColumn: "\u041F\u0435\u0440\u0448\u0438\u0439 \u0441\u0442\u043E\u0432\u043F\u0435\u0446\u044C",
+  freezeHere: "\u0414\u043E \u0432\u0438\u0434\u0456\u043B\u0435\u043D\u043E\u0457 \u043A\u043B\u0456\u0442\u0438\u043D\u043A\u0438",
+  sortUp: "\u0421\u043E\u0440\u0442\u0443\u0432\u0430\u0442\u0438 \u0432\u0456\u0434 \u0410 \u0434\u043E \u042F",
+  sortDown: "\u0421\u043E\u0440\u0442\u0443\u0432\u0430\u0442\u0438 \u0432\u0456\u0434 \u042F \u0434\u043E \u0410",
+  filter: "\u0424\u0456\u043B\u044C\u0442\u0440",
+  find: "\u0417\u043D\u0430\u0439\u0442\u0438 \u0439 \u0437\u0430\u043C\u0456\u043D\u0438\u0442\u0438",
+  note: "\u041F\u0440\u0438\u043C\u0456\u0442\u043A\u0430",
+  save: "\u0417\u0431\u0435\u0440\u0435\u0433\u0442\u0438",
+  saving: "\u0417\u0431\u0435\u0440\u0435\u0436\u0435\u043D\u043D\u044F",
+  saved: "\u0417\u0431\u0435\u0440\u0435\u0436\u0435\u043D\u043E",
+  saveFailed: "\u041D\u0435 \u0432\u0434\u0430\u043B\u043E\u0441\u044F \u0437\u0431\u0435\u0440\u0435\u0433\u0442\u0438",
+  editedNote: "\u041F\u0440\u0430\u0432\u043A\u0430 \u0442\u0430\u0431\u043B\u0438\u0446\u0456",
+  viewOnly: "\u041B\u0438\u0448\u0435 \u043F\u0435\u0440\u0435\u0433\u043B\u044F\u0434",
+  notesOnly: "\u041C\u043E\u0436\u043D\u0430 \u0434\u043E\u0434\u0430\u0432\u0430\u0442\u0438 \u043F\u0440\u0438\u043C\u0456\u0442\u043A\u0438",
+  offline: "\u041E\u0444\u043B\u0430\u0439\u043D",
+  offlineHint: "\u0417\u043C\u0456\u043D\u0438 \u043B\u0438\u0448\u0430\u044E\u0442\u044C\u0441\u044F \u0442\u0443\u0442 \u0456 \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0456\u0437\u0443\u044E\u0442\u044C\u0441\u044F, \u043A\u043E\u043B\u0438 \u0437\u2019\u044F\u0432\u0438\u0442\u044C\u0441\u044F \u0437\u0432\u2019\u044F\u0437\u043E\u043A",
+  liveOff: "\u0421\u043F\u0456\u043B\u044C\u043D\u0435 \u0440\u0435\u0434\u0430\u0433\u0443\u0432\u0430\u043D\u043D\u044F \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u0435",
+  people: "\u041B\u044E\u0434\u0438 \u0432 \u0446\u0456\u0439 \u0442\u0430\u0431\u043B\u0438\u0446\u0456",
+  you: "\u0432\u0438",
+  refused: {
+    chartSource: "\u0414\u0456\u0430\u0433\u0440\u0430\u043C\u0430 \u043D\u0430 \u0456\u043D\u0448\u043E\u043C\u0443 \u0430\u0440\u043A\u0443\u0448\u0456 \u0431\u0435\u0440\u0435 \u0434\u0430\u043D\u0456 \u0437 \u0430\u0440\u043A\u0443\u0448\u0430 \xAB{sheet}\xBB. \u041F\u043E\u0432\u0435\u0440\u043D\u0456\u0442\u044C \u0446\u0435\u0439 \u0430\u0440\u043A\u0443\u0448, \u0449\u043E\u0431 \u0437\u0431\u0435\u0440\u0435\u0433\u0442\u0438.",
+    pivotSheet: "\u0417\u0432\u0435\u0434\u0435\u043D\u0430 \u0442\u0430\u0431\u043B\u0438\u0446\u044F \u0431\u0435\u0440\u0435 \u0434\u0430\u043D\u0456 \u0437 \u0430\u0440\u043A\u0443\u0448\u0430 \xAB{sheet}\xBB. \u041F\u043E\u0432\u0435\u0440\u043D\u0456\u0442\u044C \u0446\u0435\u0439 \u0430\u0440\u043A\u0443\u0448, \u0449\u043E\u0431 \u0437\u0431\u0435\u0440\u0435\u0433\u0442\u0438.",
+    tableColumns: "\u0421\u0442\u043E\u0432\u043F\u0446\u0456 \u0437\u043C\u0456\u043D\u0438\u043B\u0438\u0441\u044F \u0432\u0441\u0435\u0440\u0435\u0434\u0438\u043D\u0456 \u0442\u0430\u0431\u043B\u0438\u0446\u0456 \u043D\u0430 \u0430\u0440\u043A\u0443\u0448\u0456 \xAB{sheet}\xBB. \u0412\u0456\u0434\u043C\u0456\u043D\u0456\u0442\u044C \u0446\u044E \u0437\u043C\u0456\u043D\u0443, \u0449\u043E\u0431 \u0437\u0431\u0435\u0440\u0435\u0433\u0442\u0438."
+  }
+};
+var sheetTexts = { en, pl, uk };
+
+// src/collab.ts
+var ours = "w100n-collab";
+var schemas = /* @__PURE__ */ new Map();
+var schemaOf = (kind) => schemas.get(kind) ?? schemas.set(kind, getSchema(kit(kind, texts.en))).get(kind);
+var parse2 = async (kind, bytes) => kind === "docx" ? (await readDocx(bytes)).doc : fromMarkdown(new TextDecoder().decode(bytes)).doc;
+var edits = (tr) => tr.changedParentTypes.has(tr.doc.get("default")) || tr.changedParentTypes.has(tr.doc.get("book"));
+var filled = (doc) => doc.getXmlFragment("default").length > 0 || doc.getMap("book").size > 0;
+function seed(doc, kind, bytes, json) {
+  if (filled(doc)) return false;
+  const fixed = new Y2.Doc();
+  fixed.clientID = fnv(new Uint8Array(bytes), fnv(new TextEncoder().encode(`${version}:${kind}`)));
+  if (kind === "xlsx" || kind === "csv") fill2(fixed, readSheet(bytes, kind));
+  else prosemirrorJSONToYXmlFragment(schemaOf(kind), json, fixed.getXmlFragment("default"));
+  Y2.applyUpdate(doc, Y2.encodeStateAsUpdate(fixed), ours);
+  return true;
+}
+function follow(doc, author) {
+  const editors = doc.getMap("editors");
+  const before = (tr) => tr.meta.set("fresh", !filled(doc));
+  const after = (tr) => {
+    const who = !tr.meta.get("fresh") && edits(tr) ? author(tr.origin) : null;
+    if (who && !editors.has(who.id)) doc.transact(() => editors.set(who.id, who), ours);
+  };
+  doc.on("beforeTransaction", before);
+  doc.on("afterTransaction", after);
+  return () => {
+    doc.off("beforeTransaction", before);
+    doc.off("afterTransaction", after);
+  };
+}
+var pending = (doc) => doc.getMap("editors").size > 0;
+var Refusal = class extends Error {
+};
+function applyText(doc, kind, changes2, origin) {
+  const schema = schemaOf(kind);
+  const fragment = doc.getXmlFragment("default");
+  const step = new Transform(yXmlFragmentToProseMirrorRootNode(fragment, schema));
+  for (const c of changes2) {
+    const hits = [];
+    step.doc.descendants((node, pos) => {
+      if (!node.isTextblock) return true;
+      const text = node.textBetween(0, node.content.size, void 0, "\uFFFC");
+      for (let i = text.indexOf(c.find); c.find && i >= 0; i = text.indexOf(c.find, i + 1)) hits.push(pos + 1 + i);
+      return false;
+    });
+    if (hits.length !== 1) throw new Refusal(`${hits.length ? "more than once" : "not"} in the document: ${c.find.slice(0, 80)}`);
+    const [at] = hits;
+    if (c.replace) step.replaceWith(at, at + c.find.length, schema.text(c.replace, step.doc.resolve(at + 1).marks()));
+    else step.delete(at, at + c.find.length);
+  }
+  updateYFragment({ transact: (run) => doc.transact(run, origin) }, fragment, step.doc, { mapping: /* @__PURE__ */ new Map(), isOMark: /* @__PURE__ */ new Map() });
+  return changes2.length;
+}
+async function write(kind, base, node, load2) {
+  if (kind === "docx") return writeDocx(base, node.toJSON(), load2);
+  const parsed = fromMarkdown(new TextDecoder().decode(base));
+  return new TextEncoder().encode(toMarkdown(node, track(parsed, node.type.schema.nodeFromJSON(parsed.doc))).text).buffer;
+}
+var blocks2 = (fragment, schema) => {
+  const out = [];
+  const walk = (parent) => parent.toArray().forEach((child) => {
+    if (!(child instanceof Y2.XmlElement) || !schema.nodes[child.nodeName]?.isBlock) return;
+    out.push(child);
+    walk(child);
+  });
+  walk(fragment);
+  return out;
+};
+var same2 = (a, b) => {
+  const [x, y] = [new Uint8Array(a), new Uint8Array(b)];
+  return x.length === y.length && x.every((v, i) => v === y[i]);
+};
+var named = (label, who) => {
+  const names = who.map((w) => w.name).join(", ");
+  return `${label}: ${names.length > 180 ? `${names.slice(0, 177)}...` : names}`;
+};
+async function save(doc, kind, base, put, load2, note) {
+  const editors = doc.getMap("editors");
+  const who = [...editors.values()];
+  if (!who.length) return null;
+  if (kind === "xlsx" || kind === "csv") return workbook(doc, kind, base, put, who, note);
+  const schema = schemaOf(kind);
+  const fragment = doc.getXmlFragment("default");
+  const list = blocks2(fragment, schema);
+  const node = yXmlFragmentToProseMirrorRootNode(fragment, schema);
+  let touched = false;
+  const watch = (tr) => {
+    touched || (touched = tr.origin !== ours && edits(tr));
+  };
+  doc.on("afterTransaction", watch);
+  try {
+    const bytes = await write(kind, base, node, load2);
+    const changed2 = !same2(bytes, base);
+    const id = changed2 ? await put(bytes, note ?? named((texts[who[0].language] ?? texts.en).editedNote, who)) : null;
+    const refs = [];
+    if (changed2) schema.nodeFromJSON(await parse2(kind, bytes)).descendants((n) => {
+      if (n.isBlock) refs.push([n.type.name, n.attrs.ref ?? null]);
+    });
+    doc.transact(() => {
+      if (refs.length === list.length && list.every((el, i) => el.nodeName === refs[i][0])) list.forEach((el, i) => {
+        const ref = refs[i][1];
+        if ((el.getAttribute("ref") ?? null) === ref) return;
+        if (ref === null) el.removeAttribute("ref");
+        else el.setAttribute("ref", ref);
+      });
+      if (id) doc.getMap("meta").set("version", id);
+      if (!touched) who.forEach((w) => editors.delete(w.id));
+    }, ours);
+    return { bytes: changed2 ? bytes : base, version: id };
+  } finally {
+    doc.off("afterTransaction", watch);
+  }
+}
+async function workbook(doc, kind, base, put, who, note) {
+  const editors = doc.getMap("editors");
+  const model = build(doc);
+  let touched = false;
+  const watch = (tr) => {
+    touched || (touched = tr.origin !== ours && edits(tr));
+  };
+  doc.on("afterTransaction", watch);
+  try {
+    const bytes = writeSheet(base, model, kind);
+    const changed2 = !same2(bytes, base);
+    const id = changed2 ? await put(bytes, note ?? named((sheetTexts[who[0].language] ?? sheetTexts.en).editedNote, who)) : null;
+    doc.transact(() => {
+      if (changed2) settle(doc, model, bytes, kind);
+      if (id) doc.getMap("meta").set("version", id);
+      if (!touched) who.forEach((w) => editors.delete(w.id));
+    }, ours);
+    return { bytes: changed2 ? bytes : base, version: id };
+  } finally {
+    doc.off("afterTransaction", watch);
+  }
+}
+
+export {
+  a4,
+  letter,
+  paging,
+  notes,
+  entries,
+  changes,
+  decide,
+  suggesting,
+  kit,
+  align,
+  indent,
+  clear,
+  locate,
+  fromMarkdown,
+  track,
+  toMarkdown,
+  SheetRefusal,
+  fresh,
+  insert,
+  move,
+  resize,
+  rebase,
+  worksheets,
+  readSheet,
+  writeSheet,
+  props,
+  spot,
+  canon,
+  strip,
+  fnv,
+  parts,
+  pieces,
+  made,
+  sheetOf,
+  notesOf,
+  build,
+  extras,
+  applyCells,
+  sheetTexts,
+  ours,
+  parse2 as parse,
+  edits,
+  filled,
+  seed,
+  follow,
+  pending,
+  Refusal,
+  applyText,
+  save
+};
+//# sourceMappingURL=chunk-CE3AADY6.js.map