@office-kit/xlsx 0.8.0

package/dist/datetime-B2ySVlXt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"datetime-B2ySVlXt.mjs","names":[],"sources":["../src/utils/datetime.ts"],"sourcesContent":["// Excel <-> JavaScript Date conversions. Mirrors\n// openpyxl/openpyxl/utils/datetime.py.\n//\n// Excel stores datetimes as fractional \"serial days\" since an epoch. Two epochs\n// are in use:\n//   * Windows  (\"1900 date system\", default): epoch 1899-12-30 with the\n//     well-known 1900 leap-year bug — Excel treats 1900-02-29 as a\n//     valid day even though it isn't. We collapse that phantom day\n//     onto 1900-02-28 (the openpyxl approach), so date math past\n//     March 1, 1900 stays consistent without leaking the bug.\n//   * Mac     (\"1904 date system\"): epoch 1904-01-01, no leap bug.\n//\n// Dates stay as numeric serials on the worksheet hot path; conversion to a JS\n// Date happens lazily only when callers ask. JS Dates are interpreted in UTC\n// throughout to avoid timezone drift between read and write.\n\nimport { OpenXmlSchemaError } from './exceptions';\n\n/** Excel epoch identifier. */\nexport type ExcelEpoch = 'windows' | 'mac';\n\n/** 1899-12-30 (UTC) — the Windows / 1900-system epoch in ms. */\nexport const WINDOWS_EPOCH_MS = Date.UTC(1899, 11, 30);\n/** 1904-01-01 (UTC) — the Mac / 1904-system epoch in ms. */\nexport const MAC_EPOCH_MS = Date.UTC(1904, 0, 1);\n\nconst MS_PER_DAY = 86_400_000;\n/** Serial day index of the phantom 1900-02-29; absorbed onto 1900-02-28. */\nconst LEAP_DUPLICATE_DAY = 60;\n\nconst epochMs = (e: ExcelEpoch | undefined): number => (e === 'mac' ? MAC_EPOCH_MS : WINDOWS_EPOCH_MS);\n\n/**\n * Convert an Excel serial date into a JS `Date` (UTC). The fractional part is\n * treated as a fraction of a day. For Windows 1900 the leap-bug compensation\n * kicks in for serials in [0, 60).\n */\nexport function excelToDate(serial: number, opts?: { epoch?: ExcelEpoch }): Date {\n  if (!Number.isFinite(serial)) {\n    throw new OpenXmlSchemaError(`excelToDate: serial \"${serial}\" is not finite`);\n  }\n  const epoch = epochMs(opts?.epoch);\n  const day = Math.floor(serial);\n  const fraction = serial - day;\n  const isWindows = epoch === WINDOWS_EPOCH_MS;\n  // Windows quirk: bump days [0, 60) by one so the day count lines up with\n  // Excel's serial numbering through the phantom Feb 29 1900.\n  const dayAdjusted = isWindows && serial >= 0 && serial < LEAP_DUPLICATE_DAY ? day + 1 : day;\n  const ms = epoch + dayAdjusted * MS_PER_DAY + Math.round(fraction * MS_PER_DAY);\n  return new Date(ms);\n}\n\n/**\n * Convert a JS `Date` into an Excel serial. The Date is read in UTC. On Windows\n * 1900, dates ≤ 1900-02-28 get a -1 day correction to account for Excel's\n * phantom leap day.\n */\nexport function dateToExcel(date: Date, opts?: { epoch?: ExcelEpoch }): number {\n  const t = date.getTime();\n  if (!Number.isFinite(t)) {\n    throw new OpenXmlSchemaError('dateToExcel: invalid Date');\n  }\n  const epoch = epochMs(opts?.epoch);\n  const dayStartMs = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());\n  const days = Math.round((dayStartMs - epoch) / MS_PER_DAY);\n  const subDay = (t - dayStartMs) / MS_PER_DAY;\n  const isWindows = epoch === WINDOWS_EPOCH_MS;\n  const daysAdjusted = isWindows && days <= LEAP_DUPLICATE_DAY ? days - 1 : days;\n  return daysAdjusted + subDay;\n}\n\n/** Excel duration serial (fraction of a day) → milliseconds. */\nexport function excelToDuration(serial: number): number {\n  if (!Number.isFinite(serial)) {\n    throw new OpenXmlSchemaError(`excelToDuration: serial \"${serial}\" is not finite`);\n  }\n  return Math.round(serial * MS_PER_DAY);\n}\n\n/** Milliseconds → Excel duration serial (fraction of a day). */\nexport function durationToExcel(ms: number): number {\n  if (!Number.isFinite(ms)) {\n    throw new OpenXmlSchemaError(`durationToExcel: ms \"${ms}\" is not finite`);\n  }\n  return ms / MS_PER_DAY;\n}\n\n// ---- ISO 8601 helpers ------------------------------------------------------\n\n/**\n * Parse an ISO-8601 / W3CDTF datetime string into a `Date`. Same grammar as\n * `new Date(string)`; the wrapper just adds typed error reporting and a\n * stricter \"must be a recognised ISO\" guard.\n */\nexport function fromIso8601(s: string): Date {\n  if (typeof s !== 'string' || s.length === 0) {\n    throw new OpenXmlSchemaError(`fromIso8601: empty input`);\n  }\n  const d = new Date(s);\n  if (Number.isNaN(d.getTime())) {\n    throw new OpenXmlSchemaError(`fromIso8601: invalid datetime \"${s}\"`);\n  }\n  return d;\n}\n\n/**\n * Format a `Date` as ISO-8601 with second precision in UTC. Trims the\n * millisecond fragment that `Date.toISOString()` always produces, so the output\n * matches Excel / openpyxl's W3CDTF style.\n */\nexport function toIso8601(d: Date): string {\n  if (Number.isNaN(d.getTime())) {\n    throw new OpenXmlSchemaError('toIso8601: invalid Date');\n  }\n  return d.toISOString().replace(/\\.\\d{3}Z$/, 'Z');\n}\n"],"mappings":";;;AAsBA,MAAa,mBAAmB,KAAK,IAAI,MAAM,IAAI,EAAE;;AAErD,MAAa,eAAe,KAAK,IAAI,MAAM,GAAG,CAAC;AAE/C,MAAM,aAAa;;AAEnB,MAAM,qBAAqB;AAE3B,MAAM,WAAW,MAAuC,MAAM,QAAQ,eAAe;;;;;;AAOrF,SAAgB,YAAY,QAAgB,MAAqC;CAC/E,IAAI,CAAC,OAAO,SAAS,MAAM,GACzB,MAAM,IAAI,mBAAmB,wBAAwB,OAAO,gBAAgB;CAE9E,MAAM,QAAQ,QAAQ,MAAM,KAAK;CACjC,MAAM,MAAM,KAAK,MAAM,MAAM;CAC7B,MAAM,WAAW,SAAS;CAK1B,MAAM,KAAK,SAJO,UAAU,oBAGK,UAAU,KAAK,SAAS,qBAAqB,MAAM,IAAI,OACvD,aAAa,KAAK,MAAM,WAAW,UAAU;CAC9E,OAAO,IAAI,KAAK,EAAE;AACpB;;;;;;AAOA,SAAgB,YAAY,MAAY,MAAuC;CAC7E,MAAM,IAAI,KAAK,QAAQ;CACvB,IAAI,CAAC,OAAO,SAAS,CAAC,GACpB,MAAM,IAAI,mBAAmB,2BAA2B;CAE1D,MAAM,QAAQ,QAAQ,MAAM,KAAK;CACjC,MAAM,aAAa,KAAK,IAAI,KAAK,eAAe,GAAG,KAAK,YAAY,GAAG,KAAK,WAAW,CAAC;CACxF,MAAM,OAAO,KAAK,OAAO,aAAa,SAAS,UAAU;CACzD,MAAM,UAAU,IAAI,cAAc;CAGlC,QAFkB,UAAU,oBACM,QAAQ,qBAAqB,OAAO,IAAI,QACpD;AACxB;;AAGA,SAAgB,gBAAgB,QAAwB;CACtD,IAAI,CAAC,OAAO,SAAS,MAAM,GACzB,MAAM,IAAI,mBAAmB,4BAA4B,OAAO,gBAAgB;CAElF,OAAO,KAAK,MAAM,SAAS,UAAU;AACvC;;AAGA,SAAgB,gBAAgB,IAAoB;CAClD,IAAI,CAAC,OAAO,SAAS,EAAE,GACrB,MAAM,IAAI,mBAAmB,wBAAwB,GAAG,gBAAgB;CAE1E,OAAO,KAAK;AACd;;;;;;AASA,SAAgB,YAAY,GAAiB;CAC3C,IAAI,OAAO,MAAM,YAAY,EAAE,WAAW,GACxC,MAAM,IAAI,mBAAmB,0BAA0B;CAEzD,MAAM,IAAI,IAAI,KAAK,CAAC;CACpB,IAAI,OAAO,MAAM,EAAE,QAAQ,CAAC,GAC1B,MAAM,IAAI,mBAAmB,kCAAkC,EAAE,EAAE;CAErE,OAAO;AACT;;;;;;AAOA,SAAgB,UAAU,GAAiB;CACzC,IAAI,OAAO,MAAM,EAAE,QAAQ,CAAC,GAC1B,MAAM,IAAI,mBAAmB,yBAAyB;CAExD,OAAO,EAAE,YAAY,EAAE,QAAQ,aAAa,GAAG;AACjD"}

