boxpdf-html 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2838 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  fontFamily: () => fontFamily,
+  htmlToBoxpdf: () => htmlToBoxpdf,
+  parseHtml: () => parseHtml
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/css.ts
+var import_css_tree = require("css-tree");
+
+// src/color.ts
+var namedColors = {
+  black: "#000000",
+  white: "#ffffff",
+  red: "#ff0000",
+  green: "#008000",
+  blue: "#0000ff",
+  transparent: "transparent"
+};
+function parseColor(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  const resolved = namedColors[normalized] ?? normalized;
+  if (resolved === "transparent") return void 0;
+  const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(resolved);
+  if (hex) {
+    const body = hex[1];
+    const rgb2 = body.length === 4 ? body.slice(0, 3) : body.length === 8 ? body.slice(0, 6) : body;
+    const full = rgb2.length === 3 ? rgb2.split("").map((c) => c + c).join("") : rgb2;
+    return {
+      r: Number.parseInt(full.slice(0, 2), 16) / 255,
+      g: Number.parseInt(full.slice(2, 4), 16) / 255,
+      b: Number.parseInt(full.slice(4, 6), 16) / 255
+    };
+  }
+  const rgb = parseRgbFunction(resolved);
+  if (rgb) return rgb;
+  const hsl = parseHslFunction(resolved);
+  if (hsl) return hsl;
+  const oklch = parseOklchFunction(resolved);
+  if (oklch) return oklch;
+  return void 0;
+}
+function parseRgbFunction(value) {
+  const match = /^rgba?\(\s*(.+)\s*\)$/.exec(value);
+  if (!match) return void 0;
+  const body = match[1].split("/")[0].trim();
+  const parts = body.includes(",") ? body.split(",") : body.split(/\s+/);
+  if (parts.length < 3) return void 0;
+  const channels = parts.slice(0, 3).map((part) => parseRgbChannel(part.trim()));
+  if (channels.some((channel) => channel === void 0)) return void 0;
+  return {
+    r: channels[0],
+    g: channels[1],
+    b: channels[2]
+  };
+}
+function parseRgbChannel(value) {
+  const percent = /^(-?[0-9.]+)%$/.exec(value);
+  if (percent) {
+    const amount2 = Number(percent[1]);
+    return Number.isFinite(amount2) ? clamp01(amount2 / 100) : void 0;
+  }
+  const amount = Number(value);
+  return Number.isFinite(amount) ? clamp255(amount) : void 0;
+}
+function parseHslFunction(value) {
+  const match = /^hsla?\(\s*(.+)\s*\)$/.exec(value);
+  if (!match) return void 0;
+  const body = match[1].split("/")[0].trim();
+  const parts = body.includes(",") ? body.split(",") : body.split(/\s+/);
+  if (parts.length < 3) return void 0;
+  const hue = parseHue(parts[0].trim());
+  const saturation = parsePercentChannel(parts[1].trim());
+  const lightness = parsePercentChannel(parts[2].trim());
+  if (hue === void 0 || saturation === void 0 || lightness === void 0) return void 0;
+  return hslToRgb(hue, saturation, lightness);
+}
+function parseHue(value) {
+  const match = /^(-?[0-9.]+)(deg|turn|rad)?$/.exec(value);
+  if (!match) return void 0;
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount)) return void 0;
+  const unit = match[2] ?? "deg";
+  if (unit === "turn") return amount * 360;
+  if (unit === "rad") return amount * (180 / Math.PI);
+  return amount;
+}
+function parseOklchFunction(value) {
+  const match = /^oklch\(\s*(.+)\s*\)$/.exec(value);
+  if (!match) return void 0;
+  const body = match[1].split("/")[0].trim();
+  const parts = body.split(/\s+/);
+  if (parts.length < 3) return void 0;
+  const lightness = parseOklchLightness(parts[0]);
+  const chroma = Number(parts[1]);
+  const hue = parseHue(parts[2]);
+  if (lightness === void 0 || !Number.isFinite(chroma) || hue === void 0) return void 0;
+  return oklchToRgb(lightness, chroma, hue);
+}
+function parseOklchLightness(value) {
+  const percent = /^(-?[0-9.]+)%$/.exec(value);
+  if (percent) {
+    const amount2 = Number(percent[1]);
+    return Number.isFinite(amount2) ? clamp01(amount2 / 100) : void 0;
+  }
+  const amount = Number(value);
+  return Number.isFinite(amount) ? clamp01(amount) : void 0;
+}
+function oklchToRgb(lightness, chroma, hue) {
+  const radians = hue * Math.PI / 180;
+  const a = chroma * Math.cos(radians);
+  const b = chroma * Math.sin(radians);
+  const lPrime = lightness + 0.3963377774 * a + 0.2158037573 * b;
+  const mPrime = lightness - 0.1055613458 * a - 0.0638541728 * b;
+  const sPrime = lightness - 0.0894841775 * a - 1.291485548 * b;
+  const l = lPrime ** 3;
+  const m = mPrime ** 3;
+  const s = sPrime ** 3;
+  return {
+    r: linearSrgbToRgb(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
+    g: linearSrgbToRgb(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
+    b: linearSrgbToRgb(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s)
+  };
+}
+function linearSrgbToRgb(value) {
+  const converted = value <= 31308e-7 ? 12.92 * value : 1.055 * value ** (1 / 2.4) - 0.055;
+  return clamp01(converted);
+}
+function parsePercentChannel(value) {
+  const match = /^(-?[0-9.]+)%$/.exec(value);
+  if (!match) return void 0;
+  const amount = Number(match[1]);
+  return Number.isFinite(amount) ? clamp01(amount / 100) : void 0;
+}
+function hslToRgb(hue, saturation, lightness) {
+  const normalizedHue = (hue % 360 + 360) % 360 / 360;
+  if (saturation === 0) return { r: lightness, g: lightness, b: lightness };
+  const q = lightness < 0.5 ? lightness * (1 + saturation) : lightness + saturation - lightness * saturation;
+  const p = 2 * lightness - q;
+  return {
+    r: hueToRgb(p, q, normalizedHue + 1 / 3),
+    g: hueToRgb(p, q, normalizedHue),
+    b: hueToRgb(p, q, normalizedHue - 1 / 3)
+  };
+}
+function hueToRgb(p, q, t) {
+  let value = t;
+  if (value < 0) value += 1;
+  if (value > 1) value -= 1;
+  if (value < 1 / 6) return p + (q - p) * 6 * value;
+  if (value < 1 / 2) return q;
+  if (value < 2 / 3) return p + (q - p) * (2 / 3 - value) * 6;
+  return p;
+}
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function clamp255(value) {
+  return clamp01(value / 255);
+}
+
+// src/units.ts
+var ROOT_FONT_SIZE = 12;
+var VIEWPORT_WIDTH = 612;
+var VIEWPORT_HEIGHT = 792;
+function parseLength(value, fontSize) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "auto" || normalized.endsWith("%")) return void 0;
+  if (isCalc(normalized)) {
+    const parsed = parseLengthPercentage(normalized, fontSize);
+    return parsed && parsed.percent === 0 ? parsed.length : void 0;
+  }
+  return parseSimpleLength(normalized, fontSize);
+}
+function parsePercentage(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (isCalc(normalized)) {
+    const parsed = parseLengthPercentage(normalized, 12);
+    return parsed && parsed.length === 0 ? parsed.percent : void 0;
+  }
+  const match = /^(-?[0-9.]+)%$/.exec(normalized);
+  if (!match) return void 0;
+  const amount = Number(match[1]);
+  return Number.isFinite(amount) ? amount / 100 : void 0;
+}
+function parseLengthPercentage(value, fontSize) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  return parseCalcLengthPercentage(normalized, fontSize);
+}
+function parseLineHeight(value, fontSize) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "normal") return void 0;
+  const unitless = /^([0-9.]+)$/.exec(normalized);
+  if (unitless) return Number(unitless[1]) * fontSize;
+  if (isCalc(normalized)) {
+    const number = parseCalcNumber(normalized);
+    if (number !== void 0) return number * fontSize;
+  }
+  return parseLength(normalized, fontSize);
+}
+function parseLineHeightScale(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  const unitless = /^([0-9.]+)$/.exec(normalized);
+  if (unitless) return Number(unitless[1]);
+  if (!isCalc(normalized)) return void 0;
+  return parseCalcNumber(normalized);
+}
+function isCalc(value) {
+  return /^calc\(.+\)$/.test(value);
+}
+function parseSimplePercentage(value) {
+  const match = /^(-?[0-9.]+)%$/.exec(value);
+  if (!match) return void 0;
+  const amount = Number(match[1]);
+  return Number.isFinite(amount) ? amount / 100 : void 0;
+}
+function parseSimpleLength(value, fontSize) {
+  const match = /^(-?[0-9.]+)(px|pt|em|rem|vw|vh)?$/.exec(value);
+  if (!match) return void 0;
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount)) return void 0;
+  const unit = match[2] ?? "px";
+  if (unit === "pt") return amount;
+  if (unit === "em") return amount * fontSize;
+  if (unit === "rem") return amount * ROOT_FONT_SIZE;
+  if (unit === "vw") return amount / 100 * VIEWPORT_WIDTH;
+  if (unit === "vh") return amount / 100 * VIEWPORT_HEIGHT;
+  return amount * 0.75;
+}
+function parseCalcLengthPercentage(value, fontSize) {
+  const stripped = stripCalc(value.trim());
+  const simplePercent = parseSimplePercentage(stripped);
+  if (simplePercent !== void 0) return { length: 0, percent: simplePercent };
+  const simpleLength = parseSimpleLength(stripped, fontSize);
+  if (simpleLength !== void 0) return { length: simpleLength, percent: 0 };
+  const sum = topLevelOperator(stripped, ["+", "-"]);
+  if (sum) {
+    const left = parseCalcLengthPercentage(stripped.slice(0, sum.index), fontSize);
+    const right = parseCalcLengthPercentage(stripped.slice(sum.index + 1), fontSize);
+    if (!left || !right) return void 0;
+    const sign = sum.operator === "-" ? -1 : 1;
+    return { length: left.length + sign * right.length, percent: left.percent + sign * right.percent };
+  }
+  const product = topLevelOperator(stripped, ["*", "/"]);
+  if (product) {
+    const leftRaw = stripped.slice(0, product.index);
+    const rightRaw = stripped.slice(product.index + 1);
+    const leftLength = parseCalcLengthPercentage(leftRaw, fontSize);
+    const rightLength = parseCalcLengthPercentage(rightRaw, fontSize);
+    const leftNumber = parseCalcNumber(leftRaw);
+    const rightNumber = parseCalcNumber(rightRaw);
+    if (product.operator === "*" && leftLength && rightNumber !== void 0) {
+      return { length: leftLength.length * rightNumber, percent: leftLength.percent * rightNumber };
+    }
+    if (product.operator === "*" && rightLength && leftNumber !== void 0) {
+      return { length: rightLength.length * leftNumber, percent: rightLength.percent * leftNumber };
+    }
+    if (product.operator === "/" && leftLength && rightNumber !== void 0 && rightNumber !== 0) {
+      return { length: leftLength.length / rightNumber, percent: leftLength.percent / rightNumber };
+    }
+  }
+  return void 0;
+}
+function parseCalcNumber(value) {
+  const stripped = stripCalc(value.trim());
+  const sum = topLevelOperator(stripped, ["+", "-"]);
+  if (sum) {
+    const left = parseCalcNumber(stripped.slice(0, sum.index));
+    const right = parseCalcNumber(stripped.slice(sum.index + 1));
+    if (left === void 0 || right === void 0) return void 0;
+    return sum.operator === "-" ? left - right : left + right;
+  }
+  const product = topLevelOperator(stripped, ["*", "/"]);
+  if (product) {
+    const left = parseCalcNumber(stripped.slice(0, product.index));
+    const right = parseCalcNumber(stripped.slice(product.index + 1));
+    if (left === void 0 || right === void 0) return void 0;
+    return product.operator === "/" ? right === 0 ? void 0 : left / right : left * right;
+  }
+  const number = Number(stripped);
+  return Number.isFinite(number) ? number : void 0;
+}
+function stripCalc(value) {
+  let out = value.trim();
+  while (isCalc(out)) out = out.slice(5, -1).trim();
+  return out;
+}
+function topLevelOperator(value, operators) {
+  let depth = 0;
+  for (let index = value.length - 1; index >= 0; index -= 1) {
+    const char = value[index];
+    if (char === ")") depth += 1;
+    else if (char === "(") depth = Math.max(0, depth - 1);
+    else if (depth === 0 && operators.includes(char)) {
+      const prev = value[index - 1];
+      if ((char === "+" || char === "-") && (index === 0 || prev === void 0 || /[+\-*/(]/.test(prev))) continue;
+      return { operator: char, index };
+    }
+  }
+  return void 0;
+}
+
+// src/css.ts
+function parseStylesheets(stylesheets) {
+  let order = 0;
+  const rules = [];
+  for (const css of stylesheets) {
+    const ast = (0, import_css_tree.parse)(css, { parseValue: false, parseCustomProperty: false });
+    (0, import_css_tree.walk)(ast, (node) => {
+      if (node.type !== "Rule") return;
+      const prelude = node.prelude;
+      const block = node.block;
+      if (!prelude || !block) return;
+      const declarations = rawDeclarationsFromBlock(block);
+      for (const selector of selectorList(prelude)) {
+        rules.push({
+          selector,
+          declarations: declarations.declarations.map((declaration) => ({ ...declaration, selector })),
+          importantDeclarations: declarations.importantDeclarations.map((declaration) => ({ ...declaration, selector })),
+          specificity: specificity(selector),
+          order: order++
+        });
+      }
+    });
+  }
+  return rules;
+}
+function parseStyleAttribute(value, fontSize, customProperties = {}, unsupportedCss) {
+  const declarations = { declarations: {}, importantDeclarations: {} };
+  if (!value) return declarations;
+  const raw = rawDeclarationsFromStyleAttribute(value);
+  const vars = mergeCustomProperties(customProperties, raw.declarations, raw.importantDeclarations);
+  parseDeclarationsInto(declarations.declarations, raw.declarations, fontSize, vars, unsupportedCss);
+  parseDeclarationsInto(declarations.importantDeclarations, raw.importantDeclarations, fontSize, vars, unsupportedCss);
+  return declarations;
+}
+function ruleDeclarationsFor(node, rules, fontSize, customProperties = {}, unsupportedCss) {
+  const out = { declarations: {}, importantDeclarations: {} };
+  const declarations = [];
+  const importantDeclarations = [];
+  for (const rule of rules.filter((r) => matchesSelector(node, r.selector)).sort(compareRule)) {
+    declarations.push(...rule.declarations);
+    importantDeclarations.push(...rule.importantDeclarations);
+  }
+  const vars = mergeCustomProperties(customProperties, declarations, importantDeclarations);
+  parseDeclarationsInto(out.declarations, declarations, fontSize, vars, unsupportedCss);
+  parseDeclarationsInto(out.importantDeclarations, importantDeclarations, fontSize, vars, unsupportedCss);
+  return out;
+}
+function rawDeclarationsFromBlock(block) {
+  const out = { declarations: [], importantDeclarations: [] };
+  const children = block.children;
+  children?.forEach((node) => {
+    if (node.type !== "Declaration") return;
+    const target = node.important ? out.importantDeclarations : out.declarations;
+    target.push({ property: String(node.property), value: (0, import_css_tree.generate)(node.value) });
+  });
+  return out;
+}
+function rawDeclarationsFromStyleAttribute(value) {
+  const out = { declarations: [], importantDeclarations: [] };
+  for (const chunk of value.split(";")) {
+    const colon = chunk.indexOf(":");
+    if (colon === -1) continue;
+    const parsed = stripImportant(chunk.slice(colon + 1).trim());
+    const target = parsed.important ? out.importantDeclarations : out.declarations;
+    target.push({ property: chunk.slice(0, colon).trim(), value: parsed.value });
+  }
+  return out;
+}
+function parseDeclarationsInto(out, declarations, fontSize, customProperties, unsupportedCss) {
+  const vars = customPropertiesFrom(declarations, customProperties);
+  for (const declaration of declarations) {
+    const property = declaration.property.trim();
+    if (property.startsWith("--")) continue;
+    if (!isSupportedCssProperty(property)) {
+      if (shouldReportUnsupportedCss(declaration)) unsupportedCss?.(declaration);
+      continue;
+    }
+    applyDeclaration(out, property, resolveVars(declaration.value, vars), fontSize);
+  }
+  if (Object.keys(vars).length > 0) out.customProperties = vars;
+}
+function shouldReportUnsupportedCss(declaration) {
+  return declaration.selector === void 0 || declaration.selector.includes(".");
+}
+var supportedCssProperties = /* @__PURE__ */ new Set([
+  "display",
+  "float",
+  "order",
+  "flex-direction",
+  "align-items",
+  "justify-content",
+  "color",
+  "background",
+  "background-color",
+  "background-image",
+  "background-size",
+  "background-repeat",
+  "background-position",
+  "object-fit",
+  "overflow",
+  "overflow-x",
+  "overflow-y",
+  "font-size",
+  "font",
+  "font-family",
+  "font-weight",
+  "font-style",
+  "line-height",
+  "white-space",
+  "text-align",
+  "text-decoration",
+  "text-decoration-line",
+  "text-transform",
+  "text-indent",
+  "vertical-align",
+  "box-sizing",
+  "position",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "inset",
+  "inset-block",
+  "inset-inline",
+  "inset-block-start",
+  "inset-block-end",
+  "inset-inline-start",
+  "inset-inline-end",
+  "z-index",
+  "list-style",
+  "list-style-type",
+  "width",
+  "min-width",
+  "max-width",
+  "height",
+  "aspect-ratio",
+  "margin",
+  "margin-block",
+  "margin-inline",
+  "margin-block-start",
+  "margin-block-end",
+  "margin-inline-start",
+  "margin-inline-end",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "padding",
+  "padding-block",
+  "padding-inline",
+  "padding-block-start",
+  "padding-block-end",
+  "padding-inline-start",
+  "padding-inline-end",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "gap",
+  "column-gap",
+  "grid-column-gap",
+  "row-gap",
+  "grid-row-gap",
+  "grid-template-columns",
+  "grid-column",
+  "grid-column-start",
+  "grid-column-end",
+  "border",
+  "border-top",
+  "border-right",
+  "border-bottom",
+  "border-left",
+  "border-block",
+  "border-inline",
+  "border-block-start",
+  "border-block-end",
+  "border-inline-start",
+  "border-inline-end",
+  "border-style",
+  "border-top-style",
+  "border-right-style",
+  "border-bottom-style",
+  "border-left-style",
+  "border-block-start-style",
+  "border-block-end-style",
+  "border-inline-start-style",
+  "border-inline-end-style",
+  "border-width",
+  "border-top-width",
+  "border-right-width",
+  "border-bottom-width",
+  "border-left-width",
+  "border-block-start-width",
+  "border-block-end-width",
+  "border-inline-start-width",
+  "border-inline-end-width",
+  "border-color",
+  "border-top-color",
+  "border-right-color",
+  "border-bottom-color",
+  "border-left-color",
+  "border-block-start-color",
+  "border-block-end-color",
+  "border-inline-start-color",
+  "border-inline-end-color",
+  "border-radius",
+  "border-collapse"
+]);
+function isSupportedCssProperty(property) {
+  return supportedCssProperties.has(property.trim().toLowerCase());
+}
+function mergeCustomProperties(inherited, declarations, importantDeclarations) {
+  return customPropertiesFrom(importantDeclarations, customPropertiesFrom(declarations, inherited));
+}
+function customPropertiesFrom(declarations, inherited) {
+  let out = inherited;
+  for (const declaration of declarations) {
+    const property = declaration.property.trim();
+    if (!property.startsWith("--")) continue;
+    if (out === inherited) out = { ...inherited };
+    out[property] = declaration.value.trim();
+  }
+  return out;
+}
+function resolveVars(value, customProperties, seen = /* @__PURE__ */ new Set()) {
+  let out = "";
+  let index = 0;
+  while (index < value.length) {
+    const start = value.indexOf("var(", index);
+    if (start === -1) {
+      out += value.slice(index);
+      break;
+    }
+    out += value.slice(index, start);
+    const end = closingParenIndex(value, start + 4);
+    if (end === -1) {
+      out += value.slice(start);
+      break;
+    }
+    out += resolveVarFunction(value.slice(start + 4, end), customProperties, seen);
+    index = end + 1;
+  }
+  return out;
+}
+function resolveVarFunction(args, customProperties, seen) {
+  const comma = topLevelCommaIndex(args);
+  const name = (comma === -1 ? args : args.slice(0, comma)).trim();
+  if (!/^--[A-Za-z0-9_-]+$/.test(name)) return "";
+  const fallback = comma === -1 ? void 0 : args.slice(comma + 1).trim();
+  if (seen.has(name)) return fallback ? resolveVars(fallback, customProperties, seen) : "";
+  const replacement = customProperties[name];
+  if (replacement === void 0) return fallback ? resolveVars(fallback, customProperties, seen) : "";
+  const nextSeen = new Set(seen);
+  nextSeen.add(name);
+  return resolveVars(replacement, customProperties, nextSeen);
+}
+function closingParenIndex(value, openIndex) {
+  let depth = 0;
+  for (let index = openIndex; index < value.length; index += 1) {
+    const char = value[index];
+    if (char === "(") depth += 1;
+    if (char === ")") {
+      if (depth === 0) return index;
+      depth -= 1;
+    }
+  }
+  return -1;
+}
+function topLevelCommaIndex(value) {
+  let depth = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (char === "(") depth += 1;
+    if (char === ")") depth = Math.max(0, depth - 1);
+    if (char === "," && depth === 0) return index;
+  }
+  return -1;
+}
+function stripImportant(value) {
+  if (!/!\s*important\s*$/i.test(value)) return { value, important: false };
+  return { value: value.replace(/!\s*important\s*$/i, "").trim(), important: true };
+}
+function applyDeclaration(out, property, rawValue, fontSize) {
+  const value = rawValue.trim().toLowerCase();
+  switch (property.trim().toLowerCase()) {
+    case "display":
+      if (value === "flow-root" || value === "list-item") out.display = "block";
+      else if (["block", "inline", "inline-block", "flex", "inline-flex", "grid", "inline-grid", "contents", "none"].includes(value)) {
+        out.display = value;
+      }
+      break;
+    case "float":
+      if (value === "none" || value === "left" || value === "right") out.float = value;
+      break;
+    case "order": {
+      const order = Number.parseInt(value, 10);
+      if (Number.isFinite(order)) out.order = order;
+      break;
+    }
+    case "flex-direction":
+      if (value === "row" || value === "row-reverse" || value === "column" || value === "column-reverse") out.flexDirection = value;
+      break;
+    case "align-items":
+      if (value === "flex-start") out.alignItems = "start";
+      else if (value === "flex-end") out.alignItems = "end";
+      else if (["start", "center", "end", "stretch", "baseline"].includes(value)) {
+        out.alignItems = value;
+      }
+      break;
+    case "justify-content":
+      if (value === "flex-start") out.justifyContent = "start";
+      else if (value === "flex-end") out.justifyContent = "end";
+      else if (value === "space-between") out.justifyContent = "between";
+      else if (value === "space-around") out.justifyContent = "around";
+      else if (value === "space-evenly") out.justifyContent = "evenly";
+      else if (["start", "center", "end"].includes(value)) out.justifyContent = value;
+      break;
+    case "color":
+      out.color = parseColor(value);
+      break;
+    case "background":
+      parseBackground(out, rawValue);
+      break;
+    case "background-color":
+      out.background = parseColor(value);
+      break;
+    case "background-image":
+      out.backgroundImageUrl = parseBackgroundImageUrl(rawValue);
+      break;
+    case "background-size":
+      if (value === "auto" || value === "cover" || value === "contain") out.backgroundSize = value;
+      break;
+    case "background-repeat":
+      if (value === "repeat" || value === "repeat-x" || value === "repeat-y" || value === "no-repeat") out.backgroundRepeat = value;
+      break;
+    case "background-position":
+      parseBackgroundPosition(out, value);
+      break;
+    case "object-fit":
+      if (value === "fill" || value === "contain" || value === "cover") out.objectFit = value;
+      break;
+    case "overflow":
+    case "overflow-x":
+    case "overflow-y":
+      if (value === "hidden" || value === "clip") out.overflow = "hidden";
+      else if (value === "visible") out.overflow = "visible";
+      break;
+    case "font-size":
+      out.fontSize = parseLength(value, fontSize) ?? out.fontSize;
+      break;
+    case "font":
+      parseFontShorthand(out, rawValue, fontSize);
+      break;
+    case "font-family":
+      out.fontFamily = parseFontFamily(rawValue);
+      break;
+    case "font-weight":
+      out.fontWeight = parseFontWeight(value);
+      break;
+    case "font-style":
+      out.fontStyle = value === "italic" ? "italic" : "normal";
+      break;
+    case "line-height":
+      {
+        const scale = parseLineHeightScale(value);
+        if (scale !== void 0) {
+          out.lineHeightScale = scale;
+          out.lineHeight = void 0;
+        } else {
+          out.lineHeight = parseLineHeight(value, fontSize);
+          out.lineHeightScale = void 0;
+        }
+      }
+      break;
+    case "white-space":
+      if (value === "normal" || value === "nowrap" || value === "pre" || value === "pre-wrap" || value === "pre-line") {
+        out.whiteSpace = value;
+      }
+      break;
+    case "text-align":
+      if (value === "left" || value === "center" || value === "right") out.textAlign = value;
+      break;
+    case "text-decoration":
+    case "text-decoration-line":
+      out.textDecorationLine = parseTextDecoration(value);
+      break;
+    case "text-transform":
+      if (value === "none" || value === "uppercase" || value === "lowercase" || value === "capitalize") {
+        out.textTransform = value;
+      }
+      break;
+    case "text-indent":
+      out.textIndent = parseLength(value, fontSize);
+      break;
+    case "vertical-align":
+      if (value === "middle" || value === "baseline") out.verticalAlign = value;
+      break;
+    case "box-sizing":
+      if (value === "content-box" || value === "border-box") out.boxSizing = value;
+      break;
+    case "position":
+      if (value === "relative" || value === "absolute") out.position = value;
+      break;
+    case "top":
+    case "right":
+    case "bottom":
+    case "left":
+      out[property] = parseLength(value, fontSize);
+      break;
+    case "inset":
+      applyInset(out, value, fontSize);
+      break;
+    case "inset-block":
+      applyTwoValueInset(out, "top", "bottom", value, fontSize);
+      break;
+    case "inset-inline":
+      applyTwoValueInset(out, "left", "right", value, fontSize);
+      break;
+    case "inset-block-start":
+      out.top = parseLength(value, fontSize);
+      break;
+    case "inset-block-end":
+      out.bottom = parseLength(value, fontSize);
+      break;
+    case "inset-inline-start":
+      out.left = parseLength(value, fontSize);
+      break;
+    case "inset-inline-end":
+      out.right = parseLength(value, fontSize);
+      break;
+    case "z-index": {
+      const zIndex = Number.parseInt(value, 10);
+      if (Number.isFinite(zIndex)) out.zIndex = zIndex;
+      break;
+    }
+    case "list-style":
+    case "list-style-type":
+      if (value.includes("none")) out.listStyleType = "none";
+      else if (value.includes("decimal")) out.listStyleType = "decimal";
+      else if (value.includes("disc")) out.listStyleType = "disc";
+      break;
+    case "width":
+      setLengthPercentage(out, "width", value, fontSize);
+      break;
+    case "min-width":
+      setLengthPercentage(out, "minWidth", value, fontSize);
+      break;
+    case "max-width":
+      if (value === "none") {
+        out.maxWidth = void 0;
+        out.maxWidthPercent = void 0;
+        out.maxWidthCalc = void 0;
+      } else {
+        setLengthPercentage(out, "maxWidth", value, fontSize);
+      }
+      break;
+    case "height":
+      out.height = parseLength(value, fontSize);
+      break;
+    case "aspect-ratio":
+      out.aspectRatio = parseAspectRatio(value);
+      break;
+    case "margin":
+      applyMargin(out, value, fontSize);
+      break;
+    case "margin-block":
+      applyTwoValueEdges(out, "margin", "top", "bottom", value, fontSize);
+      break;
+    case "margin-inline":
+      applyTwoValueMargin(out, "left", "right", value, fontSize);
+      break;
+    case "margin-block-start":
+      out.margin = setEdge(out.margin, "top", parseLength(value, fontSize));
+      break;
+    case "margin-block-end":
+      out.margin = setEdge(out.margin, "bottom", parseLength(value, fontSize));
+      break;
+    case "margin-inline-start":
+      setMarginEdge(out, "left", value, fontSize);
+      break;
+    case "margin-inline-end":
+      setMarginEdge(out, "right", value, fontSize);
+      break;
+    case "margin-top":
+    case "margin-right":
+    case "margin-bottom":
+    case "margin-left":
+      setMarginEdge(out, property.slice("margin-".length), value, fontSize);
+      break;
+    case "padding":
+      out.padding = parseEdges(value, fontSize);
+      break;
+    case "padding-block":
+      applyTwoValueEdges(out, "padding", "top", "bottom", value, fontSize);
+      break;
+    case "padding-inline":
+      applyTwoValueEdges(out, "padding", "left", "right", value, fontSize);
+      break;
+    case "padding-block-start":
+      out.padding = setEdge(out.padding, "top", parseLength(value, fontSize));
+      break;
+    case "padding-block-end":
+      out.padding = setEdge(out.padding, "bottom", parseLength(value, fontSize));
+      break;
+    case "padding-inline-start":
+      out.padding = setEdge(out.padding, "left", parseLength(value, fontSize));
+      break;
+    case "padding-inline-end":
+      out.padding = setEdge(out.padding, "right", parseLength(value, fontSize));
+      break;
+    case "padding-top":
+    case "padding-right":
+    case "padding-bottom":
+    case "padding-left":
+      out.padding = setEdge(out.padding, property.slice("padding-".length), parseLength(value, fontSize));
+      break;
+    case "gap":
+      out.gap = parseLength(value, fontSize);
+      break;
+    case "column-gap":
+    case "grid-column-gap":
+      out.columnGap = parseLength(value, fontSize);
+      break;
+    case "row-gap":
+    case "grid-row-gap":
+      out.rowGap = parseLength(value, fontSize);
+      break;
+    case "grid-template-columns":
+      out.gridTemplateColumns = parseGridTemplateColumns(value, fontSize);
+      break;
+    case "grid-column":
+      parseGridColumn(out, value);
+      break;
+    case "grid-column-start":
+      parseGridColumnLine(out, "gridColumnStart", value);
+      break;
+    case "grid-column-end":
+      parseGridColumnLine(out, "gridColumnEnd", value);
+      break;
+    case "border":
+      parseBorder(out, value, fontSize);
+      break;
+    case "border-style":
+    case "border-top-style":
+    case "border-right-style":
+    case "border-bottom-style":
+    case "border-left-style":
+    case "border-block-start-style":
+    case "border-block-end-style":
+    case "border-inline-start-style":
+    case "border-inline-end-style":
+      break;
+    case "border-top":
+    case "border-right":
+    case "border-bottom":
+    case "border-left":
+      setBorderSide(out, property.slice("border-".length), parseBorderValue(value, fontSize));
+      break;
+    case "border-block":
+      setBorderSide(out, "top", parseBorderValue(value, fontSize));
+      setBorderSide(out, "bottom", parseBorderValue(value, fontSize));
+      break;
+    case "border-inline":
+      setBorderSide(out, "left", parseBorderValue(value, fontSize));
+      setBorderSide(out, "right", parseBorderValue(value, fontSize));
+      break;
+    case "border-block-start":
+      setBorderSide(out, "top", parseBorderValue(value, fontSize));
+      break;
+    case "border-block-end":
+      setBorderSide(out, "bottom", parseBorderValue(value, fontSize));
+      break;
+    case "border-inline-start":
+      setBorderSide(out, "left", parseBorderValue(value, fontSize));
+      break;
+    case "border-inline-end":
+      setBorderSide(out, "right", parseBorderValue(value, fontSize));
+      break;
+    case "border-width":
+      out.borderWidth = parseLength(value, fontSize);
+      break;
+    case "border-top-width":
+    case "border-right-width":
+    case "border-bottom-width":
+    case "border-left-width":
+      setBorderSide(out, borderSideFromProperty(property, "-width"), { width: parseLength(value, fontSize) });
+      break;
+    case "border-block-start-width":
+      setBorderSide(out, "top", { width: parseLength(value, fontSize) });
+      break;
+    case "border-block-end-width":
+      setBorderSide(out, "bottom", { width: parseLength(value, fontSize) });
+      break;
+    case "border-inline-start-width":
+      setBorderSide(out, "left", { width: parseLength(value, fontSize) });
+      break;
+    case "border-inline-end-width":
+      setBorderSide(out, "right", { width: parseLength(value, fontSize) });
+      break;
+    case "border-color":
+      out.borderColor = parseColor(value);
+      break;
+    case "border-top-color":
+    case "border-right-color":
+    case "border-bottom-color":
+    case "border-left-color":
+      setBorderSide(out, borderSideFromProperty(property, "-color"), { color: parseColor(value) });
+      break;
+    case "border-block-start-color":
+      setBorderSide(out, "top", { color: parseColor(value) });
+      break;
+    case "border-block-end-color":
+      setBorderSide(out, "bottom", { color: parseColor(value) });
+      break;
+    case "border-inline-start-color":
+      setBorderSide(out, "left", { color: parseColor(value) });
+      break;
+    case "border-inline-end-color":
+      setBorderSide(out, "right", { color: parseColor(value) });
+      break;
+    case "border-radius":
+      out.borderRadius = parseLength(value.split(/\s+/)[0], fontSize);
+      break;
+    case "border-collapse":
+      if (value === "collapse" || value === "separate") out.borderCollapse = value;
+      break;
+  }
+}
+function parseAspectRatio(value) {
+  const normalized = value.replace(/\bauto\b/g, "").trim();
+  if (!normalized) return void 0;
+  const slash = /^([0-9.]+)\s*\/\s*([0-9.]+)$/.exec(normalized);
+  if (slash) {
+    const width = Number(slash[1]);
+    const height = Number(slash[2]);
+    return Number.isFinite(width) && Number.isFinite(height) && width > 0 && height > 0 ? width / height : void 0;
+  }
+  const ratio = Number(normalized);
+  return Number.isFinite(ratio) && ratio > 0 ? ratio : void 0;
+}
+function setLengthPercentage(out, property, value, fontSize) {
+  const parsed = parseLengthPercentage(value, fontSize);
+  const percentKey = `${property}Percent`;
+  const calcKey = `${property}Calc`;
+  out[property] = void 0;
+  out[percentKey] = void 0;
+  out[calcKey] = void 0;
+  if (!parsed) return;
+  if (parsed.percent !== 0 && parsed.length !== 0) out[calcKey] = parsed;
+  else if (parsed.percent !== 0) out[percentKey] = parsed.percent;
+  else out[property] = parsed.length;
+}
+function applyInset(out, value, fontSize) {
+  const lengths = cssValueTokens(value).map((part) => parseLength(part, fontSize));
+  if (lengths.some((length) => length === void 0)) return;
+  const [top, right = top, bottom = top, left = right] = lengths;
+  out.top = top;
+  out.right = right;
+  out.bottom = bottom;
+  out.left = left;
+}
+function applyTwoValueInset(out, firstSide, secondSide, value, fontSize) {
+  const [firstRaw, secondRaw = firstRaw] = cssValueTokens(value);
+  const first = parseLength(firstRaw, fontSize);
+  const second = parseLength(secondRaw, fontSize);
+  if (first !== void 0) out[firstSide] = first;
+  if (second !== void 0) out[secondSide] = second;
+}
+function applyTwoValueEdges(out, property, firstSide, secondSide, value, fontSize) {
+  const [firstRaw, secondRaw = firstRaw] = cssValueTokens(value);
+  out[property] = setEdge(out[property], firstSide, parseLength(firstRaw, fontSize));
+  out[property] = setEdge(out[property], secondSide, parseLength(secondRaw, fontSize));
+}
+function applyMargin(out, value, fontSize) {
+  const [topRaw, rightRaw = topRaw, bottomRaw = topRaw, leftRaw = rightRaw] = cssValueTokens(value);
+  setMarginEdge(out, "top", topRaw, fontSize);
+  setMarginEdge(out, "right", rightRaw, fontSize);
+  setMarginEdge(out, "bottom", bottomRaw, fontSize);
+  setMarginEdge(out, "left", leftRaw, fontSize);
+}
+function applyTwoValueMargin(out, firstSide, secondSide, value, fontSize) {
+  const [firstRaw, secondRaw = firstRaw] = cssValueTokens(value);
+  setMarginEdge(out, firstSide, firstRaw, fontSize);
+  setMarginEdge(out, secondSide, secondRaw, fontSize);
+}
+function setMarginEdge(out, side, value, fontSize) {
+  if (value === void 0) return;
+  if (value === "auto" && (side === "left" || side === "right")) {
+    out.margin = setEdge(out.margin, side, 0);
+    if (side === "left") out.marginAutoLeft = true;
+    else out.marginAutoRight = true;
+    return;
+  }
+  const parsed = parseLength(value, fontSize);
+  out.margin = setEdge(out.margin, side, parsed);
+  if (parsed !== void 0) {
+    if (side === "left") out.marginAutoLeft = void 0;
+    if (side === "right") out.marginAutoRight = void 0;
+  }
+}
+function parseGridColumn(out, value) {
+  const [startRaw, endRaw] = value.split("/").map((part) => part.trim().toLowerCase());
+  if (startRaw) parseGridColumnLine(out, "gridColumnStart", startRaw);
+  if (endRaw) parseGridColumnLine(out, "gridColumnEnd", endRaw);
+  else if (startRaw?.startsWith("span ")) parseGridColumnLine(out, "gridColumnEnd", startRaw);
+}
+function parseGridColumnLine(out, property, value) {
+  const normalized = value.trim().toLowerCase();
+  const span = /^span\s+(\d+)$/.exec(normalized);
+  if (span) {
+    const amount = Number(span[1]);
+    if (Number.isInteger(amount) && amount > 0) out.gridColumnSpan = amount;
+    return;
+  }
+  const line = Number.parseInt(normalized, 10);
+  if (!Number.isInteger(line)) return;
+  out[property] = line;
+}
+function parseGridTemplateColumns(value, fontSize) {
+  const expanded = expandGridRepeats(value);
+  const tracks = gridTrackTokens(expanded).map((token) => {
+    if (token === "auto" || token === "min-content" || token === "max-content") return { kind: "fr", value: 1 };
+    const fr = /^([0-9.]+)fr$/.exec(token);
+    if (fr) {
+      const amount = Number(fr[1]);
+      return Number.isFinite(amount) && amount > 0 ? { kind: "fr", value: amount } : void 0;
+    }
+    const percent = parsePercentage(token);
+    if (percent !== void 0) return { kind: "percent", value: percent };
+    const minmax = /^minmax\([^,]+,\s*([^)]+)\)$/.exec(token);
+    if (minmax) return parseGridTemplateColumns(minmax[1], fontSize)?.[0];
+    const length = parseLength(token, fontSize);
+    return length === void 0 ? void 0 : { kind: "length", value: length };
+  });
+  if (tracks.length === 0 || tracks.some((track) => track === void 0)) return void 0;
+  return tracks;
+}
+function expandGridRepeats(value) {
+  let out = "";
+  let index = 0;
+  while (index < value.length) {
+    const repeatStart = value.toLowerCase().indexOf("repeat(", index);
+    if (repeatStart === -1) {
+      out += value.slice(index);
+      break;
+    }
+    out += value.slice(index, repeatStart);
+    const argsStart = repeatStart + "repeat(".length;
+    const close = closingParenIndex(value, argsStart);
+    if (close === -1) {
+      out += value.slice(repeatStart);
+      break;
+    }
+    const args = value.slice(argsStart, close);
+    const comma = topLevelCommaIndex(args);
+    const count = Number(comma === -1 ? NaN : args.slice(0, comma).trim());
+    const repeated = comma === -1 ? "" : args.slice(comma + 1).trim();
+    out += Number.isInteger(count) && count > 0 && count <= 24 ? Array.from({ length: count }, () => repeated).join(" ") : "";
+    index = close + 1;
+  }
+  return out;
+}
+function gridTrackTokens(value) {
+  return cssValueTokens(value).map((token) => token.toLowerCase());
+}
+function cssValueTokens(value) {
+  return cssValueTokensPreservingCase(value).map((token) => token.toLowerCase());
+}
+function cssValueTokensPreservingCase(value) {
+  const tokens = [];
+  let token = "";
+  let depth = 0;
+  for (const char of value.trim()) {
+    if (char === "(") depth += 1;
+    if (char === ")") depth = Math.max(0, depth - 1);
+    if (/\s/.test(char) && depth === 0) {
+      if (token) tokens.push(token);
+      token = "";
+      continue;
+    }
+    token += char;
+  }
+  if (token) tokens.push(token);
+  return tokens;
+}
+function parseTextDecoration(value) {
+  if (value === "none") return "none";
+  if (value.includes("underline")) return "underline";
+  if (value.includes("line-through")) return "line-through";
+  return void 0;
+}
+function parseBackground(out, value) {
+  out.background = parseBackgroundColor(value) ?? out.background;
+  out.backgroundImageUrl = parseBackgroundImageUrl(value) ?? out.backgroundImageUrl;
+  const lower = value.toLowerCase();
+  if (/\bcover\b/.test(lower)) out.backgroundSize = "cover";
+  else if (/\bcontain\b/.test(lower)) out.backgroundSize = "contain";
+  if (/\bno-repeat\b/.test(lower)) out.backgroundRepeat = "no-repeat";
+  else if (/\brepeat-x\b/.test(lower)) out.backgroundRepeat = "repeat-x";
+  else if (/\brepeat-y\b/.test(lower)) out.backgroundRepeat = "repeat-y";
+  else if (/\brepeat\b/.test(lower)) out.backgroundRepeat = "repeat";
+  parseBackgroundPosition(out, lower.replace(/\/\s*(cover|contain|auto)\b/g, ""));
+}
+function parseBackgroundColor(value) {
+  const withoutUrls = value.replace(/url\([^)]*\)/gi, " ");
+  const tokens = withoutUrls.match(/#[0-9a-f]{3,8}\b|rgba?\([^)]*\)|hsla?\([^)]*\)|[a-zA-Z]+/g) ?? [];
+  for (const token of tokens) {
+    const color = parseColor(token);
+    if (color) return color;
+  }
+  return void 0;
+}
+function parseBackgroundImageUrl(value) {
+  const match = /url\(\s*(?:"([^"]+)"|'([^']+)'|([^)]*?))\s*\)/i.exec(value);
+  return match ? (match[1] ?? match[2] ?? match[3])?.trim() : void 0;
+}
+function parseBackgroundPosition(out, value) {
+  const tokens = value.split(/\s+/).map((token) => token.trim()).filter(Boolean).filter((token) => !["url", "repeat", "repeat-x", "repeat-y", "no-repeat", "cover", "contain", "auto"].includes(token));
+  const normalized = tokens.join(" ");
+  if (!normalized) return;
+  if (/\bleft\b/.test(normalized)) out.backgroundPositionX = 0;
+  else if (/\bright\b/.test(normalized)) out.backgroundPositionX = 1;
+  else if (/\bcenter\b/.test(normalized)) out.backgroundPositionX = 0.5;
+  const percentX = /(^|\s)([0-9.]+)%/.exec(normalized);
+  if (percentX) out.backgroundPositionX = Number(percentX[2]) / 100;
+  if (/\btop\b/.test(normalized)) out.backgroundPositionY = 0;
+  else if (/\bbottom\b/.test(normalized)) out.backgroundPositionY = 1;
+  else if (/\bcenter\b/.test(normalized)) out.backgroundPositionY ??= 0.5;
+  const percents = [...normalized.matchAll(/([0-9.]+)%/g)];
+  if (percents[1]) out.backgroundPositionY = Number(percents[1][1]) / 100;
+}
+function parseFontFamily(value) {
+  return value.split(",").map((family) => family.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+}
+function parseFontShorthand(out, value, inheritedFontSize) {
+  const tokens = cssValueTokensPreservingCase(value);
+  const sizeIndex = tokens.findIndex((token) => {
+    const [size] = token.split("/");
+    return isFontSizeToken(size) && parseLength(size, inheritedFontSize) !== void 0;
+  });
+  if (sizeIndex < 0) return;
+  for (const token of tokens.slice(0, sizeIndex)) {
+    const normalized = token.toLowerCase();
+    if (normalized === "italic" || normalized === "oblique") out.fontStyle = "italic";
+    else if (normalized === "normal") {
+      out.fontStyle ??= "normal";
+      out.fontWeight ??= "normal";
+    } else if (normalized === "bold" || normalized === "bolder" || normalized === "lighter" || /^[1-9]00$/.test(normalized)) {
+      out.fontWeight = parseFontWeight(normalized);
+    }
+  }
+  const [sizePart, lineHeightPart] = tokens[sizeIndex].split("/");
+  const parsedSize = parseLength(sizePart, inheritedFontSize);
+  if (parsedSize !== void 0) out.fontSize = parsedSize;
+  if (lineHeightPart) out.lineHeight = parseLineHeight(lineHeightPart, parsedSize ?? inheritedFontSize);
+  const family = tokens.slice(sizeIndex + 1).join(" ");
+  if (family.trim()) out.fontFamily = parseFontFamily(family);
+}
+function isFontSizeToken(value) {
+  return value !== void 0 && /^-?(?:\d+|\d*\.\d+)(px|pt|em|rem|vw|vh)$/i.test(value.trim());
+}
+function parseFontWeight(value) {
+  if (value === "bold" || value === "bolder") return "bold";
+  if (value === "normal" || value === "lighter") return "normal";
+  const numeric = Number(value);
+  if (Number.isFinite(numeric)) return numeric;
+  return "normal";
+}
+function parseEdges(value, fontSize) {
+  const lengths = cssValueTokens(value).map((part) => parseLength(part, fontSize));
+  if (lengths.some((length) => length === void 0)) return void 0;
+  const [top, right = top, bottom = top, left = right] = lengths;
+  if (top === right && right === bottom && bottom === left) return top;
+  return { top, right, bottom, left };
+}
+function setEdge(edges3, side, value) {
+  if (value === void 0) return edges3;
+  const out = typeof edges3 === "number" ? { top: edges3, right: edges3, bottom: edges3, left: edges3 } : { ...edges3 };
+  if (side === "top" || side === "right" || side === "bottom" || side === "left") out[side] = value;
+  return out;
+}
+function parseBorder(out, value, fontSize) {
+  const parsed = parseBorderValue(value, fontSize);
+  out.borderWidth ??= parsed.width;
+  out.borderColor ??= parsed.color;
+}
+function parseBorderValue(value, fontSize) {
+  const out = {};
+  if (/\bnone\b/.test(value)) out.width = 0;
+  for (const token of cssValueTokens(value)) {
+    out.width ??= parseLength(token, fontSize);
+    out.color ??= parseColor(token);
+  }
+  return out;
+}
+function setBorderSide(out, side, value) {
+  if (side !== "top" && side !== "right" && side !== "bottom" && side !== "left") return;
+  const current = out.borderSides?.[side];
+  const width = value.width ?? current?.width ?? out.borderWidth ?? 0.75;
+  const color = value.color ?? current?.color ?? out.borderColor ?? { r: 0, g: 0, b: 0 };
+  out.borderSides = { ...out.borderSides, [side]: { width, color } };
+}
+function borderSideFromProperty(property, suffix) {
+  return property.slice("border-".length, -suffix.length);
+}
+function selectorList(prelude) {
+  return (0, import_css_tree.generate)(prelude).split(",").map((selector) => stripWhereSelectors(selector.trim())).filter(Boolean);
+}
+function stripWhereSelectors(selector) {
+  let out = "";
+  let index = 0;
+  while (index < selector.length) {
+    const start = selector.indexOf(":where(", index);
+    if (start === -1) {
+      out += selector.slice(index);
+      break;
+    }
+    out += selector.slice(index, start);
+    const argsStart = start + ":where(".length;
+    const close = closingParenIndex(selector, argsStart);
+    if (close === -1) {
+      out += selector.slice(start);
+      break;
+    }
+    out += selector.slice(argsStart, close);
+    index = close + 1;
+  }
+  return out;
+}
+function matchesSelector(node, selector) {
+  const parts = selectorParts(selector);
+  if (parts.length === 0) return false;
+  const last = parts[parts.length - 1];
+  if (!matchesCompound(node, last.selector)) return false;
+  last.node = node;
+  let cursor = node.parent;
+  for (let i = parts.length - 2; i >= 0; i -= 1) {
+    const part = parts[i];
+    const combinator = parts[i + 1].combinator;
+    if (combinator === ">") {
+      if (!cursor || !matchesCompound(cursor, part.selector)) return false;
+      cursor = cursor.parent;
+      continue;
+    }
+    if (combinator === "+") {
+      const previous = previousElement(parts[i + 1].node ?? node);
+      if (!previous || !matchesCompound(previous, part.selector)) return false;
+      cursor = previous.parent;
+      parts[i].node = previous;
+      continue;
+    }
+    if (combinator === "~") {
+      let sibling = previousElement(parts[i + 1].node ?? node);
+      while (sibling && !matchesCompound(sibling, part.selector)) sibling = previousElement(sibling);
+      if (!sibling) return false;
+      cursor = sibling.parent;
+      parts[i].node = sibling;
+      continue;
+    }
+    while (cursor && !matchesCompound(cursor, part.selector)) cursor = cursor.parent;
+    if (!cursor) return false;
+    parts[i].node = cursor;
+    cursor = cursor.parent;
+  }
+  return true;
+}
+function selectorParts(selector) {
+  const parts = [];
+  let buffer = "";
+  let combinator = " ";
+  let depth = 0;
+  let quote = "";
+  const flush = () => {
+    const trimmed = buffer.trim();
+    if (trimmed) parts.push({ selector: trimmed, combinator });
+    buffer = "";
+    combinator = " ";
+  };
+  for (let i = 0; i < selector.length; i += 1) {
+    const char = selector[i];
+    if (quote) {
+      buffer += char;
+      if (char === quote) quote = "";
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      buffer += char;
+      continue;
+    }
+    if (char === "[" || char === "(") depth += 1;
+    if (char === "]" || char === ")") depth = Math.max(0, depth - 1);
+    if (depth === 0 && (char === ">" || char === "+" || char === "~")) {
+      flush();
+      combinator = char;
+      continue;
+    }
+    if (depth === 0 && /\s/.test(char)) {
+      let next = i + 1;
+      while (next < selector.length && /\s/.test(selector[next])) next += 1;
+      if (!buffer.trim() || selector[next] === ">" || selector[next] === "+" || selector[next] === "~") {
+        i = next - 1;
+        continue;
+      }
+      flush();
+      i = next - 1;
+      continue;
+    }
+    buffer += char;
+  }
+  flush();
+  return parts;
+}
+function matchesCompound(node, selector) {
+  const stripped = stripSupportedPseudos(selector, node);
+  if (stripped === void 0) return false;
+  selector = stripped;
+  if (selector === "*") return true;
+  if (!matchesAttributes(node, stripSimpleSelectors(selector))) return false;
+  const id = simpleSelectorValues(selector, "#")[0];
+  if (id && node.attrs.id !== id) return false;
+  const classes = simpleSelectorValues(selector, ".");
+  const nodeClasses = new Set((node.attrs.class ?? "").split(/\s+/).filter(Boolean));
+  if (classes.some((klass) => !nodeClasses.has(klass))) return false;
+  const tag = stripSimpleSelectors(selector).replace(/\[[^\]]+\]/g, "").trim();
+  return tag.length === 0 || tag === "*" || tag.toLowerCase() === node.tag;
+}
+function specificity(selector) {
+  const ids = selectorParts(selector).reduce((sum, part) => sum + simpleSelectorValues(part.selector, "#").length, 0);
+  const classes = selectorParts(selector).reduce((sum, part) => sum + simpleSelectorValues(part.selector, ".").length, 0) + (selector.match(/\[[^\]]+\]/g) ?? []).length + pseudoSelectors(selector).length;
+  const tags = selectorParts(selector).filter((part) => /^[A-Za-z]/.test(part.selector.replace(/[#.:\[].*$/, ""))).length;
+  return ids * 100 + classes * 10 + tags;
+}
+function stripSupportedPseudos(selector, node) {
+  let out = selector;
+  const pseudos = pseudoSelectors(out).reverse();
+  for (const match of pseudos) {
+    const name = match.name;
+    const arg = match.arg?.trim();
+    if (name === "first-child") {
+      if (elementIndex(node) !== 1) return void 0;
+    } else if (name === "not") {
+      if (arg === ":last-child" && elementIndex(node) === elementSiblings(node).length) return void 0;
+      else if (arg === ":first-child" && elementIndex(node) === 1) return void 0;
+      else if (arg !== ":last-child" && arg !== ":first-child") return void 0;
+    } else if (name === "root") {
+      if (node.parent !== void 0) return void 0;
+    } else if (name === "last-child") {
+      if (elementIndex(node) !== elementSiblings(node).length) return void 0;
+    } else if (name === "nth-child") {
+      if (!matchesNth(elementIndex(node), arg)) return void 0;
+    } else if (name === "first-of-type") {
+      if (typeIndex(node) !== 1) return void 0;
+    } else if (name === "last-of-type") {
+      if (typeIndex(node) !== typeSiblings(node).length) return void 0;
+    } else if (name === "nth-of-type") {
+      if (!matchesNth(typeIndex(node), arg)) return void 0;
+    } else {
+      return void 0;
+    }
+    out = out.slice(0, match.start) + out.slice(match.end);
+  }
+  return out;
+}
+function simpleSelectorValues(selector, prefix) {
+  const values = [];
+  for (let index = 0; index < selector.length; index += 1) {
+    if (selector[index] !== prefix || isEscaped(selector, index)) continue;
+    const read = readCssIdentifier(selector, index + 1);
+    if (read.value) values.push(read.value);
+    index = read.end - 1;
+  }
+  return values;
+}
+function stripSimpleSelectors(selector) {
+  let out = "";
+  for (let index = 0; index < selector.length; index += 1) {
+    const char = selector[index];
+    if ((char === "." || char === "#") && !isEscaped(selector, index)) {
+      index = readCssIdentifier(selector, index + 1).end - 1;
+      continue;
+    }
+    out += char;
+  }
+  return out;
+}
+function readCssIdentifier(input, start) {
+  let value = "";
+  let index = start;
+  while (index < input.length) {
+    const char = input[index];
+    if (char === "\\") {
+      const escaped = readCssEscape(input, index);
+      value += escaped.value;
+      index = escaped.end;
+      continue;
+    }
+    if (char === "[") {
+      const close = input.indexOf("]", index + 1);
+      if (close === -1) break;
+      const body = input.slice(index + 1, close);
+      if (body.includes("=")) break;
+      value += input.slice(index, close + 1);
+      index = close + 1;
+      continue;
+    }
+    if (/[\s>+~.#(]/.test(char)) break;
+    value += char;
+    index += 1;
+  }
+  return { value, end: index };
+}
+function readCssEscape(input, start) {
+  let index = start + 1;
+  const hex = /^[0-9a-fA-F]{1,6}/.exec(input.slice(index))?.[0];
+  if (hex) {
+    index += hex.length;
+    if (/\s/.test(input[index] ?? "")) index += 1;
+    return { value: String.fromCodePoint(Number.parseInt(hex, 16)), end: index };
+  }
+  if (index >= input.length) return { value: "", end: index };
+  return { value: input[index], end: index + 1 };
+}
+function isEscaped(input, index) {
+  let slashCount = 0;
+  for (let cursor = index - 1; cursor >= 0 && input[cursor] === "\\"; cursor -= 1) slashCount += 1;
+  return slashCount % 2 === 1;
+}
+function pseudoSelectors(selector) {
+  const pseudos = [];
+  for (let index = 0; index < selector.length; index += 1) {
+    if (selector[index] !== ":" || isEscaped(selector, index)) continue;
+    if (isInsideClassSelector(selector, index)) continue;
+    if (selector[index + 1] === ":") {
+      const read2 = readCssIdentifier(selector, index + 2);
+      if (read2.value) pseudos.push({ name: `:${read2.value}`, start: index, end: read2.end });
+      index = read2.end - 1;
+      continue;
+    }
+    const read = readCssIdentifier(selector, index + 1);
+    if (!read.value) continue;
+    let end = read.end;
+    let arg;
+    if (selector[end] === "(") {
+      const close = closingParenIndex(selector, end + 1);
+      if (close === -1) return pseudos;
+      arg = selector.slice(end + 1, close);
+      end = close + 1;
+    }
+    pseudos.push({ name: read.value, arg, start: index, end });
+    index = end - 1;
+  }
+  return pseudos;
+}
+function isInsideClassSelector(selector, index) {
+  for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+    const char = selector[cursor];
+    if (isEscaped(selector, cursor)) continue;
+    if (char === ".") return true;
+    if (/[\s>+~#\[]/.test(char)) return false;
+  }
+  return false;
+}
+function matchesAttributes(node, selector) {
+  for (const match of selector.matchAll(/\[([^\]=~|^$*\s]+)(?:\s*([~|^$*]?=)\s*(?:"([^"]*)"|'([^']*)'|([^\]\s]+)))?\]/g)) {
+    const name = match[1];
+    const op = match[2];
+    const expected = match[3] ?? match[4] ?? match[5] ?? "";
+    const actual = node.attrs[name];
+    if (actual === void 0) return false;
+    if (!op) continue;
+    if (op === "=" && actual !== expected) return false;
+    if (op === "~=" && !actual.split(/\s+/).includes(expected)) return false;
+    if (op === "|=" && actual !== expected && !actual.startsWith(`${expected}-`)) return false;
+    if (op === "^=" && !actual.startsWith(expected)) return false;
+    if (op === "$=" && !actual.endsWith(expected)) return false;
+    if (op === "*=" && !actual.includes(expected)) return false;
+  }
+  return true;
+}
+function previousElement(node) {
+  const siblings = elementSiblings(node);
+  return siblings[elementIndex(node) - 2];
+}
+function elementSiblings(node) {
+  return node.parent?.children.filter((child) => child.kind === "element") ?? [];
+}
+function typeSiblings(node) {
+  return elementSiblings(node).filter((sibling) => sibling.tag === node.tag);
+}
+function elementIndex(node) {
+  return elementSiblings(node).indexOf(node) + 1;
+}
+function typeIndex(node) {
+  return typeSiblings(node).indexOf(node) + 1;
+}
+function matchesNth(index, arg) {
+  if (!arg) return false;
+  const normalized = arg.replace(/\s+/g, "").toLowerCase();
+  if (normalized === "odd") return index % 2 === 1;
+  if (normalized === "even") return index % 2 === 0;
+  const exact = Number(normalized);
+  if (Number.isInteger(exact)) return index === exact;
+  const match = /^([+-]?\d*)n([+-]\d+)?$/.exec(normalized);
+  if (!match) return false;
+  const aRaw = match[1];
+  const a = aRaw === "" || aRaw === "+" ? 1 : aRaw === "-" ? -1 : Number(aRaw);
+  const b = match[2] ? Number(match[2]) : 0;
+  if (!Number.isFinite(a) || !Number.isFinite(b) || a === 0) return index === b;
+  return (index - b) / a >= 0 && Number.isInteger((index - b) / a);
+}
+function compareRule(a, b) {
+  return a.specificity - b.specificity || a.order - b.order;
+}
+
+// src/dom.ts
+var import_parse5 = require("parse5");
+function parseHtml(html) {
+  const fragment = (0, import_parse5.parseFragment)(html);
+  const root = {
+    kind: "element",
+    tag: "body",
+    attrs: {},
+    children: []
+  };
+  const stylesheets = [];
+  root.children = fragment.childNodes.flatMap((child) => convertNode(child, root, stylesheets));
+  return { root, stylesheets };
+}
+function convertNode(node, parent, stylesheets) {
+  if (isText(node)) {
+    return [{ kind: "text", value: node.value, parent }];
+  }
+  if (!isElement(node)) return [];
+  const tag = node.tagName.toLowerCase();
+  const attrs = Object.fromEntries(node.attrs.map((attr) => [attr.name, attr.value]));
+  const element = { kind: "element", tag, attrs, children: [], parent };
+  element.children = node.childNodes.flatMap((child) => convertNode(child, element, stylesheets));
+  if (tag === "style") {
+    const css = element.children.filter((child) => child.kind === "text").map((child) => child.value).join("");
+    if (css.trim()) stylesheets.push(css);
+    return [];
+  }
+  if (tag === "script" || tag === "noscript" || tag === "template") return [];
+  return [element];
+}
+function isText(node) {
+  return node.nodeName === "#text";
+}
+function isElement(node) {
+  return "tagName" in node && Array.isArray(node.childNodes);
+}
+
+// src/render.ts
+var import_boxpdf = require("boxpdf");
+function renderStyledTree(root, options) {
+  const warnings = [];
+  const nodes = root.children.flatMap((child) => renderNode(child, options, warnings));
+  return { nodes, warnings };
+}
+function renderNode(node, options, warnings) {
+  if ("text" in node) {
+    const trimmed = node.text.trim();
+    return trimmed ? [(0, import_boxpdf.text)(trimmed, textOptions(node, options))] : [];
+  }
+  if (node.style.display === "none") return [];
+  if (node.style.display === "contents") return node.children.flatMap((child) => renderNode(child, options, warnings));
+  if (node.node.tag === "img") {
+    const rendered = renderImageForLayout(node, options, warnings);
+    return rendered ? [rendered] : [];
+  }
+  if (node.node.tag === "br") return [(0, import_boxpdf.text)("", textOptions({ style: node.style }, options))];
+  if (node.node.tag === "hr") return [(0, import_boxpdf.hline)({ color: node.style.borderColor ?? { r: 0, g: 0, b: 0 }, thickness: node.style.borderWidth ?? 1 })];
+  if (node.node.tag === "ul" || node.node.tag === "ol") return [renderList(node, options, warnings)];
+  if (node.node.tag === "table") return renderTable(node, options, warnings);
+  if (node.style.display === "grid" || node.style.display === "inline-grid") return [renderGrid(node, options, warnings)];
+  if (node.style.display === "flex" || node.style.display === "inline-flex") return [renderFlex(node, options, warnings)];
+  if (isInlineContainer(node)) {
+    return renderInlineGroup(node, options, warnings);
+  }
+  return [renderBlock(node, options, warnings)];
+}
+function renderBlock(node, options, warnings, stretch = node.style.display === "block") {
+  const children = renderBlockChildren(node, options, warnings);
+  return (0, import_boxpdf.vstack)(
+    {
+      width: cssBoxWidth(node),
+      height: cssBoxHeight(node),
+      margin: node.style.margin,
+      padding: layoutPadding(node),
+      gap: node.style.gap ?? 0,
+      background: node.style.background,
+      backgroundImage: backgroundImage(node, options),
+      border: border(node),
+      borderSides: node.style.borderSides,
+      borderRadius: node.style.borderRadius,
+      overflow: node.style.overflow,
+      position: node.style.position,
+      top: node.style.top,
+      right: node.style.right,
+      bottom: node.style.bottom,
+      left: node.style.left,
+      zIndex: node.style.zIndex,
+      align: stretch ? "stretch" : "start"
+    },
+    ...children
+  );
+}
+function renderBlockChildren(node, options, warnings) {
+  const out = [];
+  let inlineBuffer = [];
+  let floats = [];
+  const flushInline = () => {
+    const runs = collectInlineRuns(inlineBuffer, options, warnings);
+    if (runs.length > 0 || floats.length > 0) {
+      out.push((0, import_boxpdf.paragraph)({ width: contentWidth(node), align: node.style.textAlign, wrap: shouldWrap(node.style), floats, textIndent: node.style.textIndent }, ...runs));
+      floats = [];
+    }
+    inlineBuffer = [];
+  };
+  for (const child of flattenDisplayContents(node.children)) {
+    if (!("text" in child) && child.style.float && child.style.float !== "none") {
+      floats.push({ node: renderFloatNode(child, options, warnings), side: child.style.float });
+      continue;
+    }
+    if (isInlineLike(child)) {
+      inlineBuffer.push(child);
+      continue;
+    }
+    if (inlineBuffer.some(hasInlineContent)) flushInline();
+    else inlineBuffer = [];
+    const rendered = renderNode(child, options, warnings);
+    if (floats.length > 0) {
+      const attached = attachFloatsToFirstParagraph(rendered, floats);
+      if (attached.attached) {
+        out.push(...attached.nodes);
+        floats = [];
+        continue;
+      }
+      flushInline();
+    }
+    out.push(...rendered);
+  }
+  flushInline();
+  return out;
+}
+function hasInlineContent(node) {
+  if ("text" in node) return node.text.trim().length > 0;
+  if (node.node.tag === "br") return true;
+  return node.children.some(hasInlineContent);
+}
+function flattenDisplayContents(nodes) {
+  return nodes.flatMap((node) => {
+    if ("text" in node || node.style.display !== "contents") return [node];
+    return flattenDisplayContents(node.children);
+  });
+}
+function renderFloatNode(node, options, warnings) {
+  if (node.node.tag === "table") return renderTable(node, options, warnings)[0] ?? renderBlock(node, options, warnings);
+  if (node.style.display === "flex" || node.style.display === "inline-flex") return renderFlex(node, options, warnings);
+  if (node.style.display === "grid" || node.style.display === "inline-grid") return renderGrid(node, options, warnings);
+  return renderBlock(node, options, warnings);
+}
+function attachFloatsToFirstParagraph(nodes, floats) {
+  let attached = false;
+  const next = nodes.map((node) => {
+    if (attached) return node;
+    const result = attachFloatsToNode(node, floats);
+    attached = result.attached;
+    return result.node;
+  });
+  return { nodes: next, attached };
+}
+function attachFloatsToNode(node, floats) {
+  if (node.kind === "paragraph") {
+    return { node: { ...node, props: { ...node.props, floats: [...floats, ...node.props.floats ?? []] } }, attached: true };
+  }
+  if (node.kind !== "vstack" && node.kind !== "hstack") return { node, attached: false };
+  let attached = false;
+  const children = node.children.map((child) => {
+    if (attached) return child;
+    const result = attachFloatsToNode(child, floats);
+    attached = result.attached;
+    return result.node;
+  });
+  return attached ? { node: { ...node, children }, attached } : { node, attached };
+}
+function renderFlex(node, options, warnings) {
+  const ordered = orderedChildren(node.children);
+  const sourceChildren = node.style.flexDirection.endsWith("-reverse") ? [...ordered].reverse() : ordered;
+  const width = cssBoxWidth(node);
+  const justifyWidth = contentWidth(node);
+  const children = flexChildrenWithJustification(
+    sourceChildren.flatMap((child) => renderFlexChild(child, options, warnings)).map(defaultFlexItem),
+    node.style.justifyContent,
+    node.style.flexDirection,
+    justifyWidth,
+    node.style.gap ?? 0
+  );
+  const style = {
+    width,
+    height: cssBoxHeight(node),
+    margin: node.style.margin,
+    padding: layoutPadding(node),
+    gap: node.style.gap ?? 0,
+    align: node.style.alignItems,
+    justify: children.justify,
+    background: node.style.background,
+    backgroundImage: backgroundImage(node, options),
+    border: border(node),
+    borderSides: node.style.borderSides,
+    borderRadius: node.style.borderRadius,
+    overflow: node.style.overflow,
+    position: node.style.position,
+    top: node.style.top,
+    right: node.style.right,
+    bottom: node.style.bottom,
+    left: node.style.left,
+    zIndex: node.style.zIndex
+  };
+  return node.style.flexDirection.startsWith("row") ? (0, import_boxpdf.hstack)(style, ...children.nodes) : (0, import_boxpdf.vstack)(style, ...children.nodes);
+}
+function flexChildrenWithJustification(children, justify, direction, width, gap) {
+  if (!direction.startsWith("row") || justify !== "between" || children.length < 2) return { nodes: children, justify };
+  const available = width ?? Number.POSITIVE_INFINITY;
+  if (!Number.isFinite(available)) return { nodes: children, justify };
+  const measuredWidths = children.map((child) => (0, import_boxpdf.measure)(child, Number.POSITIVE_INFINITY).width);
+  const childWidth = measuredWidths.reduce((sum, width2) => sum + width2, 0);
+  const spacerWidth = Math.max(0, (available - childWidth - gap * (children.length - 1)) / (children.length - 1));
+  const nodes = children.map((child, index) => setFlexItemWidth(child, measuredWidths[index] + (index === children.length - 1 ? 0 : spacerWidth)));
+  return { nodes, justify: "start" };
+}
+function setFlexItemWidth(node, width) {
+  if (node.kind === "vstack" || node.kind === "hstack") {
+    return { ...node, style: { ...node.style, width, shrink: 0 } };
+  }
+  if (node.kind === "text") {
+    return { ...node, props: { ...node.props, width, shrink: 0 } };
+  }
+  return node;
+}
+function renderFlexChild(node, options, warnings) {
+  if (!("text" in node) && node.node.tag === "img") {
+    const rendered = renderImageForLayout(node, options, warnings);
+    return rendered ? [rendered] : [];
+  }
+  if (!("text" in node) && isInlineContainer(node)) return [renderBlock(node, options, warnings)];
+  if (!("text" in node) && node.style.display === "block") return [renderBlock(node, options, warnings, false)];
+  return renderNode(node, options, warnings);
+}
+function renderGrid(node, options, warnings) {
+  const gridGap = node.style.columnGap ?? node.style.gap ?? 0;
+  const gridWidth = contentWidth(node) ?? (node.style.display === "inline-grid" ? inlineGridIntrinsicWidth(node.children.filter(hasRenderedContent).flatMap((child) => renderNode(child, options, warnings)), node.style.gridTemplateColumns, gridGap, options.width) : options.width);
+  const tracks = resolveGridTracks(node.style.gridTemplateColumns, gridWidth, gridGap);
+  if (tracks.length === 0) return renderBlock(node, options, warnings);
+  const rows = gridRows(node, tracks, options, warnings);
+  return (0, import_boxpdf.vstack)(
+    {
+      width: cssBoxWidth(node),
+      height: cssBoxHeight(node),
+      margin: node.style.margin,
+      padding: layoutPadding(node),
+      gap: node.style.rowGap ?? node.style.gap ?? 0,
+      background: node.style.background,
+      backgroundImage: backgroundImage(node, options),
+      border: border(node),
+      borderSides: node.style.borderSides,
+      borderRadius: node.style.borderRadius,
+      overflow: node.style.overflow,
+      position: node.style.position,
+      top: node.style.top,
+      right: node.style.right,
+      bottom: node.style.bottom,
+      left: node.style.left,
+      zIndex: node.style.zIndex
+    },
+    ...rows
+  );
+}
+function gridRows(node, tracks, options, warnings) {
+  const rows = [];
+  let row = [];
+  let cursor = 0;
+  const gap = node.style.columnGap ?? node.style.gap ?? 0;
+  for (const child of orderedChildren(node.children).filter(hasRenderedContent)) {
+    const rendered = renderNode(child, options, warnings);
+    if (rendered.length === 0) continue;
+    const requestedStart = !("text" in child) ? child.style.gridColumnStart : void 0;
+    let column = requestedStart !== void 0 ? Math.max(0, requestedStart - 1) : cursor;
+    let span = gridColumnSpan(child, tracks.length, column);
+    if (column >= tracks.length) column = tracks.length - 1;
+    span = Math.max(1, Math.min(span, tracks.length - column));
+    if (column < cursor || column + span > tracks.length) {
+      rows.push(row);
+      row = [];
+      cursor = 0;
+      column = requestedStart !== void 0 ? Math.max(0, Math.min(requestedStart - 1, tracks.length - 1)) : 0;
+      span = Math.max(1, Math.min(gridColumnSpan(child, tracks.length, column), tracks.length - column));
+    }
+    row.push({ column, span, node: gridCellNode(rendered, gridSpanWidth(tracks, column, span, gap)) });
+    cursor = column + span;
+    if (cursor >= tracks.length) {
+      rows.push(row);
+      row = [];
+      cursor = 0;
+    }
+  }
+  if (row.length > 0) rows.push(row);
+  return rows.map((cells) => renderGridRow(cells, tracks, gap, node.style.alignItems));
+}
+function gridColumnSpan(child, trackCount, column) {
+  if ("text" in child) return 1;
+  if (child.style.gridColumnSpan !== void 0) return child.style.gridColumnSpan;
+  if (child.style.gridColumnStart !== void 0 && child.style.gridColumnEnd !== void 0) {
+    return Math.max(1, child.style.gridColumnEnd - child.style.gridColumnStart);
+  }
+  return Math.max(1, Math.min(1, trackCount - column));
+}
+function gridSpanWidth(tracks, column, span, gap) {
+  return tracks.slice(column, column + span).reduce((sum, width) => sum + width, 0) + gap * Math.max(0, span - 1);
+}
+function gridCellNode(nodes, width) {
+  const node = nodes.length === 1 ? nodes[0] : (0, import_boxpdf.vstack)({}, ...nodes);
+  return constrainGridItem(node, width);
+}
+function renderGridRow(cells, tracks, gap, align) {
+  const rowChildren = [];
+  let cursor = 0;
+  for (const cell of cells.sort((a, b) => a.column - b.column)) {
+    while (cursor < cell.column) {
+      rowChildren.push((0, import_boxpdf.vstack)({ width: tracks[cursor] ?? 0 }));
+      cursor += 1;
+    }
+    rowChildren.push(cell.node);
+    cursor = cell.column + cell.span;
+  }
+  while (cursor < tracks.length) {
+    rowChildren.push((0, import_boxpdf.vstack)({ width: tracks[cursor] ?? 0 }));
+    cursor += 1;
+  }
+  return (0, import_boxpdf.hstack)({ gap, align }, ...stretchGridRow(rowChildren, tracksForCells(cells, tracks, gap, rowChildren.length)));
+}
+function tracksForCells(cells, tracks, gap, childCount) {
+  if (cells.every((cell) => cell.span === 1) && childCount === tracks.length) return tracks;
+  const out = [];
+  let cursor = 0;
+  for (const cell of cells.sort((a, b) => a.column - b.column)) {
+    while (cursor < cell.column) {
+      out.push(tracks[cursor] ?? 0);
+      cursor += 1;
+    }
+    out.push(gridSpanWidth(tracks, cell.column, cell.span, gap));
+    cursor = cell.column + cell.span;
+  }
+  while (cursor < tracks.length) {
+    out.push(tracks[cursor] ?? 0);
+    cursor += 1;
+  }
+  return out;
+}
+function inlineGridIntrinsicWidth(children, tracks, gap, parentWidth) {
+  if (!tracks || tracks.length === 0) {
+    const widths2 = children.map((child) => (0, import_boxpdf.measure)(child, parentWidth ?? Number.POSITIVE_INFINITY).width);
+    return widths2.length === 0 ? void 0 : Math.max(0, ...widths2);
+  }
+  const widths = tracks.map((track, trackIndex) => {
+    if (track.kind === "length") return track.value;
+    return children.filter((_, childIndex) => childIndex % tracks.length === trackIndex).reduce((max, child) => Math.max(max, (0, import_boxpdf.measure)(child, parentWidth ?? Number.POSITIVE_INFINITY).width), 0);
+  });
+  return widths.reduce((sum, width) => sum + width, 0) + gap * Math.max(0, widths.length - 1);
+}
+function hasRenderedContent(node) {
+  if ("text" in node) return node.text.trim().length > 0;
+  return node.style.display !== "none";
+}
+function orderedChildren(nodes) {
+  return nodes.map((node, index) => ({ node, index })).sort((a, b) => orderFor(a.node) - orderFor(b.node) || a.index - b.index).map(({ node }) => node);
+}
+function orderFor(node) {
+  return "text" in node ? 0 : node.style.order ?? 0;
+}
+function resolveGridTracks(tracks, width, gap) {
+  if (!tracks || tracks.length === 0) {
+    return width === void 0 ? [] : [width];
+  }
+  const available = width === void 0 ? void 0 : Math.max(0, width - gap * Math.max(0, tracks.length - 1));
+  const fixed = tracks.reduce((sum, track) => {
+    if (track.kind === "length") return sum + track.value;
+    if (track.kind === "percent" && available !== void 0) return sum + available * track.value;
+    return sum;
+  }, 0);
+  const fr = tracks.reduce((sum, track) => sum + (track.kind === "fr" ? track.value : 0), 0);
+  const frUnit = available === void 0 || fr === 0 ? 0 : Math.max(0, available - fixed) / fr;
+  return tracks.map((track) => {
+    if (track.kind === "length") return track.value;
+    if (track.kind === "percent" && available !== void 0) return available * track.value;
+    return frUnit * track.value;
+  });
+}
+function constrainGridItem(node, width) {
+  if (node.kind === "vstack" || node.kind === "hstack") {
+    return constrainBlockDescendants({ ...node, style: { ...node.style, width: node.style.width ?? width, shrink: node.style.shrink ?? 1 } }, width);
+  }
+  if (node.kind === "paragraph") {
+    return { ...node, props: { ...node.props, width: node.props.width ?? width } };
+  }
+  if (node.kind === "text") {
+    return { ...node, props: { ...node.props, width: node.props.width ?? width, shrink: node.props.shrink ?? 1 } };
+  }
+  return (0, import_boxpdf.vstack)({ width, shrink: 1 }, node);
+}
+function constrainBlockDescendants(node, width) {
+  const innerWidth = boxNodeContentWidth(node, width);
+  const children = node.children.map((child) => constrainFlowChild(child, innerWidth));
+  return { ...node, children };
+}
+function constrainFlowChild(child, width) {
+  if (child.kind === "paragraph") {
+    return { ...child, props: { ...child.props, width: child.props.width === void 0 ? width : Math.min(child.props.width, width) } };
+  }
+  if (child.kind === "text") {
+    return { ...child, props: { ...child.props, width: child.props.width === void 0 ? width : Math.min(child.props.width, width) } };
+  }
+  if (child.kind === "vstack" || child.kind === "hstack") {
+    const nextWidth = child.style.width === void 0 ? width : Math.min(child.style.width, width);
+    return constrainBlockDescendants({ ...child, style: { ...child.style, width: nextWidth } }, nextWidth);
+  }
+  return child;
+}
+function boxNodeContentWidth(node, width) {
+  const padding = edges(node.style.padding);
+  const borderWidth = node.style.border?.width ?? 0;
+  const leftBorder = node.style.borderSides?.left?.width ?? borderWidth;
+  const rightBorder = node.style.borderSides?.right?.width ?? borderWidth;
+  return Math.max(0, width - padding.left - padding.right - leftBorder - rightBorder);
+}
+function stretchGridRow(nodes, tracks) {
+  const heights = nodes.map((node, index) => (0, import_boxpdf.measure)(node, tracks[index] ?? tracks[tracks.length - 1] ?? Number.POSITIVE_INFINITY).height);
+  const rowHeight = Math.max(0, ...heights);
+  return nodes.map((node, index) => {
+    if (node.kind === "vstack" || node.kind === "hstack") {
+      return { ...node, style: { ...node.style, height: node.style.height ?? rowHeight } };
+    }
+    return (0, import_boxpdf.vstack)({ width: tracks[index], height: rowHeight }, node);
+  });
+}
+function defaultFlexItem(node) {
+  if (node.kind === "vstack" || node.kind === "hstack") {
+    return { ...node, style: { ...node.style, shrink: node.style.shrink ?? 1 } };
+  }
+  if (node.kind === "text") {
+    return { ...node, props: { ...node.props, shrink: node.props.shrink ?? 1 } };
+  }
+  return node;
+}
+function renderInlineGroup(node, options, warnings) {
+  const runs = collectInlineRuns([node], options, warnings);
+  if (runs.length === 0) return [];
+  return [(0, import_boxpdf.paragraph)({ width: contentWidth(node), align: node.style.textAlign, wrap: shouldWrap(node.style) }, ...runs)];
+}
+function renderList(node, options, warnings) {
+  const items = node.children.filter((child) => !("text" in child) && child.node.tag === "li");
+  const listPadding = edges(node.style.padding);
+  const markerWidth = Math.max(node.style.fontSize * 1.5, listPadding.left * 0.65);
+  const leftPadding = node.style.listStyleType === "none" ? listPadding.left : Math.max(0, listPadding.left - markerWidth);
+  return (0, import_boxpdf.vstack)(
+    {
+      margin: node.style.margin,
+      padding: { ...listPadding, left: leftPadding },
+      gap: node.style.gap ?? 0
+    },
+    ...items.flatMap((item, index) => renderListItem(item, index, node.style.listStyleType, markerWidth, options, warnings))
+  );
+}
+function renderListItem(item, index, listStyleType, markerWidth, options, warnings) {
+  const runs = collectInlineRuns(item.children, options, warnings);
+  const marker = listStyleType === "none" ? "" : listStyleType === "decimal" ? `${index + 1}.  ` : "\u2022  ";
+  const paragraphs = runs.length > 0 ? [
+    (0, import_boxpdf.paragraph)(
+      {
+        width: item.style.width,
+        align: item.style.textAlign,
+        margin: item.style.margin,
+        paddingLeft: marker ? markerWidth : 0,
+        textIndent: marker ? -markerWidth : 0,
+        wrap: shouldWrap(item.style)
+      },
+      ...marker ? [(0, import_boxpdf.run)(marker, runStyle({ style: item.style }, options))] : [],
+      ...runs
+    )
+  ] : [];
+  const blockChildren = item.children.filter((child) => !isInlineLike(child)).flatMap((child) => renderNode(child, options, warnings));
+  return [...paragraphs, ...blockChildren];
+}
+function collectInlineRuns(nodes, options, warnings) {
+  const runs = [];
+  for (const node of nodes) {
+    if ("text" in node) {
+      if (preservesWhitespace(node.style) && node.text.length > 0) {
+        runs.push((0, import_boxpdf.run)(node.text, runStyle(node, options)));
+      } else if (node.text.trim()) {
+        runs.push((0, import_boxpdf.run)(node.text, runStyle(node, options)));
+      } else if (runs.length > 0) {
+        runs.push((0, import_boxpdf.run)(" ", runStyle(node, options)));
+      }
+      continue;
+    }
+    if (node.node.tag === "br") {
+      runs.push((0, import_boxpdf.run)("\n", runStyle({ style: node.style }, options)));
+      continue;
+    }
+    if (node.node.tag === "img") {
+      const rendered = renderImageForLayout(node, options, warnings);
+      if (rendered) {
+        const measured = (0, import_boxpdf.measure)(rendered, contentWidth(node) ?? options.width ?? Number.POSITIVE_INFINITY);
+        runs.push((0, import_boxpdf.inlineNode)(rendered, { width: measured.width, height: measured.height, verticalAlign: node.style.verticalAlign === "middle" ? "middle" : void 0 }));
+      }
+      continue;
+    }
+    if (isAtomicInlineContainer(node)) {
+      const rendered = renderAtomicInlineNode(node, options, warnings);
+      const measured = (0, import_boxpdf.measure)(rendered, contentWidth(node) ?? options.width ?? Number.POSITIVE_INFINITY);
+      runs.push((0, import_boxpdf.inlineNode)(rendered, { width: measured.width, height: measured.height, verticalAlign: node.style.verticalAlign === "middle" ? "middle" : void 0 }));
+      continue;
+    }
+    if (node.style.display === "inline" || node.style.display === "contents") {
+      runs.push(...collectInlineRuns(node.children, options, warnings));
+    }
+  }
+  return runs;
+}
+function renderAtomicInlineNode(node, options, warnings) {
+  if (node.style.display === "inline-flex") return renderFlex(node, options, warnings);
+  if (node.style.display === "inline-grid") return renderGrid(node, options, warnings);
+  return renderBlock(node, options, warnings);
+}
+function renderImageNode(node, options, warnings) {
+  return renderImageContent(node, options, warnings, node.style.margin, true);
+}
+function renderImageForLayout(node, options, warnings) {
+  if (!hasImageBoxStyling(node)) return renderImageNode(node, options, warnings);
+  const content = renderImageContent(node, options, warnings, void 0, false);
+  if (!content) return void 0;
+  return (0, import_boxpdf.vstack)(
+    {
+      width: cssBoxWidth(node),
+      height: cssBoxHeight(node),
+      margin: node.style.margin,
+      padding: layoutPadding(node),
+      background: node.style.background,
+      border: border(node),
+      borderSides: node.style.borderSides,
+      borderRadius: node.style.borderRadius,
+      overflow: node.style.overflow,
+      shrink: 0
+    },
+    content
+  );
+}
+function renderImageContent(node, options, warnings, margin, decoratedFallback) {
+  const src = imageUrl(node);
+  if (!src) {
+    warnings.push("img without a resolvable src was skipped");
+    return void 0;
+  }
+  const pdfImage = options.resolveImage?.({ url: src, baseUrl: options.baseUrl });
+  if (!pdfImage) {
+    const size2 = imageSize(node, options);
+    if (hasExplicitImageSize(node)) {
+      warnings.push(`img src "${src}" did not resolve; preserved its layout box`);
+      return (0, import_boxpdf.vstack)({
+        width: size2.width,
+        height: size2.height,
+        margin,
+        border: decoratedFallback ? border(node) : void 0,
+        borderSides: decoratedFallback ? node.style.borderSides : void 0,
+        borderRadius: decoratedFallback ? node.style.borderRadius : void 0,
+        background: decoratedFallback ? node.style.background : void 0
+      });
+    }
+    warnings.push(`img src "${src}" did not resolve`);
+    return void 0;
+  }
+  const size = imageSize(node, options, pdfImage);
+  if (node.style.objectFit === "contain" || node.style.objectFit === "cover") {
+    return (0, import_boxpdf.imageFit)(pdfImage, { width: size.width, height: size.height, fit: node.style.objectFit, margin });
+  }
+  return (0, import_boxpdf.image)(pdfImage, { width: size.width, height: size.height, margin });
+}
+function hasExplicitImageSize(node) {
+  return node.style.width !== void 0 || node.style.height !== void 0 || node.node.attrs.width !== void 0 || node.node.attrs.height !== void 0;
+}
+function hasImageBoxStyling(node) {
+  return Boolean(
+    node.style.background || node.style.borderWidth || node.style.borderSides || node.style.borderRadius || node.style.padding || node.style.overflow
+  );
+}
+function imageSize(node, options, resolvedImage) {
+  const src = imageUrl(node);
+  const pdfImage = resolvedImage ?? (src ? options.resolveImage?.({ url: src, baseUrl: options.baseUrl }) : void 0);
+  const naturalWidth = Math.max(1, (pdfImage?.width ?? 1) * 0.75);
+  const naturalHeight = Math.max(1, (pdfImage?.height ?? 1) * 0.75);
+  const naturalRatio = node.style.aspectRatio ?? naturalWidth / naturalHeight;
+  const width = node.style.width;
+  const height = node.style.height;
+  if (width !== void 0 && height !== void 0) return { width, height };
+  if (width !== void 0) return { width, height: width / naturalRatio };
+  if (height !== void 0) return { width: height * naturalRatio, height };
+  return { width: naturalWidth, height: naturalHeight };
+}
+function imageUrl(node) {
+  if (node.node.parent?.tag === "picture") {
+    for (const child of node.node.parent.children) {
+      if (child.kind !== "element") continue;
+      if (child === node.node) break;
+      if (child.tag !== "source") continue;
+      const selected = srcsetUrl(child.attrs.srcset, targetImageCssWidth(node));
+      if (selected) return selected;
+    }
+  }
+  return srcsetUrl(node.node.attrs.srcset, targetImageCssWidth(node)) ?? node.node.attrs.src;
+}
+function srcsetUrl(value, targetCssPx) {
+  const candidates = srcsetCandidates(value);
+  if (candidates.length === 0) return void 0;
+  const widthCandidates = candidates.filter((candidate) => candidate.width !== void 0);
+  if (widthCandidates.length > 0) {
+    const sorted = widthCandidates.sort((a, b) => a.width - b.width);
+    if (targetCssPx !== void 0) return sorted.find((candidate) => candidate.width >= targetCssPx)?.url ?? sorted[sorted.length - 1]?.url;
+    return sorted[sorted.length - 1]?.url;
+  }
+  const densityCandidates = candidates.filter((candidate) => candidate.density !== void 0).sort((a, b) => a.density - b.density);
+  if (densityCandidates.length > 0) return densityCandidates.find((candidate) => candidate.density >= 1)?.url ?? densityCandidates[densityCandidates.length - 1]?.url;
+  return candidates[0]?.url;
+}
+function srcsetCandidates(value) {
+  if (!value) return [];
+  return value.split(",").map((raw) => raw.trim()).filter(Boolean).map((candidate) => {
+    const [url, descriptor] = candidate.split(/\s+/, 2);
+    if (!url) return void 0;
+    if (descriptor?.endsWith("w")) {
+      const width = Number.parseFloat(descriptor.slice(0, -1));
+      return Number.isFinite(width) && width > 0 ? { url, width } : { url };
+    }
+    if (descriptor?.endsWith("x")) {
+      const density = Number.parseFloat(descriptor.slice(0, -1));
+      return Number.isFinite(density) && density > 0 ? { url, density } : { url };
+    }
+    return { url };
+  }).filter((candidate) => candidate !== void 0);
+}
+function targetImageCssWidth(node) {
+  return node.style.width === void 0 ? void 0 : node.style.width / 0.75;
+}
+function renderTable(node, options, warnings) {
+  const rows = tableRows(node);
+  if (rows.length === 0) {
+    warnings.push("table without direct tr children was flattened as a block");
+    return [renderBlock(node, options, warnings)];
+  }
+  return [
+    (0, import_boxpdf.table)({
+      width: cssBoxWidth(node) ?? options.width,
+      columns: inferColumns(rows),
+      columnGap: 0,
+      borderCollapse: node.style.borderCollapse,
+      margin: node.style.margin,
+      rows: rows.map(
+        (row) => row.children.filter((child) => !("text" in child) && (child.node.tag === "td" || child.node.tag === "th")).map((cell) => ({
+          content: renderCellContent(cell, options, warnings),
+          padding: layoutPadding(cell, 4),
+          background: cell.style.background,
+          backgroundImage: backgroundImage(cell, options),
+          border: border(cell),
+          borderSides: cell.style.borderSides,
+          borderRadius: cell.style.borderRadius,
+          overflow: cell.style.overflow,
+          align: cell.style.textAlign,
+          valign: cell.style.verticalAlign === "middle" ? "middle" : "top"
+        }))
+      )
+    })
+  ];
+}
+function renderCellContent(cell, options, warnings) {
+  const children = renderBlockChildren(cell, options, warnings);
+  if (children.length === 1) return children[0];
+  return (0, import_boxpdf.vstack)({ gap: cell.style.gap ?? 0 }, ...children);
+}
+function tableRows(node) {
+  const rows = [];
+  for (const child of node.children) {
+    if ("text" in child) continue;
+    if (child.node.tag === "tr") rows.push(child);
+    if (child.node.tag === "thead" || child.node.tag === "tbody" || child.node.tag === "tfoot") {
+      rows.push(...child.children.filter((row) => !("text" in row) && row.node.tag === "tr"));
+    }
+  }
+  return rows;
+}
+function isInlineLike(node) {
+  return "text" in node || isInlineContainer(node);
+}
+function isInlineContainer(node) {
+  return node.style.display === "inline" || isAtomicInlineContainer(node);
+}
+function isAtomicInlineContainer(node) {
+  return node.style.display === "inline-block" || node.style.display === "inline-flex" || node.style.display === "inline-grid";
+}
+function inferColumns(rows) {
+  const count = Math.max(
+    1,
+    ...rows.map(
+      (row) => row.children.filter((child) => !("text" in child) && (child.node.tag === "td" || child.node.tag === "th")).length
+    )
+  );
+  return Array.from({ length: count }, () => ({ width: "1fr" }));
+}
+function cssBoxWidth(node) {
+  if (node.style.width === void 0) return void 0;
+  if (node.style.boxSizing === "border-box") return node.style.width;
+  const padding = edges(node.style.padding);
+  const borders = borderWidths(node);
+  return node.style.width + padding.left + padding.right + borders.left + borders.right;
+}
+function cssBoxHeight(node) {
+  if (node.style.height === void 0) return void 0;
+  if (node.style.boxSizing === "border-box") return node.style.height;
+  const padding = edges(node.style.padding);
+  const borders = borderWidths(node);
+  return node.style.height + padding.top + padding.bottom + borders.top + borders.bottom;
+}
+function contentWidth(node) {
+  if (node.style.width !== void 0 && node.style.boxSizing === "border-box") {
+    const padding = edges(node.style.padding);
+    const borders = borderWidths(node);
+    return Math.max(0, node.style.width - padding.left - padding.right - borders.left - borders.right);
+  }
+  return node.style.width;
+}
+function edges(input) {
+  if (input === void 0) return { top: 0, right: 0, bottom: 0, left: 0 };
+  if (typeof input === "number") return { top: input, right: input, bottom: input, left: input };
+  return {
+    top: input.top ?? 0,
+    right: input.right ?? 0,
+    bottom: input.bottom ?? 0,
+    left: input.left ?? 0
+  };
+}
+function borderWidths(node) {
+  const all = node.style.borderWidth ?? 0;
+  return {
+    top: node.style.borderSides?.top?.width ?? all,
+    right: node.style.borderSides?.right?.width ?? all,
+    bottom: node.style.borderSides?.bottom?.width ?? all,
+    left: node.style.borderSides?.left?.width ?? all
+  };
+}
+function layoutPadding(node, fallback) {
+  const padding = edges(node.style.padding ?? fallback);
+  const borders = borderWidths(node);
+  const out = {
+    top: padding.top + borders.top,
+    right: padding.right + borders.right,
+    bottom: padding.bottom + borders.bottom,
+    left: padding.left + borders.left
+  };
+  if (out.top === 0 && out.right === 0 && out.bottom === 0 && out.left === 0) return void 0;
+  if (out.top === out.right && out.right === out.bottom && out.bottom === out.left) return out.top;
+  return out;
+}
+function backgroundImage(node, options) {
+  if (!node.style.backgroundImageUrl || !options.resolveImage) return void 0;
+  const image = options.resolveImage({ url: node.style.backgroundImageUrl, baseUrl: options.baseUrl });
+  if (!image) return void 0;
+  const width = cssBoxWidth(node);
+  const height = cssBoxHeight(node);
+  if (width === void 0 || height === void 0 || width <= 0 || height <= 0) return void 0;
+  const sizing = node.style.backgroundSize ?? "auto";
+  const naturalWidth = image.width * 0.75;
+  const naturalHeight = image.height * 0.75;
+  const scale = sizing === "cover" ? Math.max(width / naturalWidth, height / naturalHeight) : sizing === "contain" ? Math.min(width / naturalWidth, height / naturalHeight) : 1;
+  const imageWidth = naturalWidth * scale;
+  const imageHeight = naturalHeight * scale;
+  const x = node.style.backgroundPositionX ?? 0;
+  const y = node.style.backgroundPositionY ?? 0;
+  return {
+    image,
+    width: imageWidth,
+    height: imageHeight,
+    offsetX: (width - imageWidth) * x,
+    offsetY: (height - imageHeight) * y,
+    repeat: node.style.backgroundRepeat ?? "repeat"
+  };
+}
+function textOptions(node, options) {
+  return {
+    ...runStyle(node, options),
+    width: node.style.width,
+    wrap: shouldWrap(node.style),
+    align: node.style.textAlign,
+    margin: node.style.margin
+  };
+}
+function runStyle(node, options) {
+  return {
+    size: node.style.fontSize,
+    font: fontFor(node, options),
+    color: node.style.color ?? options.defaultColor,
+    lineHeight: node.style.lineHeight,
+    underline: node.style.textDecorationLine === "underline",
+    strikethrough: node.style.textDecorationLine === "line-through"
+  };
+}
+function fontFor(node, options) {
+  const resolved = options.resolveFont?.({
+    families: node.style.fontFamily ?? [],
+    weight: node.style.fontWeight,
+    style: node.style.fontStyle
+  });
+  if (resolved) return resolved;
+  if (isBold(node.style.fontWeight)) return options.boldFont ?? options.font;
+  if (node.style.fontStyle === "italic") return options.italicFont ?? options.font;
+  return options.font;
+}
+function isBold(weight) {
+  return weight === "bold" || typeof weight === "number" && weight >= 600;
+}
+function shouldWrap(style) {
+  return style.whiteSpace !== "nowrap" && style.whiteSpace !== "pre";
+}
+function preservesWhitespace(style) {
+  return style.whiteSpace === "pre" || style.whiteSpace === "pre-wrap";
+}
+function border(node) {
+  if (!node.style.borderWidth || !node.style.borderColor) return void 0;
+  return { width: node.style.borderWidth, color: node.style.borderColor };
+}
+
+// src/style.ts
+var blockTags = /* @__PURE__ */ new Set([
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "body",
+  "div",
+  "dl",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hr",
+  "li",
+  "main",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "tr",
+  "ul"
+]);
+function computeStyles(root, rules, base, containingWidth, unsupportedCss) {
+  return styleElement(root, rules, base, containingWidth, unsupportedCss);
+}
+function styleNode(node, rules, inherited, containingWidth, unsupportedCss, parentDisplay) {
+  if (node.kind === "text") {
+    return { node, style: inherited, text: transformText(normalizeWhitespace(node.value, inherited.whiteSpace), inherited.textTransform) };
+  }
+  return styleElement(node, rules, inherited, containingWidth, unsupportedCss, parentDisplay);
+}
+function styleElement(node, rules, inherited, containingWidth, unsupportedCss, parentDisplay) {
+  const tagDefaults = defaultsForTag(node.tag, inherited);
+  const ruleDeclarations = ruleDeclarationsFor(node, rules, tagDefaults.fontSize, tagDefaults.customProperties, unsupportedCss);
+  const withRules = mergeStyles(tagDefaults, ruleDeclarations.declarations);
+  const inlineDeclarations = parseStyleAttribute(node.attrs.style, withRules.fontSize, withRules.customProperties, unsupportedCss);
+  const style = mergeStyles(
+    withRules,
+    inlineDeclarations.declarations,
+    ruleDeclarations.importantDeclarations,
+    inlineDeclarations.importantDeclarations
+  );
+  if (style.widthPercent !== void 0 && containingWidth !== void 0) style.width = containingWidth * style.widthPercent;
+  if (style.minWidthPercent !== void 0 && containingWidth !== void 0) style.minWidth = containingWidth * style.minWidthPercent;
+  if (style.maxWidthPercent !== void 0 && containingWidth !== void 0) style.maxWidth = containingWidth * style.maxWidthPercent;
+  if (style.widthCalc !== void 0 && containingWidth !== void 0) style.width = containingWidth * style.widthCalc.percent + style.widthCalc.length;
+  if (style.minWidthCalc !== void 0 && containingWidth !== void 0) style.minWidth = containingWidth * style.minWidthCalc.percent + style.minWidthCalc.length;
+  if (style.maxWidthCalc !== void 0 && containingWidth !== void 0) style.maxWidth = containingWidth * style.maxWidthCalc.percent + style.maxWidthCalc.length;
+  if ((style.display === "block" || style.display === "flex" || style.display === "grid") && parentDisplay !== "flex" && parentDisplay !== "grid" && style.width === void 0 && containingWidth !== void 0) {
+    style.width = autoContentWidth(style, containingWidth);
+  }
+  if (node.tag === "img") {
+    style.width ??= parseDimensionAttr(node.attrs.width);
+    style.height ??= parseDimensionAttr(node.attrs.height);
+  }
+  if (style.width === void 0 && containingWidth !== void 0 && (style.minWidth !== void 0 || style.maxWidth !== void 0)) {
+    style.width = containingWidth;
+  }
+  if (style.width !== void 0) style.width = clamp(style.width, style.minWidth, style.maxWidth);
+  applyAspectRatio(style);
+  applyAutoMargins(style, containingWidth);
+  if (style.lineHeightScale !== void 0) style.lineHeight = style.fontSize * style.lineHeightScale;
+  const inheritedForChildren = inherit(style);
+  const childContainingWidth = parentDisplay === "flex" && style.width === void 0 ? void 0 : contentWidthForChildren(style, containingWidth);
+  const children = node.children.map((child) => styleNode(child, rules, inheritedForChildren, childContainingWidth, unsupportedCss, style.display)).filter((child) => child !== void 0);
+  return { node, style, children };
+}
+function defaultStyle(fontSize = 12) {
+  return {
+    display: "block",
+    flexDirection: "row",
+    alignItems: "stretch",
+    justifyContent: "start",
+    fontSize,
+    fontWeight: "normal",
+    fontStyle: "normal",
+    textAlign: "left",
+    verticalAlign: "baseline",
+    boxSizing: "content-box",
+    whiteSpace: "normal"
+  };
+}
+function defaultsForTag(tag, inherited) {
+  const style = {
+    ...inherited,
+    display: blockTags.has(tag) ? "block" : "inline",
+    float: void 0,
+    order: void 0,
+    margin: void 0,
+    marginAutoLeft: void 0,
+    marginAutoRight: void 0,
+    padding: void 0,
+    background: void 0,
+    backgroundImageUrl: void 0,
+    backgroundSize: void 0,
+    backgroundRepeat: void 0,
+    backgroundPositionX: void 0,
+    backgroundPositionY: void 0,
+    objectFit: void 0,
+    overflow: void 0,
+    borderWidth: void 0,
+    borderColor: void 0,
+    borderSides: void 0,
+    borderRadius: void 0,
+    boxSizing: "content-box",
+    width: void 0,
+    widthPercent: void 0,
+    widthCalc: void 0,
+    minWidth: void 0,
+    minWidthPercent: void 0,
+    minWidthCalc: void 0,
+    maxWidth: void 0,
+    maxWidthPercent: void 0,
+    maxWidthCalc: void 0,
+    height: void 0,
+    aspectRatio: void 0,
+    position: void 0,
+    top: void 0,
+    right: void 0,
+    bottom: void 0,
+    left: void 0,
+    zIndex: void 0,
+    columnGap: void 0,
+    rowGap: void 0,
+    gridTemplateColumns: void 0,
+    gridColumnStart: void 0,
+    gridColumnEnd: void 0,
+    gridColumnSpan: void 0
+  };
+  if (tag === "strong" || tag === "b" || tag === "th") style.fontWeight = "bold";
+  if (tag === "em" || tag === "i") style.fontStyle = "italic";
+  if (tag === "h1") {
+    Object.assign(style, {
+      fontSize: inherited.fontSize * 2,
+      fontWeight: "bold",
+      margin: { top: 0.67 * inherited.fontSize * 2, bottom: 0.67 * inherited.fontSize * 2 }
+    });
+  }
+  if (tag === "h2") {
+    Object.assign(style, {
+      fontSize: inherited.fontSize * 1.5,
+      fontWeight: "bold",
+      margin: { top: 0.83 * inherited.fontSize * 1.5, bottom: 0.83 * inherited.fontSize * 1.5 }
+    });
+  }
+  if (tag === "h3") {
+    Object.assign(style, {
+      fontSize: inherited.fontSize * 1.17,
+      fontWeight: "bold",
+      margin: { top: inherited.fontSize * 1.17, bottom: inherited.fontSize * 1.17 }
+    });
+  }
+  if (tag === "p") style.margin = { top: inherited.fontSize, bottom: inherited.fontSize };
+  if (tag === "ul" || tag === "ol") {
+    style.margin = { top: inherited.fontSize, bottom: inherited.fontSize };
+    style.padding = { left: inherited.fontSize * 2.5 };
+    style.listStyleType = tag === "ol" ? "decimal" : "disc";
+  }
+  if (tag === "li") style.display = "block";
+  if (tag === "img") style.display = "inline";
+  if (tag === "pre") style.whiteSpace = "pre";
+  if (tag === "br") style.display = "inline";
+  return style;
+}
+function inherit(style) {
+  return {
+    ...style,
+    display: "inline",
+    float: void 0,
+    order: void 0,
+    margin: void 0,
+    marginAutoLeft: void 0,
+    marginAutoRight: void 0,
+    padding: void 0,
+    background: void 0,
+    backgroundImageUrl: void 0,
+    backgroundSize: void 0,
+    backgroundRepeat: void 0,
+    backgroundPositionX: void 0,
+    backgroundPositionY: void 0,
+    objectFit: void 0,
+    overflow: void 0,
+    borderWidth: void 0,
+    borderColor: void 0,
+    borderSides: void 0,
+    borderRadius: void 0,
+    boxSizing: "content-box",
+    width: void 0,
+    widthPercent: void 0,
+    widthCalc: void 0,
+    minWidth: void 0,
+    minWidthPercent: void 0,
+    minWidthCalc: void 0,
+    maxWidth: void 0,
+    maxWidthPercent: void 0,
+    maxWidthCalc: void 0,
+    height: void 0,
+    aspectRatio: void 0,
+    position: void 0,
+    top: void 0,
+    right: void 0,
+    bottom: void 0,
+    left: void 0,
+    zIndex: void 0,
+    columnGap: void 0,
+    rowGap: void 0,
+    gridTemplateColumns: void 0,
+    gridColumnStart: void 0,
+    gridColumnEnd: void 0,
+    gridColumnSpan: void 0
+  };
+}
+function applyAspectRatio(style) {
+  if (style.aspectRatio === void 0 || style.aspectRatio <= 0) return;
+  if (style.width !== void 0 && style.height === void 0) style.height = style.width / style.aspectRatio;
+  else if (style.height !== void 0 && style.width === void 0) style.width = style.height * style.aspectRatio;
+}
+function parseDimensionAttr(value) {
+  if (!value) return void 0;
+  const normalized = value.trim();
+  if (/^\d+(?:\.\d+)?$/.test(normalized)) return Number(normalized) * 0.75;
+  return void 0;
+}
+function mergeStyles(...styles) {
+  const out = {};
+  for (const style of styles) {
+    const borderSides = out.borderSides;
+    Object.assign(out, style);
+    if (style.borderSides) {
+      out.borderSides = { ...borderSides, ...style.borderSides };
+    }
+  }
+  return out;
+}
+function contentWidthForChildren(style, containingWidth) {
+  if (style.width !== void 0) return contentWidth2(style);
+  if (containingWidth === void 0) return void 0;
+  const padding = edges2(style.padding);
+  const borders = borderWidths2(style);
+  return Math.max(0, containingWidth - padding.left - padding.right - borders.left - borders.right);
+}
+function autoContentWidth(style, containingWidth) {
+  if (style.boxSizing === "border-box") return containingWidth;
+  const padding = edges2(style.padding);
+  const borders = borderWidths2(style);
+  return Math.max(0, containingWidth - padding.left - padding.right - borders.left - borders.right);
+}
+function applyAutoMargins(style, containingWidth) {
+  if (containingWidth === void 0 || style.width === void 0 || !style.marginAutoLeft && !style.marginAutoRight) return;
+  const margin = edges2(style.margin);
+  const remaining = Math.max(0, containingWidth - outerWidth(style) + margin.left + margin.right);
+  if (style.marginAutoLeft && style.marginAutoRight) {
+    style.margin = { ...margin, left: remaining / 2, right: remaining / 2 };
+  } else if (style.marginAutoLeft) {
+    style.margin = { ...margin, left: remaining };
+  } else if (style.marginAutoRight) {
+    style.margin = { ...margin, right: remaining };
+  }
+}
+function outerWidth(style) {
+  const margin = edges2(style.margin);
+  const padding = edges2(style.padding);
+  const borders = borderWidths2(style);
+  const box = style.boxSizing === "border-box" ? style.width ?? 0 : (style.width ?? 0) + padding.left + padding.right + borders.left + borders.right;
+  return box + margin.left + margin.right;
+}
+function contentWidth2(style) {
+  if (style.width === void 0 || style.boxSizing !== "border-box") return style.width ?? 0;
+  const padding = edges2(style.padding);
+  const borders = borderWidths2(style);
+  return Math.max(0, style.width - padding.left - padding.right - borders.left - borders.right);
+}
+function clamp(value, min, max) {
+  if (min !== void 0) value = Math.max(value, min);
+  if (max !== void 0) value = Math.min(value, max);
+  return value;
+}
+function edges2(input) {
+  if (input === void 0) return { top: 0, right: 0, bottom: 0, left: 0 };
+  if (typeof input === "number") return { top: input, right: input, bottom: input, left: input };
+  return {
+    top: input.top ?? 0,
+    right: input.right ?? 0,
+    bottom: input.bottom ?? 0,
+    left: input.left ?? 0
+  };
+}
+function borderWidths2(style) {
+  const all = style.borderWidth ?? 0;
+  return {
+    top: style.borderSides?.top?.width ?? all,
+    right: style.borderSides?.right?.width ?? all,
+    bottom: style.borderSides?.bottom?.width ?? all,
+    left: style.borderSides?.left?.width ?? all
+  };
+}
+function normalizeWhitespace(value, whiteSpace) {
+  const normalized = value.replace(/\r\n?/g, "\n");
+  if (whiteSpace === "pre" || whiteSpace === "pre-wrap") return normalized;
+  if (whiteSpace === "pre-line") return normalized.replace(/[^\S\n]+/g, " ");
+  return normalized.replace(/\s+/g, " ");
+}
+function transformText(value, transform) {
+  if (transform === "uppercase") return value.toUpperCase();
+  if (transform === "lowercase") return value.toLowerCase();
+  if (transform === "capitalize") {
+    return value.replace(/\p{L}[\p{L}\p{N}'-]*/gu, (word) => word[0].toUpperCase() + word.slice(1).toLowerCase());
+  }
+  return value;
+}
+
+// src/font.ts
+function fontFamily(families) {
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [name, face] of Object.entries(families)) {
+    normalized.set(normalizeFamily(name), face);
+  }
+  return (request) => {
+    for (const family of request.families) {
+      const face = normalized.get(normalizeFamily(family));
+      const font = face && resolveFace(face, request);
+      if (font) return font;
+    }
+    return void 0;
+  };
+}
+function resolveFace(face, request) {
+  if (isPdfFont(face)) return face;
+  const preferred = preferredKeys(request.weight, request.style);
+  for (const key of preferred) {
+    const font = face[key];
+    if (font) return font;
+  }
+  return face.normal ?? face.bold ?? face.italic;
+}
+function preferredKeys(weight, style) {
+  const keys = [];
+  if (typeof weight === "number") keys.push(`${weight}`);
+  if (isBold2(weight) && style === "italic") keys.push("boldItalic");
+  if (style === "italic") keys.push("italic");
+  if (isBold2(weight)) keys.push("bold");
+  keys.push("normal");
+  return keys;
+}
+function isBold2(weight) {
+  return weight === "bold" || typeof weight === "number" && weight >= 600;
+}
+function normalizeFamily(family) {
+  return family.trim().replace(/^['"]|['"]$/g, "").toLowerCase();
+}
+function isPdfFont(value) {
+  return "embedder" in value;
+}
+
+// src/index.ts
+function htmlToBoxpdf(html, options) {
+  const startedAt = now();
+  const profile = (event) => {
+    options.profile?.({ ...event, elapsedMs: now() - startedAt });
+  };
+  profile({ phase: "start", htmlBytes: byteLength(html) });
+  const parsed = parseHtml(html);
+  profile({ phase: "parse-html", domNodes: countDomNodes(parsed.root), stylesheets: parsed.stylesheets.length });
+  const rules = parseStylesheets(parsed.stylesheets);
+  profile({ phase: "parse-css", cssRules: rules.length });
+  const diagnostics = createDiagnostics(options);
+  const styled = computeStyles(parsed.root, rules, {
+    ...defaultStyle(options.defaultFontSize ?? 12),
+    color: options.defaultColor,
+    lineHeight: options.defaultLineHeight
+  }, options.width, diagnostics ? (declaration) => diagnostics.recordUnsupportedCss(declaration) : void 0);
+  profile({ phase: "compute-styles", styledNodes: countStyledNodes(styled) });
+  const result = renderStyledTree(styled, options);
+  if (diagnostics) result.diagnostics = diagnostics.toJSON();
+  profile({ phase: "render-tree", ...countBoxNodes(result.nodes) });
+  profile({ phase: "finish" });
+  return result;
+}
+function createDiagnostics(options) {
+  if (!options.diagnostics?.unsupportedCss) return void 0;
+  const sampleLimit = options.diagnostics.sampleLimit ?? 3;
+  const unsupported = /* @__PURE__ */ new Map();
+  return {
+    recordUnsupportedCss(declaration) {
+      const property = declaration.property.trim().toLowerCase();
+      const value = declaration.value.trim();
+      const key = `${property}
+${value}`;
+      const entry = unsupported.get(key) ?? { property, value, count: 0, samples: [] };
+      entry.count += 1;
+      const sample = declaration.selector ? `${declaration.selector} { ${property}: ${value} }` : `${property}: ${value}`;
+      if (entry.samples.length < sampleLimit && !entry.samples.includes(sample)) entry.samples.push(sample);
+      unsupported.set(key, entry);
+    },
+    toJSON() {
+      return {
+        unsupportedCss: [...unsupported.values()].sort((a, b) => b.count - a.count || a.property.localeCompare(b.property)).map(({ property, value, count, samples }) => ({ property, value, count, samples: samples.length > 0 ? samples : void 0 }))
+      };
+    }
+  };
+}
+function now() {
+  return typeof performance === "undefined" ? Date.now() : performance.now();
+}
+function byteLength(value) {
+  return typeof TextEncoder === "undefined" ? value.length : new TextEncoder().encode(value).length;
+}
+function countDomNodes(node) {
+  if (node.kind === "text") return 1;
+  return 1 + node.children.reduce((sum, child) => sum + countDomNodes(child), 0);
+}
+function countStyledNodes(node) {
+  if ("text" in node) return 1;
+  return 1 + node.children.reduce((sum, child) => sum + countStyledNodes(child), 0);
+}
+function countBoxNodes(nodes) {
+  return nodes.reduce(
+    (sum, node) => {
+      const counted = countBoxNode(node);
+      return {
+        boxNodes: sum.boxNodes + counted.boxNodes,
+        paragraphs: sum.paragraphs + counted.paragraphs,
+        textRuns: sum.textRuns + counted.textRuns
+      };
+    },
+    { boxNodes: 0, paragraphs: 0, textRuns: 0 }
+  );
+}
+function countBoxNode(node) {
+  let out = {
+    boxNodes: 1,
+    paragraphs: node.kind === "paragraph" ? 1 : 0,
+    textRuns: node.kind === "paragraph" ? node.runs.filter((run2) => "text" in run2).length : node.kind === "text" ? 1 : 0
+  };
+  if ("children" in node) {
+    for (const child of node.children) {
+      const counted = countBoxNode(child);
+      out = {
+        boxNodes: out.boxNodes + counted.boxNodes,
+        paragraphs: out.paragraphs + counted.paragraphs,
+        textRuns: out.textRuns + counted.textRuns
+      };
+    }
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fontFamily,
+  htmlToBoxpdf,
+  parseHtml
+});
+//# sourceMappingURL=index.cjs.map