@rastr/pdf-template 0.0.0-stage → 0.1.0-beta.2

package/dist/index.cjs

@@ -0,0 +1,1135 @@
+"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, {
+  MM_PER_PT: () => MM_PER_PT,
+  TemplateError: () => TemplateError,
+  TemplateStoreError: () => TemplateStoreError,
+  compileCondition: () => compileCondition,
+  createLocalTemplateStore: () => createLocalTemplateStore,
+  createRestTemplateStore: () => createRestTemplateStore,
+  defaultText: () => defaultText,
+  evaluateText: () => evaluateText,
+  formatValue: () => formatValue,
+  layoutReport: () => layoutReport,
+  layoutReportAsync: () => layoutReportAsync,
+  measureText: () => measureText,
+  parseExpression: () => parseExpression,
+  parseFontMetrics: () => parseFontMetrics,
+  round2: () => round2,
+  templateLoader: () => templateLoader,
+  validateTemplate: () => validateTemplate,
+  wrapText: () => wrapText
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var TemplateError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(issues.map((issue) => issue.path ? `${issue.path}: ${issue.message}` : issue.message).join("; "));
+    this.name = "TemplateError";
+    this.issues = issues;
+  }
+};
+function fail(message, path = "") {
+  throw new TemplateError([{ path, message }]);
+}
+
+// src/conditions.ts
+var COMPARISON = /^row\.([A-Za-z_][A-Za-z0-9_]*)\s*(==|!=|<=|>=|<|>)\s*(-?[0-9]+(?:\.[0-9]+)?|'[^']*'|true|false|null)$/;
+function parseComparison(source, whole) {
+  const match = COMPARISON.exec(source.trim());
+  if (!match) fail(`Invalid condition "${whole}"; use row.field == literal joined by && or ||`);
+  const [, field, op, raw] = match;
+  const literal = raw === "true" ? true : raw === "false" ? false : raw === "null" ? null : raw.startsWith("'") ? raw.slice(1, -1) : Number(raw);
+  return { field, op, literal };
+}
+function compare(value, op, literal) {
+  const actual = value === void 0 ? null : value;
+  if (op === "==" || op === "!=") {
+    const equal = actual === literal;
+    return op === "==" ? equal : !equal;
+  }
+  if (!(typeof actual === "number" && typeof literal === "number" || typeof actual === "string" && typeof literal === "string")) return false;
+  const a = actual;
+  const b = literal;
+  switch (op) {
+    case "<":
+      return a < b;
+    case "<=":
+      return a <= b;
+    case ">":
+      return a > b;
+    default:
+      return a >= b;
+  }
+}
+function compileCondition(source) {
+  if (/'[^']*$/.test(source.replace(/'[^']*'/g, ""))) fail(`Unterminated text in condition "${source}"`);
+  const masked = source.replace(/'[^']*'/g, (match) => "\0".repeat(match.length));
+  const splitAt = (text, mask, separator) => {
+    const parts = [];
+    let start = 0;
+    for (let i = mask.indexOf(separator); i >= 0; i = mask.indexOf(separator, i + separator.length)) {
+      parts.push(text.slice(start, i));
+      start = i + separator.length;
+    }
+    parts.push(text.slice(start));
+    return parts;
+  };
+  const maskedOr = splitAt(masked, masked, "||");
+  let offset = 0;
+  const groups = maskedOr.map((maskedGroup) => {
+    const group2 = source.slice(offset, offset + maskedGroup.length);
+    offset += maskedGroup.length + 2;
+    let inner = 0;
+    return splitAt(maskedGroup, maskedGroup, "&&").map((maskedPart) => {
+      const part = group2.slice(inner, inner + maskedPart.length);
+      inner += maskedPart.length + 2;
+      return parseComparison(part, source);
+    });
+  });
+  return (row) => groups.some((group2) => group2.every((c) => compare(Object.prototype.hasOwnProperty.call(row, c.field) ? row[c.field] : null, c.op, c.literal)));
+}
+
+// src/format.ts
+var NBSP = "\xA0";
+var ISO_DATE = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/;
+var ISO_DATETIME = /^([0-9]{4})-([0-9]{2})-([0-9]{2})(?:[T ]([0-9]{2}):([0-9]{2})(?::([0-9]{2})(?:\.([0-9]{1,9}))?)?)?(Z|[+-][0-9]{2}:[0-9]{2})?$/;
+var MIN_MS = -621355968e5;
+var MAX_MS = 253402300799999;
+var RULES = {
+  cs: { group: NBSP, decimal: "," },
+  en: { group: ",", decimal: "." }
+};
+var FORMAT_NAMES = /* @__PURE__ */ new Set(["currency", "number", "percent", "date", "datetime"]);
+function toNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string" && value.trim() !== "" && /^-?[0-9]+(\.[0-9]+)?$/.test(value.trim())) return Number(value);
+  return null;
+}
+function fixed(value, decimals) {
+  const scaled = Number((Math.abs(value) * 10 ** decimals).toPrecision(15));
+  const rounded = Math.floor(scaled + 0.5);
+  const digits = rounded.toFixed(0).padStart(decimals + 1, "0");
+  const integer = digits.slice(0, digits.length - decimals);
+  const fraction = decimals > 0 ? digits.slice(-decimals) : "";
+  return { negative: value < 0 && rounded !== 0, integer, fraction };
+}
+function group(integer, separator) {
+  return integer.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+}
+function formatNumber(value, decimals, locale) {
+  const places = decimals ?? (Number.isInteger(value) ? 0 : 2);
+  const rules = RULES[locale];
+  const parts = fixed(value, places);
+  const text = group(parts.integer, rules.group) + (places > 0 ? rules.decimal + parts.fraction : "");
+  return parts.negative ? `-${text}` : text;
+}
+var zoneFormats = /* @__PURE__ */ new Map();
+function inTimeZone(date, timeZone) {
+  let format = zoneFormats.get(timeZone);
+  if (!format) {
+    try {
+      format = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        hourCycle: "h23"
+      });
+    } catch {
+      fail(`Unknown time zone "${timeZone}"`, "timeZone");
+    }
+    zoneFormats.set(timeZone, format);
+  }
+  const parts = {};
+  for (const part of format.formatToParts(date)) parts[part.type] = part.value;
+  return { year: Number(parts["year"]), month: Number(parts["month"]), day: Number(parts["day"]), hour: Number(parts["hour"]) % 24, minute: Number(parts["minute"]) };
+}
+function toDay(value, timeZone) {
+  if (typeof value === "string") {
+    const match = ISO_DATE.exec(value);
+    if (match) return { year: Number(match[1]), month: Number(match[2]), day: Number(match[3]), hour: 0, minute: 0 };
+  }
+  const instant = toInstant(value);
+  return instant ? inTimeZone(instant, timeZone) : null;
+}
+function inRange(ms) {
+  return Number.isFinite(ms) && ms >= MIN_MS && ms <= MAX_MS ? new Date(ms) : null;
+}
+function toInstant(value) {
+  if (value instanceof Date) return inRange(value.getTime());
+  if (typeof value === "number") return inRange(Math.trunc(value));
+  if (typeof value !== "string") return null;
+  const match = ISO_DATETIME.exec(value);
+  if (!match) return null;
+  const [year, month, day, hour, minute, second] = [1, 2, 3, 4, 5, 6].map((i) => Number(match[i] ?? 0));
+  const millisecond = Number((match[7] ?? "").padEnd(3, "0").slice(0, 3));
+  if (month < 1 || month > 12 || day < 1 || hour > 23 || minute > 59 || second > 59) return null;
+  const utc = new Date(Date.UTC(2e3, month - 1, day, hour, minute, second, millisecond));
+  utc.setUTCFullYear(year);
+  if (utc.getUTCDate() !== day || utc.getUTCMonth() !== month - 1) return null;
+  const zone = match[8];
+  const offset = zone === void 0 || zone === "Z" ? 0 : (zone.startsWith("-") ? -1 : 1) * (Number(zone.slice(1, 3)) * 60 + Number(zone.slice(4, 6)));
+  return inRange(utc.getTime() - offset * 6e4);
+}
+function dateText(time, locale) {
+  return locale === "cs" ? `${time.day}.${NBSP}${time.month}.${NBSP}${time.year}` : `${time.month}/${time.day}/${time.year}`;
+}
+function timeText(time, locale) {
+  const minute = String(time.minute).padStart(2, "0");
+  if (locale === "cs") return `${time.hour}:${minute}`;
+  const hour12 = time.hour % 12 === 0 ? 12 : time.hour % 12;
+  return `${hour12}:${minute}${NBSP}${time.hour < 12 ? "AM" : "PM"}`;
+}
+function argNumber(arg, spec) {
+  if (arg === void 0 || arg === "") return null;
+  const parsed = Number(arg);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 10) fail(`Invalid decimals in "${spec}"`);
+  return parsed;
+}
+function checkFormatSpec(spec) {
+  const [name, ...args] = spec.split(":");
+  if (!name || !FORMAT_NAMES.has(name)) fail(`Unknown format "${spec}"`);
+  if (name === "currency") {
+    if (args[0] !== void 0 && !/^[A-Z]{3}$/.test(args[0])) fail(`Invalid currency in "${spec}"`);
+    argNumber(args[1], spec);
+  } else if (name === "number" || name === "percent") {
+    argNumber(args[0], spec);
+  } else if (args.length > 0) {
+    fail(`Format "${name}" takes no arguments`);
+  }
+}
+function formatValue(value, spec, locale, timeZone) {
+  if (value === null || value === void 0) return "";
+  checkFormatSpec(spec);
+  const [name, ...args] = spec.split(":");
+  switch (name) {
+    case "currency": {
+      const number = toNumber(value);
+      if (number === null) return String(value);
+      const code = args[0] ?? "CZK";
+      const text = formatNumber(number, argNumber(args[1], spec) ?? 2, locale);
+      const negative = text.startsWith("-");
+      const digits = negative ? text.slice(1) : text;
+      if (locale === "cs") return `${negative ? "-" : ""}${digits}${NBSP}${code === "CZK" ? "K\u010D" : code}`;
+      return `${negative ? "-" : ""}${code}${NBSP}${digits}`;
+    }
+    case "number": {
+      const number = toNumber(value);
+      return number === null ? String(value) : formatNumber(number, argNumber(args[0], spec), locale);
+    }
+    case "percent": {
+      const number = toNumber(value);
+      if (number === null) return String(value);
+      const text = formatNumber(number * 100, argNumber(args[0], spec) ?? 0, locale);
+      return locale === "cs" ? `${text}${NBSP}%` : `${text}%`;
+    }
+    case "date": {
+      const day = toDay(value, timeZone);
+      return day ? dateText(day, locale) : String(value);
+    }
+    default: {
+      const instant = toInstant(value);
+      if (!instant) return String(value);
+      const time = inTimeZone(instant, timeZone);
+      return `${dateText(time, locale)}${NBSP}${timeText(time, locale)}`;
+    }
+  }
+}
+function defaultText(value, locale) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "number") return Number.isFinite(value) ? formatNumber(value, null, locale) : "";
+  if (typeof value === "boolean") return locale === "cs" ? value ? "Ano" : "Ne" : value ? "Yes" : "No";
+  if (typeof value === "string") return value;
+  return "";
+}
+
+// src/expressions.ts
+var FILTER_NAMES = /* @__PURE__ */ new Set([...FORMAT_NAMES, "upper", "default"]);
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*/;
+function parseBody(body) {
+  let rest = body.trim();
+  const take = (pattern) => {
+    const match = pattern.exec(rest);
+    if (!match) return null;
+    rest = rest.slice(match[0].length).trimStart();
+    return match[0];
+  };
+  const path = [];
+  do {
+    const key = take(IDENTIFIER);
+    if (key === null) fail(`Expected a name in "{{${body}}}"`);
+    if (FORBIDDEN_KEYS.has(key)) fail(`"${key}" is not allowed in "{{${body}}}"`);
+    path.push(key);
+  } while (take(/^\./) !== null);
+  const filters = [];
+  while (take(/^\|/) !== null) {
+    const name = take(IDENTIFIER);
+    if (name === null) fail(`Expected a filter name in "{{${body}}}"`);
+    if (!FILTER_NAMES.has(name)) fail(`Unknown filter "${name}"`);
+    const args = [];
+    while (take(/^:/) !== null) {
+      const quoted = take(/^'[^']*'/);
+      const arg = quoted !== null ? quoted.slice(1, -1) : take(/^-?[A-Za-z0-9_.]+/);
+      if (arg === null) fail(`Expected an argument for "${name}" in "{{${body}}}"`);
+      args.push(arg);
+    }
+    if (name === "default" && args.length !== 1) fail(`"default" takes one argument`);
+    if (name === "upper" && args.length > 0) fail(`"upper" takes no arguments`);
+    if (FORMAT_NAMES.has(name)) checkFormatSpec([name, ...args].join(":"));
+    filters.push({ name, args });
+  }
+  if (rest !== "") fail(`Unexpected "${rest}" in "{{${body}}}"`);
+  return { kind: "expr", path, filters };
+}
+function parseExpression(text) {
+  const parts = [];
+  let index = 0;
+  while (index < text.length) {
+    const open = text.indexOf("{{", index);
+    if (open < 0) {
+      parts.push({ kind: "text", value: text.slice(index) });
+      break;
+    }
+    if (open > index) parts.push({ kind: "text", value: text.slice(index, open) });
+    const close = text.indexOf("}}", open + 2);
+    if (close < 0) fail(`Unterminated "{{" in "${text}"`);
+    parts.push(parseBody(text.slice(open + 2, close)));
+    index = close + 2;
+  }
+  return parts;
+}
+function lookup(scope, path) {
+  let current = scope;
+  for (const key of path) {
+    if (current === null || typeof current !== "object" || !Object.prototype.hasOwnProperty.call(current, key)) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function toUpper(text) {
+  let result = "";
+  for (const char of text) {
+    const upper = char.toUpperCase();
+    result += [...upper].length === 1 ? upper : char;
+  }
+  return result;
+}
+var isEmpty = (value) => value === null || value === void 0 || value === "";
+function evaluateText(parts, scope, locale, timeZone) {
+  let text = "";
+  for (const part of parts) {
+    if (part.kind === "text") {
+      text += part.value;
+      continue;
+    }
+    let value = lookup(scope, part.path);
+    let formatted = false;
+    for (const filter of part.filters) {
+      if (filter.name === "default") {
+        if (isEmpty(value)) value = filter.args[0];
+      } else if (filter.name === "upper") {
+        value = toUpper(formatted ? String(value) : defaultText(value, locale));
+        formatted = true;
+      } else if (!isEmpty(value)) {
+        value = formatValue(value, [filter.name, ...filter.args].join(":"), locale, timeZone);
+        formatted = true;
+      }
+    }
+    text += formatted ? String(value) : defaultText(value, locale);
+  }
+  return text;
+}
+
+// src/validate.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var COLOR = /^#[0-9a-fA-F]{6}$/;
+var BANDS = /* @__PURE__ */ new Set(["reportHeader", "pageHeader", "table", "reportFooter", "pageFooter"]);
+var ALIGNS = /* @__PURE__ */ new Set(["start", "center", "end"]);
+var Checker = class {
+  issues = [];
+  add(path, message) {
+    this.issues.push({ path, message });
+  }
+  /** Runs a check that throws TemplateError (expressions, conditions, formats) and records it at path. */
+  guard(path, check) {
+    try {
+      check();
+    } catch (error) {
+      if (error instanceof TemplateError) this.add(path, error.issues.map((i) => i.message).join("; "));
+      else throw error;
+    }
+  }
+  number(value, path, options = {}) {
+    if (value === void 0 && options.optional) return;
+    if (!isNumber(value)) this.add(path, "must be a number");
+    else if (options.positive && value <= 0) this.add(path, "must be greater than 0");
+    else if (options.min !== void 0 && value < options.min) this.add(path, `must be at least ${options.min}`);
+  }
+  color(value, path) {
+    if (value !== void 0 && !(typeof value === "string" && COLOR.test(value))) this.add(path, "must be a color #rrggbb");
+  }
+  oneOf(value, allowed, path, optional = false) {
+    if (value === void 0 && optional) return;
+    if (!allowed.has(value)) this.add(path, `must be one of ${[...allowed].join(", ")}`);
+  }
+};
+function checkStyle(c, style, path) {
+  if (!isRecord(style)) {
+    c.add(path, "must be an object");
+    return;
+  }
+  if (style["font"] !== void 0 && typeof style["font"] !== "string") c.add(`${path}.font`, "must be a text");
+  c.number(style["size"], `${path}.size`, { optional: true, positive: true });
+  c.oneOf(style["weight"], /* @__PURE__ */ new Set([400, 600, 700]), `${path}.weight`, true);
+  c.color(style["color"], `${path}.color`);
+  c.color(style["background"], `${path}.background`);
+}
+function checkStyleRef(c, ref, styles, path) {
+  if (ref === void 0) return;
+  if (typeof ref === "string") {
+    if (!Object.prototype.hasOwnProperty.call(styles, ref)) c.add(path, `unknown style "${ref}"`);
+  } else {
+    checkStyle(c, ref, path);
+  }
+}
+function checkText(c, value, path) {
+  if (typeof value !== "string") c.add(path, "must be a text");
+  else c.guard(path, () => parseExpression(value));
+}
+function checkElement(c, element, styles, path) {
+  if (!isRecord(element)) {
+    c.add(path, "must be an object");
+    return;
+  }
+  switch (element["type"]) {
+    case "text":
+      checkText(c, element["text"], `${path}.text`);
+      c.number(element["x"], `${path}.x`);
+      c.number(element["y"], `${path}.y`);
+      c.number(element["w"], `${path}.w`, { optional: true, positive: true });
+      c.oneOf(element["align"], ALIGNS, `${path}.align`, true);
+      checkStyleRef(c, element["style"], styles, `${path}.style`);
+      return;
+    case "image":
+      checkText(c, element["src"], `${path}.src`);
+      c.number(element["x"], `${path}.x`);
+      c.number(element["y"], `${path}.y`);
+      c.number(element["w"], `${path}.w`, { positive: true });
+      c.number(element["h"], `${path}.h`, { optional: true, positive: true });
+      return;
+    case "line":
+      for (const key of ["x1", "y1", "x2", "y2"]) c.number(element[key], `${path}.${key}`);
+      c.color(element["color"], `${path}.color`);
+      c.number(element["width"], `${path}.width`, { optional: true, positive: true });
+      return;
+    case "rect":
+      c.number(element["x"], `${path}.x`);
+      c.number(element["y"], `${path}.y`);
+      c.number(element["w"], `${path}.w`, { positive: true });
+      c.number(element["h"], `${path}.h`, { positive: true });
+      c.color(element["fill"], `${path}.fill`);
+      c.color(element["stroke"], `${path}.stroke`);
+      c.number(element["strokeWidth"], `${path}.strokeWidth`, { optional: true, positive: true });
+      return;
+    default:
+      c.add(`${path}.type`, "must be text, image, line or rect");
+  }
+}
+function checkTable(c, table, styles, path) {
+  if (!isRecord(table)) {
+    c.add(path, "must be an object");
+    return;
+  }
+  const columns = table["columns"];
+  if (columns !== "fromGrid" && !(Array.isArray(columns) && columns.every((field) => typeof field === "string"))) {
+    c.add(`${path}.columns`, 'must be "fromGrid" or a list of fields');
+  }
+  const overrides = table["overrides"];
+  if (overrides !== void 0) {
+    if (!isRecord(overrides)) c.add(`${path}.overrides`, "must be an object");
+    else {
+      for (const [field, override] of Object.entries(overrides)) {
+        const at = `${path}.overrides.${field}`;
+        if (!isRecord(override)) {
+          c.add(at, "must be an object");
+          continue;
+        }
+        c.number(override["width"], `${at}.width`, { optional: true, positive: true });
+        c.oneOf(override["align"], ALIGNS, `${at}.align`, true);
+        if (override["format"] !== void 0) {
+          const format = override["format"];
+          if (typeof format !== "string") c.add(`${at}.format`, "must be a text");
+          else c.guard(`${at}.format`, () => checkFormatSpec(format));
+        }
+        if (override["caption"] !== void 0 && typeof override["caption"] !== "string") c.add(`${at}.caption`, "must be a text");
+      }
+    }
+  }
+  const header = table["header"];
+  if (header !== void 0) {
+    if (!isRecord(header)) c.add(`${path}.header`, "must be an object");
+    else {
+      c.color(header["background"], `${path}.header.background`);
+      if (header["repeatOnEachPage"] !== void 0 && typeof header["repeatOnEachPage"] !== "boolean") c.add(`${path}.header.repeatOnEachPage`, "must be true or false");
+      checkStyleRef(c, header["style"], styles, `${path}.header.style`);
+    }
+  }
+  c.color(table["zebra"], `${path}.zebra`);
+  const rowStyles = table["rowStyles"];
+  if (rowStyles !== void 0) {
+    if (!Array.isArray(rowStyles)) c.add(`${path}.rowStyles`, "must be a list");
+    else {
+      rowStyles.forEach((rule, index) => {
+        const at = `${path}.rowStyles[${index}]`;
+        if (!isRecord(rule)) {
+          c.add(at, "must be an object");
+          return;
+        }
+        const when = rule["when"];
+        if (typeof when !== "string") c.add(`${at}.when`, "must be a text");
+        else c.guard(`${at}.when`, () => compileCondition(when));
+        checkStyleRef(c, rule["style"], styles, `${at}.style`);
+      });
+    }
+  }
+  if (table["summary"] !== void 0 && typeof table["summary"] !== "boolean") c.add(`${path}.summary`, "must be true or false");
+}
+function validateTemplate(json) {
+  const c = new Checker();
+  if (!isRecord(json)) throw new TemplateError([{ path: "", message: "Template must be an object" }]);
+  if (json["version"] !== 1) c.add("version", "must be 1");
+  const page = json["page"];
+  if (!isRecord(page)) c.add("page", "must be an object");
+  else {
+    c.oneOf(page["size"], /* @__PURE__ */ new Set(["A4", "A3", "Letter"]), "page.size");
+    c.oneOf(page["orientation"], /* @__PURE__ */ new Set(["portrait", "landscape"]), "page.orientation");
+    const margins = page["margins"];
+    if (!(Array.isArray(margins) && margins.length === 4 && margins.every((m) => isNumber(m) && m >= 0))) c.add("page.margins", "must be [top, right, bottom, left] in mm");
+    c.oneOf(page["unit"], /* @__PURE__ */ new Set(["mm"]), "page.unit");
+  }
+  const fonts = json["fonts"];
+  if (!Array.isArray(fonts)) c.add("fonts", "must be a list");
+  else {
+    fonts.forEach((font, index) => {
+      const at = `fonts[${index}]`;
+      if (!isRecord(font)) return c.add(at, "must be an object");
+      if (typeof font["family"] !== "string" || font["family"] === "") c.add(`${at}.family`, "must be a name");
+      if (typeof font["src"] !== "string" || font["src"] === "") c.add(`${at}.src`, "must be a URL");
+      c.oneOf(font["weight"], /* @__PURE__ */ new Set([400, 700]), `${at}.weight`, true);
+    });
+  }
+  const styles = isRecord(json["styles"]) ? json["styles"] : {};
+  if (!isRecord(json["styles"])) c.add("styles", "must be an object");
+  for (const [name, style] of Object.entries(styles)) checkStyle(c, style, `styles.${name}`);
+  const bands = json["bands"];
+  if (!isRecord(bands)) c.add("bands", "must be an object");
+  else {
+    for (const [name, band] of Object.entries(bands)) {
+      if (!BANDS.has(name)) {
+        c.add(`bands.${name}`, "unknown band");
+      } else if (name === "table") {
+        checkTable(c, band, styles, "bands.table");
+      } else if (!Array.isArray(band)) {
+        c.add(`bands.${name}`, "must be a list of elements");
+      } else {
+        band.forEach((element, index) => checkElement(c, element, styles, `bands.${name}[${index}]`));
+      }
+    }
+  }
+  if (c.issues.length > 0) throw new TemplateError(c.issues);
+  return json;
+}
+
+// src/font-metrics.ts
+var MM_PER_PT = 25.4 / 72;
+var invalid = (reason) => fail(`Invalid font file: ${reason}`, "font");
+function parseFontMetrics(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const u16 = (at) => {
+    if (at < 0 || at + 2 > data.byteLength) invalid("truncated");
+    return view.getUint16(at);
+  };
+  const i16 = (at) => {
+    if (at < 0 || at + 2 > data.byteLength) invalid("truncated");
+    return view.getInt16(at);
+  };
+  const u32 = (at) => {
+    if (at < 0 || at + 4 > data.byteLength) invalid("truncated");
+    return view.getUint32(at);
+  };
+  const tables = /* @__PURE__ */ new Map();
+  const count = u16(4);
+  for (let i = 0; i < count; i++) {
+    const at = 12 + i * 16;
+    const tag = String.fromCharCode(data[at], data[at + 1], data[at + 2], data[at + 3]);
+    tables.set(tag, { offset: u32(at + 8), length: u32(at + 12) });
+  }
+  const table = (tag) => {
+    const found = tables.get(tag);
+    if (!found || found.offset + found.length > data.byteLength) invalid(`missing or truncated "${tag}" table`);
+    return found;
+  };
+  const head = table("head");
+  const unitsPerEm = u16(head.offset + 18);
+  if (unitsPerEm === 0) invalid("unitsPerEm is 0");
+  const hhea = table("hhea");
+  const ascender = i16(hhea.offset + 4);
+  const descender = i16(hhea.offset + 6);
+  const numberOfHMetrics = u16(hhea.offset + 34);
+  const hmtx = table("hmtx");
+  if (numberOfHMetrics === 0 || numberOfHMetrics * 4 > hmtx.length) invalid("hmtx does not match hhea");
+  const cmap = table("cmap");
+  let format12 = null;
+  let format4 = null;
+  const subtables = u16(cmap.offset + 2);
+  for (let i = 0; i < subtables; i++) {
+    const at = cmap.offset + 4 + i * 8;
+    const platform = u16(at);
+    const encoding = u16(at + 2);
+    const offset = cmap.offset + u32(at + 4);
+    const format = u16(offset);
+    const unicode = platform === 0 || platform === 3 && (encoding === 1 || encoding === 10);
+    if (!unicode) continue;
+    if (format === 12 && format12 === null) format12 = offset;
+    if (format === 4 && format4 === null) format4 = offset;
+  }
+  if (format12 === null && format4 === null) invalid("no Unicode cmap");
+  const lookup12 = (at, codePoint) => {
+    const groups = u32(at + 12);
+    let low = 0;
+    let high = groups - 1;
+    while (low <= high) {
+      const mid = low + high >> 1;
+      const group2 = at + 16 + mid * 12;
+      const start = u32(group2);
+      const end = u32(group2 + 4);
+      if (codePoint < start) high = mid - 1;
+      else if (codePoint > end) low = mid + 1;
+      else return u32(group2 + 8) + (codePoint - start);
+    }
+    return 0;
+  };
+  const lookup4 = (at, codePoint) => {
+    if (codePoint > 65535) return 0;
+    const segments = u16(at + 6) / 2;
+    const ends = at + 14;
+    const starts = ends + segments * 2 + 2;
+    const deltas = starts + segments * 2;
+    const ranges = deltas + segments * 2;
+    for (let i = 0; i < segments; i++) {
+      if (codePoint > u16(ends + i * 2)) continue;
+      const start = u16(starts + i * 2);
+      if (codePoint < start) return 0;
+      const delta = i16(deltas + i * 2);
+      const rangeOffset = u16(ranges + i * 2);
+      if (rangeOffset === 0) return codePoint + delta & 65535;
+      const glyph = u16(ranges + i * 2 + rangeOffset + (codePoint - start) * 2);
+      return glyph === 0 ? 0 : glyph + delta & 65535;
+    }
+    return 0;
+  };
+  const advances = /* @__PURE__ */ new Map();
+  return {
+    unitsPerEm,
+    ascender,
+    descender,
+    glyphId: (codePoint) => format12 !== null ? lookup12(format12, codePoint) : lookup4(format4, codePoint),
+    advance(glyphId) {
+      const index = Math.min(glyphId, numberOfHMetrics - 1);
+      let advance = advances.get(index);
+      if (advance === void 0) {
+        advance = u16(hmtx.offset + index * 4);
+        advances.set(index, advance);
+      }
+      return advance;
+    }
+  };
+}
+function measureText(text, metrics, sizePt) {
+  let units = 0;
+  const missing = [];
+  for (const char of text) {
+    const codePoint = char.codePointAt(0);
+    const glyph = metrics.glyphId(codePoint);
+    if (glyph === 0 && !missing.includes(codePoint)) missing.push(codePoint);
+    units += metrics.advance(glyph);
+  }
+  return { widthMm: units / metrics.unitsPerEm * sizePt * MM_PER_PT, missing };
+}
+
+// src/layout.ts
+var PAGE_SIZES = { A4: [210, 297], A3: [297, 420], Letter: [215.9, 279.4] };
+var DEFAULT_STYLE = { font: "Noto Sans", size: 8, weight: 400, color: "#1b1f24" };
+var LINE_HEIGHT = 1.2;
+var CELL_PADDING_X = 1.5;
+var CELL_PADDING_Y = 1;
+var MIN_AUTO_COLUMN = 20;
+var HEADER_RULE_COLOR = "#d5d9df";
+var HEADER_RULE_WIDTH = 0.3;
+var DEFAULT_LINE_WIDTH = 0.2;
+var EPSILON = 1e-9;
+function round2(value) {
+  const scaled = Number((Math.abs(value) * 100).toPrecision(15));
+  const rounded = Math.floor(scaled + 0.5) / 100;
+  return value < 0 && rounded !== 0 ? -rounded : rounded;
+}
+var lineHeight = (size) => size * LINE_HEIGHT * MM_PER_PT;
+function wrapText(text, widthMm, metrics, sizePt) {
+  const width = (value) => measureText(value, metrics, sizePt).widthMm;
+  const lines = [];
+  for (const paragraph of text.split("\n")) {
+    let line = "";
+    let started = false;
+    for (const word of paragraph.split(" ")) {
+      const candidate = started ? `${line} ${word}` : word;
+      if (width(candidate) <= widthMm + EPSILON) {
+        line = candidate;
+        started = true;
+        continue;
+      }
+      if (started) lines.push(line);
+      if (width(word) <= widthMm + EPSILON) {
+        line = word;
+        started = true;
+        continue;
+      }
+      let chunk = "";
+      for (const char of word) {
+        if (chunk !== "" && width(chunk + char) > widthMm + EPSILON) {
+          lines.push(chunk);
+          chunk = "";
+        }
+        chunk += char;
+      }
+      line = chunk;
+      started = true;
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+var ROWS_PER_STEP = 500;
+function layoutReport(template, input, fonts) {
+  const steps = layoutSteps(template, input, fonts);
+  for (; ; ) {
+    const step = steps.next();
+    if (step.done) return step.value;
+  }
+}
+async function layoutReportAsync(template, input, fonts) {
+  const steps = layoutSteps(template, input, fonts);
+  for (; ; ) {
+    const step = steps.next();
+    if (step.done) return step.value;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+}
+function* layoutSteps(template, input, fonts) {
+  const warnings = [];
+  const warn = (message) => {
+    if (!warnings.includes(message)) warnings.push(message);
+  };
+  const [baseWidth, baseHeight] = PAGE_SIZES[template.page.size] ?? fail(`Unknown page size "${template.page.size}"`, "page.size");
+  const landscape = template.page.orientation === "landscape";
+  const pageWidth = landscape ? baseHeight : baseWidth;
+  const pageHeight = landscape ? baseWidth : baseHeight;
+  const [marginTop, marginRight, marginBottom, marginLeft] = template.page.margins;
+  const contentLeft = marginLeft;
+  const contentWidth = pageWidth - marginLeft - marginRight;
+  const contentBottom = pageHeight - marginBottom;
+  const base = template.styles["base"] ?? {};
+  const resolve = (...refs) => {
+    let style = { ...DEFAULT_STYLE, ...base };
+    for (const ref of refs) {
+      if (ref === void 0) continue;
+      style = { ...style, ...typeof ref === "string" ? template.styles[ref] ?? {} : ref };
+    }
+    return {
+      font: style.font ?? DEFAULT_STYLE.font,
+      size: style.size ?? DEFAULT_STYLE.size,
+      weight: (style.weight ?? 400) >= 600 ? 700 : 400,
+      color: style.color ?? DEFAULT_STYLE.color,
+      background: style.background ?? null
+    };
+  };
+  const metricsOf = (style) => {
+    const exact = fonts.get(`${style.font}|${style.weight}`);
+    if (exact) return exact;
+    const regular = fonts.get(`${style.font}|400`);
+    if (!regular) fail(`Font "${style.font}" is not available`, "font");
+    warn(`Font "${style.font}" has no bold variant; regular is used`);
+    return regular;
+  };
+  const checkGlyphs = (text, style, metrics) => {
+    for (const codePoint of measureText(text, metrics, style.size).missing) {
+      if (codePoint === 32 || codePoint === 160) continue;
+      warn(`Missing glyph U+${codePoint.toString(16).toUpperCase().padStart(4, "0")} in ${style.font}`);
+    }
+  };
+  const parsed = /* @__PURE__ */ new Map();
+  const evaluate = (text, scope) => {
+    let parts = parsed.get(text);
+    if (!parts) {
+      parts = parseExpression(text);
+      parsed.set(text, parts);
+    }
+    for (const part of parts) {
+      if (part.kind === "expr" && part.path[0] === "summary" && lookup(scope, part.path) === void 0) warn(`Summary "${part.path.join(".")}" is not in the data`);
+    }
+    return evaluateText(parts, scope, input.locale, input.timeZone);
+  };
+  const textItems = (out, lines, left, top, width, align, style, metrics) => {
+    const height = lineHeight(style.size);
+    const ascent = metrics.ascender / metrics.unitsPerEm * style.size * MM_PER_PT;
+    lines.forEach((line, index) => {
+      if (line === "") return;
+      checkGlyphs(line, style, metrics);
+      const lineWidth = measureText(line, metrics, style.size).widthMm;
+      const x = align === "center" ? left + (width - lineWidth) / 2 : align === "end" ? left + width - lineWidth : left;
+      const y = top + index * height;
+      out.push({ kind: "text", x: round2(x), y: round2(y), baseline: round2(y + ascent), text: line, font: style.font, weight: style.weight, size: style.size, color: style.color });
+    });
+  };
+  const drawBand = (elements, top, scope, out) => {
+    let height = 0;
+    for (const element of elements ?? []) {
+      switch (element.type) {
+        case "text": {
+          const style = resolve(element.style);
+          const metrics = metricsOf(style);
+          const width = Math.max(element.w ?? contentWidth - element.x, 1);
+          const lines = wrapText(evaluate(element.text, scope), width, metrics, style.size);
+          const blockHeight = lines.length * lineHeight(style.size);
+          if (out) {
+            if (style.background) {
+              out.push({ kind: "rect", x: round2(contentLeft + element.x), y: round2(top + element.y), w: round2(width), h: round2(blockHeight), fill: style.background, stroke: null, strokeWidth: 0 });
+            }
+            textItems(out, lines, contentLeft + element.x, top + element.y, width, element.align ?? "start", style, metrics);
+          }
+          height = Math.max(height, element.y + blockHeight);
+          break;
+        }
+        case "image": {
+          const src = evaluate(element.src, scope);
+          const size = input.imageSizes?.[src];
+          const imageHeight = element.h ?? (size && size.width > 0 ? element.w * size.height / size.width : element.w);
+          if (out && src !== "") out.push({ kind: "image", x: round2(contentLeft + element.x), y: round2(top + element.y), w: round2(element.w), h: round2(imageHeight), src });
+          height = Math.max(height, element.y + imageHeight);
+          break;
+        }
+        case "line":
+          if (out) {
+            out.push({
+              kind: "line",
+              x1: round2(contentLeft + element.x1),
+              y1: round2(top + element.y1),
+              x2: round2(contentLeft + element.x2),
+              y2: round2(top + element.y2),
+              color: element.color ?? resolve().color,
+              width: element.width ?? DEFAULT_LINE_WIDTH
+            });
+          }
+          height = Math.max(height, element.y1, element.y2);
+          break;
+        case "rect":
+          if (out) {
+            out.push({
+              kind: "rect",
+              x: round2(contentLeft + element.x),
+              y: round2(top + element.y),
+              w: round2(element.w),
+              h: round2(element.h),
+              fill: element.fill ?? null,
+              stroke: element.stroke ?? null,
+              strokeWidth: element.strokeWidth ?? DEFAULT_LINE_WIDTH
+            });
+          }
+          height = Math.max(height, element.y + element.h);
+          break;
+      }
+    }
+    return height;
+  };
+  const measureScope = { ...input.context, page: 1, pages: 1 };
+  const pageHeaderHeight = drawBand(template.bands.pageHeader, 0, measureScope, null);
+  const pageFooterHeight = drawBand(template.bands.pageFooter, 0, measureScope, null);
+  const bodyTop = marginTop + pageHeaderHeight;
+  const bodyBottom = contentBottom - pageFooterHeight;
+  const bodies = [{ items: [] }];
+  const deferred = [];
+  let cursor = bodyTop;
+  const newPage = () => {
+    bodies.push({ items: [] });
+    cursor = bodyTop;
+  };
+  const current = () => bodies[bodies.length - 1].items;
+  if (template.bands.reportHeader) {
+    const height = drawBand(template.bands.reportHeader, cursor, measureScope, null);
+    deferred.push({ page: 0, top: cursor, elements: template.bands.reportHeader });
+    cursor += height;
+  }
+  if (template.bands.table) yield* layoutTable(template.bands.table);
+  if (template.bands.reportFooter) {
+    const height = drawBand(template.bands.reportFooter, 0, measureScope, null);
+    if (cursor + height > bodyBottom + EPSILON && cursor > bodyTop + EPSILON) newPage();
+    deferred.push({ page: bodies.length - 1, top: cursor, elements: template.bands.reportFooter });
+    cursor += height;
+  }
+  const pages = bodies.length;
+  const result = bodies.map((body, index) => {
+    const scope = { ...input.context, page: index + 1, pages };
+    const items = [];
+    drawBand(template.bands.pageHeader, marginTop, scope, items);
+    for (const band of deferred.filter((d) => d.page === index && d.elements === template.bands.reportHeader)) drawBand(band.elements, band.top, scope, items);
+    items.push(...body.items);
+    for (const band of deferred.filter((d) => d.page === index && d.elements === template.bands.reportFooter)) drawBand(band.elements, band.top, scope, items);
+    drawBand(template.bands.pageFooter, contentBottom - pageFooterHeight, scope, items);
+    return { items };
+  });
+  return { page: { width: pageWidth, height: pageHeight }, pages: result, fonts: template.fonts, warnings };
+  function* layoutTable(table) {
+    const fields = table.columns === "fromGrid" ? input.columns.map((c) => c.field) : table.columns;
+    const columns = [];
+    for (const field of fields) {
+      const column = input.columns.find((c) => c.field === field);
+      if (column) columns.push(column);
+      else warn(`Column "${field}" is not in the data`);
+    }
+    if (columns.length === 0) return;
+    const explicit = columns.map((c) => table.overrides?.[c.field]?.width ?? null);
+    const preferred = columns.map((c, i) => explicit[i] !== null ? null : c.widthMm);
+    const fixedSum = explicit.reduce((sum, w) => sum + (w ?? 0), 0);
+    const gridSum = preferred.reduce((sum, w) => sum + (w ?? 0), 0);
+    const autoCount = columns.filter((_, i) => explicit[i] === null && preferred[i] === null).length;
+    const autoWidth = autoCount > 0 ? Math.max((contentWidth - fixedSum - gridSum) / autoCount, MIN_AUTO_COLUMN) : 0;
+    let widths = columns.map((_, i) => explicit[i] ?? preferred[i] ?? autoWidth);
+    const total = widths.reduce((sum, w) => sum + w, 0);
+    if (total > contentWidth + EPSILON) {
+      const flexible = total - fixedSum;
+      const room = contentWidth - fixedSum;
+      widths = room > EPSILON && flexible > EPSILON ? widths.map((w, i) => explicit[i] !== null ? w : w * room / flexible) : widths.map((w) => w * contentWidth / total);
+    }
+    const lefts = [];
+    widths.reduce((left, width) => {
+      lefts.push(left);
+      return left + width;
+    }, contentLeft);
+    const tableWidth = widths.reduce((sum, w) => sum + w, 0);
+    const aligns = columns.map((c) => table.overrides?.[c.field]?.align ?? c.align);
+    const headerStyle = resolve({ weight: 700 }, table.header?.style);
+    const headerTexts = columns.map((c) => table.overrides?.[c.field]?.caption ?? c.caption);
+    const rowStyles = (table.rowStyles ?? []).map((rule) => ({ test: compileCondition(rule.when), style: rule.style }));
+    const measureRow = (cells, style) => {
+      const metrics = metricsOf(style);
+      const lines = cells.map((text, i) => wrapText(text, Math.max(widths[i] - 2 * CELL_PADDING_X, 1), metrics, style.size));
+      const height = Math.max(...lines.map((l) => l.length)) * lineHeight(style.size) + 2 * CELL_PADDING_Y;
+      return { lines, height, style, metrics };
+    };
+    const drawRow = (row, top, background, maxHeight) => {
+      const out = current();
+      const height = Math.min(row.height, maxHeight);
+      if (background) out.push({ kind: "rect", x: round2(contentLeft), y: round2(top), w: round2(tableWidth), h: round2(height), fill: background, stroke: null, strokeWidth: 0 });
+      const fit = Math.floor((height - 2 * CELL_PADDING_Y) / lineHeight(row.style.size) + EPSILON);
+      row.lines.forEach((lines, i) => {
+        textItems(out, lines.slice(0, Math.max(fit, 0)), lefts[i] + CELL_PADDING_X, top + CELL_PADDING_Y, widths[i] - 2 * CELL_PADDING_X, aligns[i], row.style, row.metrics);
+      });
+    };
+    const header = measureRow(headerTexts, headerStyle);
+    const drawHeader = () => {
+      drawRow(header, cursor, table.header?.background ?? null, header.height);
+      current().push({ kind: "line", x1: round2(contentLeft), y1: round2(cursor + header.height), x2: round2(contentLeft + tableWidth), y2: round2(cursor + header.height), color: HEADER_RULE_COLOR, width: HEADER_RULE_WIDTH });
+      cursor += header.height;
+    };
+    const repeatHeader = table.header?.repeatOnEachPage ?? true;
+    for (let index = 0; index < input.rows.length; index++) {
+      if (index > 0 && index % ROWS_PER_STEP === 0) yield;
+      const data = input.rows[index];
+      const texts = input.texts?.[index];
+      const cells = columns.map((column) => {
+        const value = data[column.field];
+        const format = table.overrides?.[column.field]?.format ?? column.format;
+        if (format) return formatValue(value, format, input.locale, input.timeZone);
+        const text = texts?.[column.field];
+        return text !== void 0 ? text : defaultText(value, input.locale);
+      });
+      const matched = rowStyles.filter((rule) => rule.test(data)).map((rule) => rule.style);
+      const style = resolve(...matched);
+      const row = measureRow(cells, style);
+      const zebra = index % 2 === 1 ? table.zebra ?? null : null;
+      if (index === 0) {
+        if (cursor + header.height + row.height > bodyBottom + EPSILON && cursor > bodyTop + EPSILON) newPage();
+        drawHeader();
+      } else if (cursor + row.height > bodyBottom + EPSILON) {
+        newPage();
+        if (repeatHeader) drawHeader();
+      }
+      const room = bodyBottom - cursor;
+      if (row.height > room + EPSILON) warn(`Row ${index + 1} is taller than a page and was cut`);
+      if (zebra) current().push({ kind: "rect", x: round2(contentLeft), y: round2(cursor), w: round2(tableWidth), h: round2(Math.min(row.height, room)), fill: zebra, stroke: null, strokeWidth: 0 });
+      drawRow(row, cursor, style.background, room);
+      cursor += Math.min(row.height, room);
+    }
+    if (input.rows.length === 0) drawHeader();
+    if (table.summary === true && input.summaryRow) {
+      const summaryRow = input.summaryRow;
+      const row = measureRow(columns.map((column) => summaryRow[column.field] ?? ""), resolve({ weight: 700 }));
+      if (cursor + row.height > bodyBottom + EPSILON) {
+        newPage();
+        if (repeatHeader) drawHeader();
+      }
+      const room = bodyBottom - cursor;
+      current().push({ kind: "line", x1: round2(contentLeft), y1: round2(cursor), x2: round2(contentLeft + tableWidth), y2: round2(cursor), color: HEADER_RULE_COLOR, width: HEADER_RULE_WIDTH });
+      drawRow(row, cursor, null, room);
+      cursor += Math.min(row.height, room);
+    }
+  }
+}
+
+// src/store.ts
+var TemplateStoreError = class extends Error {
+  status;
+  issues;
+  constructor(message, status, issues = []) {
+    super(message);
+    this.name = "TemplateStoreError";
+    this.status = status;
+    this.issues = issues;
+  }
+};
+var DEFAULT_KEY = "rastr.pdf-templates";
+function summary(stored) {
+  return { id: stored.id, gridId: stored.gridId, name: stored.name, isDefault: stored.isDefault, shared: stored.shared, updatedAtUtc: stored.updatedAtUtc };
+}
+function createLocalTemplateStore(options = {}) {
+  const key = options.key ?? DEFAULT_KEY;
+  const storage = () => options.storage ?? globalThis.localStorage;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const newId = options.newId ?? (() => crypto.randomUUID());
+  const read = () => {
+    try {
+      const parsed = JSON.parse(storage().getItem(key) ?? "[]");
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  };
+  const write = (templates) => storage().setItem(key, JSON.stringify(templates));
+  return {
+    list: async (gridId) => read().filter((t) => t.gridId === gridId).map(summary),
+    async load(id) {
+      const found = read().find((t) => t.id === id);
+      if (!found) throw new TemplateStoreError(`Template ${id} does not exist`, 404);
+      return found;
+    },
+    async save(input) {
+      const templates = read();
+      const id = input.id ?? newId();
+      const stored = {
+        id,
+        gridId: input.gridId,
+        name: input.name,
+        isDefault: input.isDefault,
+        shared: input.shared,
+        updatedAtUtc: now().toISOString(),
+        template: input.template
+      };
+      const index = templates.findIndex((t) => t.id === id);
+      if (index >= 0) templates[index] = stored;
+      else templates.push(stored);
+      const result = input.isDefault ? templates.map((t) => t.gridId === input.gridId && t.id !== id && t.isDefault ? { ...t, isDefault: false } : t) : templates;
+      write(result);
+      return summary(stored);
+    },
+    async remove(id) {
+      write(read().filter((t) => t.id !== id));
+    }
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createRestTemplateStore(options) {
+  const base = options.url.replace(/\/+$/, "");
+  const request = async (method, path, body2) => {
+    const headers = new Headers(options.headers?.());
+    if (body2 !== void 0) headers.set("Content-Type", "application/json");
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const response = await fetchImpl(`${base}${path}`, {
+      method,
+      headers,
+      ...body2 !== void 0 ? { body: JSON.stringify(body2) } : {}
+    });
+    if (response.ok) return response;
+    let problem = null;
+    try {
+      problem = await response.json();
+    } catch {
+    }
+    const issues = isRecord2(problem) && Array.isArray(problem["issues"]) ? problem["issues"] : [];
+    const detail = isRecord2(problem) ? problem["detail"] ?? problem["title"] : null;
+    throw new TemplateStoreError(typeof detail === "string" ? detail : `Template request failed (HTTP ${response.status})`, response.status, issues);
+  };
+  const body = (input) => ({ gridId: input.gridId, name: input.name, isDefault: input.isDefault, shared: input.shared, template: input.template });
+  return {
+    list: async (gridId) => (await request("GET", `?gridId=${encodeURIComponent(gridId)}`)).json(),
+    load: async (id) => (await request("GET", `/${encodeURIComponent(id)}`)).json(),
+    save: async (input) => (input.id === void 0 ? await request("POST", "", body(input)) : await request("PUT", `/${encodeURIComponent(input.id)}`, body(input))).json(),
+    async remove(id) {
+      await request("DELETE", `/${encodeURIComponent(id)}`);
+    }
+  };
+}
+function templateLoader(store, gridId) {
+  return async () => {
+    const found = (await store.list(gridId)).find((t) => t.isDefault);
+    return found ? (await store.load(found.id)).template : null;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MM_PER_PT,
+  TemplateError,
+  TemplateStoreError,
+  compileCondition,
+  createLocalTemplateStore,
+  createRestTemplateStore,
+  defaultText,
+  evaluateText,
+  formatValue,
+  layoutReport,
+  layoutReportAsync,
+  measureText,
+  parseExpression,
+  parseFontMetrics,
+  round2,
+  templateLoader,
+  validateTemplate,
+  wrapText
+});
+//# sourceMappingURL=index.cjs.map