package/dist/defined-names-CviWmtQg.mjs

@@ -0,0 +1,89 @@
+import { m as parseSheetRange } from "./coordinate-96Ecci4d.mjs";
+//#region src/workbook/defined-names.ts
+function makeDefinedName(opts) {
+	return {
+		name: opts.name,
+		value: opts.value,
+		...opts.scope !== void 0 ? { scope: opts.scope } : {},
+		...opts.hidden !== void 0 ? { hidden: opts.hidden } : {},
+		...opts.comment !== void 0 ? { comment: opts.comment } : {}
+	};
+}
+/**
+* Add a workbook-scope or sheet-scope defined name. If a defined name with the
+* same `name` (and `scope`) already exists, it's replaced — Excel allows one
+* workbook-scope and one per-sheet-scope name, but not two with the same scope.
+* Returns the resulting `DefinedName`.
+*/
+const addDefinedName = (wb, opts) => {
+	const dn = makeDefinedName(opts);
+	const idx = wb.definedNames.findIndex((d) => d.name === dn.name && d.scope === dn.scope);
+	if (idx >= 0) wb.definedNames[idx] = dn;
+	else wb.definedNames.push(dn);
+	return dn;
+};
+/** Look up a defined name by identifier and (optional) sheet scope. */
+const getDefinedName = (wb, name, scope) => wb.definedNames.find((d) => d.name === name && d.scope === scope);
+/**
+* Resolve a defined name's `value` into one or more {@link DefinedNameTarget}s.
+* Comma-separated values (e.g. `_xlnm.Print_Titles` typically sets
+* `Sheet!$1:$1,Sheet!$A:$A`) yield one entry per leg; a plain `Sheet!A1:B5`
+* yields a single-element array.
+*
+* Returns `undefined` when the name doesn't exist; throws when the value can't
+* be parsed (e.g. a constant or a non-range formula — defined names are
+* sometimes used for things like `=42` or `=SUM(A:A)` which aren't ranges).
+*/
+const getDefinedNameTarget = (wb, name, scope) => {
+	const dn = getDefinedName(wb, name, scope);
+	if (!dn) return void 0;
+	const legs = [];
+	let current = "";
+	let inQuote = false;
+	for (let i = 0; i < dn.value.length; i++) {
+		const c = dn.value[i];
+		if (c === "'") {
+			if (inQuote && dn.value[i + 1] === "'") {
+				current += "''";
+				i++;
+				continue;
+			}
+			inQuote = !inQuote;
+			current += c;
+			continue;
+		}
+		if (c === "," && !inQuote) {
+			legs.push(current);
+			current = "";
+			continue;
+		}
+		current += c;
+	}
+	if (current.length > 0) legs.push(current);
+	return legs.map((leg) => parseSheetRange(leg));
+};
+/**
+* Remove a defined name by identifier + scope. Returns true if any entry was
+* removed.
+*/
+const removeDefinedName = (wb, name, scope) => {
+	const idx = wb.definedNames.findIndex((d) => d.name === name && d.scope === scope);
+	if (idx < 0) return false;
+	wb.definedNames.splice(idx, 1);
+	return true;
+};
+/**
+* Read-only snapshot of every defined name. Pass `{ scope }` to narrow to
+* workbook-scope (`scope: undefined`) or one specific sheet (`scope: 0`) — omit
+* the option entirely to list all.
+*/
+const listDefinedNames = (wb, opts = {}) => {
+	const scope = opts.scope ?? "all";
+	if (scope === "all") return wb.definedNames;
+	if (scope === "workbook") return wb.definedNames.filter((d) => d.scope === void 0);
+	return wb.definedNames.filter((d) => d.scope === scope);
+};
+//#endregion
+export { makeDefinedName as a, listDefinedNames as i, getDefinedName as n, removeDefinedName as o, getDefinedNameTarget as r, addDefinedName as t };
+
+//# sourceMappingURL=defined-names-CviWmtQg.mjs.map

