@rowsncolumns/spreadsheet-state 28.0.73 → 28.0.75

package/dist/esm/api/fill.js

@@ -1,6 +1,85 @@
 import { Direction } from "@rowsncolumns/common-types";
-import { toDate } from "@rowsncolumns/utils";
+import { toDate, toSerial } from "@rowsncolumns/utils";
 import { SheetCell } from "../sheet-cell";
+import { detectDecimalPattern } from "./decimals";
+import { generateSeriesSpecValues } from "./fill-series-spec";
+/** Fill types whose auto-detected outcome is a plain copy (the Ctrl toggle flips these to a series). */
+const COPY_CLASS_FILL_TYPES = new Set([
+    "FillCopy",
+    "FillDefault",
+]);
+/**
+ * Resolve the Ctrl/Cmd fill-handle toggle the way Excel does — ONE fill type
+ * for the whole drag, decided from what auto-detection would have done per
+ * fill line (each column of a vertical fill / row of a horizontal one).
+ * If ANY line would extend a series (2+ numbers, a date, a list name,
+ * "Item 1"), the toggle means Copy Cells for every line; only when every
+ * line would copy (lone numbers) does it mean Fill Series. Formula lines
+ * never vote (formulas always copy with relative-ref adjustment) and empty
+ * lines are ignored.
+ */
+export const resolveToggledFillType = (detectedPerLine) => {
+    const votes = detectedPerLine.filter((t) => t !== undefined);
+    return votes.some((t) => !COPY_CLASS_FILL_TYPES.has(t))
+        ? "FillCopy"
+        : "FillSeries";
+};
+/**
+ * Excel's Auto Fill Options payload modifiers: "Fill Formatting Only" (`FillFormats`) and
+ * "Fill Without Formatting" (`FillWithoutFormatting`; `FillValues` is the VBA `xlFillValues`
+ * spelling the AI fill tool uses). Neither is a series mode — the series is detected exactly as
+ * for a plain drag; they only change WHAT lands in each target cell.
+ */
+export const isFormatsOnlyFillType = (fillType) => fillType === "FillFormats";
+export const isValuesOnlyFillType = (fillType) => fillType === "FillWithoutFormatting" || fillType === "FillValues";
+/**
+ * Thrown when a fill source is touched by merges that don't tile it with identically sized
+ * blocks — Excel refuses the fill with this exact message and writes nothing.
+ */
+export class MergedFillSizeError extends Error {
+    constructor() {
+        super("This operation requires the merged cells to be identically sized.");
+        this.name = "MergedFillSizeError";
+    }
+}
+/**
+ * Marks a target cell the fill leaves exactly as it is: a Series-dialog `stop` value was reached
+ * before the selection's end, and Excel writes nothing into the remaining selected cells.
+ */
+export const FILL_UNTOUCHED = Symbol("fill-untouched");
+/**
+ * The merged-block geometry of a fill source: `undefined` when no merge touches it, the block
+ * size when identically sized merges tile it exactly (every merge inside the source, on the block
+ * lattice, and together covering it), else a {@link MergedFillSizeError}.
+ */
+export const resolveMergedFillBlock = (range, merges) => {
+    const inside = (merges ?? []).filter((m) => m.startRowIndex <= range.endRowIndex &&
+        m.endRowIndex >= range.startRowIndex &&
+        m.startColumnIndex <= range.endColumnIndex &&
+        m.endColumnIndex >= range.startColumnIndex);
+    const first = inside[0];
+    if (!first)
+        return undefined;
+    const rows = first.endRowIndex - first.startRowIndex + 1;
+    const cols = first.endColumnIndex - first.startColumnIndex + 1;
+    const srcRows = range.endRowIndex - range.startRowIndex + 1;
+    const srcCols = range.endColumnIndex - range.startColumnIndex + 1;
+    const onLattice = inside.every((m) => m.endRowIndex - m.startRowIndex + 1 === rows &&
+        m.endColumnIndex - m.startColumnIndex + 1 === cols &&
+        m.startRowIndex >= range.startRowIndex &&
+        m.endRowIndex <= range.endRowIndex &&
+        m.startColumnIndex >= range.startColumnIndex &&
+        m.endColumnIndex <= range.endColumnIndex &&
+        (m.startRowIndex - range.startRowIndex) % rows === 0 &&
+        (m.startColumnIndex - range.startColumnIndex) % cols === 0);
+    const tiled = onLattice &&
+        srcRows % rows === 0 &&
+        srcCols % cols === 0 &&
+        inside.length === (srcRows / rows) * (srcCols / cols);
+    if (!tiled)
+        throw new MergedFillSizeError();
+    return { rows, cols };
+};
 // Helper functions for pattern detection and fill operations
 /**
  * Extract numeric value from a string that may contain text
@@ -9,27 +88,263 @@ const extractNumber = (value) => {
     const match = value.match(/-?\d+\.?\d*/);
     return match ? parseFloat(match[0]) : null;
 };
