@beyondwork/docx-react-component 1.0.28 → 1.0.29

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

@@ -1,822 +0,0 @@
-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;
-}