@lotics/xlsx 0.1.0

package/src/ooxml_styles.ts

@@ -0,0 +1,556 @@
+import { XMLParser } from "fast-xml-parser";
+import type { CellStyle, BorderStyle, GradientData } from "./types";
+import type { ThemeData, OoxmlColor } from "./ooxml_color";
+import { parseColorElement, resolveColor, prefixHex, DEFAULT_INDEXED_COLORS } from "./ooxml_color";
+import { getPatternFillCSS } from "./excel_pattern_fills";
+import { decodeXmlEntities } from "./xml_entities";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface StyleResolver {
+  resolveStyle(xfIndex: number): CellStyle;
+  getNumFmt(xfIndex: number): string;
+  indexedColors: string[];
+}
+
+interface FontEntry {
+  bold: boolean;
+  italic: boolean;
+  strike: boolean;
+  underline?: "single" | "double";
+  vertAlign?: "superscript" | "subscript";
+  size?: number;
+  name?: string;
+  scheme?: string;
+  color?: OoxmlColor;
+}
+
+interface FillEntry {
+  patternType: string;
+  fgColor?: OoxmlColor;
+  bgColor?: OoxmlColor;
+  // Gradient fills
+  gradientType?: string;
+  gradientDegree?: number;
+  gradientStops?: Array<{ position: number; color: OoxmlColor }>;
+}
+
+interface BorderEntry {
+  left?: BorderSide;
+  right?: BorderSide;
+  top?: BorderSide;
+  bottom?: BorderSide;
+  diagonal?: BorderSide;
+  diagonalUp?: boolean;
+  diagonalDown?: boolean;
+}
+
+interface BorderSide {
+  style?: string;
+  color?: OoxmlColor;
+}
+
+interface XfEntry {
+  numFmtId: number;
+  fontId: number;
+  fillId: number;
+  borderId: number;
+  applyFont: boolean;
+  applyFill: boolean;
+  applyBorder: boolean;
+  applyAlignment: boolean;
+  applyNumFmt: boolean;
+  horizontalAlign?: string;
+  verticalAlign?: string;
+  wrapText: boolean;
+  indent: number;
+  textRotation: number;
+  shrinkToFit: boolean;
+  readingOrder: number;
+}
+
+// =============================================================================
+// Built-in number formats (IDs 0-49 are implicit in Excel)
+// =============================================================================
+
+const BUILTIN_NUM_FMTS: Record<number, string> = {
+  0: "General",
+  1: "0",
+  2: "0.00",
+  3: "#,##0",
+  4: "#,##0.00",
+  9: "0%",
+  10: "0.00%",
+  11: "0.00E+00",
+  12: "# ?/?",
+  13: "# ??/??",
+  14: "mm-dd-yy",
+  15: "d-mmm-yy",
+  16: "d-mmm",
+  17: "mmm-yy",
+  18: "h:mm AM/PM",
+  19: "h:mm:ss AM/PM",
+  20: "h:mm",
+  21: "h:mm:ss",
+  22: "m/d/yy h:mm",
+  37: "#,##0 ;(#,##0)",
+  38: "#,##0 ;[Red](#,##0)",
+  39: "#,##0.00;(#,##0.00)",
+  40: "#,##0.00;[Red](#,##0.00)",
+  45: "mm:ss",
+  46: "[h]:mm:ss",
+  47: "mmss.0",
+  48: "##0.0E+0",
+  49: "@",
+};
+
+// =============================================================================
+// XML parser
+// =============================================================================
+
+const xmlParser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  processEntities: false,
+  isArray: (tagName) =>
+    tagName === "numFmt" ||
+    tagName === "font" ||
+    tagName === "fill" ||
+    tagName === "border" ||
+    tagName === "xf" ||
+    tagName === "rgbColor" ||
+    tagName === "stop",
+});
+
+// =============================================================================
+// Main parse function
+// =============================================================================
+
+export function parseStyles(stylesXml: string, theme: ThemeData): StyleResolver {
+  const doc = xmlParser.parse(stylesXml);
+  const root = doc?.["styleSheet"];
+  if (!root) {
+    return emptyStyleResolver();
+  }
+
+  // Custom indexed colors (override defaults)
+  const indexedColors = parseIndexedColors(root);
+
+  // Number formats
+  const customFmts = parseNumFmts(root);
+
+  // Fonts
+  const fonts = parseFonts(root);
+
+  // Fills
+  const fills = parseFills(root);
+
+  // Borders
+  const borders = parseBorders(root);
+
+  // Cell XFs
+  const cellXfs = parseCellXfs(root);
+
+  function resolveStyle(xfIndex: number): CellStyle {
+    if (xfIndex < 0 || xfIndex >= cellXfs.length) return {};
+    const xf = cellXfs[xfIndex];
+    const style: CellStyle = {};
+
+    // Font
+    if (xf.applyFont && xf.fontId >= 0 && xf.fontId < fonts.length) {
+      const font = fonts[xf.fontId];
+      if (font.bold) style.fontBold = true;
+      if (font.italic) style.fontItalic = true;
+      if (font.strike) style.fontStrike = true;
+      if (font.underline) style.fontUnderline = font.underline;
+      if (font.vertAlign) style.fontVertAlign = font.vertAlign;
+      if (font.size) style.fontSize = font.size;
+
+      // Font name: resolve scheme to theme font if present
+      if (font.scheme === "minor") {
+        style.fontName = theme.minorFont;
+      } else if (font.scheme === "major") {
+        style.fontName = theme.majorFont;
+      } else if (font.name) {
+        style.fontName = font.name;
+      }
+
+      // Font color
+      const fontColor = resolveColor(font.color, theme, indexedColors, "font");
+      if (fontColor) style.fontColor = prefixHex(fontColor);
+    }
+
+    // Fill
+    if (xf.applyFill && xf.fillId >= 0 && xf.fillId < fills.length) {
+      const fill = fills[xf.fillId];
+      if (fill.gradientType) {
+        const gradientCss = buildGradientCss(fill, theme, indexedColors);
+        if (gradientCss) style.backgroundGradient = gradientCss;
+        // Populate structured gradient data for canvas rendering
+        const gradData = buildGradientData(fill, theme, indexedColors);
+        if (gradData) style.gradientData = gradData;
+      } else if (fill.patternType === "solid") {
+        const fgHex = resolveColor(fill.fgColor, theme, indexedColors, "fill");
+        if (fgHex) style.backgroundColor = prefixHex(fgHex);
+      } else if (fill.patternType && fill.patternType !== "none") {
+        const fgHex = resolveColor(fill.fgColor, theme, indexedColors, "fill");
+        const bgHex = resolveColor(fill.bgColor, theme, indexedColors, "fill");
+        const fg = fgHex ? prefixHex(fgHex) : "#000000";
+        const bg = bgHex ? prefixHex(bgHex) : "#FFFFFF";
+        const patternCss = getPatternFillCSS(fill.patternType, fg, bg);
+        if (patternCss) {
+          style.backgroundPattern = patternCss;
+          style.patternType = fill.patternType;
+        }
+      }
+    }
+
+    // Alignment
+    if (xf.applyAlignment) {
+      if (xf.horizontalAlign === "left" || xf.horizontalAlign === "center" || xf.horizontalAlign === "right") {
+        style.horizontalAlign = xf.horizontalAlign;
+      }
+      if (xf.verticalAlign === "top" || xf.verticalAlign === "bottom") {
+        style.verticalAlign = xf.verticalAlign;
+      } else if (xf.verticalAlign === "center") {
+        style.verticalAlign = "middle";
+      }
+      if (xf.wrapText) style.wrapText = true;
+      if (xf.indent > 0) style.indent = xf.indent;
+      if (xf.textRotation !== 0) {
+        if (xf.textRotation === 255) {
+          style.textRotation = "vertical";
+        } else {
+          style.textRotation = xf.textRotation;
+        }
+      }
+      if (xf.shrinkToFit) style.shrinkToFit = true;
+      if (xf.readingOrder > 0) style.readingOrder = xf.readingOrder;
+    }
+
+    // Borders
+    if (xf.applyBorder && xf.borderId >= 0 && xf.borderId < borders.length) {
+      const border = borders[xf.borderId];
+      if (border.top?.style) style.borderTop = mapBorderStyle(border.top, theme, indexedColors);
+      if (border.right?.style) style.borderRight = mapBorderStyle(border.right, theme, indexedColors);
+      if (border.bottom?.style) style.borderBottom = mapBorderStyle(border.bottom, theme, indexedColors);
+      if (border.left?.style) style.borderLeft = mapBorderStyle(border.left, theme, indexedColors);
+      if (border.diagonal?.style) {
+        style.borderDiagonal = mapBorderStyle(border.diagonal, theme, indexedColors);
+        if (border.diagonalUp) style.diagonalUp = true;
+        if (border.diagonalDown) style.diagonalDown = true;
+      }
+    }
+
+    return style;
+  }
+
+  function getNumFmt(xfIndex: number): string {
+    if (xfIndex < 0 || xfIndex >= cellXfs.length) return "General";
+    const fmtId = cellXfs[xfIndex].numFmtId;
+    if (!cellXfs[xfIndex].applyNumFmt && fmtId === 0) return "General";
+    return customFmts.get(fmtId) ?? BUILTIN_NUM_FMTS[fmtId] ?? "General";
+  }
+
+  return { resolveStyle, getNumFmt, indexedColors };
+}
+
+// =============================================================================
+// Parsing sub-functions
+// =============================================================================
+
+function parseIndexedColors(root: Record<string, unknown>): string[] {
+  const result = [...DEFAULT_INDEXED_COLORS];
+  const colorsEl = root["colors"] as Record<string, unknown> | undefined;
+  if (!colorsEl) return result;
+
+  const indexed = colorsEl["indexedColors"] as Record<string, unknown> | undefined;
+  if (!indexed) return result;
+
+  const rgbColors = indexed["rgbColor"] as Array<Record<string, string>> | undefined;
+  if (!rgbColors) return result;
+
+  for (let i = 0; i < rgbColors.length; i++) {
+    const rgb = rgbColors[i]["@_rgb"];
+    if (rgb) {
+      // AARRGGBB → RRGGBB
+      result[i] = rgb.length === 8 ? rgb.slice(2) : rgb;
+    }
+  }
+
+  return result;
+}
+
+function parseNumFmts(root: Record<string, unknown>): Map<number, string> {
+  const map = new Map<number, string>();
+  const numFmtsEl = root["numFmts"] as Record<string, unknown> | undefined;
+  if (!numFmtsEl) return map;
+
+  const fmts = numFmtsEl["numFmt"] as Array<Record<string, string>> | undefined;
+  if (!fmts) return map;
+
+  for (const fmt of fmts) {
+    const id = parseInt(fmt["@_numFmtId"], 10);
+    const code = fmt["@_formatCode"];
+    if (!isNaN(id) && code) {
+      map.set(id, decodeXmlEntities(code));
+    }
+  }
+
+  return map;
+}
+
+function parseFonts(root: Record<string, unknown>): FontEntry[] {
+  const fontsEl = root["fonts"] as Record<string, unknown> | undefined;
+  if (!fontsEl) return [];
+
+  const fontArr = fontsEl["font"] as Array<Record<string, unknown>> | undefined;
+  if (!fontArr) return [];
+
+  return fontArr.map(parseFont);
+}
+
+function parseFont(el: Record<string, unknown>): FontEntry {
+  const entry: FontEntry = {
+    bold: el["b"] !== undefined,
+    italic: el["i"] !== undefined,
+    strike: el["strike"] !== undefined,
+  };
+
+  const u = el["u"] as Record<string, string> | string | undefined;
+  if (u !== undefined) {
+    if (typeof u === "object" && u["@_val"] === "double") {
+      entry.underline = "double";
+    } else {
+      entry.underline = "single";
+    }
+  }
+
+  const va = el["vertAlign"] as Record<string, string> | undefined;
+  if (va?.["@_val"] === "superscript" || va?.["@_val"] === "subscript") {
+    entry.vertAlign = va["@_val"];
+  }
+
+  const sz = el["sz"] as Record<string, string> | undefined;
+  if (sz?.["@_val"]) entry.size = parseFloat(sz["@_val"]);
+
+  const name = el["name"] as Record<string, string> | undefined;
+  if (name?.["@_val"]) entry.name = name["@_val"];
+
+  const scheme = el["scheme"] as Record<string, string> | undefined;
+  if (scheme?.["@_val"]) entry.scheme = scheme["@_val"];
+
+  const color = el["color"] as Record<string, string> | undefined;
+  if (color) entry.color = parseColorElement(color);
+
+  return entry;
+}
+
+function parseFills(root: Record<string, unknown>): FillEntry[] {
+  const fillsEl = root["fills"] as Record<string, unknown> | undefined;
+  if (!fillsEl) return [];
+
+  const fillArr = fillsEl["fill"] as Array<Record<string, unknown>> | undefined;
+  if (!fillArr) return [];
+
+  return fillArr.map(parseFill);
+}
+
+function parseFill(el: Record<string, unknown>): FillEntry {
+  // Gradient fill
+  const gradientFill = el["gradientFill"] as Record<string, unknown> | undefined;
+  if (gradientFill) {
+    return parseGradientFill(gradientFill);
+  }
+
+  // Pattern fill
+  const patternFill = el["patternFill"] as Record<string, unknown> | undefined;
+  if (!patternFill) return { patternType: "none" };
+
+  const patternType = (patternFill["@_patternType"] as string) ?? "none";
+  const fgColor = patternFill["fgColor"] as Record<string, string> | undefined;
+  const bgColor = patternFill["bgColor"] as Record<string, string> | undefined;
+
+  return {
+    patternType,
+    fgColor: fgColor ? parseColorElement(fgColor) : undefined,
+    bgColor: bgColor ? parseColorElement(bgColor) : undefined,
+  };
+}
+
+function parseGradientFill(el: Record<string, unknown>): FillEntry {
+  const type = (el["@_type"] as string) ?? "linear";
+  const degree = el["@_degree"] !== undefined ? parseFloat(el["@_degree"] as string) : 0;
+
+  const stopArr = el["stop"] as Array<Record<string, unknown>> | undefined;
+  const stops: Array<{ position: number; color: OoxmlColor }> = [];
+  if (stopArr) {
+    for (const stop of stopArr) {
+      const position = parseFloat(stop["@_position"] as string);
+      const colorEl = stop["color"] as Record<string, string> | undefined;
+      if (colorEl && !isNaN(position)) {
+        stops.push({ position, color: parseColorElement(colorEl) });
+      }
+    }
+  }
+
+  return {
+    patternType: "none",
+    gradientType: type,
+    gradientDegree: degree,
+    gradientStops: stops,
+  };
+}
+
+function parseBorders(root: Record<string, unknown>): BorderEntry[] {
+  const bordersEl = root["borders"] as Record<string, unknown> | undefined;
+  if (!bordersEl) return [];
+
+  const borderArr = bordersEl["border"] as Array<Record<string, unknown>> | undefined;
+  if (!borderArr) return [];
+
+  return borderArr.map(parseBorder);
+}
+
+function parseBorder(el: Record<string, unknown>): BorderEntry {
+  return {
+    left: parseBorderSide(el["left"] as Record<string, unknown> | undefined),
+    right: parseBorderSide(el["right"] as Record<string, unknown> | undefined),
+    top: parseBorderSide(el["top"] as Record<string, unknown> | undefined),
+    bottom: parseBorderSide(el["bottom"] as Record<string, unknown> | undefined),
+    diagonal: parseBorderSide(el["diagonal"] as Record<string, unknown> | undefined),
+    diagonalUp: el["@_diagonalUp"] === "1" || el["@_diagonalUp"] === "true",
+    diagonalDown: el["@_diagonalDown"] === "1" || el["@_diagonalDown"] === "true",
+  };
+}
+
+function parseBorderSide(el: Record<string, unknown> | undefined): BorderSide | undefined {
+  if (!el) return undefined;
+  const style = el["@_style"] as string | undefined;
+  if (!style) return undefined;
+
+  const colorEl = el["color"] as Record<string, string> | undefined;
+  return {
+    style,
+    color: colorEl ? parseColorElement(colorEl) : undefined,
+  };
+}
+
+function parseCellXfs(root: Record<string, unknown>): XfEntry[] {
+  const xfsEl = root["cellXfs"] as Record<string, unknown> | undefined;
+  if (!xfsEl) return [];
+
+  const xfArr = xfsEl["xf"] as Array<Record<string, unknown>> | undefined;
+  if (!xfArr) return [];
+
+  return xfArr.map(parseXf);
+}
+
+function parseXf(el: Record<string, unknown>): XfEntry {
+  const alignment = el["alignment"] as Record<string, string> | undefined;
+  return {
+    numFmtId: parseInt((el["@_numFmtId"] as string) ?? "0", 10),
+    fontId: parseInt((el["@_fontId"] as string) ?? "0", 10),
+    fillId: parseInt((el["@_fillId"] as string) ?? "0", 10),
+    borderId: parseInt((el["@_borderId"] as string) ?? "0", 10),
+    applyFont: el["@_applyFont"] === "1" || el["@_applyFont"] === "true" || el["@_fontId"] !== undefined,
+    applyFill: el["@_applyFill"] === "1" || el["@_applyFill"] === "true" || el["@_fillId"] !== undefined,
+    applyBorder: el["@_applyBorder"] === "1" || el["@_applyBorder"] === "true" || el["@_borderId"] !== undefined,
+    applyAlignment: el["@_applyAlignment"] === "1" || el["@_applyAlignment"] === "true" || alignment !== undefined,
+    applyNumFmt: el["@_applyNumberFormat"] === "1" || el["@_applyNumberFormat"] === "true" || (parseInt((el["@_numFmtId"] as string) ?? "0", 10) !== 0),
+    horizontalAlign: alignment?.["@_horizontal"],
+    verticalAlign: alignment?.["@_vertical"],
+    wrapText: alignment?.["@_wrapText"] === "1" || alignment?.["@_wrapText"] === "true",
+    indent: parseInt(alignment?.["@_indent"] ?? "0", 10),
+    textRotation: parseInt(alignment?.["@_textRotation"] ?? "0", 10),
+    shrinkToFit: alignment?.["@_shrinkToFit"] === "1" || alignment?.["@_shrinkToFit"] === "true",
+    readingOrder: parseInt(alignment?.["@_readingOrder"] ?? "0", 10),
+  };
+}
+
+// =============================================================================
+// Border style mapping
+// =============================================================================
+
+function mapBorderStyle(side: BorderSide, theme: ThemeData, indexedColors: string[]): BorderStyle {
+  const colorHex = resolveColor(side.color, theme, indexedColors, "border");
+  const colorCss = colorHex ? prefixHex(colorHex) : undefined;
+
+  switch (side.style) {
+    case "thin":
+      return { width: 1, style: "solid", color: colorCss };
+    case "medium":
+      return { width: 2, style: "solid", color: colorCss };
+    case "thick":
+      return { width: 3, style: "solid", color: colorCss };
+    case "dotted":
+      return { width: 1, style: "dotted", color: colorCss };
+    case "dashed":
+    case "dashDot":
+    case "dashDotDot":
+    case "mediumDashed":
+    case "mediumDashDot":
+    case "mediumDashDotDot":
+      return { width: 1, style: "dashed", color: colorCss };
+    case "double":
+      return { width: 3, style: "double", color: colorCss };
+    case "hair":
+      return { width: 1, style: "solid", color: colorCss };
+    default:
+      return { width: 1, style: "solid", color: colorCss };
+  }
+}
+
+// =============================================================================
+// Gradient CSS
+// =============================================================================
+
+function buildGradientCss(fill: FillEntry, theme: ThemeData, indexedColors: string[]): string | undefined {
+  if (!fill.gradientStops || fill.gradientStops.length < 2) return undefined;
+
+  const cssStops = fill.gradientStops
+    .map((stop) => {
+      const hex = resolveColor(stop.color, theme, indexedColors, "fill");
+      const color = hex ? prefixHex(hex) : "transparent";
+      const position = Math.round(stop.position * 100);
+      return `${color} ${position}%`;
+    })
+    .join(", ");
+
+  if (fill.gradientType === "path") {
+    // Radial gradient — center at 50% 50% by default
+    return `radial-gradient(circle at 50% 50%, ${cssStops})`;
+  }
+
+  return `linear-gradient(${fill.gradientDegree ?? 0}deg, ${cssStops})`;
+}
+
+function buildGradientData(fill: FillEntry, theme: ThemeData, indexedColors: string[]): GradientData | undefined {
+  if (!fill.gradientStops || fill.gradientStops.length < 2) return undefined;
+
+  const stops = fill.gradientStops.map((stop) => {
+    const hex = resolveColor(stop.color, theme, indexedColors, "fill");
+    const color = hex ? prefixHex(hex) : "transparent";
+    return { position: stop.position, color };
+  });
+
+  return {
+    type: fill.gradientType === "path" ? "radial" : "linear",
+    degree: fill.gradientDegree ?? 0,
+    stops,
+  };
+}
+
+// =============================================================================
+// Empty resolver for missing styles.xml
+// =============================================================================
+
+export function emptyStyleResolver(): StyleResolver {
+  return {
+    resolveStyle: () => ({}),
+    getNumFmt: () => "General",
+    indexedColors: [...DEFAULT_INDEXED_COLORS],
+  };
+}

