mulmoclaude 2.6.0 → 2.8.0

package/src/plugins/spreadsheet/engine/coerce-boolean.ts

@@ -1,26 +0,0 @@
-import type { CellValue } from "./types";
-import { isSpreadsheetErrorValue } from "./spreadsheet-errors";
-
-/** Excel-style truthiness, shared by IF and AND/OR/NOT so the same value cannot
- *  read as true in one function and false in another. A number is false only
- *  when 0; blank and empty text are false; the words `true`/`false` are their
- *  logical values (case-insensitively); a numeric string follows its number
- *  (`"0"` → false); any other non-empty text is true. */
-export function coerceToBoolean(value: CellValue | null | undefined): boolean {
-  if (typeof value === "boolean") return value;
-  if (value === null || value === undefined) return false;
-  if (typeof value === "number") return value !== 0;
-  // Pinned: an error reads as non-empty text, i.e. true — the same answer the
-  // error strings gave before they became values.
-  if (isSpreadsheetErrorValue(value)) return true;
-
-  const text = value.trim();
-  if (text === "") return false;
-
-  const lowered = text.toLowerCase();
-  if (lowered === "true") return true;
-  if (lowered === "false") return false;
-
-  const asNumber = Number(text);
-  return Number.isNaN(asNumber) ? true : asNumber !== 0;
-}

package/src/plugins/spreadsheet/engine/condition.ts

