@portone/docx-editor 0.1.0

package/dist/numbering/parseNumbering.js

@@ -0,0 +1,116 @@
+// src/numbering/parseNumbering.ts
+import { readTabStopDirectives } from "../ooxml/tabStops.js";
+import { childValue, round, wAttr } from "../ooxml/units.js";
+import { childByLocalName, elementChildren, parseXml } from "../ooxml/xml.js";
+var NUMBER_FORMATS = [
+  "decimal",
+  "bullet",
+  "lowerLetter",
+  "upperLetter",
+  "lowerRoman"
+];
+var EMPTY_NUMBERING = { lists: /* @__PURE__ */ new Map() };
+function toInteger(value) {
+  if (value === null) return null;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isNumberFormat(value) {
+  return NUMBER_FORMATS.some((format) => format === value);
+}
+function indentOf(lvl) {
+  const pPr = childByLocalName(lvl, "pPr");
+  const ind = pPr ? childByLocalName(pPr, "ind") : null;
+  if (!ind) return null;
+  const startTwips = toInteger(wAttr(ind, "start") ?? wAttr(ind, "left"));
+  const endTwips = toInteger(wAttr(ind, "end") ?? wAttr(ind, "right"));
+  const indent = {
+    startTwips,
+    endTwips,
+    hangingTwips: toInteger(wAttr(ind, "hanging")),
+    firstLineTwips: toInteger(wAttr(ind, "firstLine"))
+  };
+  const empty = startTwips === null && endTwips === null && indent.hangingTwips === null && indent.firstLineTwips === null;
+  return empty ? null : indent;
+}
+var NO_LEVEL_INDENT = {
+  startPt: null,
+  endPt: null,
+  textIndentPt: null
+};
+function twipsToPt(twips) {
+  return twips === null ? null : round(twips / 20);
+}
+function levelIndentPt(indent) {
+  if (!indent) return NO_LEVEL_INDENT;
+  const hangingPt = twipsToPt(indent.hangingTwips);
+  return {
+    startPt: twipsToPt(indent.startTwips),
+    endPt: twipsToPt(indent.endTwips),
+    textIndentPt: hangingPt !== null ? -hangingPt : twipsToPt(indent.firstLineTwips)
+  };
+}
+function readLevel(lvl) {
+  const format = childValue(lvl, "numFmt");
+  const pPr = childByLocalName(lvl, "pPr");
+  const tabStops = readTabStopDirectives(pPr);
+  return {
+    format: isNumberFormat(format) ? format : "decimal",
+    text: childValue(lvl, "lvlText") ?? "",
+    start: toInteger(childValue(lvl, "start")) ?? 1,
+    indent: indentOf(lvl),
+    ...tabStops.length === 0 ? {} : { tabStops }
+  };
+}
+function readLevels(parent) {
+  const levels = /* @__PURE__ */ new Map();
+  for (const child of elementChildren(parent)) {
+    if (child.localName !== "lvl") continue;
+    const ilvl = toInteger(wAttr(child, "ilvl"));
+    if (ilvl !== null) levels.set(ilvl, readLevel(child));
+  }
+  return levels;
+}
+function readList(num, abstractLevels) {
+  const abstractNumId = toInteger(childValue(num, "abstractNumId"));
+  if (abstractNumId === null) return null;
+  const levels = new Map(abstractLevels.get(abstractNumId) ?? []);
+  for (const child of elementChildren(num)) {
+    if (child.localName !== "lvlOverride") continue;
+    const ilvl = toInteger(wAttr(child, "ilvl"));
+    if (ilvl === null) continue;
+    const replacement = childByLocalName(child, "lvl");
+    const base = replacement ? readLevel(replacement) : levels.get(ilvl);
+    if (!base) continue;
+    const startOverride = toInteger(childValue(child, "startOverride"));
+    levels.set(
+      ilvl,
+      startOverride === null ? base : { ...base, start: startOverride }
+    );
+  }
+  return { levels };
+}
+function parseNumbering(xml) {
+  if (xml === null) return EMPTY_NUMBERING;
+  const root = parseXml(xml).documentElement;
+  const abstractLevels = /* @__PURE__ */ new Map();
+  for (const child of elementChildren(root)) {
+    if (child.localName !== "abstractNum") continue;
+    const id = toInteger(wAttr(child, "abstractNumId"));
+    if (id !== null) abstractLevels.set(id, readLevels(child));
+  }
+  const lists = /* @__PURE__ */ new Map();
+  for (const child of elementChildren(root)) {
+    if (child.localName !== "num") continue;
+    const numId = toInteger(wAttr(child, "numId"));
+    const list = numId === null ? null : readList(child, abstractLevels);
+    if (numId !== null && list) lists.set(numId, list);
+  }
+  return { lists };
+}
+export {
+  EMPTY_NUMBERING,
+  NO_LEVEL_INDENT,
+  levelIndentPt,
+  parseNumbering
+};

package/dist/numbering/writeNumbering.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Splices the definitions of newly started lists into the original numbering.xml.
+ *
+ * Not one character of the original is altered; new elements are merely slotted in at
+ * two places.
+ * OOXML requires the definitions (`abstractNum`) to come before the numbers (`num`), so
+ * the definitions go in front of the first number and the numbers go at the very end.
+ */
+/**
+ * numbering.xml with a standard template definition added for every list number.
+ * When there is nothing to add, the original string is returned unchanged.
+ */
+export declare function addListDefinitions(xml: string, numIds: readonly number[]): string;

package/dist/numbering/writeNumbering.js

@@ -0,0 +1,49 @@
+// src/numbering/writeNumbering.ts
+import { DocxExportError } from "../ooxml/errors.js";
+import { wAttr } from "../ooxml/units.js";
+import { elementChildren, parseXml } from "../ooxml/xml.js";
+import { abstractNumXml, listKindOf, numXml } from "./listTemplate.js";
+function openTagAt(xml, name) {
+  const match = new RegExp(`<(?:[A-Za-z_][\\w.-]*:)?${name}[\\s/>]`).exec(xml);
+  return match ? match.index : null;
+}
+function closeTagAt(xml, name) {
+  const matches = Array.from(
+    xml.matchAll(new RegExp(`</(?:[A-Za-z_][\\w.-]*:)?${name}\\s*>`, "g"))
+  );
+  return matches.at(-1)?.index ?? null;
+}
+function maxAbstractNumId(xml) {
+  let max = 0;
+  for (const child of elementChildren(parseXml(xml).documentElement)) {
+    if (child.localName !== "abstractNum") continue;
+    const id = Number.parseInt(wAttr(child, "abstractNumId") ?? "", 10);
+    if (Number.isFinite(id)) max = Math.max(max, id);
+  }
+  return max;
+}
+function addListDefinitions(xml, numIds) {
+  if (numIds.length === 0) return xml;
+  const rootEnd = closeTagAt(xml, "numbering");
+  if (rootEnd === null) {
+    throw new DocxExportError(
+      "malformed-xml",
+      "no closing tag found in numbering.xml"
+    );
+  }
+  const numsAt = openTagAt(xml, "numIdMacAtCleanup") ?? rootEnd;
+  const definitionsAt = openTagAt(xml, "num") ?? numsAt;
+  const firstAbstractNumId = maxAbstractNumId(xml) + 1;
+  const additions = [...numIds].sort((a, b) => a - b).map((numId, index) => ({
+    numId,
+    abstractNumId: firstAbstractNumId + index
+  }));
+  const definitions = additions.map(
+    (added) => abstractNumXml(added.abstractNumId, listKindOf(added.numId))
+  ).join("");
+  const nums = additions.map((added) => numXml(added.numId, added.abstractNumId)).join("");
+  return xml.slice(0, definitionsAt) + definitions + xml.slice(definitionsAt, numsAt) + nums + xml.slice(numsAt);
+}
+export {
+  addListDefinitions
+};

package/dist/ooxml/errors.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The error kinds used when opening and exporting a docx.
+ *
+ * Messages are English one-liners meant for developers. The `code` is the stable,
+ * machine-readable part: consumers switch on it to show their own localized text,
+ * so a code never changes meaning even when a message is reworded.
+ */
+/**
+ * Why a document could not be opened.
+ *
+ * - `not-a-docx`: the bytes are not a readable zip container, its entry names are not a package's, or an entry does not hold what it says it does
+ * - `too-large`: the package asks to inflate to more than we open
+ * - `missing-part`: the package has no main document part to read
+ * - `missing-body`: the main part carries no `w:body`
+ * - `malformed-xml`: the XML cannot be parsed, declares a DTD, or its markup is inconsistent
+ * - `unsupported-content`: the document holds markup we cannot write back out unchanged
+ */
+export type DocxImportErrorCode = "not-a-docx" | "too-large" | "missing-part" | "missing-body" | "malformed-xml" | "unsupported-content";
+/** Thrown when we hit a document whose content cannot be kept safely. We refuse to open it instead of losing it silently */
+export declare class DocxImportError extends Error {
+    readonly code: DocxImportErrorCode;
+    constructor(code: DocxImportErrorCode, message: string, options?: ErrorOptions);
+}
+/**
+ * Why a document could not be written back out.
+ *
+ * - `missing-numbering-part`: a new list needs a numbering.xml the document does not have
+ * - `missing-content-types`: a new image needs a [Content_Types].xml the package does not have
+ * - `unsupported-content`: the document holds a node kind we have no way to serialize
+ * - `lost-original`: a node that only carries its original XML has lost it
+ * - `malformed-xml`: an original XML fragment cannot be read well enough to rewrite
+ * - `invalid-table`: the table grid is inconsistent, e.g. a vertical merge outliving its rows
+ */
+export type DocxExportErrorCode = "missing-numbering-part" | "missing-content-types" | "unsupported-content" | "lost-original" | "malformed-xml" | "invalid-table";
+/** Thrown when an edited document cannot be written back out without losing or corrupting content */
+export declare class DocxExportError extends Error {
+    readonly code: DocxExportErrorCode;
+    constructor(code: DocxExportErrorCode, message: string, options?: ErrorOptions);
+}

package/dist/ooxml/errors.js

@@ -0,0 +1,21 @@
+// src/ooxml/errors.ts
+var DocxImportError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "DocxImportError";
+    this.code = code;
+  }
+};
+var DocxExportError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "DocxExportError";
+    this.code = code;
+  }
+};
+export {
+  DocxExportError,
+  DocxImportError
+};