package/src/ooxml_table.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from "vitest";
+import { XMLParser } from "fast-xml-parser";
+import { parseTableXml, extractTableRIds } from "./ooxml_table";
+
+const parser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  isArray: (tagName) => tagName === "tableColumn" || tagName === "Relationship",
+});
+const parseXml = (xml: string) => parser.parse(xml) as Record<string, unknown>;
+
+const TABLE_XML = `<?xml version="1.0"?>
+<table xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" name="Sales" displayName="Sales" ref="A1:C5" headerRowCount="1" totalsRowCount="0">
+  <autoFilter ref="A1:C5"/>
+  <tableColumns count="3">
+    <tableColumn id="1" name="Product"/>
+    <tableColumn id="2" name="Revenue"/>
+    <tableColumn id="3" name="Cost"/>
+  </tableColumns>
+  <tableStyleInfo name="TableStyleMedium2"/>
+</table>`;
+
+const TABLE_WITH_TOTALS_XML = `<?xml version="1.0"?>
+<table xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" name="Budget" displayName="Budget" ref="A1:B6" headerRowCount="1" totalsRowCount="1">
+  <tableColumns count="2">
+    <tableColumn id="1" name="Category"/>
+    <tableColumn id="2" name="Amount" totalsRowFunction="sum"/>
+  </tableColumns>
+</table>`;
+
+describe("parseTableXml", () => {
+  it("parses table name, ref, columns, and flags", () => {
+    const result = parseTableXml(TABLE_XML, parseXml);
+    expect(result.name).toBe("Sales");
+    expect(result.displayName).toBe("Sales");
+    expect(result.ref).toBe("A1:C5");
+    expect(result.headerRow).toBe(true);
+    expect(result.totalsRow).toBe(false);
+    expect(result.autoFilter).toBe(true);
+    expect(result.columns).toHaveLength(3);
+    expect(result.columns[0]).toEqual({ id: 1, name: "Product", totalsFunction: undefined, totalsFormula: undefined });
+    expect(result.columns[1]).toEqual({ id: 2, name: "Revenue", totalsFunction: undefined, totalsFormula: undefined });
+    expect(result.columns[2]).toEqual({ id: 3, name: "Cost", totalsFunction: undefined, totalsFormula: undefined });
+  });
+
+  it("extracts style name", () => {
+    const result = parseTableXml(TABLE_XML, parseXml);
+    expect(result.styleName).toBe("TableStyleMedium2");
+  });
+
+  it("parses table with totals function", () => {
+    const result = parseTableXml(TABLE_WITH_TOTALS_XML, parseXml);
+    expect(result.totalsRow).toBe(true);
+    expect(result.columns[1].totalsFunction).toBe("sum");
+  });
+});
+
+describe("extractTableRIds", () => {
+  it("extracts table relationship IDs", () => {
+    const relsXml = `<?xml version="1.0"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/table" Target="../tables/table1.xml"/>
+  <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing" Target="../drawings/drawing1.xml"/>
+</Relationships>`;
+    const doc = parseXml(relsXml);
+    const result = extractTableRIds(doc);
+    expect(result.size).toBe(1);
+    expect(result.get("rId1")).toBe("../tables/table1.xml");
+  });
+});