package/dist/defined-names-CviWmtQg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defined-names-CviWmtQg.mjs","names":[],"sources":["../src/workbook/defined-names.ts"],"sourcesContent":["// Workbook-level defined names. Models the OOXML schema's `<definedName>` element.\n//\n// A defined name binds an identifier to a formula-style value (`'Sheet\n// 1'!$A$1:$B$10`, `SUM(A:A)`, etc). Workbook-scope names omit `localSheetId`;\n// sheet-scope names use the 0-based sheet index. Excel reserves a handful of\n// names with the `_xlnm.` prefix for built-in uses (Print_Area, Print_Titles,\n// Sheet_Title, etc) — those round-trip here as plain DefinedName entries since\n// the value semantics are the same.\n\nimport { OpenXmlSchemaError } from '../utils/exceptions';\n\nexport interface DefinedName {\n  /** Identifier — `_xlnm.Print_Area` for built-ins, otherwise user-chosen. */\n  name: string;\n  /** The formula expression the name points at. */\n  value: string;\n  /** 0-based sheet index for sheet-scope names; undefined → workbook-scope. */\n  scope?: number;\n  /** Hidden from the Name Manager when true. */\n  hidden?: boolean;\n  /** Optional human-readable description. */\n  comment?: string;\n}\n\nexport function makeDefinedName(opts: Partial<DefinedName> & { name: string; value: string }): DefinedName {\n  return {\n    name: opts.name,\n    value: opts.value,\n    ...(opts.scope !== undefined ? { scope: opts.scope } : {}),\n    ...(opts.hidden !== undefined ? { hidden: opts.hidden } : {}),\n    ...(opts.comment !== undefined ? { comment: opts.comment } : {}),\n  };\n}\n\n// ---- Workbook ergonomic helpers -----------------------------------------\n\nimport { type CellRangeBoundaries, parseSheetRange } from '../utils/coordinate';\nimport type { Worksheet } from '../worksheet/worksheet';\nimport { getRangeAddress } from '../worksheet/worksheet';\nimport type { Workbook } from './workbook';\n\n/**\n * One parsed leg of a defined name's value. Defined-name values can be\n * comma-separated multi-range expressions (e.g. `_xlnm.Print_Titles` sets\n * `Sheet!$1:$1,Sheet!$A:$A`); this represents one such leg.\n */\nexport interface DefinedNameTarget {\n  sheet: string;\n  range: string;\n  bounds: CellRangeBoundaries;\n}\n\n/**\n * Add a workbook-scope or sheet-scope defined name. If a defined name with the\n * same `name` (and `scope`) already exists, it's replaced — Excel allows one\n * workbook-scope and one per-sheet-scope name, but not two with the same scope.\n * Returns the resulting `DefinedName`.\n */\nexport const addDefinedName = (\n  wb: Workbook,\n  opts: Partial<DefinedName> & { name: string; value: string },\n): DefinedName => {\n  const dn = makeDefinedName(opts);\n  // Replace any existing entry with the same name + scope.\n  const idx = wb.definedNames.findIndex((d) => d.name === dn.name && d.scope === dn.scope);\n  if (idx >= 0) {\n    wb.definedNames[idx] = dn;\n  } else {\n    wb.definedNames.push(dn);\n  }\n  return dn;\n};\n\n/**\n * High-level: register a defined name pointing at a worksheet range. Combines\n * {@link getRangeAddress} (sheet-qualified, properly quoted) with {@link\n * addDefinedName}, so the caller doesn't have to assemble the formula string by\n * hand.\n *\n * Pass `opts.localToSheet: true` to scope the name to the worksheet (instead of\n * the workbook). Re-using the same `name` + scope replaces the previous entry\n * (Excel's per-scope-uniqueness rule).\n *\n * Throws when `localToSheet: true` is set but the worksheet isn't on\n * `wb.sheets` — that would be a stale Worksheet reference.\n */\nexport const addDefinedNameForRange = (\n  wb: Workbook,\n  name: string,\n  ws: Worksheet,\n  range: string,\n  opts: { localToSheet?: boolean; hidden?: boolean; comment?: string } = {},\n): DefinedName => {\n  const value = getRangeAddress(ws, range);\n  let scope: number | undefined;\n  if (opts.localToSheet) {\n    const idx = wb.sheets.findIndex((s) => s.sheet === ws);\n    if (idx < 0) {\n      throw new OpenXmlSchemaError(\n        `addDefinedNameForRange: worksheet \"${ws.title}\" is not registered on this workbook`,\n      );\n    }\n    scope = idx;\n  }\n  return addDefinedName(wb, {\n    name,\n    value,\n    ...(scope !== undefined ? { scope } : {}),\n    ...(opts.hidden !== undefined ? { hidden: opts.hidden } : {}),\n    ...(opts.comment !== undefined ? { comment: opts.comment } : {}),\n  });\n};\n\n/** Look up a defined name by identifier and (optional) sheet scope. */\nexport const getDefinedName = (\n  wb: Workbook,\n  name: string,\n  scope?: number,\n): DefinedName | undefined => wb.definedNames.find((d) => d.name === name && d.scope === scope);\n\n/**\n * Resolve a defined name's `value` into one or more {@link DefinedNameTarget}s.\n * Comma-separated values (e.g. `_xlnm.Print_Titles` typically sets\n * `Sheet!$1:$1,Sheet!$A:$A`) yield one entry per leg; a plain `Sheet!A1:B5`\n * yields a single-element array.\n *\n * Returns `undefined` when the name doesn't exist; throws when the value can't\n * be parsed (e.g. a constant or a non-range formula — defined names are\n * sometimes used for things like `=42` or `=SUM(A:A)` which aren't ranges).\n */\nexport const getDefinedNameTarget = (\n  wb: Workbook,\n  name: string,\n  scope?: number,\n): DefinedNameTarget[] | undefined => {\n  const dn = getDefinedName(wb, name, scope);\n  if (!dn) return undefined;\n  // Defined-name values use `,` as the leg separator. Sheet titles can\n  // themselves contain commas inside `'...'` quotes — split on commas that\n  // aren't inside an unbalanced single-quoted segment.\n  const legs: string[] = [];\n  let current = '';\n  let inQuote = false;\n  for (let i = 0; i < dn.value.length; i++) {\n    const c = dn.value[i];\n    if (c === \"'\") {\n      // Doubled `''` inside a quoted run is the escape for a literal apostrophe\n      // — skip the second one without flipping the state.\n      if (inQuote && dn.value[i + 1] === \"'\") {\n        current += \"''\";\n        i++;\n        continue;\n      }\n      inQuote = !inQuote;\n      current += c;\n      continue;\n    }\n    if (c === ',' && !inQuote) {\n      legs.push(current);\n      current = '';\n      continue;\n    }\n    current += c;\n  }\n  if (current.length > 0) legs.push(current);\n  return legs.map((leg) => parseSheetRange(leg));\n};\n\n/**\n * Remove a defined name by identifier + scope. Returns true if any entry was\n * removed.\n */\nexport const removeDefinedName = (wb: Workbook, name: string, scope?: number): boolean => {\n  const idx = wb.definedNames.findIndex((d) => d.name === name && d.scope === scope);\n  if (idx < 0) return false;\n  wb.definedNames.splice(idx, 1);\n  return true;\n};\n\n/**\n * Read-only snapshot of every defined name. Pass `{ scope }` to narrow to\n * workbook-scope (`scope: undefined`) or one specific sheet (`scope: 0`) — omit\n * the option entirely to list all.\n */\nexport const listDefinedNames = (\n  wb: Workbook,\n  opts: { scope?: number | 'workbook' | 'all' } = {},\n): ReadonlyArray<DefinedName> => {\n  const scope = opts.scope ?? 'all';\n  if (scope === 'all') return wb.definedNames;\n  if (scope === 'workbook') return wb.definedNames.filter((d) => d.scope === undefined);\n  return wb.definedNames.filter((d) => d.scope === scope);\n};\n\n/**\n * Bulk-remove every defined name matching `predicate`. Returns the count\n * removed. Mirrors {@link removeDataValidations} on worksheets.\n */\nexport const removeDefinedNames = (\n  wb: Workbook,\n  predicate: (d: DefinedName) => boolean,\n): number => {\n  const before = wb.definedNames.length;\n  wb.definedNames = wb.definedNames.filter((d) => !predicate(d));\n  return before - wb.definedNames.length;\n};\n\n/**\n * Rename a defined name, scoped or workbook-scope. Returns `true` when an entry\n * was renamed. Throws when `newName` is already taken with the same scope\n * (Excel forbids duplicates within a scope).\n */\nexport const renameDefinedName = (\n  wb: Workbook,\n  oldName: string,\n  newName: string,\n  scope?: number,\n): boolean => {\n  const idx = wb.definedNames.findIndex((d) => d.name === oldName && d.scope === scope);\n  if (idx < 0) return false;\n  const conflict = wb.definedNames.findIndex((d, i) => i !== idx && d.name === newName && d.scope === scope);\n  if (conflict >= 0) {\n    throw new OpenXmlSchemaError(`renameDefinedName: \"${newName}\" is already in use at the same scope`);\n  }\n  const existing = wb.definedNames[idx];\n  if (!existing) return false;\n  wb.definedNames[idx] = { ...existing, name: newName };\n  return true;\n};\n\n/**\n * Read-only snapshot of every `_xlnm.Print_Area` defined name. Each entry is\n * the raw DefinedName carrying `scope` (sheet index) and `value` (the\n * print-area expression like `'Sheet1'!$A$1:$D$10`).\n */\nexport const listPrintAreas = (wb: Workbook): ReadonlyArray<DefinedName> =>\n  wb.definedNames.filter((d) => d.name === '_xlnm.Print_Area');\n\n/**\n * Read-only snapshot of every `_xlnm.Print_Titles` defined name. Each entry's\n * `value` is the title-row / title-col expression Excel re-uses on every\n * printed page.\n */\nexport const listPrintTitles = (wb: Workbook): ReadonlyArray<DefinedName> =>\n  wb.definedNames.filter((d) => d.name === '_xlnm.Print_Titles');\n\n/**\n * Define the print-area for a given sheet. Excel uses the built-in\n * `_xlnm.Print_Area` defined name with sheet scope.\n */\nexport const setPrintArea = (wb: Workbook, sheetIndex: number, ref: string): DefinedName => {\n  return addDefinedName(wb, {\n    name: '_xlnm.Print_Area',\n    value: ref,\n    scope: sheetIndex,\n  });\n};\n\n/**\n * Define print-title rows / columns on a sheet. Excel uses the\n * `_xlnm.Print_Titles` defined name. Pass `rows` (\"$1:$1\") to repeat row 1 on\n * every printed page; `cols` (\"$A:$A\") to repeat column A.\n */\nexport const setPrintTitles = (\n  wb: Workbook,\n  sheetIndex: number,\n  opts: { rows?: string; cols?: string; sheetName: string },\n): DefinedName => {\n  const parts: string[] = [];\n  // The wire form is \"Sheet!$1:$1,Sheet!$A:$A\"; both refs share the sheet\n  // prefix.\n  if (opts.cols !== undefined) parts.push(`'${opts.sheetName}'!${opts.cols}`);\n  if (opts.rows !== undefined) parts.push(`'${opts.sheetName}'!${opts.rows}`);\n  if (parts.length === 0) {\n    throw new OpenXmlSchemaError('setPrintTitles: at least one of rows or cols must be set');\n  }\n  return addDefinedName(wb, {\n    name: '_xlnm.Print_Titles',\n    value: parts.join(','),\n    scope: sheetIndex,\n  });\n};\n"],"mappings":";;AAwBA,SAAgB,gBAAgB,MAA2E;CACzG,OAAO;EACL,MAAM,KAAK;EACX,OAAO,KAAK;EACZ,GAAI,KAAK,UAAU,KAAA,IAAY,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;EACxD,GAAI,KAAK,WAAW,KAAA,IAAY,EAAE,QAAQ,KAAK,OAAO,IAAI,CAAC;EAC3D,GAAI,KAAK,YAAY,KAAA,IAAY,EAAE,SAAS,KAAK,QAAQ,IAAI,CAAC;CAChE;AACF;;;;;;;AA0BA,MAAa,kBACX,IACA,SACgB;CAChB,MAAM,KAAK,gBAAgB,IAAI;CAE/B,MAAM,MAAM,GAAG,aAAa,WAAW,MAAM,EAAE,SAAS,GAAG,QAAQ,EAAE,UAAU,GAAG,KAAK;CACvF,IAAI,OAAO,GACT,GAAG,aAAa,OAAO;MAEvB,GAAG,aAAa,KAAK,EAAE;CAEzB,OAAO;AACT;;AA2CA,MAAa,kBACX,IACA,MACA,UAC4B,GAAG,aAAa,MAAM,MAAM,EAAE,SAAS,QAAQ,EAAE,UAAU,KAAK;;;;;;;;;;;AAY9F,MAAa,wBACX,IACA,MACA,UACoC;CACpC,MAAM,KAAK,eAAe,IAAI,MAAM,KAAK;CACzC,IAAI,CAAC,IAAI,OAAO,KAAA;CAIhB,MAAM,OAAiB,CAAC;CACxB,IAAI,UAAU;CACd,IAAI,UAAU;CACd,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,MAAM,QAAQ,KAAK;EACxC,MAAM,IAAI,GAAG,MAAM;EACnB,IAAI,MAAM,KAAK;GAGb,IAAI,WAAW,GAAG,MAAM,IAAI,OAAO,KAAK;IACtC,WAAW;IACX;IACA;GACF;GACA,UAAU,CAAC;GACX,WAAW;GACX;EACF;EACA,IAAI,MAAM,OAAO,CAAC,SAAS;GACzB,KAAK,KAAK,OAAO;GACjB,UAAU;GACV;EACF;EACA,WAAW;CACb;CACA,IAAI,QAAQ,SAAS,GAAG,KAAK,KAAK,OAAO;CACzC,OAAO,KAAK,KAAK,QAAQ,gBAAgB,GAAG,CAAC;AAC/C;;;;;AAMA,MAAa,qBAAqB,IAAc,MAAc,UAA4B;CACxF,MAAM,MAAM,GAAG,aAAa,WAAW,MAAM,EAAE,SAAS,QAAQ,EAAE,UAAU,KAAK;CACjF,IAAI,MAAM,GAAG,OAAO;CACpB,GAAG,aAAa,OAAO,KAAK,CAAC;CAC7B,OAAO;AACT;;;;;;AAOA,MAAa,oBACX,IACA,OAAgD,CAAC,MAClB;CAC/B,MAAM,QAAQ,KAAK,SAAS;CAC5B,IAAI,UAAU,OAAO,OAAO,GAAG;CAC/B,IAAI,UAAU,YAAY,OAAO,GAAG,aAAa,QAAQ,MAAM,EAAE,UAAU,KAAA,CAAS;CACpF,OAAO,GAAG,aAAa,QAAQ,MAAM,EAAE,UAAU,KAAK;AACxD"}

