@rowsncolumns/spreadsheet-state 28.0.74 → 28.0.75

package/dist/cjs/api/fill.js

@@ -1,7 +1,98 @@
-import { __assign, __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
+import { __assign, __awaiter, __extends, __generator, __read, __rest, __spreadArray, __values } from "tslib";
 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). */
+var 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 var resolveToggledFillType = function (detectedPerLine) {
+    var votes = detectedPerLine.filter(function (t) { return t !== undefined; });
+    return votes.some(function (t) { return !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 var isFormatsOnlyFillType = function (fillType) {
+    return fillType === "FillFormats";
+};
+export var isValuesOnlyFillType = function (fillType) {
+    return 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.
+ */
+var MergedFillSizeError = /** @class */ (function (_super) {
+    __extends(MergedFillSizeError, _super);
+    function MergedFillSizeError() {
+        var _this = _super.call(this, "This operation requires the merged cells to be identically sized.") || this;
+        _this.name = "MergedFillSizeError";
+        return _this;
+    }
+    return MergedFillSizeError;
+}(Error));
+export { 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 var 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 var resolveMergedFillBlock = function (range, merges) {
+    var inside = (merges !== null && merges !== void 0 ? merges : []).filter(function (m) {
+        return m.startRowIndex <= range.endRowIndex &&
+            m.endRowIndex >= range.startRowIndex &&
+            m.startColumnIndex <= range.endColumnIndex &&
+            m.endColumnIndex >= range.startColumnIndex;
+    });
+    var first = inside[0];
+    if (!first)
+        return undefined;
+    var rows = first.endRowIndex - first.startRowIndex + 1;
+    var cols = first.endColumnIndex - first.startColumnIndex + 1;
+    var srcRows = range.endRowIndex - range.startRowIndex + 1;
+    var srcCols = range.endColumnIndex - range.startColumnIndex + 1;
+    var onLattice = inside.every(function (m) {
+        return 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;
+    });
+    var tiled = onLattice &&
+        srcRows % rows === 0 &&
+        srcCols % cols === 0 &&
+        inside.length === (srcRows / rows) * (srcCols / cols);
+    if (!tiled)
+        throw new MergedFillSizeError();
+    return { rows: rows, cols: cols };
+};
 // Helper functions for pattern detection and fill operations
 /**
  * Extract numeric value from a string that may contain text
@@ -10,27 +101,285 @@ var extractNumber = function (value) {
     var match = value.match(/-?\d+\.?\d*/);
     return match ? parseFloat(match[0]) : null;
 };
-var 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.
+ */
+var TEXT_NUMBER_PATTERN_REGEX = /^(.*?)(\d+)(\D*)$/;
 var 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;
 var WEEKDAY_NAME_REGEX = /\b(?:mon(?:day)?|tue(?:s(?:day)?)?|wed(?:nesday)?|thu(?:rs(?:day)?)?|fri(?:day)?|sat(?:urday)?|sun(?:day)?)\b/i;
 var 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})?)?$/;
 var 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"). */
+var ORDINAL_SUFFIX_REGEX = /^(st|nd|rd|th)(?![a-z])/i;
+var BARE_DIGITS_REGEX = /^\d+$/;
+/** Excel's built-in quarter tokens: Q1, Qtr 2, Quarter3 — whole-cell only. */
+var QUARTER_TOKEN_REGEX = /^(q|qtr|quarter)(\s?)([1-4])$/i;
+var QUARTER_ORDINAL_REGEX = /^([1-4])(st|nd|rd|th)(\s)(quarter|qtr)$/i;
+var QUARTERS_IN_YEAR = 4;
 var extractTextNumberPattern = function (value) {
     var match = value.match(TEXT_NUMBER_PATTERN_REGEX);
     if (!match)
         return null;
-    var _a = __read(match, 4), prefix = _a[1], numericPortion = _a[2], suffix = _a[3];
+    var _a = __read(match, 4), prefix = _a[1], run = _a[2], suffix = _a[3];
     if (!prefix && !suffix)
         return null;
-    var parsed = parseFloat(numericPortion);
-    if (Number.isNaN(parsed))
+    var parsed = Number(run);
+    if (!Number.isFinite(parsed))
         return null;
     return {
         prefix: prefix,
         suffix: suffix,
         number: parsed,
+        width: run.length,
     };
 };