package/dist/ooxml/image.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The inline picture: the values an image node carries, and the DrawingML those values
+ * are read out of and written back into.
+ *
+ * Only the one shape a docx uses for a plain inline picture is interpreted: a
+ * `w:drawing` holding a `wp:inline` whose graphic is a `pic:pic` with an embedded blip.
+ * A floating anchor, a chart or a diagram, a blip linked to a file outside the package,
+ * an image kind a browser cannot draw - all of those are left to the preservation path
+ * that was already there, so nothing we cannot draw is ever rewritten.
+ *
+ * An imported image holds on to its whole original `<w:drawing>` XML, so an untouched
+ * image goes back out byte for byte. A resize rewrites nothing but the two extents.
+ */
+/**
+ * English Metric Units, the unit every DrawingML length is written in.
+ * At 96dpi one CSS pixel is 9525 of them.
+ */
+export declare const EMU_PER_PX = 9525;
+export declare function emuToPx(emu: number): number;
+export declare function pxToEmu(px: number): number;
+/**
+ * The size a drawing is shown at.
+ *
+ * It is kept in EMU rather than in pixels because EMU is the document's own unit:
+ * reading it and writing it back is exact, so an image nobody resized goes out carrying
+ * the very numbers it came in with. Pixels are derived from it for the screen only.
+ */
+export interface ImageExtent {
+    cx: number;
+    cy: number;
+}
+/**
+ * The image kinds we both draw on screen and write back into a package.
+ *
+ * A document may embed a tiff or an emf as well; we do not interpret those, because a
+ * browser cannot draw them and a broken picture on screen is worse than the preserved
+ * placeholder.
+ */
+export declare const IMAGE_MIMES: readonly ["image/png", "image/jpeg", "image/gif", "image/bmp"];
+export type ImageMime = (typeof IMAGE_MIMES)[number];
+export declare function isImageMime(value: unknown): value is ImageMime;
+/** The image bytes as a data URL. null for anything else */
+export declare function toImageSrc(value: unknown): string | null;
+/** The kind a src declares. It has already been checked by `toImageSrc` */
+export declare function imageMimeOf(src: string): ImageMime | null;
+/** The base64 payload of a src. It has already been checked by `toImageSrc` */
+export declare function imageBase64Of(src: string): string;
+export declare function toImageExtent(value: unknown): ImageExtent | null;
+/** What one inline picture states about itself */
+export interface DrawingPicture {
+    /** The relationship id the image bytes hang off */
+    relId: string;
+    extent: ImageExtent;
+    /** The alternative text, from `wp:docPr descr`. null when there is none */
+    alt: string | null;
+}
+/**
+ * Reads a `w:drawing` as an inline picture. null for a drawing we do not interpret,
+ * which leaves the caller on the preservation path.
+ *
+ * Children we do not know about (`wp14` extensions, a crop, a rotation) do not stop us,
+ * because the original XML is kept whole and goes back out as it came.
+ */
+export declare function readDrawingPicture(drawing: Element): DrawingPicture | null;
+/**
+ * The same drawing XML with both extents set to this size.
+ *
+ * Only those two elements are touched; every other byte of the original stays where it
+ * was. Handed the size it was imported with, this gives back the original string
+ * unchanged, so nothing has to keep track of whether a resize happened.
+ */
+export declare function withExtent(xml: string, extent: ImageExtent): string;
+/** A picture that was inserted during editing and has no original XML to go back to */
+export interface NewImage {
+    relId: string;
+    /** The drawing's id within the document. Word shows it in the selection pane */
+    docPrId: number;
+    extent: ImageExtent;
+    alt: string | null;
+}
+/**
+ * The smallest `w:drawing` Word opens as an inline picture.
+ *
+ * Every prefix used is declared right where it is used. The document element declares
+ * some of them already, but not all producers declare `a` and `pic`, and a duplicate
+ * declaration of the same namespace costs nothing.
+ */
+export declare function imageDrawingXml(image: NewImage): string;

