@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/formats/xlsx/runtime/workbook-transaction.ts

@@ -0,0 +1,822 @@
+import { parseCellKey, type CellKey, type FormulaCell } from "../model/cell.ts";
+import type { CanonicalSheet, MergeRange } from "../model/sheet.ts";
+import type { CanonicalWorkbook, NamedItem } from "../model/workbook.ts";
+import { getSheet, listSheets, workbookFromJson, workbookToJson } from "../model/workbook.ts";
+
+export interface WorkbookCellRef {
+  row: number;
+  col: number;
+}
+
+export interface WorkbookRange {
+  startRow: number;
+  startCol: number;
+  endRow: number;
+  endCol: number;
+}
+
+export type WorkbookSelectionMode = "cell" | "row" | "column" | "sheet";
+
+export interface WorkbookSelection {
+  mode: WorkbookSelectionMode;
+  sheetId?: string;
+  activeCell?: WorkbookCellRef;
+  range?: WorkbookRange;
+}
+
+export type WorkbookTransactionOperation =
+  | { type: "cell-set"; sheetId: string; row: number; col: number }
+  | { type: "row-insert"; sheetId: string; index: number; count: number }
+  | { type: "row-delete"; sheetId: string; index: number; count: number }
+  | { type: "column-insert"; sheetId: string; index: number; count: number }
+  | { type: "column-delete"; sheetId: string; index: number; count: number }
+  | { type: "merge-add"; sheetId: string; range: WorkbookRange }
+  | { type: "merge-remove"; sheetId: string; range: WorkbookRange }
+  | { type: "sheet-add"; sheetId: string; index: number; name: string }
+  | { type: "sheet-remove"; sheetId: string; index: number; name: string; fallbackSheetId?: string }
+  | { type: "sheet-rename"; sheetId: string; beforeName: string; afterName: string }
+  | { type: "sheet-reorder"; sheetId: string; fromIndex: number; toIndex: number }
+  | { type: "formula-remap"; ownerSheetId: string; row: number; col: number; before: string; after: string }
+  | { type: "named-item-remap"; name: string; before: string; after: string };
+
+export interface WorkbookTransactionMapping {
+  operations: WorkbookTransactionOperation[];
+}
+
+export interface WorkbookTransaction {
+  nextWorkbook: CanonicalWorkbook;
+  nextSelection: WorkbookSelection;
+  mapping: WorkbookTransactionMapping;
+  inverseMapping: WorkbookTransactionMapping;
+  historyBoundary: "push" | "skip";
+  label: string;
+}
+
+interface ParsedA1CellRef {
+  col: number;
+  row: number;
+  colAbsolute: boolean;
+  rowAbsolute: boolean;
+}
+
+interface ParsedFormulaToken {
+  sheetName?: string;
+  sheetQuoted: boolean;
+  start: ParsedA1CellRef;
+  end?: ParsedA1CellRef;
+}
+
+interface InsertAxisMutation {
+  axis: "row" | "col";
+  kind: "insert";
+  index: number;
+  count: number;
+}
+
+interface DeleteAxisMutation {
+  axis: "row" | "col";
+  kind: "delete";
+  index: number;
+  count: number;
+}
+
+interface RenameSheetMutation {
+  kind: "rename-sheet";
+  beforeName: string;
+  afterName: string;
+}
+
+interface RemoveSheetMutation {
+  kind: "remove-sheet";
+  removedName: string;
+}
+
+type FormulaMutation =
+  | InsertAxisMutation
+  | DeleteAxisMutation
+  | RenameSheetMutation
+  | RemoveSheetMutation;
+
+const SHEET_PREFIX_PATTERN =
+  "(?:'(?:[^']|'')+'|[A-Za-z_][A-Za-z0-9_.]*)!";
+const CELL_REFERENCE_PATTERN = "\\$?[A-Z]{1,3}\\$?[1-9][0-9]*";
+const RANGE_REFERENCE_PATTERN =
+  `${CELL_REFERENCE_PATTERN}(?::${CELL_REFERENCE_PATTERN})?`;
+const FORMULA_REFERENCE_PATTERN = new RegExp(
+  String.raw`(?<![A-Za-z0-9_.$])(?:${SHEET_PREFIX_PATTERN})?${RANGE_REFERENCE_PATTERN}(?![A-Za-z0-9_])`,
+  "g",
+);
+const SIMPLE_SHEET_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.]*$/;
+
+export function createEmptyWorkbookMapping(): WorkbookTransactionMapping {
+  return { operations: [] };
+}
+
+export function createWorkbookTransaction(
+  nextWorkbook: CanonicalWorkbook,
+  nextSelection: WorkbookSelection,
+  mapping: WorkbookTransactionMapping,
+  label: string,
+): WorkbookTransaction {
+  return {
+    nextWorkbook,
+    nextSelection,
+    mapping,
+    inverseMapping: {
+      operations: [...mapping.operations].reverse().map(invertOperation),
+    },
+    historyBoundary: "push",
+    label,
+  };
+}
+
+export function cloneWorkbook(workbook: CanonicalWorkbook): CanonicalWorkbook {
+  return workbookFromJson(workbookToJson(workbook));
+}
+
+export function createWorkbookSelection(
+  sheetId?: string,
+  row = 0,
+  col = 0,
+  mode: WorkbookSelectionMode = "cell",
+): WorkbookSelection {
+  if (!sheetId) {
+    return { mode: "sheet" };
+  }
+
+  const activeCell = { row: Math.max(0, row), col: Math.max(0, col) };
+  return {
+    mode,
+    sheetId,
+    activeCell,
+    range: {
+      startRow: activeCell.row,
+      startCol: activeCell.col,
+      endRow: activeCell.row,
+      endCol: activeCell.col,
+    },
+  };
+}
+
+export function getDefaultSelection(workbook: CanonicalWorkbook): WorkbookSelection {
+  const firstSheetId = workbook.sheetOrder[0];
+  return createWorkbookSelection(firstSheetId);
+}
+
+export function normalizeWorkbookSelection(
+  workbook: CanonicalWorkbook,
+  selection?: WorkbookSelection,
+): WorkbookSelection {
+  if (workbook.sheetOrder.length === 0) {
+    return { mode: "sheet" };
+  }
+
+  const sheetId = selection?.sheetId && workbook.sheets.has(selection.sheetId)
+    ? selection.sheetId
+    : workbook.sheetOrder[0];
+  const activeCell = selection?.activeCell ?? { row: 0, col: 0 };
+  const range = selection?.range
+    ? normalizeRange(selection.range)
+    : {
+        startRow: activeCell.row,
+        startCol: activeCell.col,
+        endRow: activeCell.row,
+        endCol: activeCell.col,
+      };
+
+  return {
+    mode: selection?.mode ?? "cell",
+    sheetId,
+    activeCell: {
+      row: Math.max(0, activeCell.row),
+      col: Math.max(0, activeCell.col),
+    },
+    range,
+  };
+}
+
+export function mapSelectionThroughMapping(
+  selection: WorkbookSelection,
+  mapping: WorkbookTransactionMapping,
+): WorkbookSelection {
+  let nextSelection: WorkbookSelection = cloneSelection(selection);
+
+  for (const operation of mapping.operations) {
+    nextSelection = mapSelectionThroughOperation(nextSelection, operation);
+  }
+
+  return nextSelection;
+}
+
+export function normalizeRange(range: WorkbookRange): WorkbookRange {
+  return {
+    startRow: Math.min(range.startRow, range.endRow),
+    startCol: Math.min(range.startCol, range.endCol),
+    endRow: Math.max(range.startRow, range.endRow),
+    endCol: Math.max(range.startCol, range.endCol),
+  };
+}
+
+export function rangesIntersect(left: WorkbookRange, right: WorkbookRange): boolean {
+  const a = normalizeRange(left);
+  const b = normalizeRange(right);
+  return !(
+    a.endRow < b.startRow ||
+    b.endRow < a.startRow ||
+    a.endCol < b.startCol ||
+    b.endCol < a.startCol
+  );
+}
+
+export function rangeContainsCell(range: WorkbookRange, cell: WorkbookCellRef): boolean {
+  const normalized = normalizeRange(range);
+  return (
+    cell.row >= normalized.startRow &&
+    cell.row <= normalized.endRow &&
+    cell.col >= normalized.startCol &&
+    cell.col <= normalized.endCol
+  );
+}
+
+export function remapFormulasForMutation(
+  workbook: CanonicalWorkbook,
+  targetSheetId: string,
+  mutation: FormulaMutation,
+  mapping: WorkbookTransactionMapping,
+): void {
+  const targetSheetName = getSheet(workbook, targetSheetId)?.name;
+  if (!targetSheetName) {
+    return;
+  }
+
+  for (const sheet of listSheets(workbook)) {
+    for (const [key, value] of sheet.cells) {
+      if (value.kind !== "formula") {
+        continue;
+      }
+
+      const rewritten = rewriteFormulaReferences(
+        value.formula,
+        sheet.name,
+        targetSheetName,
+        mutation,
+      );
+      if (!rewritten.changed) {
+        continue;
+      }
+
+      sheet.cells.set(key, {
+        ...value,
+        formula: rewritten.formula,
+        referenceTokens: extractFormulaReferenceTokens(rewritten.formula),
+      } satisfies FormulaCell);
+
+      const address = parseCellKey(key);
+      mapping.operations.push({
+        type: "formula-remap",
+        ownerSheetId: sheet.sheetId,
+        row: address.row,
+        col: address.col,
+        before: value.formula,
+        after: rewritten.formula,
+      });
+    }
+  }
+
+  workbook.namedItems = workbook.namedItems
+    .map((item) => remapNamedItemForMutation(item, workbook, targetSheetName, mutation, mapping))
+    .filter((item): item is NamedItem => item !== null);
+}
+
+export function getRequiredSheet(workbook: CanonicalWorkbook, sheetId: string): CanonicalSheet {
+  const sheet = workbook.sheets.get(sheetId);
+  if (!sheet) {
+    throw new Error(`Sheet not found: ${sheetId}`);
+  }
+  return sheet;
+}
+
+export function cloneSelection(selection: WorkbookSelection): WorkbookSelection {
+  return {
+    mode: selection.mode,
+    sheetId: selection.sheetId,
+    activeCell: selection.activeCell ? { ...selection.activeCell } : undefined,
+    range: selection.range ? { ...selection.range } : undefined,
+  };
+}
+
+export function mergeRangeToWorkbookRange(range: MergeRange): WorkbookRange {
+  return {
+    startRow: range.startRow,
+    startCol: range.startCol,
+    endRow: range.endRow,
+    endCol: range.endCol,
+  };
+}
+
+export function workbookRangeToMergeRange(range: WorkbookRange): MergeRange {
+  const normalized = normalizeRange(range);
+  return {
+    startRow: normalized.startRow,
+    startCol: normalized.startCol,
+    endRow: normalized.endRow,
+    endCol: normalized.endCol,
+  };
+}
+
+export function replaceSheetCells(
+  sheet: CanonicalSheet,
+  cells: Map<CellKey, CanonicalSheet["cells"] extends Map<CellKey, infer TValue> ? TValue : never>,
+): void {
+  sheet.cells = cells as CanonicalSheet["cells"];
+}
+
+export function replaceSheetRowProps(
+  sheet: CanonicalSheet,
+  rowProps: CanonicalSheet["rowProps"],
+): void {
+  sheet.rowProps = rowProps;
+}
+
+export function replaceSheetColProps(
+  sheet: CanonicalSheet,
+  colProps: CanonicalSheet["colProps"],
+): void {
+  sheet.colProps = colProps;
+}
+
+export function replaceSheetMerges(
+  sheet: CanonicalSheet,
+  merges: MergeRange[],
+): void {
+  sheet.merges = merges;
+}
+
+export function extractFormulaReferenceTokens(formula: string): string[] {
+  const maskedFormula = maskQuotedFormulaStrings(formula);
+  const tokens: string[] = [];
+  const seen = new Set<string>();
+
+  for (const match of maskedFormula.matchAll(FORMULA_REFERENCE_PATTERN)) {
+    const index = match.index ?? -1;
+    if (index < 0) {
+      continue;
+    }
+    const token = formula.slice(index, index + match[0].length);
+    if (seen.has(token)) {
+      continue;
+    }
+    seen.add(token);
+    tokens.push(token);
+  }
+
+  return tokens;
+}
+
+function invertOperation(operation: WorkbookTransactionOperation): WorkbookTransactionOperation {
+  switch (operation.type) {
+    case "cell-set":
+      return operation;
+    case "row-insert":
+      return { type: "row-delete", sheetId: operation.sheetId, index: operation.index, count: operation.count };
+    case "row-delete":
+      return { type: "row-insert", sheetId: operation.sheetId, index: operation.index, count: operation.count };
+    case "column-insert":
+      return { type: "column-delete", sheetId: operation.sheetId, index: operation.index, count: operation.count };
+    case "column-delete":
+      return { type: "column-insert", sheetId: operation.sheetId, index: operation.index, count: operation.count };
+    case "merge-add":
+      return { type: "merge-remove", sheetId: operation.sheetId, range: operation.range };
+    case "merge-remove":
+      return { type: "merge-add", sheetId: operation.sheetId, range: operation.range };
+    case "sheet-add":
+      return {
+        type: "sheet-remove",
+        sheetId: operation.sheetId,
+        index: operation.index,
+        name: operation.name,
+      };
+    case "sheet-remove":
+      return {
+        type: "sheet-add",
+        sheetId: operation.sheetId,
+        index: operation.index,
+        name: operation.name,
+      };
+    case "sheet-rename":
+      return {
+        type: "sheet-rename",
+        sheetId: operation.sheetId,
+        beforeName: operation.afterName,
+        afterName: operation.beforeName,
+      };
+    case "sheet-reorder":
+      return {
+        type: "sheet-reorder",
+        sheetId: operation.sheetId,
+        fromIndex: operation.toIndex,
+        toIndex: operation.fromIndex,
+      };
+    case "formula-remap":
+      return {
+        type: "formula-remap",
+        ownerSheetId: operation.ownerSheetId,
+        row: operation.row,
+        col: operation.col,
+        before: operation.after,
+        after: operation.before,
+      };
+    case "named-item-remap":
+      return {
+        type: "named-item-remap",
+        name: operation.name,
+        before: operation.after,
+        after: operation.before,
+      };
+  }
+}
+
+function mapSelectionThroughOperation(
+  selection: WorkbookSelection,
+  operation: WorkbookTransactionOperation,
+): WorkbookSelection {
+  const nextSelection = cloneSelection(selection);
+
+  switch (operation.type) {
+    case "sheet-remove":
+      if (nextSelection.sheetId === operation.sheetId) {
+        if (!operation.fallbackSheetId) {
+          return { mode: "sheet" };
+        }
+        nextSelection.sheetId = operation.fallbackSheetId;
+      }
+      return nextSelection;
+    case "row-insert":
+    case "row-delete":
+      if (nextSelection.sheetId !== operation.sheetId) {
+        return nextSelection;
+      }
+      if (nextSelection.activeCell) {
+        nextSelection.activeCell.row = mapIndexThroughOperation(nextSelection.activeCell.row, operation);
+      }
+      if (nextSelection.range) {
+        nextSelection.range.startRow = mapIndexThroughOperation(nextSelection.range.startRow, operation);
+        nextSelection.range.endRow = mapIndexThroughOperation(nextSelection.range.endRow, operation);
+        nextSelection.range = normalizeRange(nextSelection.range);
+      }
+      return nextSelection;
+    case "column-insert":
+    case "column-delete":
+      if (nextSelection.sheetId !== operation.sheetId) {
+        return nextSelection;
+      }
+      if (nextSelection.activeCell) {
+        nextSelection.activeCell.col = mapIndexThroughOperation(nextSelection.activeCell.col, operation);
+      }
+      if (nextSelection.range) {
+        nextSelection.range.startCol = mapIndexThroughOperation(nextSelection.range.startCol, operation);
+        nextSelection.range.endCol = mapIndexThroughOperation(nextSelection.range.endCol, operation);
+        nextSelection.range = normalizeRange(nextSelection.range);
+      }
+      return nextSelection;
+    default:
+      return nextSelection;
+  }
+}
+
+function mapIndexThroughOperation(
+  value: number,
+  operation:
+    | Extract<WorkbookTransactionOperation, { type: "row-insert" | "row-delete" }>
+    | Extract<WorkbookTransactionOperation, { type: "column-insert" | "column-delete" }>,
+): number {
+  if (operation.type === "row-insert" || operation.type === "column-insert") {
+    return value >= operation.index ? value + operation.count : value;
+  }
+
+  const deleteEnd = operation.index + operation.count - 1;
+  if (value < operation.index) {
+    return value;
+  }
+  if (value <= deleteEnd) {
+    return operation.index;
+  }
+  return value - operation.count;
+}
+
+function remapNamedItemForMutation(
+  item: NamedItem,
+  workbook: CanonicalWorkbook,
+  targetSheetName: string,
+  mutation: FormulaMutation,
+  mapping: WorkbookTransactionMapping,
+): NamedItem | null {
+  if (mutation.kind === "remove-sheet" && item.localSheetId === findSheetIdByName(workbook, mutation.removedName)) {
+    return null;
+  }
+
+  const ownerSheetName = item.localSheetId ? workbook.sheets.get(item.localSheetId)?.name : undefined;
+  const rewritten = rewriteFormulaReferences(
+    item.refersTo,
+    ownerSheetName,
+    targetSheetName,
+    mutation,
+  );
+  if (!rewritten.changed) {
+    return item;
+  }
+
+  mapping.operations.push({
+    type: "named-item-remap",
+    name: item.name,
+    before: item.refersTo,
+    after: rewritten.formula,
+  });
+
+  return {
+    ...item,
+    refersTo: rewritten.formula,
+  };
+}
+
+function findSheetIdByName(workbook: CanonicalWorkbook, name: string): string | undefined {
+  for (const sheet of workbook.sheets.values()) {
+    if (sheet.name === name) {
+      return sheet.sheetId;
+    }
+  }
+  return undefined;
+}
+
+function rewriteFormulaReferences(
+  formula: string,
+  ownerSheetName: string | undefined,
+  targetSheetName: string,
+  mutation: FormulaMutation,
+): { formula: string; changed: boolean } {
+  const maskedFormula = maskQuotedFormulaStrings(formula);
+  const matches = [...maskedFormula.matchAll(FORMULA_REFERENCE_PATTERN)];
+  if (matches.length === 0) {
+    return { formula, changed: false };
+  }
+
+  let changed = false;
+  let lastIndex = 0;
+  let output = "";
+
+  for (const match of matches) {
+    const index = match.index ?? -1;
+    if (index < 0) {
+      continue;
+    }
+
+    const originalToken = formula.slice(index, index + match[0].length);
+    const nextToken = rewriteFormulaToken(
+      originalToken,
+      ownerSheetName,
+      targetSheetName,
+      mutation,
+    );
+
+    output += formula.slice(lastIndex, index);
+    output += nextToken;
+    lastIndex = index + originalToken.length;
+    changed = changed || nextToken !== originalToken;
+  }
+
+  if (!changed) {
+    return { formula, changed: false };
+  }
+
+  output += formula.slice(lastIndex);
+  return { formula: output, changed: true };
+}
+
+function rewriteFormulaToken(
+  token: string,
+  ownerSheetName: string | undefined,
+  targetSheetName: string,
+  mutation: FormulaMutation,
+): string {
+  const parsed = parseFormulaToken(token);
+  if (!parsed) {
+    return token;
+  }
+
+  if (mutation.kind === "rename-sheet") {
+    if (parsed.sheetName !== mutation.beforeName) {
+      return token;
+    }
+
+    return formatFormulaToken({
+      ...parsed,
+      sheetName: mutation.afterName,
+      sheetQuoted: parsed.sheetQuoted || !SIMPLE_SHEET_NAME_PATTERN.test(mutation.afterName),
+    });
+  }
+
+  if (mutation.kind === "remove-sheet") {
+    return parsed.sheetName === mutation.removedName ? "#REF!" : token;
+  }
+
+  const tokenSheetName = parsed.sheetName ?? ownerSheetName;
+  if (tokenSheetName !== targetSheetName) {
+    return token;
+  }
+
+  const rowRange = mutation.axis === "row"
+    ? remapInterval(parsed.start.row, parsed.end?.row ?? parsed.start.row, mutation)
+    : { valid: true, start: parsed.start.row, end: parsed.end?.row ?? parsed.start.row };
+  const colRange = mutation.axis === "col"
+    ? remapInterval(parsed.start.col, parsed.end?.col ?? parsed.start.col, mutation)
+    : { valid: true, start: parsed.start.col, end: parsed.end?.col ?? parsed.start.col };
+
+  if (!rowRange.valid || !colRange.valid) {
+    return "#REF!";
+  }
+
+  const nextToken: ParsedFormulaToken = {
+    sheetName: parsed.sheetName,
+    sheetQuoted: parsed.sheetQuoted,
+    start: {
+      ...parsed.start,
+      row: rowRange.start,
+      col: colRange.start,
+    },
+    ...(parsed.end
+      ? {
+          end: {
+            ...parsed.end,
+            row: rowRange.end,
+            col: colRange.end,
+          },
+        }
+      : {}),
+  };
+
+  return formatFormulaToken(nextToken);
+}
+
+function remapInterval(
+  start: number,
+  end: number,
+  mutation: InsertAxisMutation | DeleteAxisMutation,
+): { valid: boolean; start: number; end: number } {
+  if (mutation.kind === "insert") {
+    if (mutation.index <= start) {
+      return {
+        valid: true,
+        start: start + mutation.count,
+        end: end + mutation.count,
+      };
+    }
+    if (mutation.index <= end) {
+      return {
+        valid: true,
+        start,
+        end: end + mutation.count,
+      };
+    }
+    return { valid: true, start, end };
+  }
+
+  const deleteStart = mutation.index;
+  const deleteEnd = mutation.index + mutation.count - 1;
+  const overlapStart = Math.max(start, deleteStart);
+  const overlapEnd = Math.min(end, deleteEnd);
+  if (overlapStart <= overlapEnd && overlapEnd - overlapStart + 1 >= end - start + 1) {
+    return { valid: false, start, end };
+  }
+
+  let nextStart = start;
+  let nextEnd = end;
+  if (start >= deleteStart && start <= deleteEnd) {
+    nextStart = deleteStart;
+  } else if (start > deleteEnd) {
+    nextStart = start - mutation.count;
+  }
+
+  if (end >= deleteStart && end <= deleteEnd) {
+    nextEnd = deleteStart - 1;
+  } else if (end > deleteEnd) {
+    nextEnd = end - mutation.count;
+  }
+
+  if (nextEnd < nextStart) {
+    nextEnd = nextStart;
+  }
+
+  return {
+    valid: true,
+    start: nextStart,
+    end: nextEnd,
+  };
+}
+
+function parseFormulaToken(token: string): ParsedFormulaToken | null {
+  const match = /^(?:(('(?:[^']|'')+'|[A-Za-z_][A-Za-z0-9_.]*)!)?(\$?[A-Z]{1,3}\$?[1-9][0-9]*)(?::(\$?[A-Z]{1,3}\$?[1-9][0-9]*))?)$/.exec(token);
+  if (!match) {
+    return null;
+  }
+
+  const sheetRaw = match[2];
+  const sheetName = sheetRaw
+    ? sheetRaw.startsWith("'")
+      ? sheetRaw.slice(1, -1).replace(/''/g, "'")
+      : sheetRaw
+    : undefined;
+  const start = parseA1CellRef(match[3] ?? "");
+  const end = match[4] ? parseA1CellRef(match[4]) : undefined;
+  if (!start || (match[4] && !end)) {
+    return null;
+  }
+
+  return {
+    sheetName,
+    sheetQuoted: sheetRaw ? sheetRaw.startsWith("'") : false,
+    start,
+    ...(end ? { end } : {}),
+  };
+}
+
+function parseA1CellRef(ref: string): ParsedA1CellRef | null {
+  const match = /^(\$?)([A-Z]{1,3})(\$?)([1-9][0-9]*)$/.exec(ref);
+  if (!match) {
+    return null;
+  }
+
+  return {
+    colAbsolute: match[1] === "$",
+    col: parseColumnLetters(match[2]),
+    rowAbsolute: match[3] === "$",
+    row: Number.parseInt(match[4] ?? "1", 10) - 1,
+  };
+}
+
+function formatFormulaToken(token: ParsedFormulaToken): string {
+  const sheetPrefix = token.sheetName
+    ? `${formatSheetName(token.sheetName, token.sheetQuoted)}!`
+    : "";
+  const start = formatA1CellRef(token.start);
+  if (!token.end || (token.start.row === token.end.row && token.start.col === token.end.col)) {
+    return `${sheetPrefix}${start}`;
+  }
+  return `${sheetPrefix}${start}:${formatA1CellRef(token.end)}`;
+}
+
+function formatA1CellRef(ref: ParsedA1CellRef): string {
+  return `${ref.colAbsolute ? "$" : ""}${formatColumnLetters(ref.col)}${ref.rowAbsolute ? "$" : ""}${ref.row + 1}`;
+}
+
+function formatSheetName(name: string, forceQuote: boolean): string {
+  if (!forceQuote && SIMPLE_SHEET_NAME_PATTERN.test(name)) {
+    return name;
+  }
+  return `'${name.replace(/'/g, "''")}'`;
+}
+
+function parseColumnLetters(letters: string): number {
+  let value = 0;
+  for (const char of letters) {
+    value = value * 26 + (char.charCodeAt(0) - 64);
+  }
+  return value - 1;
+}
+
+function formatColumnLetters(value: number): string {
+  let next = value + 1;
+  let output = "";
+
+  while (next > 0) {
+    const remainder = (next - 1) % 26;
+    output = String.fromCharCode(65 + remainder) + output;
+    next = Math.floor((next - 1) / 26);
+  }
+
+  return output;
+}
+
+function maskQuotedFormulaStrings(formula: string): string {
+  let output = "";
+  let inString = false;
+
+  for (let index = 0; index < formula.length; index += 1) {
+    const char = formula[index];
+    const next = formula[index + 1];
+
+    if (char === "\"") {
+      output += char;
+      if (inString && next === "\"") {
+        output += " ";
+        index += 1;
+        continue;
+      }
+      inString = !inString;
+      continue;
+    }
+
+    output += inString ? " " : char;
+  }
+
+  return output;
+}