package/dist/differential-D4dg-qtZ.mjs

@@ -0,0 +1,37 @@
+import { Zt as stableStringify } from "./cell-style-BEDjMX1y.mjs";
+//#region src/styles/differential.ts
+function makeDifferentialStyle(opts = {}) {
+	const out = {};
+	if (opts.font !== void 0) out.font = opts.font;
+	if (opts.fill !== void 0) out.fill = opts.fill;
+	if (opts.border !== void 0) out.border = opts.border;
+	if (opts.alignment !== void 0) out.alignment = opts.alignment;
+	if (opts.protection !== void 0) out.protection = opts.protection;
+	if (opts.numFmt !== void 0) out.numFmt = opts.numFmt;
+	return Object.freeze(out);
+}
+/**
+* Add a DifferentialStyle to the stylesheet's `dxfs` pool. Returns
+* the 0-based index. Idempotent on structural equality (via
+* stableStringify).
+*/
+function addDxf(ss, dxf) {
+	const w = ss;
+	if (w.dxfs === void 0) w.dxfs = [];
+	if (w._dxfIdByKey === void 0) w._dxfIdByKey = /* @__PURE__ */ new Map();
+	const key = stableStringify(dxf);
+	const cached = w._dxfIdByKey.get(key);
+	if (cached !== void 0) return cached;
+	const id = w.dxfs.length;
+	w.dxfs.push(dxf);
+	w._dxfIdByKey.set(key, id);
+	return id;
+}
+/** Read-only access to the dxfs pool. Returns `[]` when none registered. */
+function getDxfs(ss) {
+	return ss.dxfs ?? [];
+}
+//#endregion
+export { getDxfs as n, makeDifferentialStyle as r, addDxf as t };
+
+//# sourceMappingURL=differential-D4dg-qtZ.mjs.map

