reamkit 1.32.0 → 1.32.1

package/dist/esm/core/number-format.js

@@ -95,8 +95,17 @@ var FORMAT_COLORS = new Map([
 	["white", "FFFFFF"],
 	["yellow", "FFFF00"]
 ]);
+var BRACKET_CODE = /\[([^\]]*)\]/g;
+function bracketCodes(format) {
+	return format.slice(0, format.lastIndexOf("]") + 1).matchAll(BRACKET_CODE);
+}
+/** The format with each `[…]` code replaced by what `fn` makes of its inside. */
+function replaceBracketCodes(format, fn) {
+	const end = format.lastIndexOf("]") + 1;
+	return format.slice(0, end).replace(BRACKET_CODE, (_, body) => fn(body)) + format.slice(end);
+}
 function colorOfSection(section) {
-	for (const m of section.matchAll(/\[([^\]]*)\]/g)) {
+	for (const m of bracketCodes(section)) {
 		const body = m[1].trim().toLowerCase();
 		const named = FORMAT_COLORS.get(body);
 		if (named !== void 0) return named;
@@ -251,7 +260,7 @@ function hasElapsedToken(code) {
 	return /\[(?:h+|m+|s+)\]/i.test(code.replace(/"[^"]*"/g, ""));
 }
 function isDateFormat(code) {
-	const cleaned = code.replace(/"[^"]*"/g, "").replace(/\[[^\]]*\]/g, "");
+	const cleaned = replaceBracketCodes(code.replace(/"[^"]*"/g, ""), () => "");
 	return /[dyhs]|m+/i.test(cleaned) && /[dyhs]/i.test(cleaned);
 }
 function tokenizeDateFormat(format) {
@@ -442,9 +451,12 @@ function formatExcelDate(rawValue, format, date1904) {
 		case "elapsed-s":
 			out += elapsed(totalSeconds, t.text.length);
 			break;
-		case "subsec":
-			out += (totalSeconds - Math.floor(totalSeconds)).toFixed(subsecDigits).substring(1);
+		case "subsec": {
+			const places = Math.min(subsecDigits, 100);
+			const fraction = (totalSeconds - Math.floor(totalSeconds)).toFixed(places);
+			out += fraction.substring(1) + "0".repeat(subsecDigits - places);
 			break;
+		}
 		case "m":
 			out += t.text.length >= 2 ? pad2(minute) : String(minute);
 			break;
@@ -469,23 +481,28 @@ function excelExponent(rendered) {
 	return `${m[1]}E${m[2] === "-" ? "-" : "+"}${m[3].padStart(2, "0")}`;
 }
 /**
-* A General number rounded to the decimals that fit `maxChars` characters.
-*
-* General is not a fixed format: a spreadsheet shows as many decimal places as
-* the column has room for and ROUNDS to that, so 4.3900875881221957 in a
-* column eight characters wide reads 4.390088. We rendered every stored digit
-* and let the cell clip it, which turns the same value into 4.390087 — off by
-* one in the last place shown, with nothing to say a digit was cut.
+* The most characters General writes in a cell, its sign apart: however wide
+* the column, 123456789012345 is 1.23457E+14 and 0.123456789012345 is
+* 0.123456789 — Excel's own PDF (2026-10-02).
+*/
+var GENERAL_CELL_CHARS = 11;
+/**
+* A General number in its column: the most precise of the ways General may
+* write it ({@link generalRenderings}) that `fits`.
 *
-* The integer part is never dropped: a number too wide even without decimals
-* keeps them all and the cell says so its own way (see hashOnOverflow).
+* General is not a fixed format: a spreadsheet shows as many places as the
+* column has room for and ROUNDS to that, so 4.3900875881221957 in a column
+* eight characters wide reads 4.390088. We rendered every stored digit and let
+* the cell clip it, which turns the same value into 4.390087 — off by one in
+* the last place shown, with nothing to say a digit was cut. A number too wide
+* for every way of writing it comes back in its finest, and the cell fills
+* with `#` (CellProperties.hashOnOverflow); one under 1 always fits as `0` or
+* `-0`, which is what Excel prints in a column too narrow for anything else.
 *
-* `fits` decides, and it must measure in the face this will be DRAWN in rather
-* than count characters against the column's width in the document's unit.
-* Counted that way we produced nine digits for a column that holds nine of
-* Excel's and eight of ours, and the layout clipped the ninth — the very
-* truncation this exists to prevent. Fewer digits than the reference shows is a
-* coarser number; a clipped one is a different number.
+* `fits` decides whether a rendering has room. The print model asks it in the
+* document's own terms — the column's width less the padding it carries, in
+* the font's widest digits — because that is the room Excel gives up places
+* against, whatever face the page is drawn in.
 *
 * @param rawValue The cell's stored value.
 * @param fits     Whether a rendering will fit the cell.
@@ -493,36 +510,100 @@ function excelExponent(rendered) {
 function generalToWidth(rawValue, fits) {
 	const n = Number(rawValue);
 	if (!Number.isFinite(n)) return defaultNumberRender(rawValue);
-	const full = defaultNumberRender(rawValue);
-	if (fits(full)) return full;
-	const dot = full.indexOf(".");
-	if (dot < 0) return scientificToWidth(n, fits) ?? full;
-	let shortened = full;
-	for (let decimals = full.length - dot - 2; decimals >= 0; decimals--) {
-		const shifted = Number(`${Number(n.toPrecision(15))}e${decimals}`);
-		const rounded = shifted < 0 ? -Math.round(-shifted) : Math.round(shifted);
-		const back = Number(`${rounded}e${-decimals}`);
-		if (!Number.isFinite(back)) break;
-		shortened = defaultNumberRender(String(back));
-		if (fits(shortened)) return shortened;
+	let widest;
+	for (const text of generalRenderings(n, GENERAL_CELL_CHARS)) {
+		if (fits(text)) return text;
+		widest ??= text;
 	}
-	return scientificToWidth(n, fits) ?? shortened;
+	return widest ?? defaultNumberRender(rawValue);
 }
 /**
-* `value` in scientific notation with as many mantissa decimals as `fits`
-* allows, spelled Excel's way: an upper-case `E`, a signed exponent of at least
-* two digits. Undefined when even a bare `1E+09` will not fit — the cell then
-* says so with hashes rather than shrinking further.
+* Every way General may write `value` in `chars` characters, the most precise
+* first. One rule, measured in Excel's own PDF on chart axes, which give it
+* nine characters with the sign among them, and in cells, eleven with the
+* sign apart (2026-10-01/02):
+*
+*  - the number as it is, its first 15 significant digits, where that fits:
+*    0.000012345, 0.0000003, 12345678901;
+*  - else rounded to fewer places or written in scientific notation, whichever
+*    keeps the finer last digit — 0.123456789, not 1.23457E-01; 1.23457E-10,
+*    not 0; 4E-04, not 0, in a column five characters wide — and of two as
+*    fine, the plain one down to 0.0001 and the scientific one below it: 0.0001
+*    for 0.000123456 but 1E-05 for 1.00049E-05;
+*  - a whole part longer than the room only in scientific notation, and never
+*    with the zeros a mantissa or a fraction ends in: 1E+10, 2.5E+12.
+*
+* The digits are the 15 of {@link decimalOf}, rounded half away from zero, so
+* 1.2345E-05 is 1.235E-05, where `toExponential` rounded the binary double
+* down to 1.234E-05.
+*
+* @param value      The number.
+* @param chars      How many characters General has.
+* @param signCounts Whether a minus sign takes one of them.
+* @returns The renderings, sign included, finest first.
 */
-function scientificToWidth(value, fits) {
-	for (let decimals = MAX_SCIENTIFIC_DECIMALS; decimals >= 0; decimals--) {
-		const [mantissa, exp] = value.toExponential(decimals).split("e");
-		const out = `${mantissa}E${exp.startsWith("-") ? "-" : "+"}${exp.replace(/^[-+]/, "").padStart(2, "0")}`;
-		if (fits(out)) return out;
+function* generalRenderings(value, chars, signCounts = false) {
+	if (value === 0 || !Number.isFinite(value)) {
+		yield value === 0 ? "0" : String(value);
+		return;
+	}
+	const sign = value < 0 ? "-" : "";
+	const room = chars - (signCounts ? sign.length : 0);
+	const { digits, exponent } = decimalOf(value);
+	let shown = digits.length;
+	while (shown > 1 && digits[shown - 1] === "0") shown--;
+	const exactPlaces = Math.max(0, shown - 1 - exponent);
+	const exact = placeDigits(digits, exponent, exactPlaces);
+	if (exact.length <= room) yield sign + exact;
+	const forms = [];
+	if (exponent < room) {
+		const most = Math.min(exactPlaces, room - Math.max(exponent, 0) - 2);
+		for (let places = Math.max(0, most); places >= 0; places--) {
+			const text = withoutTrailingZeros(placeDigits(digits, exponent, places));
+			if (text.length <= room) forms.push({
+				text,
+				place: -decimalsIn(text),
+				plain: true
+			});
+		}
+	}
+	const tail = (e) => `E${e < 0 ? "-" : "+"}${String(Math.abs(e)).padStart(2, "0")}`;
+	for (let places = Math.max(0, room - tail(exponent).length - 2); places >= 0; places--) {
+		let e = exponent;
+		let mantissa = placeDigits(digits, 0, places);
+		if (mantissa.length > 1 && mantissa[1] !== ".") {
+			e += 1;
+			mantissa = placeDigits("1", 0, places);
+		}
+		const stripped = withoutTrailingZeros(mantissa);
+		const text = stripped + tail(e);
+		if (text.length <= room) forms.push({
+			text,
+			place: e - decimalsIn(stripped),
+			plain: false
+		});
+	}
+	const plainFirst = exponent >= -4;
+	forms.sort((a, b) => a.place - b.place || (a.plain === b.plain ? 0 : a.plain === plainFirst ? -1 : 1));
+	const seen = new Set(exact.length <= room ? [exact] : []);
+	for (const form of forms) {
+		if (seen.has(form.text)) continue;
+		seen.add(form.text);
+		yield sign + form.text;
 	}
 }
-/** Excel never shows more mantissa decimals than this under General. */
-var MAX_SCIENTIFIC_DECIMALS = 10;
+/** A decimal without the zeros that end its fraction, nor a point left bare. */
+function withoutTrailingZeros(fixed) {
+	if (!fixed.includes(".")) return fixed;
+	let end = fixed.length;
+	while (fixed[end - 1] === "0") end--;
+	return fixed.slice(0, fixed[end - 1] === "." ? end - 1 : end);
+}
+/** How many places a plain decimal shows after its point. */
+var decimalsIn = (fixed) => {
+	const dot = fixed.indexOf(".");
+	return dot < 0 ? 0 : fixed.length - dot - 1;
+};
 function applyFormatString(rawValue, format) {
 	const n = Number(rawValue);
 	const sections = splitSections(format);
@@ -571,6 +652,43 @@ function countDigitPlaceholders(s) {
 	return n;
 }
 /**
+* The decimal a spreadsheet takes a double for: its first 15 significant
+* digits, and the power of ten the first of them stands at.
+*
+* Excel shows a number as those 15 digits and zeros after them, however many
+* places its format asks for: 0.1 under thirty places is 0.1 and twenty-nine
+* zeros, 1/3 is fifteen threes and zeros, 1E+21 under `0.00` is a 1, twenty-one
+* zeros and `.00` — its own PDF of each (2026-10-01).
+*/
+function decimalOf(value) {
+	const [mantissa, exponent] = Math.abs(value).toExponential(14).split("e");
+	return {
+		digits: mantissa.replace(".", ""),
+		exponent: Number(exponent)
+	};
+}
+/**
+* Those digits at `decimals` places — the first standing at `exponent` —
+* rounded half away from zero, as plain digits with a point and no sign.
+*/
+function placeDigits(digits, exponent, decimals) {
+	const kept = exponent + 1 + decimals;
+	let units;
+	if (kept >= digits.length) units = digits + "0".repeat(kept - digits.length);
+	else if (kept < 0) units = "";
+	else units = digits[kept] >= "5" ? incremented(digits.slice(0, kept)) : digits.slice(0, kept);
+	const padded = units.replace(/^0+/, "").padStart(decimals + 1, "0");
+	const whole = padded.slice(0, padded.length - decimals);
+	return decimals > 0 ? `${whole}.${padded.slice(whole.length)}` : whole;
+}
+/** A string of decimal digits plus one. */
+function incremented(digits) {
+	let at = digits.length - 1;
+	while (at >= 0 && digits[at] === "9") at--;
+	if (at < 0) return `1${"0".repeat(digits.length)}`;
+	return `${digits.slice(0, at)}${String(Number(digits[at]) + 1)}${"0".repeat(digits.length - at - 1)}`;
+}
+/**
 * `value` rounded to `decimals` places the way a spreadsheet rounds: on the
 * DECIMAL number, half away from zero.
 *
@@ -580,21 +698,19 @@ function countDigitPlaceholders(s) {
 * every other reader show 1.0%. AverageTaxRates.xlsx had eleven of its
 * percentages a tenth low for exactly this reason.
 *
-* Rounding to 15 significant digits first collapses the binary noise back to
-* the decimal the author typed; shifting through a string exponent then keeps
-* the scaling exact, so the final round sees 9.5 and not 9.499999999999998.
+* The digits are the 15 of {@link decimalOf} and zeros after them, placed by
+* hand: past seventeen significant digits `toFixed` printed the binary
+* expansion (0.1 under twenty places as 0.10000000000000000555), from 1E+21 on
+* it wrote the exponent (`1e+21.00`), and past a hundred places it threw.
 */
 function toFixedDecimal(value, decimals) {
-	if (!Number.isFinite(value)) return value.toFixed(decimals);
-	const decimal = Number(value.toPrecision(15));
-	const shifted = Number(`${decimal}e${decimals}`);
-	if (!Number.isFinite(shifted)) return value.toFixed(decimals);
-	const rounded = shifted < 0 ? -Math.round(-shifted) : Math.round(shifted);
-	const back = Number(`${rounded}e${-decimals}`);
-	return Number.isFinite(back) ? back.toFixed(decimals) : value.toFixed(decimals);
+	if (!Number.isFinite(value)) return String(value);
+	const { digits, exponent } = decimalOf(value);
+	const placed = placeDigits(digits, exponent, decimals);
+	return value < 0 && /[1-9]/.test(placed) ? `-${placed}` : placed;
 }
 function formatScientific(value, cleaned, negativeSection) {
-	const m = /^(.*?)([eE])([+-])(.*)$/.exec(cleaned);
+	const m = hasLineEnd(cleaned) ? null : /^(.*?)([eE])([+-])(.*)$/.exec(cleaned);
 	if (!m) return cleaned;
 	const mantissaFmt = m[1];
 	const eChar = m[2];
@@ -604,17 +720,16 @@ function formatScientific(value, cleaned, negativeSection) {
 	const intDigits = Math.max(1, countDigitPlaceholders(dot >= 0 ? mantissaFmt.slice(0, dot) : mantissaFmt));
 	const decimals = dot >= 0 ? countDigitPlaceholders(mantissaFmt.slice(dot + 1)) : 0;
 	let exp = 0;
-	let mant = Math.abs(value);
-	if (mant !== 0) {
-		exp = Math.floor(Math.log10(mant));
-		exp -= (exp % intDigits + intDigits) % intDigits;
-		mant = mant / Math.pow(10, exp);
-		if (Number(mant.toFixed(decimals)) >= Math.pow(10, intDigits)) {
+	let mantStr = placeDigits("0", 0, decimals);
+	if (value !== 0) {
+		const { digits, exponent } = decimalOf(value);
+		exp = exponent - (exponent % intDigits + intDigits) % intDigits;
+		mantStr = placeDigits(digits, exponent - exp, decimals);
+		if (mantStr.split(".")[0].length > intDigits) {
 			exp += intDigits;
-			mant = mant / Math.pow(10, intDigits);
+			mantStr = placeDigits(digits, exponent - exp, decimals);
 		}
 	}
-	const mantStr = mant.toFixed(decimals);
 	const expDigits = countDigitPlaceholders(expFmt) || 2;
 	const expStr = String(Math.abs(exp)).padStart(expDigits, "0");
 	return `${value < 0 && !negativeSection ? "-" : ""}${mantStr}${eChar}${exp < 0 ? "-" : expSignFmt === "+" ? "+" : ""}${expStr}`;
@@ -629,11 +744,77 @@ function formatScientific(value, cleaned, negativeSection) {
 * conditions) is decoration here and goes.
 */
 function resolveBracketCodes(format) {
-	return format.replace(/\[([^\]]*)\]/g, (_, body) => {
+	return replaceBracketCodes(format, (body) => {
 		const symbol = /^\$([^-]*)(?:-.*)?$/.exec(body)?.[1]?.replace(/"/g, "") ?? "";
 		return symbol.length > 0 ? `"${symbol}"` : "";
 	});
 }
+var isPlaceholder = (c) => c === "0" || c === "#" || c === "?";
+var isAsciiDigit = (c) => c !== void 0 && c >= "0" && c <= "9";
+var isSpace = (c) => c !== void 0 && /\s/.test(c);
+var isLineEnd = (c) => c === 10 || c === 13 || c === 8232 || c === 8233;
+function hasLineEnd(s) {
+	for (let i = 0; i < s.length; i++) if (isLineEnd(s.charCodeAt(i))) return true;
+	return false;
+}
+/**
+* A fraction section cut into head, numerator, denominator and tail — what
+* `/^(.*?)([0#?]+)\s*\/\s*([0#?]+|\d+)(.*)$/` makes of it, in one pass. The
+* expression, lazy at the front, took every position of a run of placeholders
+* in turn as the start of the numerator and read the rest of the run from
+* each: quadratic in a long run no slash follows. A start inside a run sees
+* the same rest as the run's first, so only the first is tried. The head
+* cannot cross a line end, nor the tail hold one.
+*/
+function fractionParts(s) {
+	let firstEnd = s.length;
+	let lastEnd = -1;
+	for (let i = 0; i < s.length; i++) {
+		if (!isLineEnd(s.charCodeAt(i))) continue;
+		firstEnd = Math.min(firstEnd, i);
+		lastEnd = i;
+	}
+	for (let start = 0; start < firstEnd;) {
+		if (!isPlaceholder(s[start])) {
+			start++;
+			continue;
+		}
+		let numEnd = start;
+		while (isPlaceholder(s[numEnd])) numEnd++;
+		let slash = numEnd;
+		while (isSpace(s[slash])) slash++;
+		if (s[slash] === "/") {
+			let den = slash + 1;
+			while (isSpace(s[den])) den++;
+			let denEnd = den;
+			const inDen = isPlaceholder(s[den]) ? isPlaceholder : isAsciiDigit;
+			while (inDen(s[denEnd])) denEnd++;
+			if (denEnd > den && lastEnd < denEnd) return {
+				head: s.slice(0, start),
+				num: s.slice(start, numEnd),
+				den: s.slice(den, denEnd),
+				tail: s.slice(denEnd)
+			};
+		}
+		start = numEnd;
+	}
+}
+/**
+* The last run of placeholders in the head and what follows it — what
+* `/([0#?]+)([^0#?]*)$/` matches, read back from the end: that expression
+* retried every placeholder of an earlier run, and is quadratic in a long one.
+*/
+function lastPlaceholderRun(head) {
+	let end = head.length;
+	while (end > 0 && !isPlaceholder(head[end - 1])) end--;
+	if (end === 0) return void 0;
+	let at = end - 1;
+	while (at > 0 && isPlaceholder(head[at - 1])) at--;
+	return {
+		at,
+		after: head.slice(end)
+	};
+}
 /**
 * §18.8.31 fraction formats — `# ?/?`, `# ??/??`, `?/?`, `# ?/16`.
 *
@@ -644,15 +825,13 @@ function resolveBracketCodes(format) {
 * section is not a fraction, leaving the ordinary grammar to run.
 */
 function formatFraction(value, cleaned, negativeSection) {
-	const m = /^(.*?)([0#?]+)\s*\/\s*([0#?]+|\d+)(.*)$/.exec(cleaned);
+	const m = fractionParts(cleaned);
 	if (!m) return void 0;
-	const head = m[1];
-	const denFmt = m[3];
-	const tail = m[4];
-	const intMatch = /([0#?]+)([^0#?]*)$/.exec(head);
-	const hasInteger = intMatch !== null;
-	const literalPrefix = unquoteLiteral(head.substring(0, intMatch ? intMatch.index : head.length));
-	const separator = intMatch ? unquoteLiteral(intMatch[2]) : " ";
+	const { head, den: denFmt, tail } = m;
+	const intMatch = lastPlaceholderRun(head);
+	const hasInteger = intMatch !== void 0;
+	const literalPrefix = unquoteLiteral(head.substring(0, intMatch ? intMatch.at : head.length));
+	const separator = intMatch ? unquoteLiteral(intMatch.after) : " ";
 	const magnitude = Math.abs(value);
 	const whole = hasInteger ? Math.floor(magnitude) : 0;
 	const rest = magnitude - whole;
@@ -724,7 +903,7 @@ function applyNumericSection(value, format, negativeSection) {
 	for (let i = 0; i < intPlaceholders.length - significant.length; i++) if (intPlaceholders[i] === "0") zeros += "0";
 	else if (intPlaceholders[i] === "?") spaces += " ";
 	const intDigits = zeros + significant;
-	let numberPart = spaces + (useThousands ? intDigits.replace(/\B(?=(\d{3})+(?!\d))/g, ",") : intDigits);
+	let numberPart = spaces + (useThousands ? groupThousands(intDigits) : intDigits);
 	if (decimals > 0) {
 		let dec = decRaw ?? "".padEnd(decimals, "0");
 		if (dec.length < decimals) dec = dec.padEnd(decimals, "0");
@@ -739,6 +918,34 @@ function applyNumericSection(value, format, negativeSection) {
 	if (value < 0 && !negativeSection) signPrefix = "-";
 	return `${literalPrefix}${signPrefix}${numberPart}${isPercent ? "%" : ""}${literalSuffix}`;
 }
+/**
+* The digits with a comma before every third from the right of each run — what
+* `/\B(?=(\d{3})+(?!\d))/g` puts one at — in one pass. That expression read
+* ahead over the rest of the run from every position, and the run is as long
+* as the format has zeros, applied in every cell the format shows. A comma
+* goes where the rest of the run is a whole number of threes and the character
+* before is a word character, as `\B` asks: a digit inside the run, a letter
+* at its start.
+*/
+function groupThousands(s) {
+	const isWord = (i) => i >= 0 && /\w/.test(s[i]);
+	let out = "";
+	let from = 0;
+	for (let start = 0; start < s.length;) {
+		if (!isAsciiDigit(s[start])) {
+			start++;
+			continue;
+		}
+		let end = start;
+		while (isAsciiDigit(s[end])) end++;
+		for (let at = start; at < end; at++) if ((end - at) % 3 === 0 && isWord(at - 1)) {
+			out += `${s.slice(from, at)},`;
+			from = at;
+		}
+		start = end;
+	}
+	return out + s.slice(from);
+}
 function splitNumberFormat(cleaned) {
 	let firstDigit = -1;
 	let lastDigit = -1;
@@ -802,4 +1009,4 @@ function unquoteLiteral(s) {
 	return out;
 }
 //#endregion
-export { applyNumberFormat, excelSerialFromUtcParts, excelSerialToDate, generalToWidth, numberFormatColorHex };
+export { applyNumberFormat, excelSerialFromUtcParts, excelSerialToDate, generalRenderings, generalToWidth, numberFormatColorHex };

package/dist/esm/core/opc/tag-scan.d.ts

@@ -0,0 +1,15 @@
+/** Whether the code unit is one `\w` matches. NaN, past the end, is not. */
+export declare function isWordChar(c: number): boolean;
+/**
+ * The matches a global search with `re` finds in `xml` from `from`, in order.
+ *
+ * @param xml      The part's text.
+ * @param open     The tag's opening, `<w:font`, which `re` begins with.
+ * @param boundary Whether `re` puts `\b` right after `open`.
+ * @param re       The expression, sticky (`y`): `open`, the `\b` if any, then
+ *                 `[^>]*` (greedy or lazy) before what it looks for in the tag.
+ * @param from     Where the search starts.
+ */
+export declare function tagMatches(xml: string, open: string, boundary: boolean, re: RegExp, from?: number): Generator<RegExpExecArray>;
+/** The first of {@link tagMatches}, or undefined when there is none. */
+export declare function firstTagMatch(xml: string, open: string, boundary: boolean, re: RegExp, from?: number): RegExpExecArray | undefined;

package/dist/esm/core/opc/tag-scan.js

@@ -0,0 +1,41 @@
+//#region src/core/opc/tag-scan.ts
+/** Whether the code unit is one `\w` matches. NaN, past the end, is not. */
+function isWordChar(c) {
+	return c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
+}
+/**
+* The matches a global search with `re` finds in `xml` from `from`, in order.
+*
+* @param xml      The part's text.
+* @param open     The tag's opening, `<w:font`, which `re` begins with.
+* @param boundary Whether `re` puts `\b` right after `open`.
+* @param re       The expression, sticky (`y`): `open`, the `\b` if any, then
+*                 `[^>]*` (greedy or lazy) before what it looks for in the tag.
+* @param from     Where the search starts.
+*/
+function* tagMatches(xml, open, boundary, re, from = 0) {
+	let at = xml.indexOf(open, from);
+	while (at >= 0) {
+		if (boundary && isWordChar(xml.charCodeAt(at + open.length))) {
+			at = xml.indexOf(open, at + 1);
+			continue;
+		}
+		re.lastIndex = at;
+		const found = re.exec(xml);
+		if (found) {
+			const next = Math.max(re.lastIndex, at + 1);
+			yield found;
+			at = xml.indexOf(open, next);
+			continue;
+		}
+		const end = xml.indexOf(">", at + open.length);
+		if (end < 0) return;
+		at = xml.indexOf(open, end + 1);
+	}
+}
+/** The first of {@link tagMatches}, or undefined when there is none. */
+function firstTagMatch(xml, open, boundary, re, from = 0) {
+	for (const found of tagMatches(xml, open, boundary, re, from)) return found;
+}
+//#endregion
+export { firstTagMatch, isWordChar, tagMatches };

package/dist/esm/core/opc/xml-entities.js

@@ -3,7 +3,7 @@
 var MAX_EXPANSION = 65536;
 /** Longest total the substitutions may add to one part. */
 var MAX_TOTAL = 1048576;
-var DOCTYPE = /<!DOCTYPE\s[^[>]*(?:\[[\s\S]*?\]\s*)?>/;
+var DOCTYPE = /<!DOCTYPE\s[^[>]*(?:\[[\s\S]*?\]\s*)?>/y;
 var ENTITY_DECL = /<!ENTITY\s+([^\s%<>&;]+)\s+(?:"([^"]*)"|'([^']*)')\s*>/g;
 var REFERENCE = /&([^\s;&<>]+);/g;
 /** The five entities XML predefines; a declaration never overrides them. */
@@ -14,6 +14,43 @@ var PREDEFINED = new Set([
 	"apos",
 	"quot"
 ]);
+/**
+* The first `<!DOCTYPE …>` of a part — what {@link DOCTYPE} finds searching
+* from the start — tried only where it holds. A search tries every
+* `<!DOCTYPE`, reads on to the first `[` or `>` after it, and from a `[` on to
+* a `]` a `>` follows: a part of `<!DOCTYPE ` written over and over with none
+* of those sent it to the end of the part from each one, before the parser
+* ever saw the part. Every `<!DOCTYPE` before the same first `[` or `>` fares
+* as the one before it, and a `[` that no `]…>` follows fails every one that
+* reaches it, so those are passed over and the expression runs once.
+*/
+function findDoctype(xml) {
+	let stop = -1;
+	let close;
+	for (let at = xml.indexOf("<!DOCTYPE"); at >= 0; at = xml.indexOf("<!DOCTYPE", at + 1)) {
+		if (!/\s/.test(xml[at + 9] ?? "")) continue;
+		if (stop < at + 10) stop = firstBracketOrEnd(xml, at + 10);
+		if (stop < 0) return null;
+		if (xml[stop] === "[") {
+			close ??= lastBracketClose(xml);
+			if (close < stop) continue;
+		}
+		DOCTYPE.lastIndex = at;
+		return DOCTYPE.exec(xml);
+	}
+	return null;
+}
+/** The first `[` or `>` at or after `from`, or -1. */
+function firstBracketOrEnd(xml, from) {
+	for (let i = from; i < xml.length; i++) if (xml[i] === "[" || xml[i] === ">") return i;
+	return -1;
+}
+/** Where the last `]` stands that, past some whitespace, a `>` follows; or -1. */
+function lastBracketClose(xml) {
+	let last = -1;
+	for (const m of xml.matchAll(/\]\s*>/g)) last = m.index;
+	return last;
+}
 /** Escape resolved text so it re-enters the document as characters, not markup. */
 function escape(text) {
 	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -74,7 +111,7 @@ function expander(declared) {
 */
 function resolveInternalEntities(xml) {
 	if (!xml.includes("<!DOCTYPE")) return xml;
-	const doctype = DOCTYPE.exec(xml);
+	const doctype = findDoctype(xml);
 	if (!doctype) return xml;
 	const declared = /* @__PURE__ */ new Map();
 	for (const decl of doctype[0].matchAll(ENTITY_DECL)) {