package/dist/ooxml/image.js

@@ -0,0 +1,106 @@
+// src/ooxml/image.ts
+import { childByLocalName, escapeXml, R_NS } from "./xml.js";
+var EMU_PER_PX = 9525;
+function emuToPx(emu) {
+  return emu / EMU_PER_PX;
+}
+function pxToEmu(px) {
+  return Math.round(px * EMU_PER_PX);
+}
+var IMAGE_MIMES = [
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/bmp"
+];
+var IMAGE_DATA_URL = new RegExp(
+  `^data:(?:${IMAGE_MIMES.join("|")});base64,[A-Za-z0-9+/]+={0,2}$`
+);
+function isImageMime(value) {
+  return IMAGE_MIMES.some((mime) => mime === value);
+}
+function toImageSrc(value) {
+  return typeof value === "string" && IMAGE_DATA_URL.test(value) ? value : null;
+}
+function imageMimeOf(src) {
+  const mime = src.slice("data:".length, src.indexOf(";"));
+  return isImageMime(mime) ? mime : null;
+}
+function imageBase64Of(src) {
+  return src.slice(src.indexOf(",") + 1);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function positiveInt(value) {
+  const parsed = typeof value === "string" ? Number.parseInt(value, 10) : value;
+  return typeof parsed === "number" && Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function toImageExtent(value) {
+  if (!isRecord(value)) return null;
+  const cx = positiveInt(value.cx);
+  const cy = positiveInt(value.cy);
+  return cx === null || cy === null ? null : { cx, cy };
+}
+var PICTURE_URI = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+function childOf(el, name) {
+  return el ? childByLocalName(el, name) : null;
+}
+function relAttr(el, name) {
+  return el.getAttributeNS(R_NS, name) ?? el.getAttribute(`r:${name}`);
+}
+function readExtent(el) {
+  if (!el) return null;
+  return toImageExtent({
+    cx: el.getAttribute("cx"),
+    cy: el.getAttribute("cy")
+  });
+}
+function readDrawingPicture(drawing) {
+  const inline = childOf(drawing, "inline");
+  if (!inline) return null;
+  const extent = readExtent(childOf(inline, "extent"));
+  if (!extent) return null;
+  const graphicData = childOf(childOf(inline, "graphic"), "graphicData");
+  if (!graphicData || graphicData.getAttribute("uri") !== PICTURE_URI) {
+    return null;
+  }
+  const blip = childOf(
+    childOf(childOf(graphicData, "pic"), "blipFill"),
+    "blip"
+  );
+  if (!blip) return null;
+  if (relAttr(blip, "link") !== null) return null;
+  const relId = relAttr(blip, "embed");
+  if (relId === null) return null;
+  const descr = childOf(inline, "docPr")?.getAttribute("descr") ?? null;
+  return { relId, extent, alt: descr === "" ? null : descr };
+}
+var EXTENT_TAG = /<([\w.-]+:)?extent\b[^>]*\/>/g;
+var EXT_TAG = /<([\w.-]+:)?ext\b[^>]*\/>/g;
+function withExtent(xml, extent) {
+  const size = `cx="${extent.cx}" cy="${extent.cy}"`;
+  return xml.replace(EXTENT_TAG, (_match, prefix) => `<${prefix ?? ""}extent ${size}/>`).replace(EXT_TAG, (_match, prefix) => `<${prefix ?? ""}ext ${size}/>`);
+}
+var WP_NS = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+var A_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
+function imageDrawingXml(image) {
+  const size = `cx="${image.extent.cx}" cy="${image.extent.cy}"`;
+  const name = `Picture ${image.docPrId}`;
+  const descr = image.alt === null ? "" : ` descr="${escapeXml(image.alt)}"`;
+  return `<w:drawing><wp:inline xmlns:wp="${WP_NS}" distT="0" distB="0" distL="0" distR="0"><wp:extent ${size}/><wp:effectExtent l="0" t="0" r="0" b="0"/><wp:docPr id="${image.docPrId}" name="${name}"${descr}/><wp:cNvGraphicFramePr><a:graphicFrameLocks xmlns:a="${A_NS}" noChangeAspect="1"/></wp:cNvGraphicFramePr><a:graphic xmlns:a="${A_NS}"><a:graphicData uri="${PICTURE_URI}"><pic:pic xmlns:pic="${PICTURE_URI}"><pic:nvPicPr><pic:cNvPr id="${image.docPrId}" name="${name}"${descr}/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip xmlns:r="${R_NS}" r:embed="${escapeXml(image.relId)}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext ${size}/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing>`;
+}
+export {
+  EMU_PER_PX,
+  IMAGE_MIMES,
+  emuToPx,
+  imageBase64Of,
+  imageDrawingXml,
+  imageMimeOf,
+  isImageMime,
+  pxToEmu,
+  readDrawingPicture,
+  toImageExtent,
+  toImageSrc,
+  withExtent
+};

package/dist/ooxml/tabStops.d.ts

@@ -0,0 +1,3 @@
+import type { TabStopDirective } from "../model/tabStops";
+/** Reads one `w:tabs` property without resolving the paragraph-property hierarchy. */
+export declare function readTabStopDirectives(pPr: Element | null): TabStopDirective[];

package/dist/ooxml/tabStops.js

@@ -0,0 +1,51 @@
+// src/ooxml/tabStops.ts
+import { twipsToPt, wAttr } from "./units.js";
+import { childByLocalName } from "./xml.js";
+var ALIGN_BY_VALUE = {
+  left: "start",
+  start: "start",
+  center: "center",
+  right: "end",
+  end: "end",
+  decimal: "decimal",
+  num: "num",
+  bar: "bar",
+  clear: "clear"
+};
+var LEADERS = /* @__PURE__ */ new Set([
+  "none",
+  "dot",
+  "hyphen",
+  "underscore",
+  "heavy",
+  "middleDot"
+]);
+function tabLeader(value) {
+  return value !== null && LEADERS.has(value) ? value : void 0;
+}
+function readTabStopDirectives(pPr) {
+  if (!pPr) return [];
+  const tabs = childByLocalName(pPr, "tabs");
+  if (!tabs) return [];
+  const stops = [];
+  for (const tab of Array.from(tabs.children)) {
+    if (tab.localName !== "tab") continue;
+    const positionPt = twipsToPt(wAttr(tab, "pos"));
+    const align = ALIGN_BY_VALUE[wAttr(tab, "val") ?? ""];
+    if (positionPt === null || align === void 0) continue;
+    if (align === "clear") {
+      stops.push({ positionPt, align });
+      continue;
+    }
+    const leader = tabLeader(wAttr(tab, "leader"));
+    stops.push({
+      positionPt,
+      align,
+      ...leader === void 0 ? {} : { leader }
+    });
+  }
+  return stops;
+}
+export {
+  readTabStopDirectives
+};

package/dist/ooxml/units.d.ts

@@ -0,0 +1,37 @@
+import { type ParagraphAlign } from "../model/format";
+/** The alignment `w:jc` writes down, both for a paragraph and for a table */
+export declare const ALIGN_BY_JC: Record<string, ParagraphAlign>;
+/** A color as the document writes it, six hex digits and no `#`. Null for anything else */
+export declare function normalizeHex(value: string): string | null;
+export declare function wAttr(el: Element, name: string): string | null;
+/** `<w:b/>` means on, `<w:b w:val="0"/>` means off */
+export declare function isOn(parent: Element, name: string): boolean;
+export declare function childValue(parent: Element, name: string): string | null;
+export declare function toNumber(value: string | null): number | null;
+/** Cuts off the messy digits after the decimal point so the same input always yields the same value */
+export declare function round(value: number): number;
+/** twip (1/20 of a point) */
+export declare function twipsToPt(value: string | null): number | null;
+/** half-point (w:sz 20 = 10pt) */
+export declare function halfPointsToPt(value: string | null): number | null;
+/** 1/8 of a point */
+export declare function eighthsToPt(value: string | null): number | null;
+export declare function toHexColor(value: string | null): string | null;
+/**
+ * Moves one border side into a CSS value.
+ *
+ * A side the document has pinned down as "draw no line here" becomes `none`.
+ * A kind we do not know, or a side that is not there at all, becomes null, so the caller can pick a default.
+ * A side that draws a line but writes down no thickness gets the default one: reading it as "no
+ * line" would take away a line the style laid down.
+ */
+export declare function borderCss(el: Element | null): string | null;
+/** One side inside `w:tblBorders` or `w:tcBorders` */
+export declare function borderSide(borders: Element | null, side: string): string | null;
+/**
+ * The background color from `w:shd`. For a pattern fill we only look at the color.
+ *
+ * A shading with no color to fill with (`w:fill="auto"`, or none at all) says to paint nothing, so
+ * it reads back as `NO_FILL`. That is what takes a fill a style laid down back off, the way Word does.
+ */
+export declare function shadingOf(parent: Element): string | null;

package/dist/ooxml/units.js

@@ -0,0 +1,116 @@
+// src/ooxml/units.ts
+import { NO_FILL } from "../model/format.js";
+import { childByLocalName, W_NS } from "./xml.js";
+var ALIGN_BY_JC = {
+  left: "left",
+  start: "left",
+  center: "center",
+  right: "right",
+  end: "right",
+  both: "justify",
+  distribute: "justify"
+};
+function normalizeHex(value) {
+  const hex = value.startsWith("#") ? value.slice(1) : value;
+  return /^[0-9a-fA-F]{6}$/.test(hex) ? hex.toUpperCase() : null;
+}
+function wAttr(el, name) {
+  return el.getAttributeNS(W_NS, name) ?? el.getAttribute(name);
+}
+function isOn(parent, name) {
+  const el = childByLocalName(parent, name);
+  if (!el) return false;
+  const value = wAttr(el, "val");
+  return value === null || value === "1" || value === "true" || value === "on";
+}
+function childValue(parent, name) {
+  const el = childByLocalName(parent, name);
+  return el ? wAttr(el, "val") : null;
+}
+function toNumber(value) {
+  if (value === null) return null;
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function round(value) {
+  return Math.round(value * 100) / 100;
+}
+function twipsToPt(value) {
+  const twips = toNumber(value);
+  return twips === null ? null : round(twips / 20);
+}
+function halfPointsToPt(value) {
+  const half = toNumber(value);
+  return half === null ? null : round(half / 2);
+}
+function eighthsToPt(value) {
+  const eighths = toNumber(value);
+  return eighths === null ? null : round(eighths / 8);
+}
+function toHexColor(value) {
+  if (value === null || value === "auto") return null;
+  return /^[0-9a-fA-F]{6}$/.test(value) ? `#${value}` : null;
+}
+var BORDER_STYLE_BY_VAL = {
+  single: "solid",
+  thick: "solid",
+  double: "double",
+  dotted: "dotted",
+  dashed: "dashed",
+  dotDash: "dashed",
+  wave: "solid",
+  outset: "solid",
+  inset: "solid",
+  threeDEmboss: "solid",
+  threeDEngrave: "solid",
+  triple: "double",
+  doubleWave: "double",
+  thinThickSmallGap: "double",
+  thickThinSmallGap: "double",
+  thinThickThinSmallGap: "double",
+  thinThickMediumGap: "double",
+  thickThinMediumGap: "double",
+  thinThickThinMediumGap: "double",
+  thinThickLargeGap: "double",
+  thickThinLargeGap: "double",
+  thinThickThinLargeGap: "double",
+  dashSmallGap: "dashed",
+  dotDotDash: "dashed",
+  dashDotStroked: "dashed"
+};
+var FALLBACK_BORDER_PT = 0.5;
+function borderCss(el) {
+  if (!el) return null;
+  const val = wAttr(el, "val") ?? "";
+  if (val === "nil" || val === "none") return "none";
+  const style = BORDER_STYLE_BY_VAL[val];
+  if (!style) return null;
+  const written = eighthsToPt(wAttr(el, "sz"));
+  const widthPt = written === null || written === 0 ? FALLBACK_BORDER_PT : written;
+  const color = toHexColor(wAttr(el, "color")) ?? "#000000";
+  return `${widthPt}pt ${style} ${color}`;
+}
+function borderSide(borders, side) {
+  return borders ? borderCss(childByLocalName(borders, side)) : null;
+}
+function shadingOf(parent) {
+  const shd = childByLocalName(parent, "shd");
+  if (!shd) return null;
+  return toHexColor(wAttr(shd, "fill")) ?? NO_FILL;
+}
+export {
+  ALIGN_BY_JC,
+  borderCss,
+  borderSide,
+  childValue,
+  eighthsToPt,
+  halfPointsToPt,
+  isOn,
+  normalizeHex,
+  round,
+  shadingOf,
+  toHexColor,
+  toNumber,
+  twipsToPt,
+  wAttr
+};