package/dist/differential-D4dg-qtZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"differential-D4dg-qtZ.mjs","names":[],"sources":["../src/styles/differential.ts"],"sourcesContent":["// DifferentialStyle (DXF) — partial style overlay used by conditional\n// formatting and Excel-table style elements. Mirrors\n// openpyxl/openpyxl/styles/differential.py.\n//\n// Where a NamedStyle / CellXf carries a *complete* style snapshot, a\n// DifferentialStyle carries only the components that override the base.\n// The Stylesheet keeps DXFs in their own pool (`dxfs`) and conditional-\n// formatting rules / table-style elements reference them by index.\n\nimport { stableStringify } from '../utils/stable-stringify';\nimport type { Alignment } from './alignment';\nimport type { Border } from './borders';\nimport type { Fill } from './fills';\nimport type { Font } from './fonts';\nimport type { NumberFormat } from './numbers';\nimport type { Protection } from './protection';\nimport type { Stylesheet } from './stylesheet';\n\n/**\n * Differential (\"partial\") style. Every component is optional; only\n * the set fields override the base style of whatever the DXF is\n * applied to.\n */\nexport interface DifferentialStyle {\n  readonly font?: Font;\n  readonly fill?: Fill;\n  readonly border?: Border;\n  readonly alignment?: Alignment;\n  readonly protection?: Protection;\n  /**\n   * NumberFormat carries both the id and the format code so DXFs can\n   * reference custom user-defined number formats without ambiguity.\n   */\n  readonly numFmt?: NumberFormat;\n}\n\nexport function makeDifferentialStyle(opts: Partial<DifferentialStyle> = {}): DifferentialStyle {\n  const out: { -readonly [K in keyof DifferentialStyle]: DifferentialStyle[K] } = {};\n  if (opts.font !== undefined) out.font = opts.font;\n  if (opts.fill !== undefined) out.fill = opts.fill;\n  if (opts.border !== undefined) out.border = opts.border;\n  if (opts.alignment !== undefined) out.alignment = opts.alignment;\n  if (opts.protection !== undefined) out.protection = opts.protection;\n  if (opts.numFmt !== undefined) out.numFmt = opts.numFmt;\n  return Object.freeze(out);\n}\n\n/**\n * Stylesheet pool extension. The DXF list is allocated lazily on first\n * use so empty stylesheets stay slim.\n */\nexport interface StylesheetWithDxfs extends Stylesheet {\n  dxfs?: DifferentialStyle[];\n  _dxfIdByKey?: Map<string, number>;\n}\n\n/**\n * Add a DifferentialStyle to the stylesheet's `dxfs` pool. Returns\n * the 0-based index. Idempotent on structural equality (via\n * stableStringify).\n */\nexport function addDxf(ss: Stylesheet, dxf: DifferentialStyle): number {\n  const w = ss as StylesheetWithDxfs;\n  if (w.dxfs === undefined) w.dxfs = [];\n  if (w._dxfIdByKey === undefined) w._dxfIdByKey = new Map();\n  const key = stableStringify(dxf);\n  const cached = w._dxfIdByKey.get(key);\n  if (cached !== undefined) return cached;\n  const id = w.dxfs.length;\n  w.dxfs.push(dxf);\n  w._dxfIdByKey.set(key, id);\n  return id;\n}\n\n/** Read-only access to the dxfs pool. Returns `[]` when none registered. */\nexport function getDxfs(ss: Stylesheet): ReadonlyArray<DifferentialStyle> {\n  return (ss as StylesheetWithDxfs).dxfs ?? [];\n}\n"],"mappings":";;AAoCA,SAAgB,sBAAsB,OAAmC,CAAC,GAAsB;CAC9F,MAAM,MAA0E,CAAC;CACjF,IAAI,KAAK,SAAS,KAAA,GAAW,IAAI,OAAO,KAAK;CAC7C,IAAI,KAAK,SAAS,KAAA,GAAW,IAAI,OAAO,KAAK;CAC7C,IAAI,KAAK,WAAW,KAAA,GAAW,IAAI,SAAS,KAAK;CACjD,IAAI,KAAK,cAAc,KAAA,GAAW,IAAI,YAAY,KAAK;CACvD,IAAI,KAAK,eAAe,KAAA,GAAW,IAAI,aAAa,KAAK;CACzD,IAAI,KAAK,WAAW,KAAA,GAAW,IAAI,SAAS,KAAK;CACjD,OAAO,OAAO,OAAO,GAAG;AAC1B;;;;;;AAgBA,SAAgB,OAAO,IAAgB,KAAgC;CACrE,MAAM,IAAI;CACV,IAAI,EAAE,SAAS,KAAA,GAAW,EAAE,OAAO,CAAC;CACpC,IAAI,EAAE,gBAAgB,KAAA,GAAW,EAAE,8BAAc,IAAI,IAAI;CACzD,MAAM,MAAM,gBAAgB,GAAG;CAC/B,MAAM,SAAS,EAAE,YAAY,IAAI,GAAG;CACpC,IAAI,WAAW,KAAA,GAAW,OAAO;CACjC,MAAM,KAAK,EAAE,KAAK;CAClB,EAAE,KAAK,KAAK,GAAG;CACf,EAAE,YAAY,IAAI,KAAK,EAAE;CACzB,OAAO;AACT;;AAGA,SAAgB,QAAQ,IAAkD;CACxE,OAAQ,GAA0B,QAAQ,CAAC;AAC7C"}