+var mod = function (value, len) { return ((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.
+ */
+var applySeedCase = function (seed, canonical) {
+    // A seed without cased letters (`upper === lower`) keeps the list's casing.
+    var upper = seed.toUpperCase();
+    var lower = seed.toLowerCase();
+    if (seed === upper && upper !== lower)
+        return canonical.toUpperCase();
+    if (seed === lower && upper !== lower)
+        return canonical.toLowerCase();
+    return canonical;
+};
+var ordinalSuffix = function (n) {
+    var abs = Math.abs(Math.trunc(n));
+    var 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). */
+var formatDigitRun = function (n, width) {
+    var rounded = Math.round(n);
+    var digits = String(Math.abs(rounded)).padStart(width, "0");
+    return rounded < 0 ? "-".concat(digits) : digits;
+};
+var tokenizeDigitRuns = function (value) {
+    var parts = [];
+    var runs = [];
+    var re = /\d+/g;
+    var last = 0;
+    var 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: parts, runs: 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.
+ */
+var matchTextNumberSeries = function (values) {
+    if (values.length === 0)
+        return null;
+    var tokens = values.map(tokenizeDigitRuns);
+    var first = tokens[0];
+    if (first.runs.length === 0)
+        return null;
+    var sameSkeleton = tokens.every(function (t) {
+        return t.runs.length === first.runs.length &&
+            t.parts.every(function (part, i) { return part === first.parts[i]; });
+    });
+    if (!sameSkeleton)
+        return null;
+    var varying = [];
+    var _loop_1 = function (r) {
+        if (tokens.some(function (t) { return Number(t.runs[r]) !== Number(first.runs[r]); })) {
+            varying.push(r);
+        }
+    };
+    for (var r = 0; r < first.runs.length; r++) {
+        _loop_1(r);
+    }
+    if (varying.length > 1)
+        return null;
+    var runIndex = varying.length === 1 ? varying[0] : first.runs.length - 1;
+    var numbers = tokens.map(function (t) { return Number(t.runs[runIndex]); });
+    if (numbers.some(function (n) { return !Number.isFinite(n); }))
+        return null;
+    var step = numbers.length >= 2 ? numbers[1] - numbers[0] : 1;
+    var linear = numbers.every(function (n, i) { return i === 0 || n - numbers[i - 1] === step; });
+    if (!linear)
+        return null;
+    var lastTokens = tokens[tokens.length - 1];
+    return {
+        parts: first.parts,
+        runs: lastTokens.runs,
+        runIndex: runIndex,
+        step: step,
+        last: numbers[numbers.length - 1],
+        width: lastTokens.runs[runIndex].length,
+    };
+};
+var renderTextNumber = function (series, n) {
+    var parts = series.parts, runs = series.runs, runIndex = series.runIndex, width = series.width;
+    var out = parts[0];
+    for (var r = 0; r < runs.length; r++) {
+        out += r === runIndex ? formatDigitRun(n, width) : runs[r];
+        var after = parts[r + 1];
+        var ordinal = r === runIndex ? after.match(ORDINAL_SUFFIX_REGEX) : null;
+        out += ordinal
+            ? "".concat(applySeedCase(ordinal[1], ordinalSuffix(n))).concat(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 var generateTextNumberSeries = function (values, count, descending) {
+    if (descending === void 0) { descending = false; }
+    var series = matchTextNumberSeries(values);
+    if (!series)
+        return null;
+    var step = values.length >= 2 ? series.step : descending ? -1 : 1;
+    return Array.from({ length: count }, function (_, i) {
+        return 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.
+ */
+var parseQuarterToken = function (value) {
+    var token = value.trim();
+    var plain = token.match(QUARTER_TOKEN_REGEX);
+    if (plain) {
+        var _a = __read(plain, 4), word_1 = _a[1], space_1 = _a[2], digit = _a[3];
+        return {
+            index: Number(digit) - 1,
+            render: function (quarter) { return "".concat(word_1).concat(space_1).concat(quarter); },
+        };
+    }
+    var ordinal = token.match(QUARTER_ORDINAL_REGEX);
+    if (ordinal) {
+        var _b = __read(ordinal, 5), digit = _b[1], suffix_1 = _b[2], space_2 = _b[3], word_2 = _b[4];
+        return {
+            index: Number(digit) - 1,
+            render: function (quarter) {
+                return "".concat(quarter).concat(applySeedCase(suffix_1, ordinalSuffix(quarter))).concat(space_2).concat(word_2);
+            },
+        };
+    }
+    return null;
+};
+var isQuarterToken = function (value) {
+    return typeof value === "string" && parseQuarterToken(value) !== null;
+};
+export var generateQuarterSeries = function (values, count, descending) {
+    if (descending === void 0) { descending = false; }
+    var tokens = values.map(parseQuarterToken);
+    if (tokens.length === 0 || tokens.some(function (t) { return t === null; }))
+        return null;
+    var quarters = tokens;
+    var indices = quarters.map(function (t) { return t.index; });
+    var step;
+    if (indices.length >= 2) {
+        step = mod(indices[1] - indices[0], QUARTERS_IN_YEAR);
+        var consistent = indices.every(function (idx, i) {
+            return i === 0 || mod(idx - indices[i - 1], QUARTERS_IN_YEAR) === step;
+        });
+        if (!consistent)
+            return null;
+    }
+    else {
+        step = descending ? -1 : 1;
+    }
+    var last = quarters[quarters.length - 1];
+    return Array.from({ length: count }, function (_, i) {
+        return 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.
+ */
+var resolveNameListPosition = function (value, names) {
+    var lower = value.trim().toLowerCase();
+    if (!lower)
+        return null;
+    var fullIndex = names.findIndex(function (n) { return n.toLowerCase() === lower; });
+    if (fullIndex !== -1)
+        return { index: fullIndex, abbreviated: false };
+    var abbrIndex = names.findIndex(function (n) { return n.toLowerCase().substring(0, 3) === lower; });
+    if (abbrIndex !== -1)
+        return { index: abbrIndex, abbreviated: true };
+    if (lower.length < 3)
+        return null;
+    var looseIndex = names.findIndex(function (n) {
+        return 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.
+ */
+var generateNameListSeries = function (sourceValues, names, count, descending) {
+    if (descending === void 0) { descending = false; }
+    var seed = sourceValues[sourceValues.length - 1];
+    if (typeof seed !== "string")
+        return [];
+    var positions = sourceValues.map(function (v) {
+        return typeof v === "string" ? resolveNameListPosition(v, names) : null;
+    });
+    var last = positions[positions.length - 1];
+    if (!last)
+        return [];
+    var len = names.length;
+    var step;
+    if (positions.length >= 2 && positions.every(function (p) { return p !== null; })) {
+        var indices_1 = positions.map(function (p) { return p.index; });
+        step = mod(indices_1[1] - indices_1[0], len);
+        var consistent = indices_1.every(function (idx, i) { return i === 0 || mod(idx - indices_1[i - 1], len) === step; });
+        if (!consistent)
+            return [];
+    }
+    else {
+        step = descending ? -1 : 1;
+    }
+    var result = [];
+    for (var i = 0; i < count; i++) {
+        var canonical = names[mod(last.index + step * (i + 1), len)];
+        var form = last.abbreviated ? canonical.substring(0, 3) : canonical;
+        result.push(applySeedCase(seed, form));
+    }
+    return result;
+};
 var isLikelyDateString = function (value) {
     var trimmed = value.trim();
     if (!trimmed || /^\d+$/.test(trimmed)) {
@@ -67,6 +416,75 @@ var parseDate = function (value) {
     var 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`.
+ */
+var dateToSerial = function (date) { return toSerial(date, false); };
+var serialToDate = function (serial) { return 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".
+ */
+var isTimeOnlyDate = function (date) { return date.getFullYear() < 1900; };
+var isDateLikeFormatType = function (type) {
+    return type === "DATE" || type === "DATE_TIME" || type === "TIME";
+};
+var HOURS_PER_DAY = 24;
+var SERIAL_EPSILON = 1e-9;
+var isWholeDayStep = function (serialStep) {
+    return Math.abs(serialStep - Math.round(serialStep)) < SERIAL_EPSILON;
+};
+var daysInMonth = function (year, monthIndex) {
+    return new Date(year, monthIndex + 1, 0).getDate();
+};
+var isLastDayOfMonth = function (date) {
+    return date.getDate() === daysInMonth(date.getFullYear(), date.getMonth());
+};
+/**
+ * Whole months between two dates (ignores day-of-month).
+ */
+var monthsBetween = function (from, to) {
+    return (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.
+ */
+var addMonthsClamped = function (anchor, months, endOfMonth) {
+    if (endOfMonth === void 0) { endOfMonth = false; }
+    var total = anchor.getFullYear() * 12 + anchor.getMonth() + months;
+    var year = Math.floor(total / 12);
+    var monthIndex = total - year * 12;
+    var lastDay = daysInMonth(year, monthIndex);
+    var day = endOfMonth ? lastDay : Math.min(anchor.getDate(), lastDay);
+    return new Date(year, monthIndex, day, anchor.getHours(), anchor.getMinutes(), anchor.getSeconds(), anchor.getMilliseconds());
+};
+var isWeekend = function (date) {
+    return 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.
+ */
+var weekdaysBetween = function (from, to) {
+    var dir = to.getTime() >= from.getTime() ? 1 : -1;
+    var cursor = new Date(from);
+    var 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
  */
@@ -101,7 +519,7 @@ var matchCustomList = function (source, lists) {
     if (stringValues.some(function (v) { return v === null; }))
         return null;
     var lc = stringValues;
-    var _loop_1 = function (list) {
+    var _loop_2 = function (list) {
         if (list.length < 2)
             return "continue";
         var listLower = list.map(function (s) { return s.toLowerCase(); });
@@ -137,7 +555,7 @@ var matchCustomList = function (source, lists) {
     try {
         for (var lists_1 = __values(lists), lists_1_1 = lists_1.next(); !lists_1_1.done; lists_1_1 = lists_1.next()) {
             var list = lists_1_1.value;
-            var state_1 = _loop_1(list);
+            var state_1 = _loop_2(list);
             if (typeof state_1 === "object")
                 return state_1.value;
         }
@@ -203,8 +621,59 @@ var isSimpleDecimalSeriesNumberPattern = function (pattern) {
     var normalizedPattern = (_a = pattern === null || pattern === void 0 ? void 0 : pattern.trim()) !== null && _a !== void 0 ? _a : "General";
     return SIMPLE_DECIMAL_SERIES_NUMBER_PATTERN_REGEX.test(normalizedPattern);
 };
-var shouldNormalizeSeriesNumberFormat = function (fillType, numberFormat, value) {
-    if (fillType !== "FillSeries") {
+var TREND_FILL_TYPES = new Set([
+    "LinearTrend",
+    "GrowthTrend",
+]);
+var 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).
+ */
+var getSimpleNumberPatternShape = function (pattern) {
+    var _a, _b, _c;
+    var match = SIMPLE_SERIES_NUMBER_PATTERN_SHAPE_REGEX.exec((_a = pattern === null || pattern === void 0 ? void 0 : pattern.trim()) !== null && _a !== void 0 ? _a : "");
+    if (!match) {
+        return null;
+    }
+    return { decimals: (_c = (_b = match[2]) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 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.
+ */
+var isAutoDetectedNumberPattern = function (pattern, seedValue, locale) {
+    if (typeof seedValue !== "number" || !Number.isFinite(seedValue)) {
+        return false;
+    }
+    var shape = getSimpleNumberPatternShape(pattern);
+    var 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.
+ */
+var shouldNormalizeSeriesNumberFormat = function (fillType, numberFormat, value, seedValue, locale) {
+    if (fillType !== "FillSeries" && !TREND_FILL_TYPES.has(fillType)) {
         return false;
     }
     if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -214,13 +683,12 @@ var shouldNormalizeSeriesNumberFormat = function (fillType, numberFormat, value)
         return false;
     }
     var pattern = numberFormat.pattern;
-    if (isSimpleIntegerSeriesNumberPattern(pattern) && !isNearlyInteger(value)) {
-        return true;
-    }
-    if (isSimpleDecimalSeriesNumberPattern(pattern) && isNearlyInteger(value)) {
-        return true;
+    var integerPatternOnFraction = isSimpleIntegerSeriesNumberPattern(pattern) && !isNearlyInteger(value);
+    var decimalPatternOnInteger = isSimpleDecimalSeriesNumberPattern(pattern) && isNearlyInteger(value);
+    if (!integerPatternOnFraction && !decimalPatternOnInteger) {
+        return false;
     }
-    return false;
+    return isAutoDetectedNumberPattern(pattern, seedValue, locale);
 };
 var getCellNumberFormat = function (sheetCell) {
     var effectiveNumberFormat = sheetCell.getNumberFormat();
@@ -235,9 +703,11 @@ var getCellNumberFormat = function (sheetCell) {
     }
     return undefined;
 };
-var shouldNormalizeSeriesNumberFormatForCell = function (sheetCell, fillType, value) {
+var shouldNormalizeSeriesNumberFormatForCell = function (sheetCell, fillType, value, locale) {
     var numberFormat = getCellNumberFormat(sheetCell);
-    return shouldNormalizeSeriesNumberFormat(fillType, numberFormat, value);
+    // `sheetCell` still holds the (wrapped) seed the target is cloned from.
+    var seedValue = sheetCell.getEffectiveValue();
+    return shouldNormalizeSeriesNumberFormat(fillType, numberFormat, value, seedValue, locale);
 };
 var clearCellNumberFormatForSeries = function (sheetCell) {
     if (sheetCell.userEnteredFormat) {
@@ -266,13 +736,19 @@ export var detectFillType = function (selectionData, locale, 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
     var dayNames = getDayNames(locale);
     var monthNames = getMonthNames(locale);
     if (values.length === 1) {
         var 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") {
@@ -322,22 +798,29 @@ export var detectFillType = function (selectionData, locale, customAutofillLists
     if (dates.length >= 2) {
         var firstDate = dates[0];
         var secondDate = dates[1];
-        var timeDiff = secondDate.getTime() - firstDate.getTime();
-        var 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";
+        var 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";
         var sameDayOfMonth = firstDate.getDate() === secondDate.getDate();
-        var sameMonth = firstDate.getMonth() === secondDate.getMonth();
-        var monthDiff = (secondDate.getFullYear() - firstDate.getFullYear()) * 12 +
-            (secondDate.getMonth() - firstDate.getMonth());
-        if (sameDayOfMonth && monthDiff === 1)
+        var 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)
@@ -354,6 +837,26 @@ export var detectFillType = function (selectionData, locale, customAutofillLists
         if (isLinearSeries && diff_1 !== 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(function (v) { return 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(function (v) { return typeof v === "string"; }) &&
+        !values.every(function (v) { return BARE_DIGITS_REGEX.test(v); }) &&
+        !values.some(function (v) { return isLikelyDateString(v); })) {
+        var textSeries = matchTextNumberSeries(values);
+        if (textSeries && textSeries.step !== 0) {
+            return "FillSeries";
+        }
     }
     // Check for text patterns (days/months)
     var textValues = values.map(function (v) { return String(v).toLowerCase(); });
@@ -379,8 +882,16 @@ export var detectFillType = function (selectionData, locale, customAutofillLists
 /**
  * Generate fill values based on type and pattern
  */
-export var generateFillValues = function (sourceValues, fillType, count, locale, customAutofillLists) {
+export var generateFillValues = function (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) {
+    if (descending === void 0) { descending = false; }
     var result = [];
+    var unitStep = descending ? -1 : 1;
     switch (fillType) {
         case "FillCustomList": {
             var match = matchCustomList(sourceValues, customAutofillLists);
@@ -392,16 +903,20 @@ export var generateFillValues = function (sourceValues, fillType, count, locale,
                 }
                 break;
             }
-            var list = match.list, startIndex = match.startIndex, ascending = match.ascending;
+            var list = match.list, startIndex = match.startIndex;
+            // A single seed has no order of its own — the fill direction decides.
+            var ascending = sourceValues.length >= 2 ? match.ascending : !descending;
             var 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").
+            var seed = String(sourceValues[sourceValues.length - 1]);
             var nextOffset = ascending
                 ? startIndex + sourceValues.length
                 : startIndex - sourceValues.length;
             for (var i = 0; i < count; i++) {
                 var step = ascending ? i : -i;
                 var idx = (((nextOffset + step) % len) + len) % len;
-                result.push(list[idx]);
+                result.push(applySeedCase(seed, list[idx]));
             }
             break;
         }
@@ -412,28 +927,23 @@ export var generateFillValues = function (sourceValues, fillType, count, locale,
             break;
         }
         case "FillSeries": {
-            var textPatterns = sourceValues
-                .map(function (value) {
-                return typeof value === "string" ? extractTextNumberPattern(value) : null;
-            })
-                .filter(function (pattern) { return pattern !== null; });
-            if (textPatterns.length === sourceValues.length &&
-                textPatterns.length > 0) {
-                var _a = __read(textPatterns), firstPattern_1 = _a[0], restPatterns = _a.slice(1);
-                var hasConsistentAffixes = restPatterns.every(function (_a) {
-                    var prefix = _a.prefix, suffix = _a.suffix;
-                    return prefix === firstPattern_1.prefix && suffix === firstPattern_1.suffix;
-                });
-                if (hasConsistentAffixes) {
-                    var numbers_1 = textPatterns.map(function (pattern) { return pattern.number; });
-                    var diff = numbers_1.length >= 2
-                        ? normalizeSeriesNumber(numbers_1[1] - numbers_1[0])
-                        : 1;
-                    var lastValue = normalizeSeriesNumber(numbers_1[numbers_1.length - 1]);
-                    for (var i = 0; i < count; i++) {
-                        var nextNumber = normalizeSeriesNumber(lastValue + diff * (i + 1));
-                        result.push("".concat(firstPattern_1.prefix).concat(String(nextNumber)).concat(firstPattern_1.suffix));
-                    }
+            var allStrings = sourceValues.every(function (value) { return typeof value === "string"; });
+            // Built-in quarter list first: Q4 wraps to Q1 instead of stepping to Q5.
+            if (allStrings) {
+                var quarters = generateQuarterSeries(sourceValues, count, descending);
+                if (quarters) {
+                    result.push.apply(result, __spreadArray([], __read(quarters), false));
+                    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(function (value) { return BARE_DIGITS_REGEX.test(value); })) {
+                var textSeries = generateTextNumberSeries(sourceValues, count, descending);
+                if (textSeries) {
+                    result.push.apply(result, __spreadArray([], __read(textSeries), false));
                     break;
                 }
             }
@@ -441,18 +951,38 @@ export var generateFillValues = function (sourceValues, fillType, count, locale,
                 .map(function (v) { return (typeof v === "number" ? v : extractNumber(String(v))); })
                 .filter(function (n) { return 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
                 var diff = numbers.length >= 2
                     ? normalizeSeriesNumber(numbers[1] - numbers[0])
-                    : 1;
+                    : descending
+                        ? -1
+                        : 1;
                 var lastValue = normalizeSeriesNumber(numbers[numbers.length - 1]);
                 for (var i = 0; i < count; i++) {
                     result.push(normalizeSeriesNumber(lastValue + diff * (i + 1)));
                 }
+                break;
             }
-            else {
-                result.push.apply(result, __spreadArray([], __read(Array(count).fill(sourceValues[sourceValues.length - 1])), false));
+            // 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) {
+                var days = generateNameListSeries(sourceValues, getDayNames(locale), count, descending);
+                if (days.length) {
+                    result.push.apply(result, __spreadArray([], __read(days), false));
+                    break;
+                }
+                var months = generateNameListSeries(sourceValues, getMonthNames(locale), count, descending);
+                if (months.length) {
+                    result.push.apply(result, __spreadArray([], __read(months), false));
+                    break;
+                }
+                if (matchCustomList(sourceValues, customAutofillLists)) {
+                    result.push.apply(result, __spreadArray([], __read(generateFillValues(sourceValues, "FillCustomList", count, locale, customAutofillLists, descending)), false));
+                    break;
+                }
             }
+            result.push.apply(result, __spreadArray([], __read(Array(count).fill(sourceValues[sourceValues.length - 1])), false));
             break;
         }
         case "FillDays": {
@@ -460,58 +990,52 @@ export var generateFillValues = function (sourceValues, fillType, count, locale,
                 .map(function (value) { return parseDate(value); })
                 .filter(function (date) { return 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).
                 var lastDate = parsedDates[parsedDates.length - 1];
                 var previousDate = parsedDates.length >= 2 ? parsedDates[parsedDates.length - 2] : null;
-                var dayMs = 1000 * 60 * 60 * 24;
-                var dayIncrement = 1;
+                var lastSerial = dateToSerial(lastDate);
+                var step = unitStep;
                 if (previousDate) {
-                    var diff = Math.round((lastDate.getTime() - previousDate.getTime()) / dayMs);
-                    if (diff !== 0) {
-                        dayIncrement = diff;
+                    var diff = lastSerial - dateToSerial(previousDate);
+                    if (Math.abs(diff) > SERIAL_EPSILON) {
+                        step = diff;
                     }
                 }
-                var currentDate = new Date(lastDate);
                 for (var i = 0; i < count; i++) {
-                    currentDate.setDate(currentDate.getDate() + dayIncrement);
-                    result.push(currentDate.toLocaleDateString(locale));
+                    result.push(serialToDate(lastSerial + step * (i + 1)));
                 }
             }
             else {
-                var lastDayValue = sourceValues[sourceValues.length - 1];
-                if (typeof lastDayValue === "string") {
-                    // Handle day names (like "Mon", "Tue", "Wed")
-                    var allDayNames = getDayNames(locale);
-                    var allDayAbbrevs = allDayNames.map(function (d) { return d.substring(0, 3); });
-                    // Find which day we're at
-                    var lastDayLower_1 = lastDayValue.toLowerCase();
-                    var dayIndex = allDayNames.findIndex(function (d) {
-                        return d.toLowerCase().includes(lastDayLower_1) ||
-                            lastDayLower_1.includes(d.toLowerCase());
-                    });
-                    if (dayIndex !== -1) {
-                        // Determine if we're using full names or abbreviations
-                        var isAbbreviated = lastDayValue.length <= 3;
-                        for (var i = 0; i < count; i++) {
-                            var nextDayIndex = (dayIndex + i + 1) % 7;
-                            var dayName = isAbbreviated
-                                ? allDayAbbrevs[nextDayIndex]
-                                : allDayNames[nextDayIndex];
-                            result.push(dayName);
-                        }
-                    }
-                }
+                // Day names ("Mon", "Tue", "Wed"): seed gap as the step, seed casing kept.
+                result.push.apply(result, __spreadArray([], __read(generateNameListSeries(sourceValues, getDayNames(locale), count, descending)), false));
             }
             break;
         }
         case "FillWeekdays": {
-            var 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).
+            var weekdayDates = sourceValues
+                .map(function (value) { return parseDate(value); })
+                .filter(function (date) { return date !== null; });
+            var lastWeekday = weekdayDates[weekdayDates.length - 1];
             if (lastWeekday) {
+                var previous = weekdayDates.length >= 2
+                    ? weekdayDates[weekdayDates.length - 2]
+                    : null;
+                var seedStep = previous ? weekdaysBetween(previous, lastWeekday) : 0;
+                var step = seedStep === 0 ? unitStep : seedStep;
+                var dir = step > 0 ? 1 : -1;
                 var currentDate = new Date(lastWeekday);
                 for (var 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 (var taken = 0; taken < Math.abs(step);) {
+                        currentDate.setDate(currentDate.getDate() + dir);
+                        if (!isWeekend(currentDate))
+                            taken += 1;
+                    }
+                    result.push(new Date(currentDate));
                 }
             }
             break;
@@ -521,44 +1045,73 @@ export var generateFillValues = function (sourceValues, fillType, count, locale,
             var lastValue = sourceValues[sourceValues.length - 1];
             var 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).
+                var monthDates = sourceValues
+                    .map(function (value) { return parseDate(value); })
+                    .filter(function (date) { return date !== null; });
+                var previous = monthDates.length >= 2 ? monthDates[monthDates.length - 2] : null;
+                var seedStep = previous ? monthsBetween(previous, lastMonth) : 0;
+                var step = seedStep === 0 ? unitStep : seedStep;
+                var endOfMonth = monthDates.length >= 2 && monthDates.every(isLastDayOfMonth);
                 for (var i = 0; i < count; i++) {
-                    var 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")
-                var allMonthNames = getMonthNames(locale);
-                var allMonthAbbrevs = allMonthNames.map(function (m) { return m.substring(0, 3); });
-                // Find which month we're at
-                var lastValueLower_1 = lastValue.toLowerCase();
-                var monthIndex = allMonthNames.findIndex(function (m) {
-                    return m.toLowerCase().includes(lastValueLower_1) ||
-                        lastValueLower_1.includes(m.toLowerCase());
-                });
-                if (monthIndex !== -1) {
-                    // Determine if we're using full names or abbreviations
-                    var isAbbreviated = lastValue.length <= 3;
-                    for (var i = 0; i < count; i++) {
-                        var nextMonthIndex = (monthIndex + i + 1) % 12;
-                        var monthName = isAbbreviated
-                            ? allMonthAbbrevs[nextMonthIndex]
-                            : allMonthNames[nextMonthIndex];
-                        result.push(monthName);
-                    }
-                }
+                // Month names ("Jan", "Feb", "Mar"): seed gap as the step, seed casing kept.
+                result.push.apply(result, __spreadArray([], __read(generateNameListSeries(sourceValues, getMonthNames(locale), count, descending)), false));
             }
             break;
         }
         case "FillYears": {
-            var 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).
+            var yearDates = sourceValues
+                .map(function (value) { return parseDate(value); })
+                .filter(function (date) { return date !== null; });
+            var lastYear = yearDates[yearDates.length - 1];
             if (lastYear) {
+                var previous = yearDates.length >= 2 ? yearDates[yearDates.length - 2] : null;
+                var seedStep = previous
+                    ? lastYear.getFullYear() - previous.getFullYear()
+                    : 0;
+                var step = seedStep === 0 ? unitStep : seedStep;
+                for (var i = 0; i < count; i++) {
+                    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.
+            var timeSerials = sourceValues
+                .map(function (value) {
+                return value instanceof Date
+                    ? dateToSerial(value)
+                    : typeof value === "number"
+                        ? value
+                        : null;
+            })
+                .filter(function (serial) { return serial !== null; });
+            if (timeSerials.length) {
+                var lastSerial = timeSerials[timeSerials.length - 1];
+                var previous = timeSerials.length >= 2 ? timeSerials[timeSerials.length - 2] : null;
+                var seedStep = previous === null ? 0 : lastSerial - previous;
+                var step = Math.abs(seedStep) > SERIAL_EPSILON
+                    ? seedStep
+                    : unitStep / HOURS_PER_DAY;
                 for (var i = 0; i < count; i++) {
-                    var newDate = new Date(lastYear);
-                    newDate.setFullYear(lastYear.getFullYear() + i + 1);
-                    result.push(newDate.toLocaleDateString(locale));
+                    result.push(normalizeSeriesNumber(lastSerial + step * (i + 1)));
                 }
             }
             break;
@@ -578,7 +1131,7 @@ export var generateFillValues = function (sourceValues, fillType, count, locale,
                 var intercept = (sumY - slope * sumX) / n;
                 for (var i = 0; i < count; i++) {
                     var x = numValues.length + i;
-                    result.push(slope * x + intercept);
+                    result.push(normalizeSeriesNumber(slope * x + intercept));
                 }
             }
             break;
@@ -602,25 +1155,12 @@ export var generateFillValues = function (sourceValues, fillType, count, locale,
             }
             break;
         }
-        case "FillValues": {
-            // Similar to FillSeries but preserves text formatting
-            for (var i = 0; i < count; i++) {
-                var sourceIndex = i % sourceValues.length;
-                var value = sourceValues[sourceIndex];
-                if (typeof value === "string") {
-                    var num = extractNumber(value);
-                    if (num !== null && sourceValues.length >= 2) {
-                        var nextNum = extractNumber(String(sourceValues[(sourceIndex + 1) % sourceValues.length]));
-                        if (nextNum !== null) {
-                            var diff = nextNum - num;
-                            var cycles = Math.floor(i / sourceValues.length);
-                            var 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.
+            var detected = detectFillType([sourceValues], locale, customAutofillLists);
+            result.push.apply(result, __spreadArray([], __read(generateFillValues(sourceValues, detected, count, locale, customAutofillLists, descending)), false));
             break;
         }
         case "FillFormats": {
@@ -641,49 +1181,189 @@ export var generateFillValues = function (sourceValues, fillType, count, locale,
     }
     return result;
 };
+var hasExcelTextPrefix = function (value) {
+    return 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.
+ */
+var classifyFillValue = function (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)) {
+        var parts = tokenizeDigitRuns(value).parts;
+        return { kind: "textnum", key: "textnum:".concat(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" };
+};
+var repeatValues = function (values, count) {
+    return Array.from({ length: count }, function (_, i) { return 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).
+ */
+var generateGroupValues = function (cls, values, count, mixedLine, _a) {
+    var _b, _c;
+    var locale = _a.locale, customAutofillLists = _a.customAutofillLists, descending = _a.descending;
+    var fallback = function () { return 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();
+                var step_1 = descending ? -1 : 1;
+                var last_1 = normalizeSeriesNumber(values[0]);
+                return Array.from({ length: count }, function (_, i) {
+                    return normalizeSeriesNumber(last_1 + step_1 * (i + 1));
+                });
+            }
+            var type = detectFillType([values], locale, customAutofillLists);
+            var 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, …).
+            var type = detectFillType([values], locale, customAutofillLists);
+            var out = generateFillValues(values, type, count, locale, customAutofillLists, descending);
+            return out.length === count ? out : fallback();
+        }
+        case "quarter":
+            return (_b = generateQuarterSeries(values, count, descending)) !== null && _b !== void 0 ? _b : fallback();
+        case "textnum":
+            return (_c = generateTextNumberSeries(values, count, descending)) !== null && _c !== void 0 ? _c : fallback();
+        case "day": {
+            var out = generateNameListSeries(values, getDayNames(locale), count, descending);
+            return out.length === count ? out : fallback();
+        }
+        case "month": {
+            var out = generateNameListSeries(values, getMonthNames(locale), count, descending);
+            return out.length === count ? out : fallback();
+        }
+        case "custom": {
+            var 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".
+ */
+var generateLineSeries = function (sourceValues, count, options) {
+    var e_2, _a;
+    var _b, _c;
+    var locale = options.locale, customAutofillLists = options.customAutofillLists;
+    var len = sourceValues.length;
+    if (len === 0 || count <= 0)
+        return { fillType: "FillDefault", values: [] };
+    var dayNames = getDayNames(locale);
+    var monthNames = getMonthNames(locale);
+    var classes = sourceValues.map(function (v) {
+        return classifyFillValue(v, dayNames, monthNames, customAutofillLists);
+    });
+    var groups = new Map();
+    classes.forEach(function (cls, position) {
+        var _a;
+        var group = (_a = groups.get(cls.key)) !== null && _a !== void 0 ? _a : {
+            cls: cls,
+            values: [],
+            generated: [],
+            cursor: 0,
+        };
+        group.values.push(sourceValues[position]);
+        groups.set(cls.key, group);
+    });
+    var nonBlankGroups = __spreadArray([], __read(groups.values()), false).filter(function (g) { return g.cls.kind !== "blank"; });
+    if (nonBlankGroups.length === 0) {
+        return { fillType: "FillDefault", values: Array(count).fill(null) };
+    }
+    var mixedLine = groups.size > 1;
+    var needed = new Map();
+    for (var i = 0; i < count; i++) {
+        var key = classes[i % len].key;
+        needed.set(key, ((_b = needed.get(key)) !== null && _b !== void 0 ? _b : 0) + 1);
+    }
+    try {
+        for (var groups_1 = __values(groups), groups_1_1 = groups_1.next(); !groups_1_1.done; groups_1_1 = groups_1.next()) {
+            var _d = __read(groups_1_1.value, 2), key = _d[0], group = _d[1];
+            group.generated = generateGroupValues(group.cls, group.values, (_c = needed.get(key)) !== null && _c !== void 0 ? _c : 0, mixedLine, options);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (groups_1_1 && !groups_1_1.done && (_a = groups_1.return)) _a.call(groups_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var values = [];
+    for (var i = 0; i < count; i++) {
+        var group = groups.get(classes[i % len].key);
+        values.push(group.generated[group.cursor++]);
+    }
+    // The number group's own detection drives number-format normalisation.
+    var numberGroup = groups.get("number");
+    var lineFillType;
+    if (numberGroup) {
+        lineFillType =
+            numberGroup.values.length >= 2
+                ? detectFillType([numberGroup.values], locale, customAutofillLists)
+                : mixedLine
+                    ? "FillSeries"
+                    : "FillCopy";
+    }
+    else if (mixedLine || nonBlankGroups.some(function (g) { return g.cls.kind !== "text"; })) {
+        lineFillType = "FillSeries";
+    }
+    else {
+        lineFillType = "FillDefault";
+    }
+    return { fillType: lineFillType, values: values };
+};
 /**
  * Get auto fill values
  * @returns T[][]
  */
 export var getAutoFillValues = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
-    var sheetCell, activeSheetName, textCell, getTextInfo, buildTextCell, getFillSourceValue, selectionData, rowIndex, rowData, columnIndex, cellData, selectionRows, selectionCols, fillValues, fillCount, columnIndex, sourceValues, sourceCells, rowIndex, cellValue, textInfo, columnData, actualFillType, newValues, i, targetRowIndex, targetColumnIndex, sourceRowIndex, sourceCellData, shouldNormalizeSeriesNumberFormat_1, fillCount, columnIndex, sourceValues, sourceCells, rowIndex, cellValue, textInfo, columnData, actualFillType, newValues, i, targetRowIndex, targetColumnIndex, sourceRowIndex, sourceCellData, shouldNormalizeSeriesNumberFormat_2, fillCount, rowIndex, sourceValues, sourceCells, textSourceCellData, columnIndex, cellValue, textInfo, rowData, actualFillType, newValues, targetRowIndex, i, targetColumnIndex, sourceColumnIndex, sourceCellData, shouldNormalizeSeriesNumberFormat_3, fillCount, rowIndex, sourceValues, sourceCells, textSourceCellData, columnIndex, cellValue, textInfo, rowData, actualFillType, newValues, targetRowIndex, i, targetColumnIndex, sourceColumnIndex, sourceCellData, shouldNormalizeSeriesNumberFormat_4;
-    var _c, _d, _e, _f;
-    var sheetId = _b.sheetId, direction = _b.direction, selection = _b.selection, fillBounds = _b.fillBounds, getCellData = _b.getCellData, getEffectiveValue = _b.getEffectiveValue, getFormattedValue = _b.getFormattedValue, getSheetName = _b.getSheetName, getDataValidationById = _b.getDataValidationById, cellXfsRegistry = _b.cellXfsRegistry, locale = _b.locale, fillType = _b.fillType, customAutofillLists = _b.customAutofillLists;
-    return __generator(this, function (_g) {
+    var sheetCell, activeSheetName, buildTextCell, readFillSource, toCellValue, writeFillValue, fillValues, vertical, descending, range, block, stride, lineStride, lineCount, seedCount, span, fillCount, snapped, seedCoord, targetCoord, originRow, originColumn, place, lines, line, sourceValues, sourceMeta, k, _c, rowIndex, columnIndex, _d, value, meta, fillType, isFormatsOnly, isValuesOnly, seriesFillType, formatsOnlyCell, finalizeCell, computeLine, coveredCell, placeBlock, markUntouched, line, _e, sourceValues, sourceMeta, _f, lineFillType, newValues, seeds, untouchedTail, seeds_1, seeds_1_1, seed, from, sourceCellData, i, target, k, from, sourceCellData;
+    var e_3, _g;
+    var _h;
+    var sheetId = _b.sheetId, direction = _b.direction, selection = _b.selection, fillBounds = _b.fillBounds, getCellData = _b.getCellData, getEffectiveValue = _b.getEffectiveValue, getFormattedValue = _b.getFormattedValue, getSheetName = _b.getSheetName, getDataValidationById = _b.getDataValidationById, cellXfsRegistry = _b.cellXfsRegistry, locale = _b.locale, requestedFillType = _b.fillType, modifier = _b.modifier, series = _b.series, customAutofillLists = _b.customAutofillLists, merges = _b.merges;
+    return __generator(this, function (_j) {
         sheetCell = new SheetCell();
         activeSheetName = getSheetName(sheetId);
-        textCell = new SheetCell();
-        getTextInfo = function (cells) {
-            var e_2, _a;
-            var _b, _c, _d, _e, _f;
-            try {
-                for (var cells_1 = __values(cells), cells_1_1 = cells_1.next(); !cells_1_1.done; cells_1_1 = cells_1.next()) {
-                    var _g = cells_1_1.value, rowIndex = _g.rowIndex, columnIndex = _g.columnIndex;
-                    var cellData = getCellData(sheetId, rowIndex, columnIndex);
-                    textCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
-                        locale: locale,
-                        cellXfsRegistry: cellXfsRegistry,
-                        getDataValidationById: getDataValidationById,
-                    });
-                    if (((_b = textCell.getNumberFormat()) === null || _b === void 0 ? void 0 : _b.type) === "TEXT") {
-                        var fallback = getFillSourceValue(sheetId, rowIndex, columnIndex);
-                        return {
-                            isText: true,
-                            textValue: (_d = (_c = textCell.getUserEnteredValue()) !== null && _c !== void 0 ? _c : textCell.getEffectiveValue()) !== null && _d !== void 0 ? _d : String(fallback !== null && fallback !== void 0 ? fallback : ""),
-                            pattern: (_f = (_e = textCell.getNumberFormat()) === null || _e === void 0 ? void 0 : _e.pattern) !== null && _f !== void 0 ? _f : "General",
-                        };
-                    }
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (cells_1_1 && !cells_1_1.done && (_a = cells_1.return)) _a.call(cells_1);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-            return { isText: false, textValue: "", pattern: "General" };
-        };
         buildTextCell = function (sourceCellData, value, pattern) {
             var newCell = new SheetCell();
             newCell.assign(sheetId, { rowIndex: selection.range.startRowIndex, columnIndex: 0 }, sourceCellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
@@ -694,7 +1374,7 @@ export var getAutoFillValues = function (_a) { return __awaiter(void 0, [_a], vo
             newCell.setUserEnteredValue(value);
             return newCell.getCellData();
         };
-        getFillSourceValue = function (sheetId, rowIndex, columnIndex) {
+        readFillSource = function (rowIndex, columnIndex) {
             var _a;
             var cellData = getCellData(sheetId, rowIndex, columnIndex);
             sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
@@ -702,256 +1382,344 @@ export var getAutoFillValues = function (_a) { return __awaiter(void 0, [_a], vo
                 cellXfsRegistry: cellXfsRegistry,
                 getDataValidationById: getDataValidationById,
             });
-            var numFmtType = (_a = sheetCell.getNumberFormat()) === null || _a === void 0 ? void 0 : _a.type;
-            var isDateTime = numFmtType === "DATE" || numFmtType === "DATE_TIME";
-            var isText = numFmtType === "TEXT";
+            var numberFormat = sheetCell.getNumberFormat();
+            var numFmtType = numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type;
+            var isDateTime = isDateLikeFormatType(numFmtType);
+            var textFormat = numFmtType === "TEXT";
+            var userEntered = sheetCell.getUserEnteredValue();
+            var quotePrefixed = !sheetCell.isFormula() && hasExcelTextPrefix(userEntered);
+            var value;
             if (isDateTime) {
                 var effectiveValue = getEffectiveValue === null || getEffectiveValue === void 0 ? void 0 : getEffectiveValue(sheetId, rowIndex, columnIndex);
-                if (typeof effectiveValue === "number") {
-                    return toDate(effectiveValue, sheetCell.use1904);
-                }
-                return getFormattedValue === null || getFormattedValue === void 0 ? void 0 : 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 === null || getFormattedValue === void 0 ? void 0 : getFormattedValue(sheetId, rowIndex, columnIndex);
+            }
+            else if (textFormat) {
+                value = userEntered !== null && userEntered !== void 0 ? userEntered : sheetCell.getEffectiveValue();
             }
-            var cellValue = isText
-                ? sheetCell.getUserEnteredValue()
-                : getEffectiveValue === null || getEffectiveValue === void 0 ? void 0 : getEffectiveValue(sheetId, rowIndex, columnIndex);
-            return cellValue;
+            else {
+                value = getEffectiveValue === null || getEffectiveValue === void 0 ? void 0 : getEffectiveValue(sheetId, rowIndex, columnIndex);
+            }
+            if (quotePrefixed && hasExcelTextPrefix(value)) {
+                value = value.slice(1);
+            }
+            var textTyped = textFormat ||
+                quotePrefixed ||
+                (!sheetCell.isFormula() &&
+                    typeof userEntered === "string" &&
+                    typeof value === "string");
+            return {
+                value: value,
+                meta: {
+                    textFormat: textFormat,
+                    textPattern: (_a = numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.pattern) !== null && _a !== void 0 ? _a : "General",
+                    quotePrefixed: quotePrefixed,
+                    textTyped: textTyped,
+                    formula: sheetCell.isFormula(),
+                },
+            };
+        };
+        toCellValue = function (value) {
+            var _a;
+            if (!(value instanceof Date))
+                return value;
+            if (!isDateLikeFormatType((_a = sheetCell.getNumberFormat()) === null || _a === void 0 ? void 0 : _a.type))
+                return value;
+            return isTimeOnlyDate(value)
+                ? dateToSerial(value)
+                : toSerial(value, sheetCell.use1904);
         };
-        selectionData = [];
-        for (rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-            rowData = [];
-            for (columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-                cellData = getFillSourceValue(sheetId, rowIndex, columnIndex);
-                rowData.push(cellData || null);
+        writeFillValue = function (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();
             }
-            selectionData.push(rowData);
-        }
-        selectionRows = selection.range.endRowIndex - selection.range.startRowIndex + 1;
-        selectionCols = selection.range.endColumnIndex - selection.range.startColumnIndex + 1;
+            if (meta.textFormat) {
+                return buildTextCell(sourceCellData, value == null ? "" : String(value), meta.textPattern);
+            }
+            if (meta.quotePrefixed && typeof value === "string" && value !== "") {
+                sheetCell.setUserEnteredValue("'".concat(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("'".concat(value));
+            }
+            return sheetCell.getCellData();
+        };
         fillValues = [];
-        switch (direction) {
-            case Direction.Down: {
-                fillCount = fillBounds.endRowIndex - selection.range.endRowIndex;
-                for (columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-                    sourceValues = [];
-                    sourceCells = [];
-                    for (rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-                        cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
-                        sourceValues.push(cellValue);
-                        sourceCells.push({ rowIndex: rowIndex, columnIndex: columnIndex });
-                    }
-                    textInfo = getTextInfo(sourceCells);
-                    columnData = [sourceValues];
-                    actualFillType = fillType || detectFillType(columnData, locale, customAutofillLists);
-                    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 (i = 0; i < fillCount; i++) {
-                        targetRowIndex = selection.range.endRowIndex + 1 + i;
-                        targetColumnIndex = columnIndex;
-                        if (!fillValues[i])
-                            fillValues[i] = [];
-                        if (actualFillType === "FillFormats") {
-                            // Copy format but not value
-                            fillValues[i][targetColumnIndex - fillBounds.startColumnIndex] =
-                                "";
-                        }
-                        else {
-                            sourceRowIndex = selection.range.startRowIndex + (i % selectionRows);
-                            sourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, sourceRowIndex, columnIndex);
-                            sheetCell.assign(sheetId, { rowIndex: sourceRowIndex, columnIndex: columnIndex }, sourceCellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
-                            if (sheetCell.isFormula()) {
-                                sheetCell.moveFormula({ rowIndex: sourceRowIndex, columnIndex: 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((_c = newValues[i]) !== null && _c !== void 0 ? _c : ""), textInfo.pattern);
-                                continue;
-                            }
-                            else {
-                                shouldNormalizeSeriesNumberFormat_1 = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
-                                if (shouldNormalizeSeriesNumberFormat_1) {
-                                    clearCellNumberFormatForSeries(sheetCell);
-                                }
-                                sheetCell.setUserEnteredValue(newValues[i]);
-                            }
-                            fillValues[i][targetColumnIndex - fillBounds.startColumnIndex] =
-                                sheetCell.getCellData();
-                        }
-                    }
+        vertical = direction === Direction.Down || direction === Direction.Up;
+        descending = direction === Direction.Up || direction === Direction.Left;
+        range = selection.range;
+        block = resolveMergedFillBlock(range, merges);
+        stride = block ? (vertical ? block.rows : block.cols) : 1;
+        lineStride = block ? (vertical ? block.cols : block.rows) : 1;
+        lineCount = (vertical
+            ? range.endColumnIndex - range.startColumnIndex + 1
+            : range.endRowIndex - range.startRowIndex + 1) / lineStride;
+        seedCount = (vertical
+            ? range.endRowIndex - range.startRowIndex + 1
+            : range.endColumnIndex - range.startColumnIndex + 1) / stride;
+        span = (function () {
+            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;
+            }
+        })();
+        fillCount = Math.floor(Math.max(span, 0) / stride);
+        snapped = __assign({}, 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 = [];
+        }
+        seedCoord = function (line, k) {
+            if (vertical) {
+                var columnIndex_1 = range.startColumnIndex + line * lineStride;
+                var rowIndex_1 = descending
+                    ? range.endRowIndex - (stride - 1) - k * stride
+                    : range.startRowIndex + k * stride;
+                return { rowIndex: rowIndex_1, columnIndex: columnIndex_1 };
+            }
+            var rowIndex = range.startRowIndex + line * lineStride;
+            var columnIndex = descending
+                ? range.endColumnIndex - (stride - 1) - k * stride
+                : range.startColumnIndex + k * stride;
+            return { rowIndex: rowIndex, columnIndex: columnIndex };
+        };
+        targetCoord = function (line, i) {
+            if (vertical) {
+                var columnIndex_2 = range.startColumnIndex + line * lineStride;
+                var rowIndex_2 = descending
+                    ? range.startRowIndex - (i + 1) * stride
+                    : range.endRowIndex + 1 + i * stride;
+                return { rowIndex: rowIndex_2, columnIndex: columnIndex_2 };
+            }
+            var rowIndex = range.startRowIndex + line * lineStride;
+            var columnIndex = descending
+                ? range.startColumnIndex - (i + 1) * stride
+                : range.endColumnIndex + 1 + i * stride;
+            return { rowIndex: rowIndex, columnIndex: columnIndex };
+        };
+        originRow = direction === Direction.Down ? range.endRowIndex + 1 : snapped.startRowIndex;
+        originColumn = direction === Direction.Right
+            ? range.endColumnIndex + 1
+            : snapped.startColumnIndex;
+        place = function (target, cell) {
+            var r = target.rowIndex - originRow;
+            var c = target.columnIndex - originColumn;
+            if (!fillValues[r])
+                fillValues[r] = [];
+            fillValues[r][c] = cell;
+        };
+        lines = [];
+        for (line = 0; line < lineCount; line++) {
+            sourceValues = [];
+            sourceMeta = [];
+            for (k = 0; k < seedCount; k++) {
+                _c = seedCoord(line, k), rowIndex = _c.rowIndex, columnIndex = _c.columnIndex;
+                _d = readFillSource(rowIndex, columnIndex), value = _d.value, meta = _d.meta;
+                sourceValues.push(value);
+                sourceMeta.push(meta);
+            }
+            lines.push({ sourceValues: sourceValues, sourceMeta: sourceMeta });
+        }
+        fillType = (function () {
+            if (requestedFillType)
+                return requestedFillType;
+            if (modifier !== "toggle")
+                return undefined;
+            var detectedPerLine = lines.map(function (_a) {
+                var sourceValues = _a.sourceValues, sourceMeta = _a.sourceMeta;
+                if (sourceMeta.every(function (m) { return m.formula; }))
+                    return undefined;
+                if (sourceValues.every(function (v) { return v == null || v === ""; }))
+                    return undefined;
+                return generateLineSeries(sourceValues, 1, {
+                    locale: locale,
+                    customAutofillLists: customAutofillLists,
+                    descending: descending,
+                }).fillType;
+            });
+            return resolveToggledFillType(detectedPerLine);
+        })();
+        isFormatsOnly = isFormatsOnlyFillType(fillType);
+        isValuesOnly = isValuesOnlyFillType(fillType);
+        seriesFillType = isFormatsOnly || isValuesOnly ? undefined : fillType;
+        formatsOnlyCell = function (source, target) {
+            var _a, _b;
+            var sourceUf = (_a = getCellData(sheetId, source.rowIndex, source.columnIndex)) === null || _a === void 0 ? void 0 : _a.uf;
+            var _c = ((_b = getCellData(sheetId, target.rowIndex, target.columnIndex)) !== null && _b !== void 0 ? _b : {}), _targetUf = _c.uf, rest = __rest(_c, ["uf"]);
+            return (sourceUf === undefined ? rest : __assign(__assign({}, rest), { uf: sourceUf }));
+        };
+        finalizeCell = function (cell, target) {
+            var _a;
+            if (!isValuesOnly)
+                return cell;
+            var targetUf = (_a = getCellData(sheetId, target.rowIndex, target.columnIndex)) === null || _a === void 0 ? void 0 : _a.uf;
+            var _b = cell, _sourceUf = _b.uf, rest = __rest(_b, ["uf"]);
+            return (targetUf === undefined ? rest : __assign(__assign({}, rest), { uf: targetUf }));
+        };
+        computeLine = function (sourceValues, count) {
+            if (series) {
+                var specLine = generateSeriesSpecValues(sourceValues, series, count, locale);
+                if (specLine) {
+                    return {
+                        fillType: seriesFillType !== null && seriesFillType !== void 0 ? seriesFillType : "FillSeries",
+                        values: specLine.values,
+                        seeds: specLine.seeds,
+                        untouchedTail: true,
+                    };
                 }
-                break;
             }
-            case Direction.Up: {
-                fillCount = selection.range.startRowIndex - fillBounds.startRowIndex;
-                for (columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-                    sourceValues = [];
-                    sourceCells = [];
-                    for (rowIndex = selection.range.endRowIndex; rowIndex >= selection.range.startRowIndex; rowIndex--) {
-                        cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
-                        sourceValues.push(cellValue);
-                        sourceCells.push({ rowIndex: rowIndex, columnIndex: columnIndex });
-                    }
-                    textInfo = getTextInfo(sourceCells);
-                    columnData = [sourceValues];
-                    actualFillType = fillType || detectFillType(columnData, locale, customAutofillLists);
-                    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 (i = 0; i < fillCount; i++) {
-                        targetRowIndex = selection.range.startRowIndex - 1 - i;
-                        targetColumnIndex = columnIndex;
-                        if (!fillValues[fillCount - 1 - i])
-                            fillValues[fillCount - 1 - i] = [];
-                        if (actualFillType === "FillFormats") {
-                            fillValues[fillCount - 1 - i][targetColumnIndex - fillBounds.startColumnIndex] = "";
-                        }
-                        else {
-                            sourceRowIndex = selection.range.endRowIndex - (i % selectionRows);
-                            sourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, sourceRowIndex, columnIndex);
-                            sheetCell.assign(sheetId, { rowIndex: sourceRowIndex, columnIndex: columnIndex }, sourceCellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
-                            if (sheetCell.isFormula()) {
-                                sheetCell.moveFormula({ rowIndex: sourceRowIndex, columnIndex: 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((_d = newValues[i]) !== null && _d !== void 0 ? _d : ""), textInfo.pattern);
-                                continue;
-                            }
-                            else {
-                                shouldNormalizeSeriesNumberFormat_2 = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
-                                if (shouldNormalizeSeriesNumberFormat_2) {
-                                    clearCellNumberFormatForSeries(sheetCell);
-                                }
-                                sheetCell.setUserEnteredValue(newValues[i]);
-                            }
-                            fillValues[fillCount - 1 - i][targetColumnIndex - fillBounds.startColumnIndex] = sheetCell.getCellData();
-                        }
-                    }
+            if (seriesFillType) {
+                var 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: values };
             }
-            case Direction.Right: {
-                fillCount = fillBounds.endColumnIndex - selection.range.endColumnIndex;
-                for (rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-                    sourceValues = [];
-                    sourceCells = [];
-                    textSourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, rowIndex, selection.range.startColumnIndex);
-                    for (columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-                        cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
-                        sourceValues.push(cellValue);
-                        sourceCells.push({ rowIndex: rowIndex, columnIndex: columnIndex });
-                    }
-                    textInfo = getTextInfo(sourceCells);
-                    rowData = [sourceValues];
-                    actualFillType = fillType || detectFillType(rowData, locale);
-                    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);
-                    }
-                    targetRowIndex = rowIndex - fillBounds.startRowIndex;
-                    if (!fillValues[targetRowIndex])
-                        fillValues[targetRowIndex] = [];
-                    for (i = 0; i < fillCount; i++) {
-                        targetColumnIndex = selection.range.endColumnIndex + 1 + i;
-                        if (actualFillType === "FillFormats") {
-                            fillValues[targetRowIndex][i] = "";
-                        }
-                        else if (textInfo.isText) {
-                            fillValues[targetRowIndex][i] = buildTextCell(textSourceCellData, String((_e = newValues[i]) !== null && _e !== void 0 ? _e : ""), textInfo.pattern);
-                        }
-                        else {
-                            sourceColumnIndex = selection.range.startColumnIndex + (i % selectionCols);
-                            sourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, rowIndex, sourceColumnIndex);
-                            sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: sourceColumnIndex }, sourceCellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
-                            if (sheetCell.isFormula()) {
-                                sheetCell.moveFormula({ rowIndex: rowIndex, columnIndex: sourceColumnIndex }, { rowIndex: rowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
-                                // Remove effective value for formulas
-                                sheetCell.clearEffectiveValueForFormula();
-                            }
-                            else {
-                                shouldNormalizeSeriesNumberFormat_3 = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
-                                if (shouldNormalizeSeriesNumberFormat_3) {
-                                    clearCellNumberFormatForSeries(sheetCell);
-                                }
-                                sheetCell.setUserEnteredValue(newValues[i]);
-                            }
-                            fillValues[targetRowIndex][i] = sheetCell.getCellData();
-                        }
-                    }
+            return generateLineSeries(sourceValues, count, {
+                locale: locale,
+                customAutofillLists: customAutofillLists,
+                descending: descending,
+            });
+        };
+        coveredCell = function (target, sourceCovered) {
+            var _a;
+            var targetCell = getCellData(sheetId, target.rowIndex, target.columnIndex);
+            var sourceUf = (_a = getCellData(sheetId, sourceCovered.rowIndex, sourceCovered.columnIndex)) === null || _a === void 0 ? void 0 : _a.uf;
+            if (isFormatsOnly) {
+                return sourceUf === undefined
+                    ? (targetCell !== null && targetCell !== void 0 ? targetCell : undefined)
+                    : __assign(__assign({}, (targetCell !== null && targetCell !== void 0 ? targetCell : {})), { uf: sourceUf });
+            }
+            var uf = isValuesOnly ? targetCell === null || targetCell === void 0 ? void 0 : targetCell.uf : sourceUf;
+            return uf === undefined ? undefined : { uf: uf };
+        };
+        placeBlock = function (target, cell, from) {
+            var _a;
+            place(target, cell);
+            if (!block)
+                return;
+            var landed = {
+                startRowIndex: target.rowIndex,
+                endRowIndex: target.rowIndex + block.rows - 1,
+                startColumnIndex: target.columnIndex,
+                endColumnIndex: target.columnIndex + block.cols - 1,
+            };
+            for (var r = landed.startRowIndex; r <= landed.endRowIndex; r++) {
+                for (var 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: {
-                fillCount = selection.range.startColumnIndex - fillBounds.startColumnIndex;
-                for (rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-                    sourceValues = [];
-                    sourceCells = [];
-                    textSourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, rowIndex, selection.range.endColumnIndex);
-                    for (columnIndex = selection.range.endColumnIndex; columnIndex >= selection.range.startColumnIndex; columnIndex--) {
-                        cellValue = getFillSourceValue(sheetId, rowIndex, columnIndex);
-                        sourceValues.push(cellValue);
-                        sourceCells.push({ rowIndex: rowIndex, columnIndex: columnIndex });
-                    }
-                    textInfo = getTextInfo(sourceCells);
-                    rowData = [sourceValues];
-                    actualFillType = fillType || detectFillType(rowData, locale);
-                    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);
+            (_a = fillValues.fillMerges) === null || _a === void 0 ? void 0 : _a.push(landed);
+        };
+        markUntouched = function (target) {
+            var _a, _b;
+            var rows = (_a = block === null || block === void 0 ? void 0 : block.rows) !== null && _a !== void 0 ? _a : 1;
+            var cols = (_b = block === null || block === void 0 ? void 0 : block.cols) !== null && _b !== void 0 ? _b : 1;
+            for (var r = 0; r < rows; r++) {
+                for (var c = 0; c < cols; c++) {
+                    place({ rowIndex: target.rowIndex + r, columnIndex: target.columnIndex + c }, FILL_UNTOUCHED);
+                }
+            }
+        };
+        for (line = 0; line < lineCount; line++) {
+            _e = lines[line], sourceValues = _e.sourceValues, sourceMeta = _e.sourceMeta;
+            _f = computeLine(sourceValues, fillCount), lineFillType = _f.fillType, newValues = _f.values, seeds = _f.seeds, untouchedTail = _f.untouchedTail;
+            // 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 === null || seeds === void 0 ? void 0 : seeds.length) && !isFormatsOnly) {
+                (_h = fillValues.seedCells) !== null && _h !== void 0 ? _h : (fillValues.seedCells = []);
+                try {
+                    for (seeds_1 = (e_3 = void 0, __values(seeds)), seeds_1_1 = seeds_1.next(); !seeds_1_1.done; seeds_1_1 = seeds_1.next()) {
+                        seed = seeds_1_1.value;
+                        from = seedCoord(line, seed.index);
+                        sourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, from.rowIndex, from.columnIndex);
+                        sheetCell.assign(sheetId, from, sourceCellData, {
+                            locale: locale,
+                            cellXfsRegistry: cellXfsRegistry,
+                            getDataValidationById: getDataValidationById,
+                        });
+                        fillValues.seedCells.push({
+                            rowIndex: from.rowIndex,
+                            columnIndex: from.columnIndex,
+                            cell: finalizeCell(writeFillValue(seed.value, sourceMeta[seed.index], sourceCellData, from, from, lineFillType), from),
+                        });
                     }
-                    targetRowIndex = rowIndex - fillBounds.startRowIndex;
-                    if (!fillValues[targetRowIndex])
-                        fillValues[targetRowIndex] = [];
-                    for (i = 0; i < fillCount; i++) {
-                        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((_f = newValues[i]) !== null && _f !== void 0 ? _f : ""), textInfo.pattern);
-                        }
-                        else {
-                            sourceColumnIndex = selection.range.endColumnIndex - (i % selectionCols);
-                            sourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, rowIndex, sourceColumnIndex);
-                            sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: sourceColumnIndex }, sourceCellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
-                            if (sheetCell.isFormula()) {
-                                sheetCell.moveFormula({ rowIndex: rowIndex, columnIndex: sourceColumnIndex }, { rowIndex: rowIndex, columnIndex: targetColumnIndex }, activeSheetName, { preserveAbsolutes: true });
-                                // Remove effective value for formulas
-                                sheetCell.clearEffectiveValueForFormula();
-                            }
-                            else {
-                                shouldNormalizeSeriesNumberFormat_4 = shouldNormalizeSeriesNumberFormatForCell(sheetCell, actualFillType, newValues[i]);
-                                if (shouldNormalizeSeriesNumberFormat_4) {
-                                    clearCellNumberFormatForSeries(sheetCell);
-                                }
-                                sheetCell.setUserEnteredValue(newValues[i]);
-                            }
-                            fillValues[targetRowIndex][fillCount - 1 - i] =
-                                sheetCell.getCellData();
-                        }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (seeds_1_1 && !seeds_1_1.done && (_g = seeds_1.return)) _g.call(seeds_1);
                     }
+                    finally { if (e_3) throw e_3.error; }
                 }
-                break;
+            }
+            for (i = 0; i < fillCount; i++) {
+                target = targetCoord(line, i);
+                k = i % seedCount;
+                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;
+                }
+                sourceCellData = getCellData === null || getCellData === void 0 ? void 0 : getCellData(sheetId, from.rowIndex, from.columnIndex);
+                sheetCell.assign(sheetId, from, sourceCellData, {
+                    locale: locale,
+                    cellXfsRegistry: cellXfsRegistry,
+                    getDataValidationById: getDataValidationById,
+                });
+                placeBlock(target, finalizeCell(writeFillValue(newValues[i], sourceMeta[k], sourceCellData, from, target, lineFillType), target), from);
             }
         }
         return [2 /*return*/, fillValues];