-const TEXT_NUMBER_PATTERN_REGEX = /^(.*?)(-?\d+(?:\.\d+)?)(.*)$/;
+/**
+ * Excel's text+number rule steps the LAST digit run of the string
+ * ("Text1Text2" → "Text1Text3", "Q1 2024" → "Q1 2025"). The lazy prefix plus
+ * the `\D*$` tail pins the captured run to the trailing one.
+ */
+const TEXT_NUMBER_PATTERN_REGEX = /^(.*?)(\d+)(\D*)$/;
 const MONTH_NAME_REGEX = /\b(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:t(?:ember)?)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\b/i;
 const WEEKDAY_NAME_REGEX = /\b(?:mon(?:day)?|tue(?:s(?:day)?)?|wed(?:nesday)?|thu(?:rs(?:day)?)?|fri(?:day)?|sat(?:urday)?|sun(?:day)?)\b/i;
 const ISO_DATE_TIME_REGEX = /^\d{4}-\d{2}-\d{2}(?:[tT ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
 const NUMERIC_DATE_REGEX = /^\d{1,4}[\/.-]\d{1,2}(?:[\/.-]\d{1,4})?(?:\s+\d{1,2}:\d{2}(?::\d{2})?)?$/;
+/** English ordinal suffix glued to a digit run ("1st Period", "2nd Quarter"). */
+const ORDINAL_SUFFIX_REGEX = /^(st|nd|rd|th)(?![a-z])/i;
+const BARE_DIGITS_REGEX = /^\d+$/;
+/** Excel's built-in quarter tokens: Q1, Qtr 2, Quarter3 — whole-cell only. */
+const QUARTER_TOKEN_REGEX = /^(q|qtr|quarter)(\s?)([1-4])$/i;
+const QUARTER_ORDINAL_REGEX = /^([1-4])(st|nd|rd|th)(\s)(quarter|qtr)$/i;
+const QUARTERS_IN_YEAR = 4;
 const extractTextNumberPattern = (value) => {
     const match = value.match(TEXT_NUMBER_PATTERN_REGEX);
     if (!match)
         return null;
-    const [, prefix, numericPortion, suffix] = match;
+    const [, prefix, run, suffix] = match;
     if (!prefix && !suffix)
         return null;
-    const parsed = parseFloat(numericPortion);
-    if (Number.isNaN(parsed))
+    const parsed = Number(run);
+    if (!Number.isFinite(parsed))
         return null;
     return {
         prefix,
         suffix,
         number: parsed,
+        width: run.length,
+    };
+};
+const mod = (value, len) => ((value % len) + len) % len;
+/**
+ * Re-apply the seed's letter case to a canonical list entry: an all-caps seed
+ * continues in caps ("MONDAY" → "TUESDAY"), an all-lowercase one in lowercase
+ * ("jan" → "feb"); anything else keeps the list's own casing.
+ */
+const applySeedCase = (seed, canonical) => {
+    // A seed without cased letters (`upper === lower`) keeps the list's casing.
+    const upper = seed.toUpperCase();
+    const lower = seed.toLowerCase();
+    if (seed === upper && upper !== lower)
+        return canonical.toUpperCase();
+    if (seed === lower && upper !== lower)
+        return canonical.toLowerCase();
+    return canonical;
+};
+const ordinalSuffix = (n) => {
+    const abs = Math.abs(Math.trunc(n));
+    const mod100 = abs % 100;
+    if (mod100 >= 11 && mod100 <= 13)
+        return "th";
+    switch (abs % 10) {
+        case 1:
+            return "st";
+        case 2:
+            return "nd";
+        case 3:
+            return "rd";
+        default:
+            return "th";
+    }
+};
+/** Render an integer digit run zero-padded to the seed's width (sign outside the padding). */
+const formatDigitRun = (n, width) => {
+    const rounded = Math.round(n);
+    const digits = String(Math.abs(rounded)).padStart(width, "0");
+    return rounded < 0 ? `-${digits}` : digits;
+};
+const tokenizeDigitRuns = (value) => {
+    const parts = [];
+    const runs = [];
+    const re = /\d+/g;
+    let last = 0;
+    let match;
+    while ((match = re.exec(value)) !== null) {
+        parts.push(value.slice(last, match.index));
+        runs.push(match[0]);
+        last = match.index + match[0].length;
+    }
+    parts.push(value.slice(last));
+    return { parts, runs };
+};
+/**
+ * Align text seeds on their digit runs the way Excel does: every seed shares
+ * the same non-digit skeleton, exactly one run varies between seeds (the LAST
+ * run when nothing varies — the single-seed case) and it steps linearly.
+ * "Q1 2024","Q2 2024" → step the quarter; "Q1 2024" alone → step the year.
+ */
+const matchTextNumberSeries = (values) => {
+    if (values.length === 0)
+        return null;
+    const tokens = values.map(tokenizeDigitRuns);
+    const first = tokens[0];
+    if (first.runs.length === 0)
+        return null;
+    const sameSkeleton = tokens.every((t) => t.runs.length === first.runs.length &&
+        t.parts.every((part, i) => part === first.parts[i]));
+    if (!sameSkeleton)
+        return null;
+    const varying = [];
+    for (let r = 0; r < first.runs.length; r++) {
+        if (tokens.some((t) => Number(t.runs[r]) !== Number(first.runs[r]))) {
+            varying.push(r);
+        }
+    }
+    if (varying.length > 1)
+        return null;
+    const runIndex = varying.length === 1 ? varying[0] : first.runs.length - 1;
+    const numbers = tokens.map((t) => Number(t.runs[runIndex]));
+    if (numbers.some((n) => !Number.isFinite(n)))
+        return null;
+    const step = numbers.length >= 2 ? numbers[1] - numbers[0] : 1;
+    const linear = numbers.every((n, i) => i === 0 || n - numbers[i - 1] === step);
+    if (!linear)
+        return null;
+    const lastTokens = tokens[tokens.length - 1];
+    return {
+        parts: first.parts,
+        runs: lastTokens.runs,
+        runIndex,
+        step,
+        last: numbers[numbers.length - 1],
+        width: lastTokens.runs[runIndex].length,
     };
 };
+const renderTextNumber = (series, n) => {
+    const { parts, runs, runIndex, width } = series;
+    let out = parts[0];
+    for (let r = 0; r < runs.length; r++) {
+        out += r === runIndex ? formatDigitRun(n, width) : runs[r];
+        const after = parts[r + 1];
+        const ordinal = r === runIndex ? after.match(ORDINAL_SUFFIX_REGEX) : null;
+        out += ordinal
+            ? `${applySeedCase(ordinal[1], ordinalSuffix(n))}${after.slice(2)}`
+            : after;
+    }
+    return out;
+};
+/**
+ * Continue a text+number series ("Item 1" → "Item 2"; "001" → "002" keeps the
+ * zero padding; "1st Period" → "2nd Period" re-derives the ordinal). One seed
+ * steps by ±1 (by fill direction); two or more take the seeds' difference.
+ */
+export const generateTextNumberSeries = (values, count, descending = false) => {
+    const series = matchTextNumberSeries(values);
+    if (!series)
+        return null;
+    const step = values.length >= 2 ? series.step : descending ? -1 : 1;
+    return Array.from({ length: count }, (_, i) => renderTextNumber(series, series.last + step * (i + 1)));
+};
+/**
+ * Excel's built-in quarter list: `Q1`/`Qtr 1`/`Quarter 1` and the ordinal form
+ * `1st Quarter`, spelling and casing preserved, cycling mod 4. Whole-cell
+ * tokens only — with a year attached ("Q1 2024") the text+number rule applies.
+ */
+const parseQuarterToken = (value) => {
+    const token = value.trim();
+    const plain = token.match(QUARTER_TOKEN_REGEX);
+    if (plain) {
+        const [, word, space, digit] = plain;
+        return {
+            index: Number(digit) - 1,
+            render: (quarter) => `${word}${space}${quarter}`,
+        };
+    }
+    const ordinal = token.match(QUARTER_ORDINAL_REGEX);
+    if (ordinal) {
+        const [, digit, suffix, space, word] = ordinal;
+        return {
+            index: Number(digit) - 1,
+            render: (quarter) => `${quarter}${applySeedCase(suffix, ordinalSuffix(quarter))}${space}${word}`,
+        };
+    }
+    return null;
+};
+const isQuarterToken = (value) => typeof value === "string" && parseQuarterToken(value) !== null;
+export const generateQuarterSeries = (values, count, descending = false) => {
+    const tokens = values.map(parseQuarterToken);
+    if (tokens.length === 0 || tokens.some((t) => t === null))
+        return null;
+    const quarters = tokens;
+    const indices = quarters.map((t) => t.index);
+    let step;
+    if (indices.length >= 2) {
+        step = mod(indices[1] - indices[0], QUARTERS_IN_YEAR);
+        const consistent = indices.every((idx, i) => i === 0 || mod(idx - indices[i - 1], QUARTERS_IN_YEAR) === step);
+        if (!consistent)
+            return null;
+    }
+    else {
+        step = descending ? -1 : 1;
+    }
+    const last = quarters[quarters.length - 1];
+    return Array.from({ length: count }, (_, i) => last.render(mod(last.index + step * (i + 1), QUARTERS_IN_YEAR) + 1));
+};
+/**
+ * Locate a weekday/month seed in its locale list, case-insensitively: exact
+ * full name, exact 3-letter abbreviation, then the loose prefix match the
+ * detector accepts.
+ */
+const resolveNameListPosition = (value, names) => {
+    const lower = value.trim().toLowerCase();
+    if (!lower)
+        return null;
+    const fullIndex = names.findIndex((n) => n.toLowerCase() === lower);
+    if (fullIndex !== -1)
+        return { index: fullIndex, abbreviated: false };
+    const abbrIndex = names.findIndex((n) => n.toLowerCase().substring(0, 3) === lower);
+    if (abbrIndex !== -1)
+        return { index: abbrIndex, abbreviated: true };
+    if (lower.length < 3)
+        return null;
+    const looseIndex = names.findIndex((n) => n.toLowerCase().startsWith(lower) ||
+        lower.startsWith(n.toLowerCase().substring(0, 3)));
+    if (looseIndex !== -1) {
+        return { index: looseIndex, abbreviated: value.trim().length <= 3 };
+    }
+    return null;
+};
+/**
+ * Continue a weekday/month NAME series (cyclic). Two or more seeds fix the
+ * step from their list-index gap (Mon, Wed → Fri, Sun, Tue); a single seed
+ * steps ±1 by fill direction. Output keeps the seed's abbreviation and casing.
+ * Returns `[]` when the last seed is not a list member.
+ */
+const generateNameListSeries = (sourceValues, names, count, descending = false) => {
+    const seed = sourceValues[sourceValues.length - 1];
+    if (typeof seed !== "string")
+        return [];
+    const positions = sourceValues.map((v) => typeof v === "string" ? resolveNameListPosition(v, names) : null);
+    const last = positions[positions.length - 1];
+    if (!last)
+        return [];
+    const len = names.length;
+    let step;
+    if (positions.length >= 2 && positions.every((p) => p !== null)) {
+        const indices = positions.map((p) => p.index);
+        step = mod(indices[1] - indices[0], len);
+        const consistent = indices.every((idx, i) => i === 0 || mod(idx - indices[i - 1], len) === step);
+        if (!consistent)
+            return [];
+    }
+    else {
+        step = descending ? -1 : 1;
+    }
+    const result = [];
+    for (let i = 0; i < count; i++) {
+        const canonical = names[mod(last.index + step * (i + 1), len)];
+        const form = last.abbreviated ? canonical.substring(0, 3) : canonical;
+        result.push(applySeedCase(seed, form));
+    }
+    return result;
+};
 const isLikelyDateString = (value) => {
     const trimmed = value.trim();
     if (!trimmed || /^\d+$/.test(trimmed)) {
@@ -66,6 +381,62 @@ const parseDate = (value) => {
     const parsed = Date.parse(value);
     return isNaN(parsed) ? null : new Date(parsed);
 };
+/**
+ * Calendar arithmetic for date fills runs in Excel-serial space (days since
+ * the 1900 epoch, wall-clock — no DST). `toDate`/`toSerial` round-trip on the
+ * 1900 epoch regardless of the workbook's date system, so the epoch offset
+ * cancels and only the caller that writes the cell needs `use1904`.
+ */
+const dateToSerial = (date) => toSerial(date, false);
+const serialToDate = (serial) => toDate(serial, false);
+/**
+ * A time-of-day value (Excel serial in [0, 1) — `9:00` = 0.375) travels through
+ * the fill as a Date on Excel's day zero, 1899-12-31. No real date lives there
+ * (Excel starts at 1900-01-01), so "before 1900" ⇔ "time-only".
+ */
+const isTimeOnlyDate = (date) => date.getFullYear() < 1900;
+const isDateLikeFormatType = (type) => type === "DATE" || type === "DATE_TIME" || type === "TIME";
+const HOURS_PER_DAY = 24;
+const SERIAL_EPSILON = 1e-9;
+const isWholeDayStep = (serialStep) => Math.abs(serialStep - Math.round(serialStep)) < SERIAL_EPSILON;
+const daysInMonth = (year, monthIndex) => new Date(year, monthIndex + 1, 0).getDate();
+const isLastDayOfMonth = (date) => date.getDate() === daysInMonth(date.getFullYear(), date.getMonth());
+/**
+ * Whole months between two dates (ignores day-of-month).
+ */
+const monthsBetween = (from, to) => (to.getFullYear() - from.getFullYear()) * 12 +
+    (to.getMonth() - from.getMonth());
+/**
+ * `anchor` + `months`, Excel style: the anchor's day-of-month is kept and
+ * clamped to the target month's length (Jan 31 + 1 → Feb 29 in 2024, + 2 →
+ * Mar 31 — never JS `setMonth`'s overflow into the next month). `endOfMonth`
+ * forces the target month's last day (a month-end series: Jan 31, Feb 29 →
+ * Mar 31, Apr 30). Time-of-day rides along unchanged.
+ */
+const addMonthsClamped = (anchor, months, endOfMonth = false) => {
+    const total = anchor.getFullYear() * 12 + anchor.getMonth() + months;
+    const year = Math.floor(total / 12);
+    const monthIndex = total - year * 12;
+    const lastDay = daysInMonth(year, monthIndex);
+    const day = endOfMonth ? lastDay : Math.min(anchor.getDate(), lastDay);
+    return new Date(year, monthIndex, day, anchor.getHours(), anchor.getMinutes(), anchor.getSeconds(), anchor.getMilliseconds());
+};
+const isWeekend = (date) => date.getDay() === 0 || date.getDay() === 6;
+/**
+ * Signed count of weekdays (Mon–Fri) stepped from `from` to reach `to`.
+ * Weekend days are not counted, so Fri → next Fri is 5.
+ */
+const weekdaysBetween = (from, to) => {
+    const dir = to.getTime() >= from.getTime() ? 1 : -1;
+    const cursor = new Date(from);
+    let steps = 0;
+    while (dir > 0 ? cursor.getTime() < to.getTime() : cursor.getTime() > to.getTime()) {
+        cursor.setDate(cursor.getDate() + dir);
+        if (!isWeekend(cursor))
+            steps += dir;
+    }
+    return steps;
+};
 /**
  * Get day names array
  */
@@ -179,8 +550,58 @@ const isSimpleDecimalSeriesNumberPattern = (pattern) => {
     const normalizedPattern = pattern?.trim() ?? "General";
     return SIMPLE_DECIMAL_SERIES_NUMBER_PATTERN_REGEX.test(normalizedPattern);
 };
-const shouldNormalizeSeriesNumberFormat = (fillType, numberFormat, value) => {
-    if (fillType !== "FillSeries") {
+const TREND_FILL_TYPES = new Set([
+    "LinearTrend",
+    "GrowthTrend",
+]);
+const SIMPLE_SERIES_NUMBER_PATTERN_SHAPE_REGEX = /^(#,##0|#|0)(?:\.(0+))?$/i;
+/**
+ * The shape of a simple NUMBER pattern — how many forced decimals it has
+ * and whether it groups thousands — ignoring the "#" vs "0" integer
+ * placeholder (the auto-stamp picks "0" only for |value| < 1).
+ */
+const getSimpleNumberPatternShape = (pattern) => {
+    const match = SIMPLE_SERIES_NUMBER_PATTERN_SHAPE_REGEX.exec(pattern?.trim() ?? "");
+    if (!match) {
+        return null;
+    }
+    return { decimals: match[2]?.length ?? 0, grouped: match[1].includes(",") };
+};
+/**
+ * Whether a seed's NUMBER pattern is the one the editor stamps itself when
+ * the value is typed (`SheetCell.setNumberValue` → `detectDecimalPattern`:
+ * typing 1.1 stamps one decimal, typing 1 stamps none). A pattern whose
+ * shape differs from what the seed's own value produces ("0.00" on the value
+ * 1) can only have been applied by the user or imported, and Excel carries a
+ * user-applied format onto the filled cells untouched.
+ *
+ * Type inference stamps a pattern only for TEXT entry — a JS number written
+ * by a fill (or a program) stays General (`detectValueTypeAndPattern`), so a
+ * generated value never picks up a decimal pattern of its own. This shape
+ * check is how fill tells the seed's auto-stamped pattern from an explicit
+ * one when deciding whether to carry it onto the target.
+ */
+const isAutoDetectedNumberPattern = (pattern, seedValue, locale) => {
+    if (typeof seedValue !== "number" || !Number.isFinite(seedValue)) {
+        return false;
+    }
+    const shape = getSimpleNumberPatternShape(pattern);
+    const autoShape = getSimpleNumberPatternShape(detectDecimalPattern(seedValue, undefined, locale));
+    return (shape !== null &&
+        autoShape !== null &&
+        shape.decimals === autoShape.decimals &&
+        shape.grouped === autoShape.grouped);
+};
+/**
+ * Decide whether a generated series value should drop the pattern cloned
+ * from its seed so it renders under its own inferred pattern instead:
+ * an integer pattern on a fractional result (1, 2, 4 → 5.333… would show
+ * "5") or a decimal pattern on an integer result (1.1, 1.2 → 2 would show
+ * "2.0"). Only auto-stamped patterns are dropped — an explicit "0.00" stays
+ * "0.00" (3.00, 4.00), as in Excel.
+ */
+const shouldNormalizeSeriesNumberFormat = (fillType, numberFormat, value, seedValue, locale) => {
+    if (fillType !== "FillSeries" && !TREND_FILL_TYPES.has(fillType)) {
         return false;
     }
     if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -190,13 +611,12 @@ const shouldNormalizeSeriesNumberFormat = (fillType, numberFormat, value) => {
         return false;
     }
     const pattern = numberFormat.pattern;
-    if (isSimpleIntegerSeriesNumberPattern(pattern) && !isNearlyInteger(value)) {
-        return true;
-    }
-    if (isSimpleDecimalSeriesNumberPattern(pattern) && isNearlyInteger(value)) {
-        return true;
+    const integerPatternOnFraction = isSimpleIntegerSeriesNumberPattern(pattern) && !isNearlyInteger(value);
+    const decimalPatternOnInteger = isSimpleDecimalSeriesNumberPattern(pattern) && isNearlyInteger(value);
+    if (!integerPatternOnFraction && !decimalPatternOnInteger) {
+        return false;
     }
-    return false;
+    return isAutoDetectedNumberPattern(pattern, seedValue, locale);
 };
 const getCellNumberFormat = (sheetCell) => {
     const effectiveNumberFormat = sheetCell.getNumberFormat();
@@ -211,9 +631,11 @@ const getCellNumberFormat = (sheetCell) => {
     }
     return undefined;
 };
-const shouldNormalizeSeriesNumberFormatForCell = (sheetCell, fillType, value) => {
+const shouldNormalizeSeriesNumberFormatForCell = (sheetCell, fillType, value, locale) => {
     const numberFormat = getCellNumberFormat(sheetCell);
-    return shouldNormalizeSeriesNumberFormat(fillType, numberFormat, value);
+    // `sheetCell` still holds the (wrapped) seed the target is cloned from.
+    const seedValue = sheetCell.getEffectiveValue();
+    return shouldNormalizeSeriesNumberFormat(fillType, numberFormat, value, seedValue, locale);
 };
 const clearCellNumberFormatForSeries = (sheetCell) => {
     if (sheetCell.userEnteredFormat) {
@@ -240,13 +662,19 @@ export const detectFillType = (selectionData, locale = "en", customAutofillLists
     if (matchCustomList(values, customAutofillLists)) {
         return "FillCustomList";
     }
+    // Excel's built-in quarter list (Q1 / Qtr 1 / Quarter 1 / 1st Quarter):
+    // a cyclic series of four, never "Q5".
+    if (values.every(isQuarterToken)) {
+        return "FillSeries";
+    }
     // Helper to check for day/month names
     const dayNames = getDayNames(locale);
     const monthNames = getMonthNames(locale);
     if (values.length === 1) {
         const singleValue = values[0];
         if (singleValue instanceof Date) {
-            return "FillDays";
+            // A lone time (9:00) steps by the hour; a lone date by the day (Excel).
+            return isTimeOnlyDate(singleValue) ? "FillHours" : "FillDays";
         }
         // Single numbers → FillCopy (Excel standard: need 2+ cells for series)
         if (typeof singleValue === "number") {
@@ -292,22 +720,29 @@ export const detectFillType = (selectionData, locale = "en", customAutofillLists
     if (dates.length >= 2) {
         const firstDate = dates[0];
         const secondDate = dates[1];
-        const timeDiff = secondDate.getTime() - firstDate.getTime();
-        const dayDiff = timeDiff / (1000 * 60 * 60 * 24);
-        if (Math.abs(dayDiff - 1) < 0.1)
+        // Time-of-day seeds (9:00, 9:30) continue at their own step (30 min).
+        if (dates.every(isTimeOnlyDate))
+            return "FillHours";
+        const serialStep = dateToSerial(secondDate) - dateToSerial(firstDate);
+        // A sub-day step (09:00, 15:00 → +6h) is linear on the serial — Excel only
+        // infers a calendar unit from whole-day differences.
+        if (!isWholeDayStep(serialStep))
             return "FillDays";
-        if (Math.abs(dayDiff - 7) < 0.1)
-            return "FillWeekdays";
         const sameDayOfMonth = firstDate.getDate() === secondDate.getDate();
-        const sameMonth = firstDate.getMonth() === secondDate.getMonth();
-        const monthDiff = (secondDate.getFullYear() - firstDate.getFullYear()) * 12 +
-            (secondDate.getMonth() - firstDate.getMonth());
-        if (sameDayOfMonth && monthDiff === 1)
+        const monthDiff = monthsBetween(firstDate, secondDate);
+        // Same day-of-month N months apart → a month series with step N (15-Jan,
+        // 15-Apr → 15-Jul, 15-Oct); whole years → a year series. Two month-ends
+        // (Jan 31, Feb 29) are a month series too, staying on the month-end.
+        // NOTE: Excel never infers "weekdays" — a 7-day gap is a 7-day step; Fill
+        // Weekdays is only ever an explicit choice.
+        if (sameDayOfMonth && monthDiff !== 0) {
+            return monthDiff % 12 === 0 ? "FillYears" : "FillMonths";
+        }
+        if (monthDiff !== 0 &&
+            isLastDayOfMonth(firstDate) &&
+            isLastDayOfMonth(secondDate)) {
             return "FillMonths";
-        if (sameDayOfMonth &&
-            sameMonth &&
-            secondDate.getFullYear() - firstDate.getFullYear() === 1)
-            return "FillYears";
+        }
         return "FillDays";
     }
     // Check for numeric series (after dates to avoid Date objects being treated as timestamps)
@@ -324,6 +759,26 @@ export const detectFillType = (selectionData, locale = "en", customAutofillLists
         if (isLinearSeries && diff !== 0) {
             return "FillSeries";
         }
+        // Excel fits a least-squares line through 3+ bare numbers whose step is
+        // not constant (1, 2, 4 → 5.333…, 6.833…) instead of repeating them.
+        // Only bare numbers qualify: "Item 1", "Item 2", "Item 4" also extract
+        // numbers but stay a text pattern.
+        if (!isLinearSeries &&
+            numbers.length >= 3 &&
+            nonDateValues.every((v) => typeof v === "number")) {
+            return "LinearTrend";
+        }
+    }
+    // Text+number seeds aligned on one varying digit run ("Text1Text2",
+    // "Text1Text3" → the trailing run steps) are a series even when the
+    // first number in each string does not move.
+    if (values.every((v) => typeof v === "string") &&
+        !values.every((v) => BARE_DIGITS_REGEX.test(v)) &&
+        !values.some((v) => isLikelyDateString(v))) {
+        const textSeries = matchTextNumberSeries(values);
+        if (textSeries && textSeries.step !== 0) {
+            return "FillSeries";
+        }
     }
     // Check for text patterns (days/months)
     const textValues = values.map((v) => String(v).toLowerCase());
@@ -341,8 +796,15 @@ export const detectFillType = (selectionData, locale = "en", customAutofillLists
 /**
  * Generate fill values based on type and pattern
  */
-export const generateFillValues = (sourceValues, fillType, count, locale, customAutofillLists) => {
+export const generateFillValues = (sourceValues, fillType, count, locale, customAutofillLists, 
+/**
+ * The fill walks away from the selection's start (fill up / fill left), so a
+ * single seed continues backwards: "Item 5" → "Item 4", Wednesday → Tuesday.
+ * Multi-seed lines already encode the direction in their reversed order.
+ */
+descending = false) => {
     const result = [];
+    const unitStep = descending ? -1 : 1;
     switch (fillType) {
         case "FillCustomList": {
             const match = matchCustomList(sourceValues, customAutofillLists);
@@ -354,16 +816,20 @@ export const generateFillValues = (sourceValues, fillType, count, locale, custom
                 }
                 break;
             }
-            const { list, startIndex, ascending } = match;
+            const { list, startIndex } = match;
+            // A single seed has no order of its own — the fill direction decides.
+            const ascending = sourceValues.length >= 2 ? match.ascending : !descending;
             const len = list.length;
-            // Continue from where the source slice ended.
+            // Continue from where the source slice ended; the output follows the
+            // seed's casing pattern like the built-in lists ("low" → "medium").
+            const seed = String(sourceValues[sourceValues.length - 1]);
             const nextOffset = ascending
                 ? startIndex + sourceValues.length
                 : startIndex - sourceValues.length;
             for (let i = 0; i < count; i++) {
                 const step = ascending ? i : -i;
                 const idx = (((nextOffset + step) % len) + len) % len;
-                result.push(list[idx]);
+                result.push(applySeedCase(seed, list[idx]));
             }
             break;
         }
@@ -374,23 +840,23 @@ export const generateFillValues = (sourceValues, fillType, count, locale, custom
             break;
         }
         case "FillSeries": {
-            const textPatterns = sourceValues
-                .map((value) => typeof value === "string" ? extractTextNumberPattern(value) : null)
-                .filter((pattern) => pattern !== null);
-            if (textPatterns.length === sourceValues.length &&
-                textPatterns.length > 0) {
-                const [firstPattern, ...restPatterns] = textPatterns;
-                const hasConsistentAffixes = restPatterns.every(({ prefix, suffix }) => prefix === firstPattern.prefix && suffix === firstPattern.suffix);
-                if (hasConsistentAffixes) {
-                    const numbers = textPatterns.map((pattern) => pattern.number);
-                    const diff = numbers.length >= 2
-                        ? normalizeSeriesNumber(numbers[1] - numbers[0])
-                        : 1;
-                    const lastValue = normalizeSeriesNumber(numbers[numbers.length - 1]);
-                    for (let i = 0; i < count; i++) {
-                        const nextNumber = normalizeSeriesNumber(lastValue + diff * (i + 1));
-                        result.push(`${firstPattern.prefix}${String(nextNumber)}${firstPattern.suffix}`);
-                    }
+            const allStrings = sourceValues.every((value) => typeof value === "string");
+            // Built-in quarter list first: Q4 wraps to Q1 instead of stepping to Q5.
+            if (allStrings) {
+                const quarters = generateQuarterSeries(sourceValues, count, descending);
+                if (quarters) {
+                    result.push(...quarters);
+                    break;
+                }
+            }
+            // Text+number series ("Item 1" → "Item 2"). Bare digit strings stay on
+            // the numeric path below so "5" → 6, 7, 8 (numbers) as before.
+            if (allStrings &&
+                sourceValues.length > 0 &&
+                !sourceValues.every((value) => BARE_DIGITS_REGEX.test(value))) {
+                const textSeries = generateTextNumberSeries(sourceValues, count, descending);
+                if (textSeries) {
+                    result.push(...textSeries);
                     break;
                 }
             }
@@ -398,18 +864,38 @@ export const generateFillValues = (sourceValues, fillType, count, locale, custom
                 .map((v) => (typeof v === "number" ? v : extractNumber(String(v))))
                 .filter((n) => n !== null);
             if (numbers.length >= 1) {
-                // Default increment is 1 for single values, or calculated diff for 2+ values
+                // Default increment is 1 for single values (−1 when filling up /
+                // left), or calculated diff for 2+ values
                 const diff = numbers.length >= 2
                     ? normalizeSeriesNumber(numbers[1] - numbers[0])
-                    : 1;
+                    : descending
+                        ? -1
+                        : 1;
                 const lastValue = normalizeSeriesNumber(numbers[numbers.length - 1]);
                 for (let i = 0; i < count; i++) {
                     result.push(normalizeSeriesNumber(lastValue + diff * (i + 1)));
                 }
+                break;
             }
-            else {
-                result.push(...Array(count).fill(sourceValues[sourceValues.length - 1]));
+            // No numeric run at all: an explicit "Fill Series" on a list item walks
+            // the list (Monday → Tuesday…), like Excel's AutoFill Options menu.
+            if (allStrings) {
+                const days = generateNameListSeries(sourceValues, getDayNames(locale), count, descending);
+                if (days.length) {
+                    result.push(...days);
+                    break;
+                }
+                const months = generateNameListSeries(sourceValues, getMonthNames(locale), count, descending);
+                if (months.length) {
+                    result.push(...months);
+                    break;
+                }
+                if (matchCustomList(sourceValues, customAutofillLists)) {
+                    result.push(...generateFillValues(sourceValues, "FillCustomList", count, locale, customAutofillLists, descending));
+                    break;
+                }
             }
+            result.push(...Array(count).fill(sourceValues[sourceValues.length - 1]));
             break;
         }
         case "FillDays": {
@@ -417,56 +903,52 @@ export const generateFillValues = (sourceValues, fillType, count, locale, custom
                 .map((value) => parseDate(value))
                 .filter((date) => date !== null);
             if (parsedDates.length) {
+                // Step in serial space from the LAST two seeds so a sub-day step
+                // (09:00, 15:00 → 21:00, 03:00) and the time-of-day both survive;
+                // a lone date steps one day (backwards when filling up / left).
                 const lastDate = parsedDates[parsedDates.length - 1];
                 const previousDate = parsedDates.length >= 2 ? parsedDates[parsedDates.length - 2] : null;
-                const dayMs = 1000 * 60 * 60 * 24;
-                let dayIncrement = 1;
+                const lastSerial = dateToSerial(lastDate);
+                let step = unitStep;
                 if (previousDate) {
-                    const diff = Math.round((lastDate.getTime() - previousDate.getTime()) / dayMs);
-                    if (diff !== 0) {
-                        dayIncrement = diff;
+                    const diff = lastSerial - dateToSerial(previousDate);
+                    if (Math.abs(diff) > SERIAL_EPSILON) {
+                        step = diff;
                     }
                 }
-                const currentDate = new Date(lastDate);
                 for (let i = 0; i < count; i++) {
-                    currentDate.setDate(currentDate.getDate() + dayIncrement);
-                    result.push(currentDate.toLocaleDateString(locale));
+                    result.push(serialToDate(lastSerial + step * (i + 1)));
                 }
             }
             else {
-                const lastDayValue = sourceValues[sourceValues.length - 1];
-                if (typeof lastDayValue === "string") {
-                    // Handle day names (like "Mon", "Tue", "Wed")
-                    const allDayNames = getDayNames(locale);
-                    const allDayAbbrevs = allDayNames.map((d) => d.substring(0, 3));
-                    // Find which day we're at
-                    const lastDayLower = lastDayValue.toLowerCase();
-                    const dayIndex = allDayNames.findIndex((d) => d.toLowerCase().includes(lastDayLower) ||
-                        lastDayLower.includes(d.toLowerCase()));
-                    if (dayIndex !== -1) {
-                        // Determine if we're using full names or abbreviations
-                        const isAbbreviated = lastDayValue.length <= 3;
-                        for (let i = 0; i < count; i++) {
-                            const nextDayIndex = (dayIndex + i + 1) % 7;
-                            const dayName = isAbbreviated
-                                ? allDayAbbrevs[nextDayIndex]
-                                : allDayNames[nextDayIndex];
-                            result.push(dayName);
-                        }
-                    }
-                }
+                // Day names ("Mon", "Tue", "Wed"): seed gap as the step, seed casing kept.
+                result.push(...generateNameListSeries(sourceValues, getDayNames(locale), count, descending));
             }
             break;
         }
         case "FillWeekdays": {
-            const lastWeekday = parseDate(sourceValues[sourceValues.length - 1]);
+            // Explicit Fill Weekdays: step Mon–Fri only, from a weekend seed too
+            // (Sat 1/6 → Mon 1/8). Two seeds set the step in weekdays (Fri, Fri →
+            // 5); a lone seed steps one weekday (backwards when filling up / left).
+            const weekdayDates = sourceValues
+                .map((value) => parseDate(value))
+                .filter((date) => date !== null);
+            const lastWeekday = weekdayDates[weekdayDates.length - 1];
             if (lastWeekday) {
+                const previous = weekdayDates.length >= 2
+                    ? weekdayDates[weekdayDates.length - 2]
+                    : null;
+                const seedStep = previous ? weekdaysBetween(previous, lastWeekday) : 0;
+                const step = seedStep === 0 ? unitStep : seedStep;
+                const dir = step > 0 ? 1 : -1;
                 const currentDate = new Date(lastWeekday);
                 for (let i = 0; i < count; i++) {
-                    do {
-                        currentDate.setDate(currentDate.getDate() + 1);
-                    } while (currentDate.getDay() === 0 || currentDate.getDay() === 6); // Skip weekends
-                    result.push(new Date(currentDate).toLocaleDateString(locale));
+                    for (let taken = 0; taken < Math.abs(step);) {
+                        currentDate.setDate(currentDate.getDate() + dir);
+                        if (!isWeekend(currentDate))
+                            taken += 1;
+                    }
+                    result.push(new Date(currentDate));
                 }
             }
             break;
@@ -476,42 +958,71 @@ export const generateFillValues = (sourceValues, fillType, count, locale, custom
             const lastValue = sourceValues[sourceValues.length - 1];
             const lastMonth = parseDate(lastValue);
             if (lastMonth) {
-                // Handle actual dates
+                // Anchor on the last seed and add whole months, clamping the day to
+                // the target month (Jan 31 → Feb 29, Mar 31, Apr 30). Two seeds set
+                // the step (15-Jan, 15-Apr → 3 months); two month-ends (Jan 31, Feb
+                // 29) keep the series on the month-end. A lone seed steps one month
+                // (backwards when filling up / left).
+                const monthDates = sourceValues
+                    .map((value) => parseDate(value))
+                    .filter((date) => date !== null);
+                const previous = monthDates.length >= 2 ? monthDates[monthDates.length - 2] : null;
+                const seedStep = previous ? monthsBetween(previous, lastMonth) : 0;
+                const step = seedStep === 0 ? unitStep : seedStep;
+                const endOfMonth = monthDates.length >= 2 && monthDates.every(isLastDayOfMonth);
                 for (let i = 0; i < count; i++) {
-                    const newDate = new Date(lastMonth);
-                    newDate.setMonth(lastMonth.getMonth() + i + 1);
-                    result.push(newDate.toLocaleDateString(locale));
+                    result.push(addMonthsClamped(lastMonth, step * (i + 1), endOfMonth));
                 }
             }
             else if (typeof lastValue === "string") {
-                // Handle month names (like "Jan", "Feb", "Mar")
-                const allMonthNames = getMonthNames(locale);
-                const allMonthAbbrevs = allMonthNames.map((m) => m.substring(0, 3));
-                // Find which month we're at
-                const lastValueLower = lastValue.toLowerCase();
-                const monthIndex = allMonthNames.findIndex((m) => m.toLowerCase().includes(lastValueLower) ||
-                    lastValueLower.includes(m.toLowerCase()));
-                if (monthIndex !== -1) {
-                    // Determine if we're using full names or abbreviations
-                    const isAbbreviated = lastValue.length <= 3;
-                    for (let i = 0; i < count; i++) {
-                        const nextMonthIndex = (monthIndex + i + 1) % 12;
-                        const monthName = isAbbreviated
-                            ? allMonthAbbrevs[nextMonthIndex]
-                            : allMonthNames[nextMonthIndex];
-                        result.push(monthName);
-                    }
-                }
+                // Month names ("Jan", "Feb", "Mar"): seed gap as the step, seed casing kept.
+                result.push(...generateNameListSeries(sourceValues, getMonthNames(locale), count, descending));
             }
             break;
         }
         case "FillYears": {
-            const lastYear = parseDate(sourceValues[sourceValues.length - 1]);
+            // Anchor on the last seed and add whole years, clamping Feb 29 to Feb 28
+            // in non-leap years (2/29/2024 → 2/28/2025 … 2/29/2028 — the day comes
+            // back, it is never lost). Two seeds set the step; a lone seed steps one
+            // year (backwards when filling up / left).
+            const yearDates = sourceValues
+                .map((value) => parseDate(value))
+                .filter((date) => date !== null);
+            const lastYear = yearDates[yearDates.length - 1];
             if (lastYear) {
+                const previous = yearDates.length >= 2 ? yearDates[yearDates.length - 2] : null;
+                const seedStep = previous
+                    ? lastYear.getFullYear() - previous.getFullYear()
+                    : 0;
+                const step = seedStep === 0 ? unitStep : seedStep;
                 for (let i = 0; i < count; i++) {
-                    const newDate = new Date(lastYear);
-                    newDate.setFullYear(lastYear.getFullYear() + i + 1);
-                    result.push(newDate.toLocaleDateString(locale));
+                    result.push(addMonthsClamped(lastYear, 12 * step * (i + 1)));
+                }
+            }
+            break;
+        }
+        case "FillHours": {
+            // Time-of-day series on the raw serial: a lone time steps one hour
+            // (9:00 → 10:00, 11:00; backwards when filling up / left), two set the
+            // step (9:00, 9:30 → 10:00, 10:30). Emits serials, not Dates, so the
+            // series can pass midnight (22:00 → 23:00, 0:00 = serial 1.0, 1:00)
+            // while the cell keeps the seed's time format.
+            const timeSerials = sourceValues
+                .map((value) => value instanceof Date
+                ? dateToSerial(value)
+                : typeof value === "number"
+                    ? value
+                    : null)
+                .filter((serial) => serial !== null);
+            if (timeSerials.length) {
+                const lastSerial = timeSerials[timeSerials.length - 1];
+                const previous = timeSerials.length >= 2 ? timeSerials[timeSerials.length - 2] : null;
+                const seedStep = previous === null ? 0 : lastSerial - previous;
+                const step = Math.abs(seedStep) > SERIAL_EPSILON
+                    ? seedStep
+                    : unitStep / HOURS_PER_DAY;
+                for (let i = 0; i < count; i++) {
+                    result.push(normalizeSeriesNumber(lastSerial + step * (i + 1)));
                 }
             }
             break;
@@ -531,7 +1042,7 @@ export const generateFillValues = (sourceValues, fillType, count, locale, custom
                 const intercept = (sumY - slope * sumX) / n;
                 for (let i = 0; i < count; i++) {
                     const x = numValues.length + i;
-                    result.push(slope * x + intercept);
+                    result.push(normalizeSeriesNumber(slope * x + intercept));
                 }
             }
             break;
@@ -555,25 +1066,12 @@ export const generateFillValues = (sourceValues, fillType, count, locale, custom
             }
             break;
         }
-        case "FillValues": {
-            // Similar to FillSeries but preserves text formatting
-            for (let i = 0; i < count; i++) {
-                const sourceIndex = i % sourceValues.length;
-                let value = sourceValues[sourceIndex];
-                if (typeof value === "string") {
-                    const num = extractNumber(value);
-                    if (num !== null && sourceValues.length >= 2) {
-                        const nextNum = extractNumber(String(sourceValues[(sourceIndex + 1) % sourceValues.length]));
-                        if (nextNum !== null) {
-                            const diff = nextNum - num;
-                            const cycles = Math.floor(i / sourceValues.length);
-                            const newNum = num + diff * (cycles + 1);
-                            value = value.replace(String(num), String(newNum));
-                        }
-                    }
-                }
-                result.push(value);
-            }
+        case "FillValues":
+        case "FillWithoutFormatting": {
+            // Values-only is a payload modifier, not a series mode: the values extrapolate exactly as a
+            // plain drag would (1,2 → 3,4,5,6); only the formatting is withheld by the caller.
+            const detected = detectFillType([sourceValues], locale, customAutofillLists);
+            result.push(...generateFillValues(sourceValues, detected, count, locale, customAutofillLists, descending));
             break;
         }
         case "FillFormats": {
@@ -594,36 +1092,162 @@ export const generateFillValues = (sourceValues, fillType, count, locale, custom
     }
     return result;
 };
+const hasExcelTextPrefix = (value) => typeof value === "string" && value.startsWith("'") && value.length > 1;
+/**
+ * Classify one seed the way Excel partitions a mixed selection: by type, and
+ * for text+number by its non-digit skeleton, so "Item 1" and "Box 1" run as
+ * two independent series.
+ */
+const classifyFillValue = (value, dayNames, monthNames, customAutofillLists) => {
+    if (value == null || value === "")
+        return { kind: "blank", key: "blank" };
+    if (value instanceof Date)
+        return { kind: "date", key: "date" };
+    if (typeof value === "number")
+        return { kind: "number", key: "number" };
+    if (typeof value !== "string")
+        return { kind: "text", key: "text" };
+    if (matchCustomList([value], customAutofillLists)) {
+        return { kind: "custom", key: "custom" };
+    }
+    if (parseQuarterToken(value))
+        return { kind: "quarter", key: "quarter" };
+    if (isLikelyDateString(value) && parseDate(value)) {
+        return { kind: "date", key: "date" };
+    }
+    if (/\d/.test(value)) {
+        const { parts } = tokenizeDigitRuns(value);
+        return { kind: "textnum", key: `textnum:${parts.join(" ")}` };
+    }
+    if (resolveNameListPosition(value, dayNames)) {
+        return { kind: "day", key: "day" };
+    }
+    if (resolveNameListPosition(value, monthNames)) {
+        return { kind: "month", key: "month" };
+    }
+    return { kind: "text", key: "text" };
+};
+const repeatValues = (values, count) => Array.from({ length: count }, (_, i) => values[i % values.length]);
+/**
+ * Extend one class group. `mixedLine` is true when the group shares its line
+ * with other classes or blanks — there a lone number steps (1, x → 2, x, 3, x)
+ * where a lone number on its own copies (Excel needs two cells for a series).
+ */
+const generateGroupValues = (cls, values, count, mixedLine, { locale, customAutofillLists, descending }) => {
+    const fallback = () => repeatValues(values, count);
+    switch (cls.kind) {
+        case "blank":
+            return Array(count).fill(null);
+        case "text":
+            return fallback();
+        case "number": {
+            if (values.length === 1) {
+                if (!mixedLine)
+                    return fallback();
+                const step = descending ? -1 : 1;
+                const last = normalizeSeriesNumber(values[0]);
+                return Array.from({ length: count }, (_, i) => normalizeSeriesNumber(last + step * (i + 1)));
+            }
+            const type = detectFillType([values], locale, customAutofillLists);
+            const out = generateFillValues(values, type, count, locale, customAutofillLists, descending);
+            return out.length === count ? out : fallback();
+        }
+        case "date": {
+            // `detectFillType` picks the calendar unit (a lone time → FillHours,
+            // a lone date → FillDays, month-ends → FillMonths, …).
+            const type = detectFillType([values], locale, customAutofillLists);
+            const out = generateFillValues(values, type, count, locale, customAutofillLists, descending);
+            return out.length === count ? out : fallback();
+        }
+        case "quarter":
+            return generateQuarterSeries(values, count, descending) ?? fallback();
+        case "textnum":
+            return generateTextNumberSeries(values, count, descending) ?? fallback();
+        case "day": {
+            const out = generateNameListSeries(values, getDayNames(locale), count, descending);
+            return out.length === count ? out : fallback();
+        }
+        case "month": {
+            const out = generateNameListSeries(values, getMonthNames(locale), count, descending);
+            return out.length === count ? out : fallback();
+        }
+        case "custom": {
+            const out = generateFillValues(values, "FillCustomList", count, locale, customAutofillLists, descending);
+            return out.length === count ? out : fallback();
+        }
+    }
+};
+/**
+ * Compose a fill line from its seeds. A homogeneous line is one series; a
+ * mixed line (text1, textA / 1, blank, 2, blank / Monday, 1) is partitioned by
+ * class, each group extended on its own, and the results interleaved back
+ * onto the source pattern so blanks stay blank and every slot continues its
+ * own sub-series — Excel's "text1, textA → text2, textA, text3, textA".
+ */
+const generateLineSeries = (sourceValues, count, options) => {
+    const { locale, customAutofillLists } = options;
+    const len = sourceValues.length;
+    if (len === 0 || count <= 0)
+        return { fillType: "FillDefault", values: [] };
+    const dayNames = getDayNames(locale);
+    const monthNames = getMonthNames(locale);
+    const classes = sourceValues.map((v) => classifyFillValue(v, dayNames, monthNames, customAutofillLists));
+    const groups = new Map();
+    classes.forEach((cls, position) => {
+        const group = groups.get(cls.key) ?? {
+            cls,
+            values: [],
+            generated: [],
+            cursor: 0,
+        };
+        group.values.push(sourceValues[position]);
+        groups.set(cls.key, group);
+    });
+    const nonBlankGroups = [...groups.values()].filter((g) => g.cls.kind !== "blank");
+    if (nonBlankGroups.length === 0) {
+        return { fillType: "FillDefault", values: Array(count).fill(null) };
+    }
+    const mixedLine = groups.size > 1;
+    const needed = new Map();
+    for (let i = 0; i < count; i++) {
+        const key = classes[i % len].key;
+        needed.set(key, (needed.get(key) ?? 0) + 1);
+    }
+    for (const [key, group] of groups) {
+        group.generated = generateGroupValues(group.cls, group.values, needed.get(key) ?? 0, mixedLine, options);
+    }
+    const values = [];
+    for (let i = 0; i < count; i++) {
+        const group = groups.get(classes[i % len].key);
+        values.push(group.generated[group.cursor++]);
+    }
+    // The number group's own detection drives number-format normalisation.
+    const numberGroup = groups.get("number");
+    let lineFillType;
+    if (numberGroup) {
+        lineFillType =
+            numberGroup.values.length >= 2
+                ? detectFillType([numberGroup.values], locale, customAutofillLists)
+                : mixedLine
+                    ? "FillSeries"
+                    : "FillCopy";
+    }
+    else if (mixedLine || nonBlankGroups.some((g) => g.cls.kind !== "text")) {
+        lineFillType = "FillSeries";
+    }
+    else {
+        lineFillType = "FillDefault";
+    }
+    return { fillType: lineFillType, values };
+};
 /**
  * Get auto fill values
  * @returns T[][]
  */
-export const getAutoFillValues = async ({ sheetId, direction, selection, fillBounds, getCellData, getEffectiveValue, getFormattedValue, getSheetName, getDataValidationById, cellXfsRegistry, locale, fillType, customAutofillLists, }) => {
+export const getAutoFillValues = async ({ sheetId, direction, selection, fillBounds, getCellData, getEffectiveValue, getFormattedValue, getSheetName, getDataValidationById, cellXfsRegistry, locale, fillType: requestedFillType, modifier, series, customAutofillLists, merges, }) => {
     // Create a cell helper
     const sheetCell = new SheetCell();
     const activeSheetName = getSheetName(sheetId);
-    const textCell = new SheetCell();
-    const getTextInfo = (cells) => {
-        for (const { rowIndex, columnIndex } of cells) {
-            const cellData = getCellData(sheetId, rowIndex, columnIndex);
-            textCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
-                locale,
-                cellXfsRegistry,
-                getDataValidationById,
-            });
-            if (textCell.getNumberFormat()?.type === "TEXT") {
-                const fallback = getFillSourceValue(sheetId, rowIndex, columnIndex);
-                return {
-                    isText: true,
-                    textValue: textCell.getUserEnteredValue() ??
-                        textCell.getEffectiveValue() ??
-                        String(fallback ?? ""),
-                    pattern: textCell.getNumberFormat()?.pattern ?? "General",
-                };
-            }
-        }
-        return { isText: false, textValue: "", pattern: "General" };
-    };
     const buildTextCell = (sourceCellData, value, pattern) => {
         const newCell = new SheetCell();
         newCell.assign(sheetId, { rowIndex: selection.range.startRowIndex, columnIndex: 0 }, sourceCellData, { locale, cellXfsRegistry, getDataValidationById });
@@ -634,285 +1258,401 @@ export const getAutoFillValues = async ({ sheetId, direction, selection, fillBou
         newCell.setUserEnteredValue(value);
         return newCell.getCellData();
     };
-    const getFillSourceValue = (sheetId, rowIndex, columnIndex) => {
+    /**
+     * Read one seed: its series value plus how it is typed. TEXT-formatted and
+     * `'`-prefixed cells yield their text (so "001" stays a zero-padded text
+     * number rather than the number 1), DATE cells yield a Date.
+     */
+    const readFillSource = (rowIndex, columnIndex) => {
         const cellData = getCellData(sheetId, rowIndex, columnIndex);
         sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
             locale,
             cellXfsRegistry,
             getDataValidationById,
         });
-        const numFmtType = sheetCell.getNumberFormat()?.type;
-        const isDateTime = numFmtType === "DATE" || numFmtType === "DATE_TIME";
-        const isText = numFmtType === "TEXT";
+        const numberFormat = sheetCell.getNumberFormat();
+        const numFmtType = numberFormat?.type;
+        const isDateTime = isDateLikeFormatType(numFmtType);
+        const textFormat = numFmtType === "TEXT";
+        const userEntered = sheetCell.getUserEnteredValue();
+        const quotePrefixed = !sheetCell.isFormula() && hasExcelTextPrefix(userEntered);
+        let value;
         if (isDateTime) {
             const effectiveValue = getEffectiveValue?.(sheetId, rowIndex, columnIndex);
-            if (typeof effectiveValue === "number") {
-                return toDate(effectiveValue, sheetCell.use1904);
-            }
-            return getFormattedValue?.(sheetId, rowIndex, columnIndex);
+            // A time-of-day (serial in [0, 1) — a typed `9:00` is DATE_TIME
+            // 0.375) is epoch-independent: carry it on the 1900 epoch's day zero
+            // so `detectFillType` can tell a time from a date.
+            value =
+                typeof effectiveValue === "number"
+                    ? effectiveValue >= 0 && effectiveValue < 1
+                        ? serialToDate(effectiveValue)
+                        : toDate(effectiveValue, sheetCell.use1904)
+                    : getFormattedValue?.(sheetId, rowIndex, columnIndex);
+        }
+        else if (textFormat) {
+            value = userEntered ?? sheetCell.getEffectiveValue();
         }
-        const cellValue = isText
-            ? sheetCell.getUserEnteredValue()
-            : getEffectiveValue?.(sheetId, rowIndex, columnIndex);
-        return cellValue;
+        else {
+            value = getEffectiveValue?.(sheetId, rowIndex, columnIndex);
+        }
+        if (quotePrefixed && hasExcelTextPrefix(value)) {
+            value = value.slice(1);
+        }
+        const textTyped = textFormat ||
+            quotePrefixed ||
+            (!sheetCell.isFormula() &&
+                typeof userEntered === "string" &&
+                typeof value === "string");
+        return {
+            value,
+            meta: {
+                textFormat,
+                textPattern: numberFormat?.pattern ?? "General",
+                quotePrefixed,
+                textTyped,
+                formula: sheetCell.isFormula(),
+            },
+        };
+    };
+    /**
+     * A generated Date is written into a date/time-formatted cell as its serial
+     * so the seed's number format (DATE d/m/yy, DATE_TIME hh:mm, …) survives
+     * verbatim — a Date instance would be re-classified on entry (midnight →
+     * DATE) and could flip the pattern. Time-of-day Dates sit on the 1900
+     * epoch's day zero and convert on that epoch whatever the workbook's date
+     * system. `sheetCell` must already be assigned to the source cell.
+     */
+    const toCellValue = (value) => {
+        if (!(value instanceof Date))
+            return value;
+        if (!isDateLikeFormatType(sheetCell.getNumberFormat()?.type))
+            return value;
+        return isTimeOnlyDate(value)
+            ? dateToSerial(value)
+            : toSerial(value, sheetCell.use1904);
+    };
+    /**
+     * Write one generated value onto `sheetCell` (already assigned the wrapped
+     * seed cell). Formulas shift; text-typed seeds stay text — a TEXT format
+     * is re-applied, and a value that type inference would turn into a number,
+     * date or boolean is written with Excel's `'` escape.
+     */
+    const writeFillValue = (value, meta, sourceCellData, from, to, lineFillType) => {
+        if (sheetCell.isFormula()) {
+            sheetCell.moveFormula(from, to, activeSheetName, {
+                preserveAbsolutes: true,
+            });
+            // Remove effective value for formulas
+            sheetCell.clearEffectiveValueForFormula();
+            return sheetCell.getCellData();
+        }
+        if (meta.textFormat) {
+            return buildTextCell(sourceCellData, value == null ? "" : String(value), meta.textPattern);
+        }
+        if (meta.quotePrefixed && typeof value === "string" && value !== "") {
+            sheetCell.setUserEnteredValue(`'${value}`);
+            return sheetCell.getCellData();
+        }
+        if (shouldNormalizeSeriesNumberFormatForCell(sheetCell, lineFillType, value, locale)) {
+            clearCellNumberFormatForSeries(sheetCell);
+        }
+        sheetCell.setUserEnteredValue(toCellValue(value));
+        if (meta.textTyped &&
+            typeof value === "string" &&
+            value !== "" &&
+            (sheetCell.isFormula() ||
+                typeof sheetCell.getUserEnteredValue() !== "string")) {
+            sheetCell.setUserEnteredValue(`'${value}`);
+        }
+        return sheetCell.getCellData();
     };
-    // Get selection data for pattern analysis
-    const selectionData = [];
-    for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-        const rowData = [];
-        for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-            const cellData = getFillSourceValue(sheetId, rowIndex, columnIndex);
-            rowData.push(cellData || null);
-        }
-        selectionData.push(rowData);
-    }
-    // Calculate fill dimensions
-    const selectionRows = selection.range.endRowIndex - selection.range.startRowIndex + 1;
-    const selectionCols = selection.range.endColumnIndex - selection.range.startColumnIndex + 1;
     const fillValues = [];
-    switch (direction) {
-        case Direction.Down: {
-            const fillCount = fillBounds.endRowIndex - selection.range.endRowIndex;
-            for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-                // Get source values for this column
-                const sourceValues = [];
-                const sourceCells = [];
-                for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-                    // Check data type
-                    const cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
-                    sourceValues.push(cellValue);
-                    sourceCells.push({ rowIndex, columnIndex });
-                }
-                const textInfo = getTextInfo(sourceCells);
-                // Detect fill type for this specific column
-                const columnData = [sourceValues]; // Convert to 2D array for detectFillType
-                const actualFillType = fillType || detectFillType(columnData, locale, customAutofillLists);
-                // Generate fill values for this column
-                let newValues = textInfo.isText
-                    ? Array(fillCount).fill(textInfo.textValue)
-                    : generateFillValues(sourceValues, actualFillType, fillCount, locale, customAutofillLists);
-                // Fallback to FillDefault if no values were generated
-                if (newValues.length === 0 && actualFillType !== "FillDefault") {
-                    newValues = generateFillValues(sourceValues, "FillDefault", fillCount, locale);
-                }
-                // Apply the values
-                for (let i = 0; i < fillCount; i++) {
-                    const targetRowIndex = selection.range.endRowIndex + 1 + i;
-                    const targetColumnIndex = columnIndex;
-                    if (!fillValues[i])
-                        fillValues[i] = [];
-                    if (actualFillType === "FillFormats") {
-                        // Copy format but not value
-                        fillValues[i][targetColumnIndex - fillBounds.startColumnIndex] =
-                            "";
-                    }
-                    else {
-                        // Get a source cell for formatting/properties
-                        const sourceRowIndex = selection.range.startRowIndex + (i % selectionRows);
-                        const sourceCellData = getCellData?.(sheetId, sourceRowIndex, columnIndex);
-                        sheetCell.assign(sheetId, { rowIndex: sourceRowIndex, columnIndex }, sourceCellData, { locale, cellXfsRegistry, getDataValidationById });
-                        if (sheetCell.isFormula()) {
-                            sheetCell.moveFormula({ rowIndex: sourceRowIndex, columnIndex }, { rowIndex: targetRowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
-                            // Remove effective value for formulas
-                            sheetCell.clearEffectiveValueForFormula();
-                        }
-                        else if (textInfo.isText) {
-                            fillValues[i][targetColumnIndex - fillBounds.startColumnIndex] =
-                                buildTextCell(sourceCellData, String(newValues[i] ?? ""), textInfo.pattern);
-                            continue;
-                        }
-                        else {
-                            // Use the generated fill value instead of source cell value
-                            const shouldNormalizeSeriesNumberFormat = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
-                            if (shouldNormalizeSeriesNumberFormat) {
-                                clearCellNumberFormatForSeries(sheetCell);
-                            }
-                            sheetCell.setUserEnteredValue(newValues[i]);
-                        }
-                        fillValues[i][targetColumnIndex - fillBounds.startColumnIndex] =
-                            sheetCell.getCellData();
-                    }
-                }
+    const vertical = direction === Direction.Down || direction === Direction.Up;
+    const descending = direction === Direction.Up || direction === Direction.Left;
+    const { range } = selection;
+    // A merged seed fills by whole blocks (Excel: the drag advances in block multiples and every
+    // landed block is merged like the seed). Along the fill the seeds and targets step by the block
+    // size (`stride`); across it one fill line runs per block column/row (`lineStride`). Only the
+    // ANCHOR cells feed detection — covered cells never count as blanks in the series — and every
+    // landed block is reported for `applyFill` to merge. A plain fill is the 1×1 case.
+    const block = resolveMergedFillBlock(range, merges);
+    const stride = block ? (vertical ? block.rows : block.cols) : 1;
+    const lineStride = block ? (vertical ? block.cols : block.rows) : 1;
+    // Fill lines run along the drag: one per column for a vertical fill, one per
+    // row for a horizontal one. Seeds are read in fill order (reversed for
+    // up/left) so the writer's `i % seedCount` wrap picks the matching seed.
+    const lineCount = (vertical
+        ? range.endColumnIndex - range.startColumnIndex + 1
+        : range.endRowIndex - range.startRowIndex + 1) / lineStride;
+    const seedCount = (vertical
+        ? range.endRowIndex - range.startRowIndex + 1
+        : range.endColumnIndex - range.startColumnIndex + 1) / stride;
+    const span = (() => {
+        switch (direction) {
+            case Direction.Down:
+                return fillBounds.endRowIndex - range.endRowIndex;
+            case Direction.Up:
+                return range.startRowIndex - fillBounds.startRowIndex;
+            case Direction.Right:
+                return fillBounds.endColumnIndex - range.endColumnIndex;
+            case Direction.Left:
+                return range.startColumnIndex - fillBounds.startColumnIndex;
+            default:
+                return 0;
+        }
+    })();
+    // Number of target cells (plain) or target blocks (merged seed) per line; a merged extent snaps
+    // to whole blocks, truncating toward the source.
+    const fillCount = Math.floor(Math.max(span, 0) / stride);
+    const snapped = { ...fillBounds };
+    if (block) {
+        if (direction === Direction.Down) {
+            snapped.endRowIndex = range.endRowIndex + fillCount * stride;
+        }
+        else if (direction === Direction.Up) {
+            snapped.startRowIndex = range.startRowIndex - fillCount * stride;
+        }
+        else if (direction === Direction.Right) {
+            snapped.endColumnIndex = range.endColumnIndex + fillCount * stride;
+        }
+        else {
+            snapped.startColumnIndex = range.startColumnIndex - fillCount * stride;
+        }
+        fillValues.snappedFillBounds = snapped;
+        fillValues.fillMerges = [];
+    }
+    const seedCoord = (line, k) => {
+        if (vertical) {
+            const columnIndex = range.startColumnIndex + line * lineStride;
+            const rowIndex = descending
+                ? range.endRowIndex - (stride - 1) - k * stride
+                : range.startRowIndex + k * stride;
+            return { rowIndex, columnIndex };
+        }
+        const rowIndex = range.startRowIndex + line * lineStride;
+        const columnIndex = descending
+            ? range.endColumnIndex - (stride - 1) - k * stride
+            : range.startColumnIndex + k * stride;
+        return { rowIndex, columnIndex };
+    };
+    const targetCoord = (line, i) => {
+        if (vertical) {
+            const columnIndex = range.startColumnIndex + line * lineStride;
+            const rowIndex = descending
+                ? range.startRowIndex - (i + 1) * stride
+                : range.endRowIndex + 1 + i * stride;
+            return { rowIndex, columnIndex };
+        }
+        const rowIndex = range.startRowIndex + line * lineStride;
+        const columnIndex = descending
+            ? range.startColumnIndex - (i + 1) * stride
+            : range.endColumnIndex + 1 + i * stride;
+        return { rowIndex, columnIndex };
+    };
+    // The result grid starts at the first filled cell: below/right of the
+    // selection for down/right fills, at the (snapped) fill bounds' origin for up/left.
+    const originRow = direction === Direction.Down ? range.endRowIndex + 1 : snapped.startRowIndex;
+    const originColumn = direction === Direction.Right
+        ? range.endColumnIndex + 1
+        : snapped.startColumnIndex;
+    const place = (target, cell) => {
+        const r = target.rowIndex - originRow;
+        const c = target.columnIndex - originColumn;
+        if (!fillValues[r])
+            fillValues[r] = [];
+        fillValues[r][c] = cell;
+    };
+    const lines = [];
+    for (let line = 0; line < lineCount; line++) {
+        const sourceValues = [];
+        const sourceMeta = [];
+        for (let k = 0; k < seedCount; k++) {
+            const { rowIndex, columnIndex } = seedCoord(line, k);
+            const { value, meta } = readFillSource(rowIndex, columnIndex);
+            sourceValues.push(value);
+            sourceMeta.push(meta);
+        }
+        lines.push({ sourceValues, sourceMeta });
+    }
+    /**
+     * Resolve the fill type once for the whole drag. An explicit type wins; the
+     * Ctrl toggle is decided from what every line would auto-detect (columns
+     * for a vertical fill, rows for a horizontal one) — formula and empty lines
+     * don't vote.
+     */
+    const fillType = (() => {
+        if (requestedFillType)
+            return requestedFillType;
+        if (modifier !== "toggle")
+            return undefined;
+        const detectedPerLine = lines.map(({ sourceValues, sourceMeta }) => {
+            if (sourceMeta.every((m) => m.formula))
+                return undefined;
+            if (sourceValues.every((v) => v == null || v === ""))
+                return undefined;
+            return generateLineSeries(sourceValues, 1, {
+                locale,
+                customAutofillLists,
+                descending,
+            }).fillType;
+        });
+        return resolveToggledFillType(detectedPerLine);
+    })();
+    // Excel's Auto Fill Options: formats-only leaves the targets' values alone, values-only leaves
+    // their formatting alone. Neither is a series mode — detect the series as for a plain drag.
+    const isFormatsOnly = isFormatsOnlyFillType(fillType);
+    const isValuesOnly = isValuesOnlyFillType(fillType);
+    const seriesFillType = isFormatsOnly || isValuesOnly ? undefined : fillType;
+    /**
+     * "Fill Formatting Only": the target keeps its value and takes the source's user-entered format
+     * (a style reference is copied as-is — same registry). Equivalent to Paste Special > Formats.
+     */
+    const formatsOnlyCell = (source, target) => {
+        const sourceUf = getCellData(sheetId, source.rowIndex, source.columnIndex)?.uf;
+        const { uf: _targetUf, ...rest } = (getCellData(sheetId, target.rowIndex, target.columnIndex) ?? {});
+        return (sourceUf === undefined ? rest : { ...rest, uf: sourceUf });
+    };
+    /**
+     * "Fill Without Formatting": the generated cell keeps the TARGET's own user-entered format
+     * instead of the source's. A plain fill returns the generated cell untouched.
+     */
+    const finalizeCell = (cell, target) => {
+        if (!isValuesOnly)
+            return cell;
+        const targetUf = getCellData(sheetId, target.rowIndex, target.columnIndex)?.uf;
+        const { uf: _sourceUf, ...rest } = cell;
+        return (targetUf === undefined ? rest : { ...rest, uf: targetUf });
+    };
+    /**
+     * One fill line's generated values, in fill order: the Series dialog's spec
+     * first (explicit intent), then the requested fill type, else auto-detect.
+     */
+    const computeLine = (sourceValues, count) => {
+        if (series) {
+            const specLine = generateSeriesSpecValues(sourceValues, series, count, locale);
+            if (specLine) {
+                return {
+                    fillType: seriesFillType ?? "FillSeries",
+                    values: specLine.values,
+                    seeds: specLine.seeds,
+                    untouchedTail: true,
+                };
             }
-            break;
         }
-        case Direction.Up: {
-            const fillCount = selection.range.startRowIndex - fillBounds.startRowIndex;
-            for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-                // Get source values for this column (in reverse order for up direction)
-                const sourceValues = [];
-                const sourceCells = [];
-                for (let rowIndex = selection.range.endRowIndex; rowIndex >= selection.range.startRowIndex; rowIndex--) {
-                    const cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
-                    sourceValues.push(cellValue);
-                    sourceCells.push({ rowIndex, columnIndex });
-                }
-                const textInfo = getTextInfo(sourceCells);
-                // Detect fill type for this specific column
-                const columnData = [sourceValues]; // Convert to 2D array for detectFillType
-                const actualFillType = fillType || detectFillType(columnData, locale, customAutofillLists);
-                // Generate fill values for this column
-                let newValues = textInfo.isText
-                    ? Array(fillCount).fill(textInfo.textValue)
-                    : generateFillValues(sourceValues, actualFillType, fillCount, locale, customAutofillLists);
-                // Fallback to FillDefault if no values were generated
-                if (newValues.length === 0 && actualFillType !== "FillDefault") {
-                    newValues = generateFillValues(sourceValues, "FillDefault", fillCount, locale);
-                }
-                // Apply the values (in reverse order)
-                for (let i = 0; i < fillCount; i++) {
-                    const targetRowIndex = selection.range.startRowIndex - 1 - i;
-                    const targetColumnIndex = columnIndex;
-                    if (!fillValues[fillCount - 1 - i])
-                        fillValues[fillCount - 1 - i] = [];
-                    if (actualFillType === "FillFormats") {
-                        fillValues[fillCount - 1 - i][targetColumnIndex - fillBounds.startColumnIndex] = "";
-                    }
-                    else {
-                        const sourceRowIndex = selection.range.endRowIndex - (i % selectionRows);
-                        const sourceCellData = getCellData?.(sheetId, sourceRowIndex, columnIndex);
-                        sheetCell.assign(sheetId, { rowIndex: sourceRowIndex, columnIndex }, sourceCellData, { locale, cellXfsRegistry, getDataValidationById });
-                        if (sheetCell.isFormula()) {
-                            sheetCell.moveFormula({ rowIndex: sourceRowIndex, columnIndex }, { rowIndex: targetRowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
-                            // Remove effective value for formulas
-                            sheetCell.clearEffectiveValueForFormula();
-                        }
-                        else if (textInfo.isText) {
-                            fillValues[fillCount - 1 - i][targetColumnIndex - fillBounds.startColumnIndex] = buildTextCell(sourceCellData, String(newValues[i] ?? ""), textInfo.pattern);
-                            continue;
-                        }
-                        else {
-                            // Use the generated fill value instead of source cell value
-                            const shouldNormalizeSeriesNumberFormat = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
-                            if (shouldNormalizeSeriesNumberFormat) {
-                                clearCellNumberFormatForSeries(sheetCell);
-                            }
-                            sheetCell.setUserEnteredValue(newValues[i]);
-                        }
-                        fillValues[fillCount - 1 - i][targetColumnIndex - fillBounds.startColumnIndex] = sheetCell.getCellData();
-                    }
-                }
+        if (seriesFillType) {
+            let values = generateFillValues(sourceValues, seriesFillType, count, locale, customAutofillLists, descending);
+            if (values.length === 0 && seriesFillType !== "FillDefault") {
+                values = generateFillValues(sourceValues, "FillDefault", count, locale);
             }
-            break;
+            return { fillType: seriesFillType, values };
         }
-        case Direction.Right: {
-            const fillCount = fillBounds.endColumnIndex - selection.range.endColumnIndex;
-            for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-                // Get source values for this row
-                const sourceValues = [];
-                const sourceCells = [];
-                const textSourceCellData = getCellData?.(sheetId, rowIndex, selection.range.startColumnIndex);
-                for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-                    const cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
-                    sourceValues.push(cellValue);
-                    sourceCells.push({ rowIndex, columnIndex });
-                }
-                const textInfo = getTextInfo(sourceCells);
-                // Detect fill type for this specific row
-                const rowData = [sourceValues]; // Convert to 2D array for detectFillType
-                const actualFillType = fillType || detectFillType(rowData, locale);
-                // Generate fill values for this row
-                let newValues = textInfo.isText
-                    ? Array(fillCount).fill(textInfo.textValue)
-                    : generateFillValues(sourceValues, actualFillType, fillCount, locale, customAutofillLists);
-                // Fallback to FillDefault if no values were generated
-                if (newValues.length === 0 && actualFillType !== "FillDefault") {
-                    newValues = generateFillValues(sourceValues, "FillDefault", fillCount, locale);
-                }
-                // Apply the values
-                const targetRowIndex = rowIndex - fillBounds.startRowIndex;
-                if (!fillValues[targetRowIndex])
-                    fillValues[targetRowIndex] = [];
-                for (let i = 0; i < fillCount; i++) {
-                    const targetColumnIndex = selection.range.endColumnIndex + 1 + i;
-                    if (actualFillType === "FillFormats") {
-                        fillValues[targetRowIndex][i] = "";
-                    }
-                    else if (textInfo.isText) {
-                        fillValues[targetRowIndex][i] = buildTextCell(textSourceCellData, String(newValues[i] ?? ""), textInfo.pattern);
-                    }
-                    else {
-                        const sourceColumnIndex = selection.range.startColumnIndex + (i % selectionCols);
-                        const sourceCellData = getCellData?.(sheetId, rowIndex, sourceColumnIndex);
-                        sheetCell.assign(sheetId, { rowIndex, columnIndex: sourceColumnIndex }, sourceCellData, { locale, cellXfsRegistry, getDataValidationById });
-                        if (sheetCell.isFormula()) {
-                            sheetCell.moveFormula({ rowIndex, columnIndex: sourceColumnIndex }, { rowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
-                            // Remove effective value for formulas
-                            sheetCell.clearEffectiveValueForFormula();
-                        }
-                        else {
-                            // Use the generated fill value instead of source cell value
-                            const shouldNormalizeSeriesNumberFormat = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
-                            if (shouldNormalizeSeriesNumberFormat) {
-                                clearCellNumberFormatForSeries(sheetCell);
-                            }
-                            sheetCell.setUserEnteredValue(newValues[i]);
-                        }
-                        fillValues[targetRowIndex][i] = sheetCell.getCellData();
-                    }
-                }
+        return generateLineSeries(sourceValues, count, {
+            locale,
+            customAutofillLists,
+            descending,
+        });
+    };
+    /**
+     * What a landed block's covered cell becomes. Excel copies the whole block, so the covered cell
+     * takes the format of the source block's matching covered cell (a border on the block's far edge
+     * lives on a covered cell) and no value — the merge owns the block. Formats-only keeps the
+     * target's own payload under the source format; values-only clears the value and keeps the
+     * target's own format.
+     */
+    const coveredCell = (target, sourceCovered) => {
+        const targetCell = getCellData(sheetId, target.rowIndex, target.columnIndex);
+        const sourceUf = getCellData(sheetId, sourceCovered.rowIndex, sourceCovered.columnIndex)?.uf;
+        if (isFormatsOnly) {
+            return sourceUf === undefined
+                ? (targetCell ?? undefined)
+                : { ...(targetCell ?? {}), uf: sourceUf };
+        }
+        const uf = isValuesOnly ? targetCell?.uf : sourceUf;
+        return uf === undefined ? undefined : { uf };
+    };
+    /**
+     * Land one block at `target` (its anchor), repeating the source block anchored at `from`: the
+     * anchor takes `cell`, the covered cells take the source block's covered-cell formats (see
+     * `coveredCell`) and the block is reported as a merge. A plain 1×1 fill just places the cell.
+     */
+    const placeBlock = (target, cell, from) => {
+        place(target, cell);
+        if (!block)
+            return;
+        const landed = {
+            startRowIndex: target.rowIndex,
+            endRowIndex: target.rowIndex + block.rows - 1,
+            startColumnIndex: target.columnIndex,
+            endColumnIndex: target.columnIndex + block.cols - 1,
+        };
+        for (let r = landed.startRowIndex; r <= landed.endRowIndex; r++) {
+            for (let c = landed.startColumnIndex; c <= landed.endColumnIndex; c++) {
+                if (r === target.rowIndex && c === target.columnIndex)
+                    continue;
+                place({ rowIndex: r, columnIndex: c }, coveredCell({ rowIndex: r, columnIndex: c }, {
+                    rowIndex: from.rowIndex + (r - target.rowIndex),
+                    columnIndex: from.columnIndex + (c - target.columnIndex),
+                }));
             }
-            break;
         }
-        case Direction.Left: {
-            const fillCount = selection.range.startColumnIndex - fillBounds.startColumnIndex;
-            for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-                // Get source values for this row (in reverse order for left direction)
-                const sourceValues = [];
-                const sourceCells = [];
-                const textSourceCellData = getCellData?.(sheetId, rowIndex, selection.range.endColumnIndex);
-                for (let columnIndex = selection.range.endColumnIndex; columnIndex >= selection.range.startColumnIndex; columnIndex--) {
-                    const cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
-                    sourceValues.push(cellValue);
-                    sourceCells.push({ rowIndex, columnIndex });
-                }
-                const textInfo = getTextInfo(sourceCells);
-                // Detect fill type for this specific row
-                const rowData = [sourceValues]; // Convert to 2D array for detectFillType
-                const actualFillType = fillType || detectFillType(rowData, locale);
-                // Generate fill values for this row
-                let newValues = textInfo.isText
-                    ? Array(fillCount).fill(textInfo.textValue)
-                    : generateFillValues(sourceValues, actualFillType, fillCount, locale, customAutofillLists);
-                // Fallback to FillDefault if no values were generated
-                if (newValues.length === 0 && actualFillType !== "FillDefault") {
-                    newValues = generateFillValues(sourceValues, "FillDefault", fillCount, locale);
-                }
-                // Apply the values (in reverse order)
-                const targetRowIndex = rowIndex - fillBounds.startRowIndex;
-                if (!fillValues[targetRowIndex])
-                    fillValues[targetRowIndex] = [];
-                for (let i = 0; i < fillCount; i++) {
-                    const targetColumnIndex = selection.range.startColumnIndex - 1 - i;
-                    if (actualFillType === "FillFormats") {
-                        fillValues[targetRowIndex][fillCount - 1 - i] = "";
-                    }
-                    else if (textInfo.isText) {
-                        fillValues[targetRowIndex][fillCount - 1 - i] = buildTextCell(textSourceCellData, String(newValues[i] ?? ""), textInfo.pattern);
-                    }
-                    else {
-                        const sourceColumnIndex = selection.range.endColumnIndex - (i % selectionCols);
-                        const sourceCellData = getCellData?.(sheetId, rowIndex, sourceColumnIndex);
-                        sheetCell.assign(sheetId, { rowIndex, columnIndex: sourceColumnIndex }, sourceCellData, { locale, cellXfsRegistry, getDataValidationById });
-                        if (sheetCell.isFormula()) {
-                            sheetCell.moveFormula({ rowIndex, columnIndex: sourceColumnIndex }, { rowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
-                            // Remove effective value for formulas
-                            sheetCell.clearEffectiveValueForFormula();
-                        }
-                        else {
-                            // Use the generated fill value instead of source cell value
-                            const shouldNormalizeSeriesNumberFormat = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
-                            if (shouldNormalizeSeriesNumberFormat) {
-                                clearCellNumberFormatForSeries(sheetCell);
-                            }
-                            sheetCell.setUserEnteredValue(newValues[i]);
-                        }
-                        fillValues[targetRowIndex][fillCount - 1 - i] =
-                            sheetCell.getCellData();
-                    }
-                }
+        fillValues.fillMerges?.push(landed);
+    };
+    /**
+     * A target block a Series-dialog `stop` never reached: every cell of it (anchor and covered) is
+     * marked untouched so `applyFill` leaves it exactly as it is — no value, no format, no merge.
+     */
+    const markUntouched = (target) => {
+        const rows = block?.rows ?? 1;
+        const cols = block?.cols ?? 1;
+        for (let r = 0; r < rows; r++) {
+            for (let c = 0; c < cols; c++) {
+                place({ rowIndex: target.rowIndex + r, columnIndex: target.columnIndex + c }, FILL_UNTOUCHED);
             }
-            break;
+        }
+    };
+    for (let line = 0; line < lineCount; line++) {
+        const { sourceValues, sourceMeta } = lines[line];
+        const { fillType: lineFillType, values: newValues, seeds, untouchedTail, } = computeLine(sourceValues, fillCount);
+        // Series-dialog Trend: Excel REPLACES the starting values with the fitted trend — each numeric
+        // seed cell is rewritten in place (formula shifting is moot: `from` = `to`) and keeps its format.
+        if (seeds?.length && !isFormatsOnly) {
+            fillValues.seedCells ??= [];
+            for (const seed of seeds) {
+                const from = seedCoord(line, seed.index);
+                const sourceCellData = getCellData?.(sheetId, from.rowIndex, from.columnIndex);
+                sheetCell.assign(sheetId, from, sourceCellData, {
+                    locale,
+                    cellXfsRegistry,
+                    getDataValidationById,
+                });
+                fillValues.seedCells.push({
+                    rowIndex: from.rowIndex,
+                    columnIndex: from.columnIndex,
+                    cell: finalizeCell(writeFillValue(seed.value, sourceMeta[seed.index], sourceCellData, from, from, lineFillType), from),
+                });
+            }
+        }
+        for (let i = 0; i < fillCount; i++) {
+            const target = targetCoord(line, i);
+            const k = i % seedCount;
+            const from = seedCoord(line, k);
+            if (untouchedTail && i >= newValues.length) {
+                // The Series dialog's `stop` ended this line: Excel leaves the rest of the selection alone.
+                markUntouched(target);
+                continue;
+            }
+            if (isFormatsOnly) {
+                // Copy format but not value
+                placeBlock(target, formatsOnlyCell(from, target), from);
+                continue;
+            }
+            const sourceCellData = getCellData?.(sheetId, from.rowIndex, from.columnIndex);
+            sheetCell.assign(sheetId, from, sourceCellData, {
+                locale,
+                cellXfsRegistry,
+                getDataValidationById,
+            });
+            placeBlock(target, finalizeCell(writeFillValue(newValues[i], sourceMeta[k], sourceCellData, from, target, lineFillType), target), from);
         }
     }
     return fillValues;