package/dist/drawing/anchor.d.ts

@@ -0,0 +1,63 @@
+/** EMU = English Metric Units. Drawing coordinates are stored in EMU on the wire. */
+export interface Point2D {
+    /** Horizontal offset in EMU. */
+    x: number;
+    /** Vertical offset in EMU. */
+    y: number;
+}
+export interface PositiveSize2D {
+    cx: number;
+    cy: number;
+}
+/**
+ * `from` / `to` corners reference a cell by 0-based column + row index plus an
+ * EMU offset within the cell. Excel's wire format is 0-based here even though
+ * cell references in formulas / sheetData are 1-based.
+ */
+export interface AnchorMarker {
+    col: number;
+    colOff: number;
+    row: number;
+    rowOff: number;
+}
+export type DrawingAnchor = {
+    kind: 'absolute';
+    pos: Point2D;
+    ext: PositiveSize2D;
+} | {
+    kind: 'oneCell';
+    from: AnchorMarker;
+    ext: PositiveSize2D;
+} | {
+    kind: 'twoCell';
+    from: AnchorMarker;
+    to: AnchorMarker;
+    editAs?: 'twoCell' | 'oneCell' | 'absolute';
+};
+/**
+ * Convert a cell ref ("A1", "C5") to a 0-based AnchorMarker with `colOff =
+ * rowOff = 0`. Throws on malformed refs.
+ */
+export declare function anchorMarkerFromCellRef(ref: string): AnchorMarker;
+/** Build an absolute anchor from an (x, y, cx, cy) EMU bundle. */
+export declare function makeAbsoluteAnchor(opts: {
+    x: number;
+    y: number;
+    cx: number;
+    cy: number;
+}): DrawingAnchor;
+/** Build a one-cell anchor pinned at `from` with an explicit pixel extent. */
+export declare function makeOneCellAnchor(opts: {
+    from: string | AnchorMarker;
+    widthPx: number;
+    heightPx: number;
+}): DrawingAnchor;
+/**
+ * Build a two-cell anchor from cell-ref pairs (or pre-built markers). Defaults
+ * to `editAs='twoCell'` — drag both corners with the cells.
+ */
+export declare function makeTwoCellAnchor(opts: {
+    from: string | AnchorMarker;
+    to: string | AnchorMarker;
+    editAs?: 'twoCell' | 'oneCell' | 'absolute';
+}): DrawingAnchor;

package/dist/drawing/dml/colors.d.ts

