ooxml-core 1.1.0 → 1.2.1

package/dist/xlsx/collab/index.cjs

@@ -0,0 +1,1245 @@
+'use strict';
+
+var Y = require('yjs');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Y__namespace = /*#__PURE__*/_interopNamespace(Y);
+
+// xlsx/workbook.ts
+var DEFAULT_THEME = {
+  colors: [
+    "FFFFFF",
+    "000000",
+    "E7E6E6",
+    "44546A",
+    "4472C4",
+    "ED7D31",
+    "A5A5A5",
+    "FFC000",
+    "5B9BD5",
+    "70AD47",
+    "0563C1",
+    "954F72"
+  ],
+  majorFont: "Calibri Light",
+  minorFont: "Calibri"
+};
+var DEFAULT_ROW_HEIGHT = 15;
+function defaultCellStyle() {
+  return {
+    font: { name: "Calibri", size: 11, family: 2, scheme: "minor", color: { theme: 1 } },
+    fill: { type: "pattern", pattern: "none" },
+    border: {},
+    numFmt: "General"
+  };
+}
+function createWorksheet(name, sheetId) {
+  return {
+    name,
+    sheetId,
+    state: "visible",
+    rows: /* @__PURE__ */ new Map(),
+    rowInfo: /* @__PURE__ */ new Map(),
+    columns: [],
+    defaultRowHeight: DEFAULT_ROW_HEIGHT,
+    merges: [],
+    view: {
+      showGridLines: true,
+      showHeaders: true,
+      showZeros: true,
+      rightToLeft: false,
+      zoom: 100
+    },
+    hyperlinks: [],
+    comments: [],
+    conditionalFormats: [],
+    dataValidations: [],
+    tables: [],
+    drawings: [],
+    preserved: /* @__PURE__ */ new Map()
+  };
+}
+function createWorkbook(options = {}) {
+  const names = options.sheets?.length ? options.sheets : ["Sheet1"];
+  return {
+    sheets: names.map((name, index) => createWorksheet(name, index + 1)),
+    styles: [defaultCellStyle()],
+    namedStyles: [{ name: "Normal", style: defaultCellStyle(), builtinId: 0 }],
+    definedNames: [],
+    theme: { ...DEFAULT_THEME, colors: [...DEFAULT_THEME.colors] },
+    activeSheet: 0,
+    date1904: false,
+    properties: {},
+    format: "new",
+    warnings: []
+  };
+}
+
+// xlsx/address.ts
+var MAX_ROW = 1048575;
+var MAX_COL = 16383;
+function columnLabel(col) {
+  let label = "";
+  let n = col + 1;
+  while (n > 0) {
+    const rem = (n - 1) % 26;
+    label = String.fromCharCode(65 + rem) + label;
+    n = Math.floor((n - 1) / 26);
+  }
+  return label;
+}
+function columnIndex(label) {
+  if (!/^[A-Za-z]{1,3}$/.test(label)) return -1;
+  let n = 0;
+  for (const ch of label.toUpperCase()) n = n * 26 + (ch.charCodeAt(0) - 64);
+  return n - 1;
+}
+var formatAddress = (address) => `${columnLabel(address.col)}${address.row + 1}`;
+function parseAddress(ref) {
+  const match = /^\$?([A-Za-z]{1,3})\$?(\d{1,7})$/.exec(ref.trim());
+  if (!match) return void 0;
+  const col = columnIndex(match[1] ?? "");
+  const row = Number(match[2]) - 1;
+  if (col < 0 || col > MAX_COL || row < 0 || row > MAX_ROW) return void 0;
+  return { row, col };
+}
+function normalizeRange(range) {
+  return {
+    start: {
+      row: Math.min(range.start.row, range.end.row),
+      col: Math.min(range.start.col, range.end.col)
+    },
+    end: {
+      row: Math.max(range.start.row, range.end.row),
+      col: Math.max(range.start.col, range.end.col)
+    }
+  };
+}
+function parseRange(ref) {
+  const parts = ref.trim().split(":");
+  if (parts.length === 1) {
+    const cell = parseAddress(parts[0] ?? "");
+    return cell ? { start: cell, end: { ...cell } } : void 0;
+  }
+  if (parts.length !== 2) return void 0;
+  const [a = "", b = ""] = parts.map((part) => part.replace(/\$/g, ""));
+  if (/^[A-Za-z]{1,3}$/.test(a) && /^[A-Za-z]{1,3}$/.test(b)) {
+    const c1 = columnIndex(a);
+    const c2 = columnIndex(b);
+    return normalizeRange({ start: { row: 0, col: c1 }, end: { row: MAX_ROW, col: c2 } });
+  }
+  if (/^\d+$/.test(a) && /^\d+$/.test(b)) {
+    const r1 = Number(a) - 1;
+    const r2 = Number(b) - 1;
+    if (r1 < 0 || r2 < 0) return void 0;
+    return normalizeRange({ start: { row: r1, col: 0 }, end: { row: r2, col: MAX_COL } });
+  }
+  const start = parseAddress(a);
+  const end = parseAddress(b);
+  return start && end ? normalizeRange({ start, end }) : void 0;
+}
+function formatRange(range) {
+  const { start, end } = normalizeRange(range);
+  const a = formatAddress(start);
+  return start.row === end.row && start.col === end.col ? a : `${a}:${formatAddress(end)}`;
+}
+var rangeContains = (range, address) => address.row >= range.start.row && address.row <= range.end.row && address.col >= range.start.col && address.col <= range.end.col;
+var rangesIntersect = (a, b) => a.start.row <= b.end.row && b.start.row <= a.end.row && a.start.col <= b.end.col && b.start.col <= a.end.col;
+
+// xlsx/cells.ts
+var getCell = (sheet, row, col) => sheet.rows.get(row)?.get(col);
+function putCell(sheet, row, col, cell) {
+  let cells = sheet.rows.get(row);
+  if (!cells) {
+    cells = /* @__PURE__ */ new Map();
+    sheet.rows.set(row, cells);
+  }
+  cells.set(col, cell);
+}
+function deleteCell(sheet, row, col) {
+  const cells = sheet.rows.get(row);
+  if (!cells) return;
+  cells.delete(col);
+  if (cells.size === 0) sheet.rows.delete(row);
+}
+function forEachCell(sheet, visit) {
+  for (const row of [...sheet.rows.keys()].sort((a, b) => a - b)) {
+    const cells = sheet.rows.get(row);
+    if (!cells) continue;
+    for (const col of [...cells.keys()].sort((a, b) => a - b)) {
+      const cell = cells.get(col);
+      if (cell) visit(cell, row, col);
+    }
+  }
+}
+function forEachCellInRange(sheet, range, visit) {
+  const rows = [...sheet.rows.keys()].filter((row) => row >= range.start.row && row <= range.end.row).sort((a, b) => a - b);
+  for (const row of rows) {
+    const cells = sheet.rows.get(row);
+    if (!cells) continue;
+    const cols = [...cells.keys()].filter((col) => col >= range.start.col && col <= range.end.col).sort((a, b) => a - b);
+    for (const col of cols) {
+      const cell = cells.get(col);
+      if (cell) visit(cell, row, col);
+    }
+  }
+}
+
+// xlsx/model.ts
+var ERROR_CODES = [
+  "#NULL!",
+  "#DIV/0!",
+  "#VALUE!",
+  "#REF!",
+  "#NAME?",
+  "#NUM!",
+  "#N/A",
+  "#GETTING_DATA",
+  "#SPILL!",
+  "#CALC!"
+];
+var isErrorCode = (value) => ERROR_CODES.includes(value);
+var cellError = (error) => ({ error });
+var isCellError = (value) => typeof value === "object" && value !== null && "error" in value;
+
+// xlsx/formula/spill.ts
+var isSpilledCell = (cell) => cell !== void 0 && "spillAnchor" in cell;
+var SCHEMA_VERSION = 1;
+var META = "xlsx:meta";
+var STYLES = "xlsx:styles";
+var NAMES = "xlsx:names";
+var SHEETS = "xlsx:sheets";
+var SHEET_PARTS = ["props", "cells", "rows", "cols", "merges"];
+function sharedWorkbook(doc) {
+  return {
+    meta: doc.getMap(META),
+    styles: doc.getMap(STYLES),
+    names: doc.getMap(NAMES),
+    sheets: doc.getMap(SHEETS)
+  };
+}
+var sharedTypes = (shared) => [
+  shared.meta,
+  shared.styles,
+  shared.names,
+  shared.sheets
+];
+function childMap(parent, key) {
+  const value = parent.get(key);
+  return value instanceof Y__namespace.Map ? value : void 0;
+}
+function sheetPart(sheet, part) {
+  const existing = childMap(sheet, part);
+  if (existing) return existing;
+  const created = new Y__namespace.Map();
+  sheet.set(part, created);
+  return created;
+}
+function newSheetMap() {
+  const sheet = new Y__namespace.Map();
+  for (const part of SHEET_PARTS) sheet.set(part, new Y__namespace.Map());
+  return sheet;
+}
+function jsonEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const ka = Object.keys(a).filter((k) => a[k] !== void 0);
+  const kb = Object.keys(b).filter((k) => b[k] !== void 0);
+  if (ka.length !== kb.length) return false;
+  return ka.every(
+    (k) => jsonEqual(a[k], b[k])
+  );
+}
+function setIfChanged(map, key, value) {
+  if (value === void 0) {
+    if (!map.has(key)) return false;
+    map.delete(key);
+    return true;
+  }
+  if (jsonEqual(map.get(key), value)) return false;
+  map.set(key, value);
+  return true;
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+
+// xlsx/collab/codec.ts
+var MAX_TEXT = 32767;
+var isText = (v, max = MAX_TEXT) => typeof v === "string" && v.length <= max;
+var isCount = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+function encodeCell(cell, keyOf) {
+  const entry = {};
+  const s = cell.styleId ? keyOf(cell.styleId) : void 0;
+  if (isSpilledCell(cell)) return s ? { s } : void 0;
+  const value = cell.value;
+  if (isCellError(value)) {
+    entry.v = value.error;
+    entry.t = "e";
+  } else if (typeof value === "number") {
+    entry.v = value;
+    entry.t = "n";
+  } else if (typeof value === "string") {
+    entry.v = value;
+    entry.t = "s";
+  } else if (typeof value === "boolean") {
+    entry.v = value;
+    entry.t = "b";
+  }
+  if (cell.formula !== void 0) entry.f = cell.formula;
+  if (s) entry.s = s;
+  if (cell.arrayRange) entry.a = formatRange(cell.arrayRange);
+  if (cell.richText) entry.r = structuredClone(cell.richText);
+  if (cell.dynamicArray) entry.d = 1;
+  if (cell.legacyFormula) entry.l = 1;
+  return Object.keys(entry).length ? entry : void 0;
+}
+function decodeRuns(raw) {
+  if (!Array.isArray(raw) || raw.length > 1024) return void 0;
+  const runs = [];
+  for (const run of raw) {
+    if (!isRecord(run) || !isText(run.text)) return void 0;
+    const out = { text: run.text };
+    if (isRecord(run.font)) out.font = structuredClone(run.font);
+    runs.push(out);
+  }
+  return runs;
+}
+function decodeCell(raw, idOf) {
+  if (!isRecord(raw)) return void 0;
+  const cell = { value: null };
+  const { v, t } = raw;
+  if (t === "e") {
+    if (typeof v !== "string" || !isErrorCode(v)) return void 0;
+    cell.value = cellError(v);
+  } else if (t === "n") {
+    if (typeof v !== "number" || !Number.isFinite(v)) return void 0;
+    cell.value = v;
+  } else if (t === "s") {
+    if (!isText(v)) return void 0;
+    cell.value = v;
+  } else if (t === "b") {
+    if (typeof v !== "boolean") return void 0;
+    cell.value = v;
+  } else if (t !== void 0 || v !== void 0) return void 0;
+  if (raw.f !== void 0) {
+    if (!isText(raw.f, 8192)) return void 0;
+    cell.formula = raw.f;
+  }
+  if (raw.s !== void 0 && typeof raw.s !== "string") return void 0;
+  const styleId = idOf(raw.s);
+  if (styleId) cell.styleId = styleId;
+  if (typeof raw.a === "string") {
+    const range = parseRange(raw.a);
+    if (range) cell.arrayRange = range;
+  }
+  if (raw.r !== void 0) {
+    const runs = decodeRuns(raw.r);
+    if (runs) cell.richText = runs;
+  }
+  if (raw.d === 1) cell.dynamicArray = true;
+  if (raw.l === 1) cell.legacyFormula = true;
+  return cell;
+}
+function encodeLine(info, keyOf, column = false) {
+  const entry = {};
+  const size = column ? info.width : info.height;
+  const custom = column ? info.customWidth : info.customHeight;
+  if (size !== void 0) entry.size = size;
+  if (custom) entry.custom = 1;
+  if (info.hidden) entry.hidden = 1;
+  const s = info.styleId ? keyOf(info.styleId) : void 0;
+  if (s) entry.s = s;
+  if (info.outlineLevel) entry.ol = info.outlineLevel;
+  if (info.collapsed) entry.c = 1;
+  if (column && info.bestFit) entry.bf = 1;
+  return entry;
+}
+function decodeLine(raw) {
+  if (!isRecord(raw)) return void 0;
+  if (raw.size !== void 0 && !isCount(raw.size)) return void 0;
+  if (raw.ol !== void 0 && !isCount(raw.ol)) return void 0;
+  if (raw.s !== void 0 && typeof raw.s !== "string") return void 0;
+  return raw;
+}
+function decodeRow(raw, idOf) {
+  const entry = decodeLine(raw);
+  if (!entry) return void 0;
+  const info = {};
+  if (entry.size !== void 0) info.height = entry.size;
+  if (entry.custom === 1) info.customHeight = true;
+  if (entry.hidden === 1) info.hidden = true;
+  const styleId = entry.s ? idOf(entry.s) : void 0;
+  if (styleId) info.styleId = styleId;
+  if (entry.ol) info.outlineLevel = entry.ol;
+  if (entry.c === 1) info.collapsed = true;
+  return info;
+}
+function decodeColumn(raw, min, max, idOf) {
+  const entry = decodeLine(raw);
+  if (!entry) return void 0;
+  const info = { min, max };
+  if (entry.size !== void 0) info.width = entry.size;
+  if (entry.custom === 1) info.customWidth = true;
+  if (entry.hidden === 1) info.hidden = true;
+  const styleId = entry.s ? idOf(entry.s) : void 0;
+  if (styleId) info.styleId = styleId;
+  if (entry.ol) info.outlineLevel = entry.ol;
+  if (entry.c === 1) info.collapsed = true;
+  if (entry.bf === 1) info.bestFit = true;
+  return info;
+}
+
+// xlsx/collab/lines.ts
+var rowKey = (row) => String(row + 1);
+var spanKey = (min, max) => `${columnLabel(min)}:${columnLabel(max)}`;
+function parseRowKey(key) {
+  if (!/^\d{1,7}$/.test(key)) return void 0;
+  const row = Number(key) - 1;
+  return row >= 0 && row <= 1048575 ? row : void 0;
+}
+function parseSpanKey(key) {
+  const match = /^([A-Z]{1,3}):([A-Z]{1,3})$/.exec(key);
+  if (!match) return void 0;
+  const min = columnIndex(match[1] ?? "");
+  const max = columnIndex(match[2] ?? "");
+  return min >= 0 && max >= min && max <= 16383 ? [min, max] : void 0;
+}
+function writeLines(sheet, parts, keyOf) {
+  const rowKeys = /* @__PURE__ */ new Set();
+  for (const [row, info] of sheet.rowInfo) {
+    const key = rowKey(row);
+    rowKeys.add(key);
+    setIfChanged(parts.rows, key, encodeLine(info, keyOf));
+  }
+  for (const key of [...parts.rows.keys()]) if (!rowKeys.has(key)) parts.rows.delete(key);
+  const colKeys = /* @__PURE__ */ new Set();
+  for (const info of sheet.columns) {
+    const key = spanKey(info.min, info.max);
+    colKeys.add(key);
+    setIfChanged(parts.cols, key, encodeLine(info, keyOf, true));
+  }
+  for (const key of [...parts.cols.keys()]) if (!colKeys.has(key)) parts.cols.delete(key);
+  const mergeKeys = new Set(sheet.merges.map(formatRange));
+  for (const key of mergeKeys) setIfChanged(parts.merges, key, true);
+  for (const key of [...parts.merges.keys()]) if (!mergeKeys.has(key)) parts.merges.delete(key);
+}
+function applyRows(sheet, rows, idOf, keys) {
+  if (!keys) sheet.rowInfo.clear();
+  for (const key of keys ?? rows.keys()) {
+    const row = parseRowKey(key);
+    if (row === void 0) continue;
+    const info = rows.has(key) ? decodeRow(rows.get(key), idOf) : void 0;
+    if (info) sheet.rowInfo.set(row, info);
+    else sheet.rowInfo.delete(row);
+  }
+}
+function applyColumns(sheet, cols, idOf) {
+  const spans = [];
+  for (const [key, raw] of cols.entries()) {
+    const span = parseSpanKey(key);
+    const info = span && decodeColumn(raw, span[0], span[1], idOf);
+    if (info) spans.push(info);
+  }
+  const bounds = [...new Set(spans.flatMap((s) => [s.min, s.max + 1]))].sort((a, b) => a - b);
+  const out = [];
+  for (let i = 0; i + 1 < bounds.length; i++) {
+    const min = bounds[i] ?? 0;
+    const max = (bounds[i + 1] ?? 0) - 1;
+    let pick;
+    for (const span of spans) {
+      if (span.min > min || span.max < max) continue;
+      const width = span.max - span.min;
+      const best = pick && pick.max - pick.min;
+      if (!pick || best === void 0 || width < best || width === best && span.min < pick.min)
+        pick = span;
+    }
+    if (!pick) continue;
+    const last = out.at(-1);
+    if (last && last.max === min - 1 && spanOf.get(last) === pick) last.max = max;
+    else {
+      const piece = { ...pick, min, max };
+      spanOf.set(piece, pick);
+      out.push(piece);
+    }
+  }
+  sheet.columns = out;
+}
+var spanOf = /* @__PURE__ */ new WeakMap();
+function applyMerges(sheet, merges) {
+  const ranges = [...merges.keys()].map(parseRange).filter((r) => r !== void 0).sort(
+    (a, b) => a.start.row - b.start.row || a.start.col - b.start.col || a.end.row - b.end.row || a.end.col - b.end.col
+  );
+  const kept = [];
+  for (const range of ranges)
+    if (!kept.some((other) => rangesIntersect(other, range))) kept.push(range);
+  sheet.merges = kept;
+}
+
+// xlsx/collab/names.ts
+var nameKey = (name, sheetKey) => `${sheetKey ?? ""}!${name.toLowerCase()}`;
+function writeNames(names, list, sheetKeyAt) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const name of list) {
+    const scope = name.localSheet === void 0 ? void 0 : sheetKeyAt(name.localSheet);
+    if (name.localSheet !== void 0 && scope === void 0) continue;
+    const entry = { n: name.name, f: name.formula };
+    if (scope !== void 0) entry.k = scope;
+    if (name.hidden) entry.h = 1;
+    if (name.comment !== void 0) entry.c = name.comment;
+    const key = nameKey(name.name, scope);
+    keys.add(key);
+    setIfChanged(names, key, entry);
+  }
+  for (const key of [...names.keys()]) if (!keys.has(key)) names.delete(key);
+}
+function readNames(names, sheetIndexOf) {
+  const out = [];
+  for (const key of [...names.keys()].sort()) {
+    const raw = names.get(key);
+    if (!isRecord(raw) || typeof raw.n !== "string" || typeof raw.f !== "string") continue;
+    if (!raw.n || raw.n.length > 255 || raw.f.length > 8192) continue;
+    const name = { name: raw.n, formula: raw.f };
+    if (typeof raw.k === "string") {
+      const index = sheetIndexOf(raw.k);
+      if (index === void 0) continue;
+      name.localSheet = index;
+    }
+    if (raw.h === 1) name.hidden = true;
+    if (typeof raw.c === "string") name.comment = raw.c;
+    out.push(name);
+  }
+  return out;
+}
+
+// xlsx/collab/sheets.ts
+var STATES = ["visible", "hidden", "veryHidden"];
+var isNumber = (v) => typeof v === "number" && Number.isFinite(v);
+function sheetEntries(sheets) {
+  const out = [];
+  for (const key of [...sheets.keys()].sort()) {
+    const map = childMap(sheets, key);
+    const props = map && childMap(map, "props");
+    const name = props?.get("name");
+    if (!map || !props || typeof name !== "string" || !name || name.length > 31) continue;
+    const sheetId = props.get("sheetId");
+    const order = props.get("order");
+    const state = props.get("state");
+    const entry = {
+      key,
+      map,
+      name,
+      sheetId: isNumber(sheetId) && sheetId > 0 ? Math.floor(sheetId) : 0,
+      order: isNumber(order) ? order : 0,
+      state: STATES.includes(state) ? state : "visible"
+    };
+    const tab = props.get("tab");
+    if (isRecord(tab)) entry.tabColor = structuredClone(tab);
+    const rh = props.get("rh");
+    if (isNumber(rh) && rh > 0) entry.defaultRowHeight = rh;
+    const cw = props.get("cw");
+    if (isNumber(cw) && cw > 0) entry.defaultColWidth = cw;
+    out.push(entry);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const names = /* @__PURE__ */ new Set();
+  let maxId = out.reduce((max, e) => Math.max(max, e.sheetId), 0);
+  for (const entry of out) {
+    if (!entry.sheetId || ids.has(entry.sheetId)) entry.sheetId = ++maxId;
+    ids.add(entry.sheetId);
+    if (names.has(entry.name.toLowerCase())) {
+      const base = entry.name.slice(0, 26);
+      let n = 2;
+      while (names.has(`${base} (${n})`.toLowerCase())) n++;
+      entry.name = `${base} (${n})`;
+    }
+    names.add(entry.name.toLowerCase());
+  }
+  return out.sort((a, b) => a.order - b.order || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+}
+var SheetKeys = class {
+  constructor(clientId) {
+    this.clientId = clientId;
+  }
+  clientId;
+  byObject = /* @__PURE__ */ new WeakMap();
+  counter = 0;
+  remember(sheet, key) {
+    this.byObject.set(sheet, key);
+  }
+  /** The key of a known sheet object, else of the shared sheet with its sheetId. */
+  find(sheet, entries) {
+    const known = this.byObject.get(sheet);
+    if (known !== void 0) return known;
+    const match = entries.find((entry) => entry.sheetId === sheet.sheetId)?.key;
+    if (match !== void 0) this.byObject.set(sheet, match);
+    return match;
+  }
+  /** The sheet's key, minting a new one for a sheet the room does not know. */
+  resolve(sheet, entries, taken) {
+    const found = this.find(sheet, entries);
+    if (found !== void 0 && taken.has(found)) return found;
+    let key;
+    do
+      key = `${this.clientId.toString(36)}-${(this.counter++).toString(36)}`;
+    while (taken.has(key));
+    this.byObject.set(sheet, key);
+    return key;
+  }
+};
+function reorder(current) {
+  const n = current.length;
+  const len = new Array(n).fill(0);
+  const prev = new Array(n).fill(-1);
+  let best = -1;
+  for (let i = 0; i < n; i++) {
+    const v = current[i];
+    if (v === void 0) continue;
+    len[i] = 1;
+    for (let j = 0; j < i; j++) {
+      const u = current[j];
+      if (u !== void 0 && u < v && (len[j] ?? 0) + 1 > (len[i] ?? 0)) {
+        len[i] = (len[j] ?? 0) + 1;
+        prev[i] = j;
+      }
+    }
+    if (best < 0 || (len[i] ?? 0) > (len[best] ?? 0)) best = i;
+  }
+  const keep = /* @__PURE__ */ new Set();
+  for (let i = best; i >= 0; i = prev[i] ?? -1) keep.add(i);
+  const out = /* @__PURE__ */ new Map();
+  let low = 0;
+  for (let i = 0; i < n; i++) {
+    if (keep.has(i)) {
+      low = current[i] ?? low;
+      continue;
+    }
+    let high;
+    for (let j = i + 1; j < n; j++)
+      if (keep.has(j)) {
+        high = current[j];
+        break;
+      }
+    const value = high === void 0 ? low + 1 : (low + high) / 2;
+    if (high !== void 0 && !(value > low && value < high)) {
+      out.clear();
+      current.forEach((_v, k) => out.set(k, k + 1));
+      return out;
+    }
+    out.set(i, value);
+    low = value;
+  }
+  return out;
+}
+
+// xlsx/styles.ts
+function styleKey(style) {
+  return JSON.stringify(sortKeys(style));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      const entry = value[key];
+      if (entry !== void 0) out[key] = sortKeys(entry);
+    }
+    return out;
+  }
+  return value;
+}
+function internStyle(workbook, style) {
+  const key = styleKey(style);
+  const cache = styleCache(workbook);
+  const known = cache.get(key);
+  if (known !== void 0 && workbook.styles[known] && styleKey(workbook.styles[known]) === key)
+    return known;
+  const index = workbook.styles.findIndex((candidate) => styleKey(candidate) === key);
+  if (index >= 0) {
+    cache.set(key, index);
+    return index;
+  }
+  workbook.styles.push(style);
+  cache.set(key, workbook.styles.length - 1);
+  return workbook.styles.length - 1;
+}
+var caches = /* @__PURE__ */ new WeakMap();
+function styleCache(workbook) {
+  let cache = caches.get(workbook);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    caches.set(workbook, cache);
+  }
+  return cache;
+}
+
+// xlsx/collab/styles.ts
+function hash53(text) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+}
+var hashes = /* @__PURE__ */ new WeakMap();
+function sharedStyleKey(style) {
+  let key = hashes.get(style);
+  if (key === void 0) {
+    key = hash53(styleKey(style)).toString(36);
+    hashes.set(style, key);
+  }
+  return key;
+}
+function isCellStyle(value) {
+  return isRecord(value) && isRecord(value.font) && isRecord(value.fill) && isRecord(value.border) && typeof value.numFmt === "string";
+}
+var StyleBridge = class {
+  constructor(workbook, table, defaultKey, writable) {
+    this.workbook = workbook;
+    this.table = table;
+    this.defaultKey = defaultKey;
+    this.writable = writable;
+  }
+  workbook;
+  table;
+  defaultKey;
+  writable;
+  ids = /* @__PURE__ */ new Map();
+  /** The shared key of a local style id (undefined for the room default). */
+  keyOf = (styleId) => {
+    const style = this.workbook.styles[styleId ?? 0] ?? this.workbook.styles[0];
+    if (!style) return void 0;
+    const key = sharedStyleKey(style);
+    if (this.writable && !this.table.has(key)) this.table.set(key, structuredClone(style));
+    return key === this.defaultKey ? void 0 : key;
+  };
+  /** The local style id of a shared key (undefined for style 0). */
+  idOf = (key) => {
+    const resolved = key ?? this.defaultKey;
+    if (this.ids.has(resolved)) return this.ids.get(resolved);
+    const style = this.table.get(resolved);
+    const id = isCellStyle(style) ? internStyle(this.workbook, structuredClone(style)) : 0;
+    const out = id === 0 ? void 0 : id;
+    this.ids.set(resolved, out);
+    return out;
+  };
+};
+
+// xlsx/collab/apply.ts
+function applyShared(shared, keys, workbook, dirty, label = "Remote change") {
+  const defaultKey = shared.meta.get("defaultStyle");
+  const styles = new StyleBridge(workbook, shared.styles, String(defaultKey ?? ""), false);
+  const entries = sheetEntries(shared.sheets);
+  let structural = false;
+  if (dirty.all || dirty.list) structural = applyList(workbook, keys, entries);
+  const date1904 = shared.meta.get("date1904");
+  if (dirty.all && typeof date1904 === "boolean") workbook.date1904 = date1904;
+  const indexOf = /* @__PURE__ */ new Map();
+  workbook.sheets.forEach((sheet, index) => {
+    const key = keys.find(sheet, entries);
+    if (key !== void 0) indexOf.set(key, index);
+  });
+  const touched = [];
+  const ranges = [];
+  const sheetsTouched = /* @__PURE__ */ new Set();
+  const visit = dirty.all ? entries.map((e) => e.key) : [...dirty.sheets.keys()];
+  for (const key of visit) {
+    const index = indexOf.get(key);
+    const sheet = index === void 0 ? void 0 : workbook.sheets[index];
+    const map = childMap(shared.sheets, key);
+    if (!sheet || index === void 0 || !map) continue;
+    const part = dirty.sheets.get(key);
+    const full = dirty.all || !part || part.full;
+    const rows = childMap(map, "rows");
+    if (rows && (full || part.rows.size)) {
+      applyRows(sheet, rows, styles.idOf, full ? void 0 : part.rows);
+      structural = true;
+    }
+    const cols = childMap(map, "cols");
+    if (cols && (full || part.cols)) {
+      applyColumns(sheet, cols, styles.idOf);
+      structural = true;
+    }
+    const merges = childMap(map, "merges");
+    if (merges && (full || part.merges)) {
+      applyMerges(sheet, merges);
+      sheetsTouched.add(index);
+    }
+    const cells = childMap(map, "cells");
+    if (!cells) continue;
+    const put = (address) => {
+      const at = parseAddress(address);
+      if (!at) return;
+      const raw = cells.get(address);
+      const local = getCell(sheet, at.row, at.col);
+      if (local && jsonEqual(encodeCell(local, styles.keyOf), raw)) return;
+      const cell = raw === void 0 ? void 0 : decodeCell(raw, styles.idOf);
+      if (cell) putCell(sheet, at.row, at.col, cell);
+      else if (local && !isSpilledCell(local)) deleteCell(sheet, at.row, at.col);
+      else return;
+      touched.push({ sheet: index, row: at.row, col: at.col });
+      ranges.push({ start: at, end: { ...at } });
+      sheetsTouched.add(index);
+    };
+    if (full) {
+      const stale = [];
+      forEachCell(sheet, (cell, row, col) => {
+        const address = formatAddress({ row, col });
+        if (!isSpilledCell(cell) && !cells.has(address)) stale.push(address);
+      });
+      for (const address of [...cells.keys(), ...stale]) put(address);
+    } else for (const address of part.cells) put(address);
+  }
+  let namesChanged = false;
+  if (dirty.all || dirty.list || dirty.names) {
+    const names = readNames(shared.names, (key) => indexOf.get(key));
+    namesChanged = !jsonEqual(names, workbook.definedNames);
+    if (namesChanged) workbook.definedNames = names;
+  }
+  if (!structural && !sheetsTouched.size && !namesChanged) return void 0;
+  const change = { label, structural, cells: touched };
+  const [only] = sheetsTouched;
+  if (sheetsTouched.size === 1 && only !== void 0) change.sheet = only;
+  if (!structural && ranges.length && ranges.length <= 1024) change.ranges = ranges;
+  return change;
+}
+function applyList(workbook, keys, entries) {
+  if (!entries.length) return false;
+  const byKey = /* @__PURE__ */ new Map();
+  for (const sheet of workbook.sheets) {
+    const key = keys.find(sheet, entries);
+    if (key !== void 0 && !byKey.has(key)) byKey.set(key, sheet);
+  }
+  const active = workbook.sheets[workbook.activeSheet];
+  let changed = entries.length !== workbook.sheets.length;
+  const next = entries.map((entry, index) => {
+    const sheet = byKey.get(entry.key) ?? createWorksheet(entry.name, entry.sheetId);
+    keys.remember(sheet, entry.key);
+    if (workbook.sheets[index] !== sheet || sheet.name !== entry.name || sheet.state !== entry.state || sheet.sheetId !== entry.sheetId)
+      changed = true;
+    sheet.name = entry.name;
+    sheet.sheetId = entry.sheetId;
+    sheet.state = entry.state;
+    if (entry.tabColor) sheet.tabColor = entry.tabColor;
+    else delete sheet.tabColor;
+    if (entry.defaultRowHeight !== void 0) sheet.defaultRowHeight = entry.defaultRowHeight;
+    if (entry.defaultColWidth !== void 0) sheet.defaultColWidth = entry.defaultColWidth;
+    else delete sheet.defaultColWidth;
+    return sheet;
+  });
+  workbook.sheets.splice(0, workbook.sheets.length, ...next);
+  const kept = active ? next.indexOf(active) : -1;
+  workbook.activeSheet = kept >= 0 ? kept : Math.min(workbook.activeSheet, next.length - 1);
+  return changed;
+}
+
+// xlsx/collab/dirty.ts
+var emptyDirty = (all = false) => ({
+  all,
+  list: false,
+  names: false,
+  sheets: /* @__PURE__ */ new Map()
+});
+var isDirty = (dirty) => dirty.all || dirty.list || dirty.names || dirty.sheets.size > 0;
+function sheetDirty(dirty, key) {
+  let entry = dirty.sheets.get(key);
+  if (!entry) {
+    entry = { full: false, rows: /* @__PURE__ */ new Set(), cols: false, merges: false, cells: /* @__PURE__ */ new Set() };
+    dirty.sheets.set(key, entry);
+  }
+  return entry;
+}
+var changedKeys = (event) => [...event.changes.keys.keys()];
+function collectDirty(dirty, top, events) {
+  if (top === "styles") return;
+  if (top === "meta") {
+    dirty.all = true;
+    return;
+  }
+  if (top === "names") {
+    dirty.names = true;
+    return;
+  }
+  for (const event of events) {
+    const path = event.path;
+    const key = path[0];
+    const part = path[1];
+    if (key === void 0) {
+      dirty.list = true;
+      for (const changed of changedKeys(event)) sheetDirty(dirty, changed).full = true;
+      continue;
+    }
+    const entry = sheetDirty(dirty, String(key));
+    if (part === void 0 || path.length > 2) entry.full = true;
+    else if (part === "props") dirty.list = true;
+    else if (part === "cells") for (const k of changedKeys(event)) entry.cells.add(k);
+    else if (part === "rows") for (const k of changedKeys(event)) entry.rows.add(k);
+    else if (part === "cols") entry.cols = true;
+    else if (part === "merges") entry.merges = true;
+    else entry.full = true;
+  }
+}
+
+// xlsx/collab/write.ts
+var PROBE_LIMIT = 4096;
+function writeWorkbook(shared, keys, workbook, scope) {
+  const { meta, sheets } = shared;
+  setIfChanged(meta, "v", SCHEMA_VERSION);
+  let defaultKey = meta.get("defaultStyle");
+  if (typeof defaultKey !== "string") {
+    const base = workbook.styles[0];
+    defaultKey = base ? sharedStyleKey(base) : "";
+    meta.set("defaultStyle", defaultKey);
+  }
+  const styles = new StyleBridge(workbook, shared.styles, defaultKey, true);
+  styles.keyOf(0);
+  const entries = sheetEntries(sheets);
+  const known = workbook.sheets.map((sheet) => keys.find(sheet, entries));
+  const full = scope.kind === "all" || known.some((key) => key === void 0 || !sheets.has(key));
+  if (full) setIfChanged(meta, "date1904", workbook.date1904);
+  const keyList = workbook.sheets.map((sheet) => keys.resolve(sheet, entries, sheets));
+  if (full) {
+    const live = new Set(keyList);
+    for (const key of [...sheets.keys()]) if (!live.has(key)) sheets.delete(key);
+  }
+  workbook.sheets.forEach((sheet, index) => {
+    const key = keyList[index];
+    if (key === void 0) return;
+    let map = childMap(sheets, key);
+    const created = !map;
+    if (!map) {
+      map = newSheetMap();
+      sheets.set(key, map);
+    }
+    if (!full && !created && scope.kind === "sheet" && scope.sheet !== index) {
+      writeProps(map, sheet);
+      return;
+    }
+    writeProps(map, sheet);
+    writeLines(
+      sheet,
+      {
+        rows: sheetPart(map, "rows"),
+        cols: sheetPart(map, "cols"),
+        merges: sheetPart(map, "merges")
+      },
+      styles.keyOf
+    );
+    const ranges = !full && scope.kind === "sheet" ? scope.ranges : void 0;
+    writeCells(sheet, sheetPart(map, "cells"), styles.keyOf, ranges);
+  });
+  writeOrder(sheets, keyList, entries);
+  writeNames(shared.names, workbook.definedNames, (index) => keyList[index]);
+}
+function writeProps(map, sheet) {
+  const props = sheetPart(map, "props");
+  setIfChanged(props, "name", sheet.name);
+  setIfChanged(props, "sheetId", sheet.sheetId);
+  setIfChanged(props, "state", sheet.state);
+  setIfChanged(props, "tab", sheet.tabColor ? structuredClone(sheet.tabColor) : void 0);
+  setIfChanged(props, "rh", sheet.defaultRowHeight);
+  setIfChanged(props, "cw", sheet.defaultColWidth);
+}
+function writeOrder(sheets, keyList, entries) {
+  const orders = new Map(entries.map((entry) => [entry.key, entry.order]));
+  const current = keyList.map((key) => {
+    const props = childMap(sheets, key);
+    return props && childMap(props, "props")?.has("order") ? orders.get(key) : void 0;
+  });
+  for (const [index, order] of reorder(current)) {
+    const key = keyList[index];
+    const props = key === void 0 ? void 0 : childMap(sheets, key);
+    if (props) sheetPart(props, "props").set("order", order);
+  }
+}
+function writeCells(sheet, cells, keyOf, ranges) {
+  const write = (row, col) => {
+    const key = formatAddress({ row, col });
+    const cell = getCell(sheet, row, col);
+    setIfChanged(cells, key, cell && encodeCell(cell, keyOf));
+    return key;
+  };
+  if (!ranges) {
+    const live = /* @__PURE__ */ new Set();
+    forEachCell(sheet, (_cell, row, col) => live.add(write(row, col)));
+    for (const key of [...cells.keys()]) if (!live.has(key)) cells.delete(key);
+    return;
+  }
+  for (const raw of ranges) {
+    const range = normalizeRange(raw);
+    const area = (range.end.row - range.start.row + 1) * (range.end.col - range.start.col + 1);
+    if (area <= PROBE_LIMIT) {
+      for (let row = range.start.row; row <= range.end.row; row++)
+        for (let col = range.start.col; col <= range.end.col; col++) write(row, col);
+      continue;
+    }
+    const live = /* @__PURE__ */ new Set();
+    forEachCellInRange(sheet, range, (_cell, row, col) => live.add(write(row, col)));
+    for (const key of [...cells.keys()]) {
+      const at = parseAddress(key);
+      if (!live.has(key) && at && rangeContains(range, at)) cells.delete(key);
+    }
+  }
+}
+
+// xlsx/collab/adapter.ts
+var isSharedWorkbookEmpty = (doc) => sharedWorkbook(doc).sheets.size === 0;
+function readSharedWorkbook(doc, base) {
+  const shared = sharedWorkbook(doc);
+  const workbook = base ? structuredClone(base) : createWorkbook();
+  if (!base) {
+    const style = shared.styles.get(String(shared.meta.get("defaultStyle")));
+    if (isCellStyle(style)) workbook.styles = [structuredClone(style)];
+  }
+  applyShared(shared, new SheetKeys(doc.clientID), workbook, emptyDirty(true));
+  return workbook;
+}
+function writeSharedWorkbook(doc, workbook, origin) {
+  doc.transact(() => {
+    writeWorkbook(sharedWorkbook(doc), new SheetKeys(doc.clientID), workbook, { kind: "all" });
+  }, origin);
+}
+function xlsxDocumentAdapter(options = {}) {
+  return {
+    isEmpty: isSharedWorkbookEmpty,
+    read: (doc) => readSharedWorkbook(doc, options.base?.()),
+    write: (doc, model, origin) => writeSharedWorkbook(doc, model, origin),
+    observe: (doc, onChange) => {
+      const types = sharedTypes(sharedWorkbook(doc));
+      let origin;
+      let changed = false;
+      const mark = (_events, transaction) => {
+        changed = true;
+        origin = transaction.origin;
+      };
+      const flush = () => {
+        if (!changed) return;
+        changed = false;
+        onChange(origin);
+      };
+      for (const type of types) type.observeDeep(mark);
+      doc.on("afterTransaction", flush);
+      return () => {
+        for (const type of types) type.unobserveDeep(mark);
+        doc.off("afterTransaction", flush);
+      };
+    }
+  };
+}
+
+// xlsx/collab/presence.ts
+var SHEET_KEY = /^[a-z0-9]{1,16}-[a-z0-9]{1,16}$/;
+function sanitizeXlsxPresence(raw) {
+  const out = {};
+  const { sheet, range, joined } = raw;
+  if (typeof joined === "number" && Number.isFinite(joined) && joined > 0) out.joined = joined;
+  if (typeof sheet !== "string" || !SHEET_KEY.test(sheet)) return out;
+  if (typeof range !== "string" || range.length > 32) return out;
+  const parsed = parseRange(range);
+  if (!parsed) return out;
+  out.sheet = sheet;
+  out.range = formatRange(parsed);
+  return out;
+}
+function resolveSelections(peers, sheetIndex) {
+  const out = [];
+  for (const peer of peers) {
+    if (!peer.sheet || !peer.range) continue;
+    const sheet = sheetIndex(peer.sheet);
+    const range = parseRange(peer.range);
+    if (sheet === void 0 || !range) continue;
+    out.push({
+      clientId: peer.clientId,
+      userName: peer.userName,
+      userColor: peer.userColor,
+      sheet,
+      range
+    });
+  }
+  return out;
+}
+
+// xlsx/collab/bind.ts
+var XLSX_EDIT_ORIGIN = /* @__PURE__ */ Symbol("ooxml-core:xlsx:edit");
+var XLSX_SYNC_ORIGIN = /* @__PURE__ */ Symbol("ooxml-core:xlsx:sync");
+var WHOLE_WORKBOOK = /* @__PURE__ */ new Set(["sheets", "structure", "names", "batch", "undo", "redo"]);
+function scopeOf(change) {
+  if (change.structural || change.sheet === void 0 || WHOLE_WORKBOOK.has(change.kind))
+    return { kind: "all" };
+  if ((change.kind === "cells" || change.kind === "format") && change.ranges?.length)
+    return { kind: "sheet", sheet: change.sheet, ranges: change.ranges };
+  return { kind: "sheet", sheet: change.sheet };
+}
+function bindWorkbookSession(host, edit, options = {}) {
+  const { doc } = host;
+  const shared = sharedWorkbook(doc);
+  const types = sharedTypes(shared);
+  const keys = new SheetKeys(doc.clientID);
+  const workbook = edit.workbook;
+  const undoManager = new Y__namespace.UndoManager(types, {
+    trackedOrigins: /* @__PURE__ */ new Set([XLSX_EDIT_ORIGIN]),
+    captureTimeout: 0
+  });
+  let disposed = false;
+  let settled = false;
+  let unsent = false;
+  let replaying;
+  let dirty = emptyDirty();
+  let waiting = false;
+  const joined = Date.now();
+  host.updatePresence({ joined });
+  const earlierWriter = () => host.peers().some(
+    (peer) => peer.joined !== void 0 && peer.role !== "viewer" && (peer.joined < joined || peer.joined === joined && peer.clientId < doc.clientID)
+  );
+  const write = (scope, origin) => {
+    doc.transact(() => writeWorkbook(shared, keys, workbook, scope), origin);
+    undoManager.stopCapturing();
+  };
+  const apply = (all, kind = "remote") => {
+    const pending = all ? emptyDirty(true) : dirty;
+    dirty = emptyDirty();
+    try {
+      edit.applyExternal(() => {
+        const change = applyShared(shared, keys, workbook, pending);
+        if (change) change.kind = kind;
+        return change;
+      });
+    } catch (error) {
+      options.onError?.(error);
+    }
+  };
+  const settle = () => {
+    if (disposed) return;
+    if (shared.sheets.size === 0) {
+      if (!host.canWrite()) return;
+      waiting = !settled && earlierWriter();
+      if (waiting) return;
+      write({ kind: "all" }, XLSX_SYNC_ORIGIN);
+    } else if (settled && unsent && host.canWrite()) write({ kind: "all" }, XLSX_SYNC_ORIGIN);
+    else if (!settled) apply(true);
+    settled = true;
+    waiting = false;
+    unsent = false;
+  };
+  const observers = types.map((type, i) => {
+    const top = ["meta", "styles", "names", "sheets"][i] ?? "sheets";
+    const observer = (events, transaction) => {
+      const origin = transaction.origin;
+      if (origin === XLSX_EDIT_ORIGIN || origin === XLSX_SYNC_ORIGIN) return;
+      collectDirty(dirty, top, events);
+    };
+    type.observeDeep(observer);
+    return () => type.unobserveDeep(observer);
+  });
+  const afterTransaction = (transaction) => {
+    if (disposed || !isDirty(dirty)) return;
+    if (!settled) {
+      dirty = emptyDirty();
+      if (waiting && shared.sheets.size > 0) settle();
+      return;
+    }
+    const kind = transaction.origin === undoManager ? replaying ?? "undo" : "remote";
+    apply(false, kind);
+  };
+  doc.on("afterTransaction", afterTransaction);
+  const stopEdits = edit.onChange((change) => {
+    if (disposed || change.external || !settled) return;
+    if (!host.canWrite()) {
+      unsent = true;
+      return;
+    }
+    write(scopeOf(change), XLSX_EDIT_ORIGIN);
+  });
+  const stopReady = host.on("ready", settle);
+  const stopSynced = host.on("synced", (synced) => {
+    if (synced && !host.canWrite()) settle();
+  });
+  const stopPeers = host.on("peers", () => {
+    if (waiting && !settled) settle();
+  });
+  if (host.synced || host.canWrite()) settle();
+  const replay = (kind) => {
+    const stack = kind === "undo" ? undoManager.undoStack : undoManager.redoStack;
+    if (disposed || !stack.length) return false;
+    replaying = kind;
+    try {
+      if (kind === "undo") undoManager.undo();
+      else undoManager.redo();
+    } finally {
+      replaying = void 0;
+    }
+    return true;
+  };
+  const sheetKey = (index) => {
+    const sheet = workbook.sheets[index];
+    return sheet && keys.find(sheet, sheetEntries(shared.sheets));
+  };
+  const sheetIndex = (key) => {
+    const entries = sheetEntries(shared.sheets);
+    const index = workbook.sheets.findIndex((sheet) => keys.find(sheet, entries) === key);
+    return index >= 0 ? index : void 0;
+  };
+  return {
+    undo: () => replay("undo"),
+    redo: () => replay("redo"),
+    canUndo: () => undoManager.undoStack.length > 0,
+    canRedo: () => undoManager.redoStack.length > 0,
+    setSelection: (sheet, range) => {
+      const key = sheetKey(sheet);
+      if (key !== void 0) host.updatePresence({ sheet: key, range: formatRange(range) });
+    },
+    remoteSelections: () => resolveSelections(host.peers(), sheetIndex),
+    sheetKey,
+    sheetIndex,
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      for (const stop of observers) stop();
+      doc.off("afterTransaction", afterTransaction);
+      stopEdits();
+      stopReady();
+      stopSynced();
+      stopPeers();
+      undoManager.destroy();
+    }
+  };
+}
+
+exports.META = META;
+exports.NAMES = NAMES;
+exports.SCHEMA_VERSION = SCHEMA_VERSION;
+exports.SHEETS = SHEETS;
+exports.STYLES = STYLES;
+exports.XLSX_EDIT_ORIGIN = XLSX_EDIT_ORIGIN;
+exports.XLSX_SYNC_ORIGIN = XLSX_SYNC_ORIGIN;
+exports.bindWorkbookSession = bindWorkbookSession;
+exports.isSharedWorkbookEmpty = isSharedWorkbookEmpty;
+exports.readSharedWorkbook = readSharedWorkbook;
+exports.resolveSelections = resolveSelections;
+exports.sanitizeXlsxPresence = sanitizeXlsxPresence;
+exports.scopeOf = scopeOf;
+exports.sharedStyleKey = sharedStyleKey;
+exports.sharedWorkbook = sharedWorkbook;
+exports.writeSharedWorkbook = writeSharedWorkbook;
+exports.xlsxDocumentAdapter = xlsxDocumentAdapter;