@@ -1,182 +0,0 @@
-/**
- * Evaluating a spreadsheet condition without running it as code.
- *
- * A condition is one comparison, or a bare value tested for truthiness. That is
- * the whole grammar — small enough to read directly, which is the point: the
- * previous implementation handed the substituted text to `eval`, so a cell
- * containing `globalThis.x = 1` executed when any IFS referenced it.
- */
-
-import type { CellValue } from "./types";
-import { isSpreadsheetErrorValue } from "./spreadsheet-errors";
-
-export type ComparisonOperator = ">=" | "<=" | "<>" | "!=" | "==" | "=" | ">" | "<";
-
-// Longest first: `>=` must win over `>`, and `<>` / `<=` over `<`.
-const OPERATORS: readonly ComparisonOperator[] = [">=", "<=", "<>", "!=", "==", "=", ">", "<"];
-
-export interface Comparison {
-  left: string;
-  operator: ComparisonOperator;
-  right: string;
-}
-
-/** Remove parentheses that wrap the WHOLE expression, repeatedly. `(1>0)` is
- *  the same condition as `1>0`, but `(A)=(B)` is not `A)=(B` — the leading `(`
- *  closes before the end, so it wraps only its own operand and must stay.
- *  Unbalanced input is left untouched rather than guessed at. */
-export function stripOuterParens(condition: string): string {
-  let text = condition.trim();
-  while (text.startsWith("(") && text.endsWith(")")) {
-    let depth = 0;
-    let quote: string | null = null;
-    let wrapsAll = true;
-    for (let index = 0; index < text.length; index++) {
-      const char = text[index];
-      if (quote !== null) {
-        if (char === "\\")
-          index++; // skip the escaped character
-        else if (char === quote) quote = null;
-        continue;
-      }
-      if (char === '"' || char === "'") {
-        quote = char;
-        continue;
-      }
-      if (char === "(") depth++;
-      else if (char === ")") {
-        depth--;
-        // Back to zero before the end means this `(` closed early.
-        if (depth === 0 && index < text.length - 1) {
-          wrapsAll = false;
-          break;
-        }
-        if (depth < 0) return text; // unbalanced
-      }
-    }
-    if (!wrapsAll || depth !== 0) return text;
-    text = text.slice(1, -1).trim();
-  }
-  return text;
-}
-
-/** Split a condition into its two sides, or null when it holds no comparison.
- *  Only the FIRST top-level operator counts — `a>b>c` is not a chain here, and
- *  treating it as one is what let `1=1=1` reach a JS parser before.
- *
- *  "Top-level" means outside quotes: a cell holding `a>b` substitutes into the
- *  condition as `"a>b"`, and splitting on that `>` would compare two fragments
- *  of one string literal. */
-export function splitComparison(condition: string): Comparison | null {
-  const text = stripOuterParens(condition);
-  let quote: string | null = null;
-  for (let index = 0; index < text.length; index++) {
-    const char = text[index];
-    if (quote !== null) {
-      if (char === "\\")
-        index++; // skip the escaped character
-      else if (char === quote) quote = null;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      continue;
-    }
-    for (const operator of OPERATORS) {
-      if (!text.startsWith(operator, index)) continue;
-      return { left: text.slice(0, index).trim(), operator, right: text.slice(index + operator.length).trim() };
-    }
-  }
-  return null;
-}
-
-/** Strip one matching pair of surrounding quotes, and undo the `\"` / `\\`
- *  escaping that `renderConditionOperand` applies when it quotes a cell value. */
-function unquote(text: string): { value: string; quoted: boolean } {
-  const isQuoted = text.length >= 2 && ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'")));
-  if (!isQuoted) return { value: text, quoted: false };
-  const inner = text.slice(1, -1).replace(/\\(["'\\])/g, "$1");
-  return { value: inner, quoted: true };
-}
-
-/** Read an operand as the value it denotes: a quoted string stays text, a
- *  numeric literal becomes a number, `TRUE`/`FALSE` become booleans, and
- *  anything else stays the text it already is. */
-export function readOperand(raw: string): CellValue {
-  const { value, quoted } = unquote(raw.trim());
-  if (quoted) return value;
-  if (value === "") return "";
-  const upper = value.toUpperCase();
-  if (upper === "TRUE") return true;
-  if (upper === "FALSE") return false;
-  // `Number` rather than `parseFloat`: it rejects trailing garbage, so "12abc"
-  // stays text instead of becoming 12.
-  const numeric = Number(value);
-  return Number.isNaN(numeric) ? value : numeric;
-}
-
-function compareValues(left: CellValue, right: CellValue): number | null {
-  if (typeof left === "number" && typeof right === "number") return left - right;
-  if (typeof left === "boolean" || typeof right === "boolean") return null;
-  return String(left).localeCompare(String(right));
-}
-
-function applyOperator(operator: ComparisonOperator, left: CellValue, right: CellValue): boolean {
-  // Equality does not need an ordering, so it works for every type pair —
-  // including the boolean combinations `compareValues` refuses to order.
-  if (operator === "=" || operator === "==") return left === right;
-  if (operator === "<>" || operator === "!=") return left !== right;
-  const ordering = compareValues(left, right);
-  if (ordering === null) return false;
-  if (operator === ">") return ordering > 0;
-  if (operator === ">=") return ordering >= 0;
-  if (operator === "<") return ordering < 0;
-  return ordering <= 0;
-}
-
-/** Whether a resolved condition value counts as satisfied. Mirrors the
- *  spreadsheet convention rather than JavaScript's: 0 and an empty string are
- *  false, every other value is true. */
-function valueIsTruthy(value: CellValue): boolean {
-  if (typeof value === "boolean") return value;
-  if (typeof value === "number") return value !== 0;
-  return value !== "";
-}
-
-/** True when a bare (non-comparison) condition counts as satisfied. */
-export function isTruthyCondition(raw: string): boolean {
-  return valueIsTruthy(readOperand(stripOuterParens(raw)));
-}
-
-/** Evaluate a condition — one comparison, or a value tested for truthiness.
- *  Never executes its input. */
-export function evaluateCondition(condition: string): boolean {
-  const comparison = splitComparison(condition);
-  if (!comparison) return isTruthyCondition(condition);
-  return applyOperator(comparison.operator, readOperand(comparison.left), readOperand(comparison.right));
-}
-
-/** Like `evaluateCondition`, but each operand is resolved by `evaluate` — so a
- *  caller holding the engine can compute arithmetic and sub-expressions
- *  (`5+1>10`) instead of reading each side as a bare string. It still never runs
- *  the condition as code: it only splits on the top-level comparison and
- *  compares the two resolved values. */
-export function evaluateConditionValues(condition: string, evaluate: (operand: string) => CellValue): boolean {
-  const comparison = splitComparison(condition);
-  if (!comparison) return valueIsTruthy(evaluate(stripOuterParens(condition)));
-  return applyOperator(comparison.operator, evaluate(comparison.left), evaluate(comparison.right));
-}
-
-/** Render a cell's value as an operand for a condition string. A string is
- *  quoted, with its own quotes and backslashes escaped, so its contents cannot
- *  be re-parsed as operators — `evaluateCondition` then unquotes it back to the
- *  original text. A missing value becomes an empty string; numbers and booleans
- *  render as themselves. */
-export function renderConditionOperand(value: CellValue | null | undefined): string {
-  if (value === null || value === undefined) return '""';
-  // A formula error renders as its quoted code, so a condition compares it as
-  // the text a cell shows rather than as a bare `#NUM!` token.
-  const text = isSpreadsheetErrorValue(value) ? value.code : value;
-  if (typeof text === "string") return `"${text.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-  return text.toString();
-}

package/src/plugins/spreadsheet/engine/date-locale.ts

@@ -1,47 +0,0 @@
-/**
- * Which order an ambiguous slash date is written in, per locale.
- *
- * Only dates whose two leading numbers are BOTH 12 or under are ambiguous —
- * `13/04/2025` can only be day-first, and `04/13/2025` can only be month-first,
- * so those decide themselves. This is purely about `03/04/2025`.
- */
-
-// Day-first locales among the ones the app ships. The rest are month-first
-// here: `en` because the app cannot see the region (`en-GB` is folded to `en`
-// before it reaches any plugin), and ja / zh / ko because their conventional
-// order is year-month-day, which puts the month before the day in a two-part
-// date just as US order does.
-const DAY_FIRST_LANGUAGES = new Set(["es", "pt", "fr", "de", "it", "nl", "ru", "pl", "tr", "id", "vi", "th"]);
-
-// English regions that write month-first. Everywhere else that speaks English
-// writes day-first.
-const MONTH_FIRST_EN_REGIONS = new Set(["us", "ca", "ph"]);
-
-/** The region subtag, or "" when the tag carries none. Scanning rather than
- *  taking position 1: a script subtag (`en-Latn-US`) sits between the language
- *  and the region, and reading it as the region flips month-first English
- *  locales to day-first. A region is two letters or three digits; a
- *  single-character subtag starts an extension, so nothing past it is one. */
-function regionOf(subtags: readonly string[]): string {
-  for (const subtag of subtags) {
-    if (subtag.length === 1) break;
-    if (/^[a-z]{2}$/.test(subtag) || /^[0-9]{3}$/.test(subtag)) return subtag;
-  }
-  return "";
-}
-
-/** True when an ambiguous `A/B/YYYY` should read as day-first. Accepts a full
- *  BCP 47 tag or a bare language subtag; the region is used when present so a
- *  caller that can supply `en-GB` gets the right answer even though the app's
- *  own locale resolution discards it. */
-export function prefersDayFirst(locale: string | undefined | null): boolean {
-  if (!locale) return false;
-  const [language = "", ...rest] = locale.toLowerCase().split(/[-_]/);
-  // English splits on region rather than language. A bare `en` carries no
-  // region to split on, so it keeps the US default.
-  if (language === "en") {
-    const region = regionOf(rest);
-    return region !== "" && !MONTH_FIRST_EN_REGIONS.has(region);
-  }
-  return DAY_FIRST_LANGUAGES.has(language);
-}

package/src/plugins/spreadsheet/engine/date-parser.ts

@@ -1,234 +0,0 @@
-/**
- * Date Parsing Utilities
- *
- * Parse various date string formats into Excel serial numbers.
- */
-
-import { dateToSerial, MONTH_NAMES_SHORT, MONTH_NAMES_FULL } from "./date-utils";
-
-/**
- * Check if a string looks like a date
- *
- * @param str - String to check
- * @returns true if string matches common date patterns
- */
-export function isDateLike(str: string): boolean {
-  if (typeof str !== "string") return false;
-  if (str.length < 6 || str.length > 30) return false; // Reasonable length for dates
-
-  // Common date patterns:
-  // MM/DD/YYYY, DD/MM/YYYY, M/D/YYYY
-  // YYYY-MM-DD, YYYY/MM/DD
-  // DD-MMM-YYYY, D-MMM-YYYY
-  // MMM D, YYYY, MMMM D, YYYY
-
-  // Pattern 1: Contains digits and separators (/, -, space)
-  const hasDigits = /\d/.test(str);
-  const hasSeparator = /[/\-\s,]/.test(str);
-
-  if (!hasDigits || !hasSeparator) return false;
-
-  // Pattern 2: Matches common date formats
-  const datePatterns = [
-    /^\d{1,2}\/\d{1,2}\/\d{2,4}$/, // MM/DD/YYYY or DD/MM/YYYY
-    /^\d{4}-\d{1,2}-\d{1,2}$/, // YYYY-MM-DD
-    /^\d{4}\/\d{1,2}\/\d{1,2}$/, // YYYY/MM/DD
-    /^\d{1,2}-[A-Za-z]{3}-\d{2,4}$/, // DD-MMM-YYYY
-    /^[A-Za-z]{3,9}\s+\d{1,2},?\s+\d{4}$/, // MMM D, YYYY or MMMM D, YYYY
-    /^\d{1,2}\s+[A-Za-z]{3,9}\s+\d{4}$/, // D MMM YYYY
-  ];
-
-  return datePatterns.some((pattern) => pattern.test(str.trim()));
-}
-
-/**
- * Build the Excel serial number for a year/month/day triple, or null when the
- * triple is not a valid calendar date. Every dated branch of `parseDate` ends in
- * this same validate → Date.UTC → dateToSerial step.
- */
-export function serialFromParts(year: number, month: number, day: number): number | null {
-  if (!isValidDate(year, month, day)) return null;
-  return dateToSerial(new Date(Date.UTC(year, month - 1, day)));
-}
-
-/**
- * The three capture groups of a date pattern, as a tuple the caller can
- * destructure. `null` when the text does not match — or when a group did not
- * participate, which every pattern here makes impossible, so it lands on the
- * same "not a date" answer rather than reading an absent group as text.
- */
-function matchDateParts(text: string, pattern: RegExp): [string, string, string] | null {
-  const [, first, second, third] = text.match(pattern) ?? [];
-  if (first === undefined || second === undefined || third === undefined) return null;
-  return [first, second, third];
-}
-
-const SLASH_DATE_PATTERN = /^(\d{1,2})\/(\d{1,2})\/(\d{2,4})$/;
-const MAX_MONTH = 12;
-
-/** Whether `A/B/YYYY` reads day-first. A number no month can hold decides on its
- *  own; an ambiguous pair follows the reading preference. Shared with
- *  `getDefaultDateFormat` so a slash date renders in the order it was READ. */
-const readsDayFirst = (first: number, second: number, preferDDMMYYYY: boolean): boolean =>
-  first > MAX_MONTH || (second <= MAX_MONTH && first <= MAX_MONTH && preferDDMMYYYY);
-
-/**
- * Parse a month name to month number (1-12)
- */
-function parseMonthName(monthStr: string): number | null {
-  const month = monthStr.toLowerCase();
-
-  // Try short names
-  const shortIndex = MONTH_NAMES_SHORT.findIndex((m) => m.toLowerCase() === month);
-  if (shortIndex !== -1) return shortIndex + 1;
-
-  // Try full names
-  const fullIndex = MONTH_NAMES_FULL.findIndex((m) => m.toLowerCase() === month);
-  if (fullIndex !== -1) return fullIndex + 1;
-
-  return null;
-}
-
-/**
- * Parse a date string into Excel serial number
- *
- * Supports formats:
- * - MM/DD/YYYY, M/D/YYYY
- * - DD/MM/YYYY (when day > 12)
- * - YYYY-MM-DD, YYYY/MM/DD (ISO format)
- * - DD-MMM-YYYY, D-MMM-YYYY
- * - MMM D, YYYY, MMMM D, YYYY
- *
- * @param dateStr - String that might contain a date
- * @param preferDDMMYYYY - Prefer DD/MM/YYYY over MM/DD/YYYY for ambiguous dates (default: false)
- * @returns Serial number or null if not a valid date
- */
-export function parseDate(dateStr: string, preferDDMMYYYY: boolean = false): number | null {
-  if (!isDateLike(dateStr)) return null;
-
-  const trimmed = dateStr.trim();
-
-  // Try YYYY-MM-DD or YYYY/MM/DD (ISO format)
-  const isoParts = matchDateParts(trimmed, /^(\d{4})[-/](\d{1,2})[-/](\d{1,2})$/);
-  if (isoParts) {
-    const [year, month, day] = isoParts;
-    return serialFromParts(parseInt(year), parseInt(month), parseInt(day));
-  }
-
-  // Try DD-MMM-YYYY or D-MMM-YYYY
-  const dmmyParts = matchDateParts(trimmed, /^(\d{1,2})-([A-Za-z]{3})-(\d{2,4})$/);
-  if (dmmyParts) {
-    const [day, monthName, year] = dmmyParts;
-    return serialFromNamedMonth(expandTwoDigitYear(parseInt(year)), monthName, parseInt(day));
-  }
-
-  // Try MMM D, YYYY or MMMM D, YYYY
-  const mmmParts = matchDateParts(trimmed, /^([A-Za-z]{3,9})\s+(\d{1,2}),?\s+(\d{4})$/);
-  if (mmmParts) {
-    const [monthName, day, year] = mmmParts;
-    return serialFromNamedMonth(parseInt(year), monthName, parseInt(day));
-  }
-
-  // Try D MMM YYYY
-  const dMmmParts = matchDateParts(trimmed, /^(\d{1,2})\s+([A-Za-z]{3,9})\s+(\d{4})$/);
-  if (dMmmParts) {
-    const [day, monthName, year] = dMmmParts;
-    return serialFromNamedMonth(parseInt(year), monthName, parseInt(day));
-  }
-
-  // Try MM/DD/YYYY or DD/MM/YYYY
-  const slashParts = matchDateParts(trimmed, SLASH_DATE_PATTERN);
-  if (slashParts) {
-    const [first, second, year] = slashParts;
-    // If first > 12, it must be DD/MM; if second > 12, it must be MM/DD.
-    // Otherwise use preference (default to MM/DD for US format).
-    const dayFirst = readsDayFirst(parseInt(first), parseInt(second), preferDDMMYYYY);
-    const month = dayFirst ? parseInt(second) : parseInt(first);
-    const day = dayFirst ? parseInt(first) : parseInt(second);
-    return serialFromParts(expandTwoDigitYear(parseInt(year)), month, day);
-  }
-
-  return null;
-}
-
-/** A two-digit year reads as this century up to 29, the previous one after. */
-const TWO_DIGIT_YEAR_LIMIT = 100;
-const CENTURY_PIVOT = 30;
-
-function expandTwoDigitYear(year: number): number {
-  if (year >= TWO_DIGIT_YEAR_LIMIT) return year;
-  return year < CENTURY_PIVOT ? 2000 + year : 1900 + year;
-}
-
-function serialFromNamedMonth(year: number, monthName: string, day: number): number | null {
-  const month = parseMonthName(monthName);
-  if (month === null) return null;
-  return serialFromParts(year, month, day);
-}
-
-/**
- * Validate that a date is valid
- */
-function isValidDate(year: number, month: number, day: number): boolean {
-  // Check basic ranges
-  if (year < 1900 || year > 2100) return false;
-  if (month < 1 || month > 12) return false;
-  if (day < 1 || day > 31) return false;
-
-  // Check if day is valid for the given month
-  const date = new Date(Date.UTC(year, month - 1, day));
-
-  // If the date rolls over to the next month, it's invalid
-  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
-}
-
-/**
- * Get default date format based on parsed date
- *
- * @param originalStr - Original date string
- * @returns Appropriate format code
- */
-export function getDefaultDateFormat(originalStr: string, preferDDMMYYYY: boolean = false): string {
-  const trimmed = originalStr.trim();
-
-  // YYYY-MM-DD → use same format
-  if (/^\d{4}-\d{1,2}-\d{1,2}$/.test(trimmed)) {
-    return "YYYY-MM-DD";
-  }
-
-  // YYYY/MM/DD parses as ISO, so it must keep a year-first label. Without this
-  // branch it fell through to the slash default and re-rendered as MM/DD or
-  // DD/MM — the same digits in a different order, which reads as a different
-  // date (Codex review).
-  if (/^\d{4}\/\d{1,2}\/\d{1,2}$/.test(trimmed)) {
-    return "YYYY/MM/DD";
-  }
-
-  // DD-MMM-YYYY → use same format
-  if (/^\d{1,2}-[A-Za-z]{3}-\d{2,4}$/.test(trimmed)) {
-    return "DD-MMM-YYYY";
-  }
-
-  // MMM D, YYYY → use same format
-  if (/^[A-Za-z]{3}\s+\d{1,2},?\s+\d{4}$/.test(trimmed)) {
-    return "MMM D, YYYY";
-  }
-
-  // MMMM D, YYYY → use same format
-  if (/^[A-Za-z]{4,9}\s+\d{1,2},?\s+\d{4}$/.test(trimmed)) {
-    return "MMMM D, YYYY";
-  }
-
-  // A slash date must render in the order it was READ, or the cell shows the
-  // user's own input with its two halves swapped. `parseDate` takes the first
-  // number as the day whenever it cannot be a month, whatever the preference
-  // says, so that case is decided here the same way.
-  const slashParts = matchDateParts(trimmed, SLASH_DATE_PATTERN);
-  if (slashParts) {
-    const [first, second] = slashParts;
-    return readsDayFirst(parseInt(first), parseInt(second), preferDDMMYYYY) ? "DD/MM/YYYY" : "MM/DD/YYYY";
-  }
-
-  // Anything unrecognised keeps the reading order's default.
-  return preferDDMMYYYY ? "DD/MM/YYYY" : "MM/DD/YYYY";
-}

package/src/plugins/spreadsheet/engine/date-utils.ts

@@ -1,73 +0,0 @@
-/**
- * Date Utility Functions
- *
- * Shared utilities for converting between JavaScript Date objects and Excel serial numbers.
- * Excel stores dates as sequential serial numbers so they can be used in calculations.
- * January 1, 1900 is serial number 1.
- */
-
-// Constants
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-// Excel base date: Dec 30, 1899 (to handle the 1900 leap year bug correctly)
-const EXCEL_BASE_DATE = new Date(Date.UTC(1899, 11, 30));
-
-/**
- * Convert JavaScript Date to Excel Serial Number
- *
- * @param date - JavaScript Date object
- * @returns Excel serial number (days since Dec 30, 1899)
- */
-export const dateToSerial = (date: Date): number => {
-  const diff = date.getTime() - EXCEL_BASE_DATE.getTime();
-  return diff / MS_PER_DAY;
-};
-
-/**
- * Convert Excel Serial Number to JavaScript Date
- *
- * @param serial - Excel serial number
- * @returns JavaScript Date object
- */
-export const serialToDate = (serial: number): Date => {
-  const days = Math.floor(serial);
-  const timePart = serial - days;
-
-  const date = new Date(EXCEL_BASE_DATE.getTime() + days * MS_PER_DAY);
-
-  // Add time component
-  const totalSeconds = Math.round(timePart * 24 * 60 * 60);
-  date.setSeconds(date.getSeconds() + totalSeconds);
-
-  return date;
-};
-
-/** A name list that always has a first entry, so a formatter can fall back to it
- *  when a date is unreadable and its month/weekday index comes out NaN. */
-export type NameList = readonly [string, ...string[]];
-
-/**
- * Month names for formatting
- */
-export const MONTH_NAMES_SHORT: NameList = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-
-export const MONTH_NAMES_FULL: NameList = [
-  "January",
-  "February",
-  "March",
-  "April",
-  "May",
-  "June",
-  "July",
-  "August",
-  "September",
-  "October",
-  "November",
-  "December",
-];
-
-/**
- * Day names for formatting
- */
-export const DAY_NAMES_SHORT: NameList = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-
-export const DAY_NAMES_FULL: NameList = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];

package/src/plugins/spreadsheet/engine/datedif.ts

@@ -1,93 +0,0 @@
-/**
- * DATEDIF — complete elapsed time between two dates, in a chosen unit.
- *
- * Pure: two Excel serials and a unit in, a number (or a formula error value)
- * out. The unit branches each have their own boundary handling (month-end
- * borrowing, year wraparound), which is exactly what makes them worth testing
- * apart from the handler that reads the arguments.
- */
-
-import { serialToDate } from "./date-utils";
-import { NUM_ERROR, type SpreadsheetError } from "./spreadsheet-errors";
-
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-const MONTHS_PER_YEAR = 12;
-
-/** `date` advanced by `months`, clamping the day to the target month's length so
- *  adding a month to Jan 30 lands on the last day of a shorter month instead of
- *  overflowing into the next one. */
-function addMonthsClamped(date: Date, months: number): Date {
-  const monthIndex = date.getUTCMonth() + months;
-  const year = date.getUTCFullYear() + Math.floor(monthIndex / MONTHS_PER_YEAR);
-  const month = ((monthIndex % MONTHS_PER_YEAR) + MONTHS_PER_YEAR) % MONTHS_PER_YEAR;
-  const lastDayOfMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
-  const day = Math.min(date.getUTCDate(), lastDayOfMonth);
-  return new Date(Date.UTC(year, month, day));
-}
-
-/** Complete `unit`s between two dates, or `#NUM!` when start is after end or
- *  the unit is not one of Y / M / D / MD / YM / YD. `unit` is matched
- *  case-insensitively. */
-export function computeDatedif(startSerial: number, endSerial: number, unit: string): number | SpreadsheetError {
-  if (startSerial > endSerial) return NUM_ERROR;
-
-  const startDate = serialToDate(startSerial);
-  const endDate = serialToDate(endSerial);
-
-  const yearDiff = endDate.getUTCFullYear() - startDate.getUTCFullYear();
-  const monthDiff = endDate.getUTCMonth() - startDate.getUTCMonth();
-  const dayDiff = endDate.getUTCDate() - startDate.getUTCDate();
-
-  switch (unit.toUpperCase()) {
-    case "Y": {
-      // Complete years: back off one if the end has not yet reached the
-      // start's month-and-day within its year.
-      const years = yearDiff;
-      return monthDiff < 0 || (monthDiff === 0 && dayDiff < 0) ? years - 1 : years;
-    }
-
-    case "M": {
-      // Complete months, backing off one when the day-of-month has not been reached.
-      const months = yearDiff * MONTHS_PER_YEAR + monthDiff;
-      return dayDiff < 0 ? months - 1 : months;
-    }
-
-    case "D":
-      return Math.floor(endSerial - startSerial);
-
-    case "MD": {
-      // Days left after the complete months "M" counts. Anchoring on start plus
-      // those months keeps the result non-negative and self-consistent (start +
-      // M months + MD days == end). Subtracting the calendar month before `end`
-      // instead goes negative when the start day outruns that month's length —
-      // Jan 30 → Mar 1 borrowed Feb's 28 days and returned -1.
-      const completeMonths = yearDiff * MONTHS_PER_YEAR + monthDiff - (dayDiff < 0 ? 1 : 0);
-      const anchor = addMonthsClamped(startDate, completeMonths);
-      // Compare whole days only. `end` may carry a time-of-day (a datetime
-      // serial); anchor is already UTC midnight, so strip end's time too or the
-      // remainder would swing with the clock (Codex review).
-      const endMidnight = Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth(), endDate.getUTCDate());
-      return Math.round((endMidnight - anchor.getTime()) / MS_PER_DAY);
-    }
-
-    case "YM": {
-      // Month difference, ignoring years — wraps into 0..11.
-      const ym = dayDiff < 0 ? monthDiff - 1 : monthDiff;
-      return ym < 0 ? ym + MONTHS_PER_YEAR : ym;
-    }
-
-    case "YD": {
-      // Day difference, ignoring years: move the start into the end's year,
-      // stepping back a year if that would put it after the end.
-      const startInEndYear = new Date(startDate);
-      startInEndYear.setUTCFullYear(endDate.getUTCFullYear());
-      if (startInEndYear.getTime() - endDate.getTime() > 0) {
-        startInEndYear.setUTCFullYear(endDate.getUTCFullYear() - 1);
-      }
-      return Math.floor((endDate.getTime() - startInEndYear.getTime()) / MS_PER_DAY);
-    }
-
-    default:
-      return NUM_ERROR;
-  }
-}