@@ -0,0 +1,109 @@
+/** ECMA-376 scheme-color names (`<a:schemeClr val="...">`). */
+export type SchemeColorName = 'bg1' | 'tx1' | 'bg2' | 'tx2' | 'accent1' | 'accent2' | 'accent3' | 'accent4' | 'accent5' | 'accent6' | 'hlink' | 'folHlink' | 'phClr' | 'dk1' | 'lt1' | 'dk2' | 'lt2';
+export declare const SCHEME_COLOR_NAMES: ReadonlyArray<SchemeColorName>;
+export type DmlColor = {
+    kind: 'srgb';
+    value: string;
+} | {
+    kind: 'sysClr';
+    value: string;
+    lastClr?: string;
+} | {
+    kind: 'schemeClr';
+    value: SchemeColorName;
+} | {
+    kind: 'prstClr';
+    value: string;
+} | {
+    kind: 'hslClr';
+    hue: number;
+    sat: number;
+    lum: number;
+} | {
+    kind: 'scrgbClr';
+    r: number;
+    g: number;
+    b: number;
+};
+export type ColorMod = {
+    kind: 'lumMod';
+    val: number;
+} | {
+    kind: 'lumOff';
+    val: number;
+} | {
+    kind: 'satMod';
+    val: number;
+} | {
+    kind: 'satOff';
+    val: number;
+} | {
+    kind: 'hueMod';
+    val: number;
+} | {
+    kind: 'hueOff';
+    val: number;
+} | {
+    kind: 'tint';
+    val: number;
+} | {
+    kind: 'shade';
+    val: number;
+} | {
+    kind: 'alpha';
+    val: number;
+} | {
+    kind: 'alphaMod';
+    val: number;
+} | {
+    kind: 'alphaOff';
+    val: number;
+} | {
+    kind: 'red';
+    val: number;
+} | {
+    kind: 'green';
+    val: number;
+} | {
+    kind: 'blue';
+    val: number;
+} | {
+    kind: 'redMod';
+    val: number;
+} | {
+    kind: 'greenMod';
+    val: number;
+} | {
+    kind: 'blueMod';
+    val: number;
+} | {
+    kind: 'redOff';
+    val: number;
+} | {
+    kind: 'greenOff';
+    val: number;
+} | {
+    kind: 'blueOff';
+    val: number;
+} | {
+    kind: 'gray';
+} | {
+    kind: 'comp';
+} | {
+    kind: 'inv';
+} | {
+    kind: 'invGamma';
+} | {
+    kind: 'gamma';
+};
+/** Color mod kinds that take no `val` attribute (their elements are empty). */
+export declare const VALUELESS_COLOR_MOD_KINDS: ReadonlyArray<ColorMod['kind']>;
+/** Color mod kinds that carry a numeric `val` attribute. */
+export declare const VALUED_COLOR_MOD_KINDS: ReadonlyArray<ColorMod['kind']>;
+export interface DmlColorWithMods {
+    base: DmlColor;
+    mods: ColorMod[];
+}
+export declare const makeSrgbColor: (rrggbb: string) => DmlColor;
+export declare const makeSchemeColor: (name: SchemeColorName) => DmlColor;
+export declare const makeColor: (base: DmlColor, mods?: ColorMod[]) => DmlColorWithMods;

package/dist/drawing/dml/dml-xml.d.ts

@@ -0,0 +1,35 @@
+import { type XmlNode } from '../../xml/tree';
+import { type DmlColorWithMods } from './colors';
+import type { EffectsRef } from './effect';
+import type { Fill } from './fill';
+import type { Geometry } from './geometry';
+import type { LineProperties } from './line';
+import type { ShapeProperties } from './shape-properties';
+import type { TextBody, TextBodyProperties } from './text';
+/** Parse the first known color base element (with its mods) found inside `parent`. */
+export declare const parseDmlColor: (parent: XmlNode) => DmlColorWithMods | undefined;
+/** Serialize a color directly (without an enclosing wrapper). */
+export declare const serializeDmlColor: (c: DmlColorWithMods) => string;
+/** Parse the first fill element under `parent` (any of the 6 kinds). */
+export declare const parseFill: (parent: XmlNode) => Fill | undefined;
+export declare const serializeFill: (f: Fill) => string;
+export declare const parseLine: (el: XmlNode) => LineProperties;
+export declare const serializeLine: (ln: LineProperties) => string;
+export declare const parseGeometry: (parent: XmlNode) => Geometry | undefined;
+export declare const serializeGeometry: (g: Geometry) => string;
+export declare const parseEffects: (parent: XmlNode) => EffectsRef | undefined;
+export declare const serializeEffects: (e: EffectsRef) => string;
+export declare const parseTextBodyProperties: (el: XmlNode) => TextBodyProperties;
+export declare const serializeTextBodyProperties: (tag: string, p: TextBodyProperties) => string;
+/** Parse an `<a:txBody>` (or `<c:txPr>` / `<cdr:txBody>`) element. */
+export declare const parseTextBody: (el: XmlNode) => TextBody;
+/** Serialise a TextBody. Wrapper defaults to `<c:txPr>` to match chart usage. */
+export declare const serializeTextBody: (body: TextBody, wrapperTag?: string) => string;
+/**
+ * Parse a `<spPr>` (or `<c:spPr>` / `<cdr:spPr>`) element. Caller provides the
+ * element directly — we don't filter by tag name so the helper works for any
+ * namespace prefix.
+ */
+export declare const parseShapeProperties: (el: XmlNode) => ShapeProperties;
+/** Serialize a ShapeProperties as `<wrapper>...</wrapper>`. Wrapper defaults to `<c:spPr>`. */
+export declare const serializeShapeProperties: (sp: ShapeProperties, wrapperTag?: string) => string;

package/dist/drawing/dml/effect.d.ts

@@ -0,0 +1,92 @@
+import type { DmlColorWithMods } from './colors';
+import type { Fill } from './fill';
+export type FillBlendMode = 'over' | 'mult' | 'screen' | 'darken' | 'lighten';
+export type ShadowAlign = 'tl' | 't' | 'tr' | 'l' | 'ctr' | 'r' | 'bl' | 'b' | 'br';
+/** Preset-shadow names (`<a:prstShdw prst="shdwN"/>`, 20 entries). */
+export type PresetShadowName = 'shdw1' | 'shdw2' | 'shdw3' | 'shdw4' | 'shdw5' | 'shdw6' | 'shdw7' | 'shdw8' | 'shdw9' | 'shdw10' | 'shdw11' | 'shdw12' | 'shdw13' | 'shdw14' | 'shdw15' | 'shdw16' | 'shdw17' | 'shdw18' | 'shdw19' | 'shdw20';
+export declare const PRESET_SHADOW_NAMES: ReadonlyArray<PresetShadowName>;
+export type Effect = {
+    kind: 'blur';
+    rad: number;
+    grow?: boolean;
+} | {
+    kind: 'fillOverlay';
+    blend: FillBlendMode;
+    fill: Fill;
+} | {
+    kind: 'glow';
+    rad: number;
+    color: DmlColorWithMods;
+} | {
+    kind: 'innerShdw';
+    blurRad?: number;
+    dist?: number;
+    dir?: number;
+    color: DmlColorWithMods;
+} | {
+    kind: 'outerShdw';
+    blurRad?: number;
+    dist?: number;
+    dir?: number;
+    sx?: number;
+    sy?: number;
+    kx?: number;
+    ky?: number;
+    algn?: ShadowAlign;
+    rotWithShape?: boolean;
+    color: DmlColorWithMods;
+} | {
+    kind: 'prstShdw';
+    prst: PresetShadowName;
+    dist?: number;
+    dir?: number;
+    color: DmlColorWithMods;
+} | {
+    kind: 'reflection';
+    blurRad?: number;
+    stA?: number;
+    stPos?: number;
+    endA?: number;
+    endPos?: number;
+    dist?: number;
+    dir?: number;
+    fadeDir?: number;
+    sx?: number;
+    sy?: number;
+    kx?: number;
+    ky?: number;
+    algn?: ShadowAlign;
+    rotWithShape?: boolean;
+} | {
+    kind: 'softEdge';
+    rad: number;
+};
+/** `<a:effectLst>` — ordered list of effect leaves. */
+export interface EffectList {
+    list: Effect[];
+}
+/**
+ * Inner `<a:cont type="tree|sib">` node. Lives inside `<a:effectDag>` or inside
+ * another `<a:cont>`. Children may be effect leaves or further containers.
+ */
+export interface EffectContainer {
+    /** Compose children sequentially (`sib`) or as a tree (`tree`). */
+    type: 'tree' | 'sib';
+    /** Optional name for cross-referencing other DAG nodes. */
+    name?: string;
+    children: Array<Effect | EffectContainer>;
+}
+/**
+ * Either `<a:effectLst>` or `<a:effectDag>`. The dag root has no `type`
+ * attribute in ECMA-376; only its `<a:cont>` children do, hence we model the
+ * dag as a flat list of children rather than a single EffectContainer.
+ */
+export type EffectsRef = {
+    kind: 'lst';
+    list: EffectList;
+} | {
+    kind: 'dag';
+    children: Array<Effect | EffectContainer>;
+};
+export declare const makeEffectList: (list: Effect[]) => EffectList;
+export declare const makeEffectContainer: (type: "tree" | "sib", children: Array<Effect | EffectContainer>, name?: string) => EffectContainer;

package/dist/drawing/dml/fill.d.ts

@@ -0,0 +1,115 @@
+import type { DmlColor, DmlColorWithMods } from './colors';
+/** Relative rectangle (0..100000-thousandths). */
+export interface RelativeRect {
+    l?: number;
+    t?: number;
+    r?: number;
+    b?: number;
+}
+export interface GradientStop {
+    /** Position along the gradient (0..100000). */
+    pos: number;
+    color: DmlColorWithMods;
+}
+export type GradientLineDir = {
+    kind: 'lin';
+    ang: number;
+    scaled?: boolean;
+} | {
+    kind: 'path';
+    pathType: 'shape' | 'circle' | 'rect';
+    tileRect?: RelativeRect;
+};
+export type TileFlip = 'x' | 'y' | 'xy' | 'none';
+export interface TileFill {
+    tx?: number;
+    ty?: number;
+    sx?: number;
+    sy?: number;
+    flip?: TileFlip;
+    algn?: 'tl' | 't' | 'tr' | 'l' | 'ctr' | 'r' | 'bl' | 'b' | 'br';
+}
+/** Blip-source effects. The full ECMA-376 list is preserved here; `kind` discriminates. */
+export type BlipEffect = {
+    kind: 'biLevel';
+    thresh: number;
+} | {
+    kind: 'blur';
+    rad: number;
+    grow?: boolean;
+} | {
+    kind: 'clrChange';
+    useA?: boolean;
+    clrFrom: DmlColor;
+    clrTo: DmlColor;
+} | {
+    kind: 'clrRepl';
+    color: DmlColor;
+} | {
+    kind: 'duotone';
+    colors: [DmlColor, DmlColor];
+} | {
+    kind: 'grayscl';
+} | {
+    kind: 'lum';
+    bright?: number;
+    contrast?: number;
+} | {
+    kind: 'tint';
+    hue?: number;
+    amt?: number;
+} | {
+    kind: 'alphaModFix';
+    amt: number;
+};
+export interface Blip {
+    embedRId?: string;
+    linkRId?: string;
+    cstate?: 'email' | 'screen' | 'print' | 'hqprint';
+    effects?: BlipEffect[];
+}
+/** Discriminated union for any fill that can attach to a shape. */
+export type Fill = {
+    kind: 'noFill';
+} | {
+    kind: 'solidFill';
+    color: DmlColorWithMods;
+} | {
+    kind: 'gradFill';
+    flip?: TileFlip;
+    rotWithShape?: boolean;
+    stops: GradientStop[];
+    lineDir?: GradientLineDir;
+} | {
+    kind: 'blipFill';
+    blip: Blip;
+    tile?: TileFill;
+    stretch?: {
+        fillRect?: RelativeRect;
+    };
+    srcRect?: RelativeRect;
+    dpi?: number;
+    rotWithShape?: boolean;
+} | {
+    kind: 'pattFill';
+    preset: string;
+    fgClr?: DmlColorWithMods;
+    bgClr?: DmlColorWithMods;
+} | {
+    kind: 'grpFill';
+};
+export declare const makeNoFill: () => Fill;
+export declare const makeSolidFill: (color: DmlColorWithMods) => Fill;
+export declare const makeGradientFill: (opts: {
+    stops: GradientStop[];
+    flip?: TileFlip;
+    rotWithShape?: boolean;
+    lineDir?: GradientLineDir;
+}) => Fill;
+export declare const makePatternFill: (opts: {
+    preset: string;
+    fgClr?: DmlColorWithMods;
+    bgClr?: DmlColorWithMods;
+}) => Fill;
+/** Excel's preset pattern names (54 entries, ECMA-376 §20.1.10.50; matches openpyxl). */
+export declare const PRESET_PATTERN_NAMES: ReadonlyArray<string>;