@leavepulse/ui 0.43.4 → 0.45.0

package/dist/components/codeHighlight.js

@@ -173,23 +173,58 @@ const BOOLEANS = /* @__PURE__ */ new Set([
   "Err"
   // rust common variants read as constants
 ]);
-const MASTER = new RegExp(
-  [
-    "(\\/\\/[^\\n]*|#[^\\n]*|\\/\\*[\\s\\S]*?\\*\\/)",
-    // 1 comment
-    "(\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|`(?:\\\\.|[^`\\\\])*`)",
-    // 2 string
-    "(@[A-Za-z_$][\\w$]*)",
-    // 3 annotation (@Override, @ConfigSerializable — JVM)
-    "(\\b\\d[\\d_]*(?:\\.\\d+)?(?:e[+-]?\\d+)?[fFlLdD]?\\b)",
-    // 4 number (JVM suffixes)
-    "([A-Za-z_$][\\w$]*)",
-    // 5 identifier (keyword/bool/func/prop/plain)
-    "([{}()\\[\\];:,.<>=+\\-*/%!&|?]+)"
-    // 6 punctuation
-  ].join("|"),
-  "g"
-);
+const COMMENTS = {
+  ts: "c",
+  js: "c",
+  json: "none",
+  bash: "hash",
+  html: "html",
+  python: "hash",
+  rust: "c",
+  yaml: "hash",
+  toml: "hash",
+  kotlin: "c",
+  java: "c",
+  groovy: "c",
+  plain: "none"
+};
+const COMMENT_PATTERN = {
+  c: "\\/\\/[^\\n]*|\\/\\*[\\s\\S]*?\\*\\/",
+  // A `#` only starts a comment at the start of a word, so `a#b` in a URL or
+  // `${#arr[@]}` in shell stay code.
+  hash: "(?<![\\w$])#[^\\n]*",
+  html: "<!--[\\s\\S]*?-->",
+  none: "(?!)"
+};
+const BLOCK = {
+  c: { open: "/*", close: "*/" },
+  html: { open: "<!--", close: "-->" }
+};
+const masters = /* @__PURE__ */ new Map();
+function masterFor(style) {
+  let re = masters.get(style);
+  if (!re) {
+    re = new RegExp(
+      [
+        `(${COMMENT_PATTERN[style]})`,
+        // 1 comment
+        "(\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|`(?:\\\\.|[^`\\\\])*`)",
+        // 2 string
+        "(@[A-Za-z_$][\\w$]*)",
+        // 3 annotation (@Override, @ConfigSerializable — JVM)
+        "(\\b\\d[\\d_]*(?:\\.\\d+)?(?:e[+-]?\\d+)?[fFlLdD]?\\b)",
+        // 4 number (JVM suffixes)
+        "(#?[A-Za-z_$][\\w$]*)",
+        // 5 identifier (keyword/bool/func/prop/plain), incl. #private
+        "([{}()\\[\\];:,.<>=+\\-*/%!&|?]+)"
+        // 6 punctuation
+      ].join("|"),
+      "g"
+    );
+    masters.set(style, re);
+  }
+  return re;
+}
 function classifyIdent(name, before, after) {
   if (KEYWORDS.has(name)) return C.keyword;
   if (BOOLEANS.has(name)) return C.boolean;
@@ -198,11 +233,13 @@ function classifyIdent(name, before, after) {
   return "";
 }
 function tokenizeLine(line, lang) {
+  if (lang === "plain") return line ? [{ text: line, cls: "" }] : [];
   const out = [];
   let last = 0;
   let m;
-  MASTER.lastIndex = 0;
-  while ((m = MASTER.exec(line)) !== null) {
+  const master = masterFor(COMMENTS[lang]);
+  master.lastIndex = 0;
+  while ((m = master.exec(line)) !== null) {
     if (m.index > last) out.push({ text: line.slice(last, m.index), cls: "" });
     const [full, comment, str, annotation, num, ident, punct] = m;
     if (comment != null) out.push({ text: full, cls: C.comment });
@@ -225,6 +262,41 @@ function tokenizeLine(line, lang) {
   if (last < line.length) out.push({ text: line.slice(last), cls: "" });
   return out;
 }
+function tokenizeLines(lines, lang) {
+  const block = BLOCK[COMMENTS[lang]];
+  if (!block) return lines.map((line) => tokenizeLine(line, lang));
+  const out = [];
+  let open = false;
+  for (const line of lines) {
+    let rest = line;
+    const tokens = [];
+    if (open) {
+      const end = rest.indexOf(block.close);
+      if (end === -1) {
+        out.push(rest ? [{ text: rest, cls: C.comment }] : []);
+        continue;
+      }
+      tokens.push({ text: rest.slice(0, end + block.close.length), cls: C.comment });
+      rest = rest.slice(end + block.close.length);
+      open = false;
+    }
+    const lineTokens = tokenizeLine(rest, lang);
+    const at = lineTokens.findIndex(
+      (t) => t.cls !== C.comment && t.cls !== C.string && t.text.includes(block.open)
+    );
+    if (at >= 0) {
+      const cut = lineTokens[at].text.indexOf(block.open);
+      const tail = lineTokens.slice(at).map((t) => t.text).join("").slice(cut);
+      tokens.push(...lineTokens.slice(0, at));
+      if (cut > 0) tokens.push({ text: lineTokens[at].text.slice(0, cut), cls: lineTokens[at].cls });
+      tokens.push({ text: tail, cls: C.comment });
+      open = true;
+    } else tokens.push(...lineTokens);
+    out.push(tokens);
+  }
+  return out;
+}
 export {
-  tokenizeLine
+  tokenizeLine,
+  tokenizeLines
 };

package/dist/components/color.d.ts

@@ -17,7 +17,7 @@ export type ColorFormat = "hex" | "rgb" | "hsl";
 /** Wraps rather than clamps: hue is a circle, and 370° is 10°, not 360°. */
 export declare function normalizeHue(h: number): number;
 export declare function clampHsv(c: Hsv): Hsv;
-export declare function hsvToRgb({ h, s, v, a }: Hsv): Rgb;
+export declare function hsvToRgb(color: Hsv): Rgb;
 export declare function rgbToHsv({ r, g, b, a }: Rgb): Hsv;
 /** "#rrggbb", or "#rrggbbaa" when the colour is not fully opaque. */
 export declare function rgbToHex({ r, g, b, a }: Rgb): string;

package/dist/components/color.js

@@ -11,7 +11,12 @@ function clampHsv(c) {
     a: clamp(c.a, 0, 1)
   };
 }
-function hsvToRgb({ h, s, v, a }) {
+const finite = (n) => Number.isFinite(n) ? n : 0;
+function hsvToRgb(color) {
+  const h = finite(color.h);
+  const s = clamp(finite(color.s), 0, 1);
+  const v = clamp(finite(color.v), 0, 1);
+  const a = Number.isFinite(color.a) ? color.a : 1;
   const hue = normalizeHue(h) / 60;
   const c = v * s;
   const x = c * (1 - Math.abs(hue % 2 - 1));
@@ -52,9 +57,13 @@ function rgbToHsv({ r, g, b, a }) {
   };
 }
 const hex2 = (n) => clamp(Math.round(n), 0, 255).toString(16).padStart(2, "0");
+function alphaByte(a) {
+  return Math.round(clamp(a, 0, 1) * 255);
+}
 function rgbToHex({ r, g, b, a }) {
   const base = `#${hex2(r)}${hex2(g)}${hex2(b)}`;
-  return a >= 1 ? base : base + hex2(a * 255);
+  const byte = alphaByte(a);
+  return byte >= 255 ? base : base + hex2(byte);
 }
 function parseHex(input) {
   const s = input.trim().replace(/^#/, "");
@@ -105,16 +114,18 @@ function hsvToHsl({ h, s, v }) {
 }
 function formatColor(c, format) {
   const rgb = hsvToRgb(c);
-  const a = Math.round(clamp(c.a, 0, 1) * 100) / 100;
+  const byte = alphaByte(rgb.a);
+  const a = Math.round(byte / 255 * 1e3) / 1e3;
   if (format === "hex") return rgbToHex(rgb);
   if (format === "rgb") {
-    return a >= 1 ? `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})` : `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${a})`;
+    return byte >= 255 ? `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})` : `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${a})`;
   }
-  const { h, s, l } = hsvToHsl(c);
-  const hh = Math.round(h);
-  const ss = Math.round(s * 100);
-  const ll = Math.round(l * 100);
-  return a >= 1 ? `hsl(${hh}, ${ss}%, ${ll}%)` : `hsla(${hh}, ${ss}%, ${ll}%, ${a})`;
+  const { h, s, l } = hsvToHsl({ ...c, h: finite(c.h), s: clamp(finite(c.s), 0, 1), v: clamp(finite(c.v), 0, 1) });
+  const dec = (n) => Math.round(n * 10) / 10;
+  const hh = dec(h) % 360;
+  const ss = dec(s * 100);
+  const ll = dec(l * 100);
+  return byte >= 255 ? `hsl(${hh}, ${ss}%, ${ll}%)` : `hsla(${hh}, ${ss}%, ${ll}%, ${a})`;
 }
 function opaqueCss(c) {
   const { r, g, b } = hsvToRgb({ ...c, a: 1 });

package/dist/components/commandSearch.js

@@ -39,6 +39,9 @@ function score(command, terms) {
     if (!hit) return 0;
     total += hit;
   }
+  const typed = terms.include.join(" ");
+  if (typed && label === typed) total += 6;
+  else if (typed && label.startsWith(typed)) total += 2;
   return total;
 }
 function rankCommandItems(items, terms) {

package/dist/components/confirm.d.ts

@@ -0,0 +1,25 @@
+export interface ConfirmOptions {
+    title: string;
+    description?: string;
+    danger?: boolean;
+    icon?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    loadingLabel?: string;
+    /**
+     * Work to run on confirm. The dialog stays open with a loading state while it
+     * runs and shows the error's message if it rejects; the promise from
+     * `confirm()` resolves true only once it succeeded.
+     */
+    action?: () => unknown;
+}
+export interface ConfirmRequest extends ConfirmOptions {
+    id: number;
+    resolve: (confirmed: boolean) => void;
+}
+export declare const confirmQueue: ConfirmRequest[];
+/** Ask for confirmation. Resolves false when the user cancels or dismisses. */
+export declare function confirm(options: ConfirmOptions): Promise<boolean>;
+/** Settle a request and drop it from the queue. Used by the host. */
+export declare function settleConfirm(id: number, confirmed: boolean): void;
+export declare function useConfirm(): typeof confirm;

package/dist/components/confirm.js

@@ -0,0 +1,26 @@
+import { reactive } from "vue";
+const STATE_KEY = /* @__PURE__ */ Symbol.for("@leavepulse/ui:confirm-queue");
+const g = globalThis;
+const state = g[STATE_KEY] ??= { queue: reactive([]), nextId: 0 };
+const confirmQueue = state.queue;
+function confirm(options) {
+  if (typeof window === "undefined") return Promise.resolve(false);
+  return new Promise((resolve) => {
+    state.queue.push({ ...options, id: state.nextId++, resolve });
+  });
+}
+function settleConfirm(id, confirmed) {
+  const i = state.queue.findIndex((r) => r.id === id);
+  if (i === -1) return;
+  const [request] = state.queue.splice(i, 1);
+  request?.resolve(confirmed);
+}
+function useConfirm() {
+  return confirm;
+}
+export {
+  confirm,
+  confirmQueue,
+  settleConfirm,
+  useConfirm
+};

package/dist/components/countries.d.ts

@@ -18,3 +18,9 @@ export declare function loadCountries(): Promise<Country[]>;
  * country is preferred. Pass the list (from loadCountries). Undefined if none.
  */
 export declare function matchCountryByValue(value: string, list: Country[]): Country | undefined;
+/**
+ * Countries matching a search query: by name, or by dial code when the query
+ * carries digits ("+44", "44"). A query without digits must not match on the
+ * dial code at all, or every country would match the empty string.
+ */
+export declare function filterCountries(list: Country[], query: string): Country[];

package/dist/components/countries.js

@@ -31,7 +31,14 @@ function matchCountryByValue(value, list) {
   }
   return best;
 }
+function filterCountries(list, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return list;
+  const digits = q.replace(/\D/g, "");
+  return list.filter((c) => c.name.toLowerCase().includes(q) || digits !== "" && c.dial.includes(digits));
+}
 export {
+  filterCountries,
   flagEmoji,
   loadCountries,
   matchCountryByValue

package/dist/components/dateRange.d.ts

@@ -0,0 +1,43 @@
+import { type CalendarDate } from "@internationalized/date";
+export interface DateRange {
+    start: string;
+    end: string;
+}
+export interface DateRangePreset {
+    label: string;
+    range: () => DateRange;
+}
+export interface DateRangePresetLabels {
+    today: string;
+    last7: string;
+    last30: string;
+    thisMonth: string;
+    lastMonth: string;
+}
+/** The default preset list. `now` is injectable so the set can be tested. */
+export declare function defaultRangePresets(labels: DateRangePresetLabels, now?: () => CalendarDate): DateRangePreset[];
+export declare function parseIsoDay(iso: string | undefined): CalendarDate | undefined;
+/** A range with both ends parsed and in order, or undefined. */
+export declare function normalizeRange(range: Partial<DateRange> | undefined): DateRange | undefined;
+export declare function sameRange(a: Partial<DateRange> | undefined, b: Partial<DateRange> | undefined): boolean;
+/** Clip a preset to the allowed bounds; undefined when nothing of it is left. */
+export declare function clampRange(range: DateRange, min?: string, max?: string): DateRange | undefined;
+/**
+ * "Jun 3 – 18, 2026" style text: Intl's own range formatting collapses the
+ * shared month and year, which is how a range reads naturally in every locale.
+ */
+export declare function formatRange(range: DateRange, locale?: string, format?: Intl.DateTimeFormatOptions): string;
+export interface ReshapeRules {
+    /** Whether the moving end may land on this day (min, max, disabled). */
+    allowed?: (iso: string) => boolean;
+    /** Days a range may not include. */
+    unavailable?: (iso: string) => boolean;
+    /** Longest range, in days, counting both ends. */
+    maximumDays?: number;
+}
+/**
+ * The range one end makes when it is dragged to `moving` while the other stays
+ * at `anchor`; passing the anchor flips which end is which. Null when the result
+ * would break a rule, so a drag simply does not follow onto that day.
+ */
+export declare function reshapeRange(anchor: string, moving: string, rules?: ReshapeRules): DateRange | null;

package/dist/components/dateRange.js

@@ -0,0 +1,76 @@
+import { endOfMonth, startOfMonth, today, getLocalTimeZone, parseDate } from "@internationalized/date";
+function span(start, end) {
+  return { start: start.toString(), end: end.toString() };
+}
+function defaultRangePresets(labels, now = () => today(getLocalTimeZone())) {
+  return [
+    { label: labels.today, range: () => span(now(), now()) },
+    { label: labels.last7, range: () => span(now().subtract({ days: 6 }), now()) },
+    { label: labels.last30, range: () => span(now().subtract({ days: 29 }), now()) },
+    { label: labels.thisMonth, range: () => span(startOfMonth(now()), endOfMonth(now())) },
+    {
+      label: labels.lastMonth,
+      range: () => {
+        const previous = now().subtract({ months: 1 });
+        return span(startOfMonth(previous), endOfMonth(previous));
+      }
+    }
+  ];
+}
+function parseIsoDay(iso) {
+  if (!iso) return void 0;
+  try {
+    return parseDate(iso.slice(0, 10));
+  } catch {
+    return void 0;
+  }
+}
+function normalizeRange(range) {
+  const start = parseIsoDay(range?.start);
+  const end = parseIsoDay(range?.end);
+  if (!start || !end) return void 0;
+  return start.compare(end) <= 0 ? span(start, end) : span(end, start);
+}
+function sameRange(a, b) {
+  const x = normalizeRange(a);
+  const y = normalizeRange(b);
+  return !!x && !!y && x.start === y.start && x.end === y.end;
+}
+function clampRange(range, min, max) {
+  const r = normalizeRange(range);
+  if (!r) return void 0;
+  const start = min && r.start < min ? min : r.start;
+  const end = max && r.end > max ? max : r.end;
+  return start <= end ? { start, end } : void 0;
+}
+function formatRange(range, locale, format = { year: "numeric", month: "short", day: "numeric" }) {
+  const start = parseIsoDay(range.start);
+  const end = parseIsoDay(range.end);
+  if (!start || !end) return "";
+  const zone = "UTC";
+  const fmt = new Intl.DateTimeFormat(locale, { ...format, timeZone: zone });
+  return fmt.formatRange(start.toDate(zone), end.toDate(zone));
+}
+function reshapeRange(anchor, moving, rules = {}) {
+  const a = parseIsoDay(anchor);
+  const m = parseIsoDay(moving);
+  if (!a || !m) return null;
+  if (rules.allowed && !rules.allowed(m.toString())) return null;
+  const [start, end] = a.compare(m) <= 0 ? [a, m] : [m, a];
+  if (rules.maximumDays && end.compare(start) + 1 > rules.maximumDays) return null;
+  if (rules.unavailable) {
+    for (let d = start; d.compare(end) <= 0; d = d.add({ days: 1 })) {
+      if (rules.unavailable(d.toString())) return null;
+    }
+  }
+  return { start: start.toString(), end: end.toString() };
+}
+export {
+  clampRange,
+  defaultRangePresets,
+  formatRange,
+  normalizeRange,
+  parseIsoDay,
+  reshapeRange,
+  sameRange
+};

package/dist/components/exportData.d.ts

@@ -0,0 +1,58 @@
+export interface CsvColumn<Row> {
+    key: string;
+    /** Header cell. Defaults to the key. */
+    label?: string;
+    /** The value written for a row; the row's `key` field when omitted. */
+    value?: (row: Row) => unknown;
+}
+export interface CsvOptions {
+    /** Field separator. Default ",". Some locales' spreadsheets expect ";". */
+    separator?: string;
+    /** Prefix a UTF-8 byte order mark so Excel reads non-ASCII text correctly. */
+    bom?: boolean;
+    /**
+     * Neutralise cells a spreadsheet would run as a formula (leading = + - @,
+     * tab or CR) by prefixing a quote. On by default: exported data is often
+     * user-supplied, and opening it is enough to trigger a formula.
+     */
+    guardFormulas?: boolean;
+    /** Line ending. Default "\r\n", as RFC 4180 specifies. */
+    newline?: string;
+}
+/** One CSV field, quoted when it holds a separator, a quote or a line break. */
+export declare function csvField(value: unknown, options?: CsvOptions): string;
+/** Rows as CSV text, a header line first. */
+export declare function toCsv<Row>(rows: readonly Row[], columns: readonly CsvColumn<Row>[], options?: CsvOptions): string;
+/**
+ * Hand the viewer a file to save. Does nothing outside a browser, so a call
+ * that runs during SSR is harmless.
+ */
+export declare function downloadFile(name: string, data: Blob | string, type?: string): void;
+/**
+ * A standalone copy of a live SVG: every element carries its computed paint as
+ * an inline style, so CSS custom properties and classes from the page's
+ * stylesheet survive being rendered as an image, and running SMIL animations
+ * are frozen at their end state.
+ */
+export declare function inlineSvg(svg: SVGSVGElement): SVGSVGElement;
+export interface RasterOptions {
+    /** Device pixels per CSS pixel. Default: the screen's ratio, at least 2. */
+    scale?: number;
+    /** Fill behind the drawing; transparent when omitted. */
+    background?: string;
+    /** Extra space around the drawing, in CSS pixels. */
+    padding?: number;
+    /** Drawn above the SVG, in the page's own font. */
+    header?: (ctx: CanvasRenderingContext2D, width: number) => number;
+}
+/** Rasterise an SVG element to a PNG blob with its theme resolved. */
+export declare function svgToPng(svg: SVGSVGElement, options?: RasterOptions): Promise<Blob>;
+/** The first non-transparent background at or above an element. */
+export declare function backgroundOf(el: Element | null): string | undefined;
+/**
+ * A colour as the browser resolves it where `within` sits, for APIs that cannot
+ * read custom properties (canvas, an SVG drawn as an image).
+ */
+export declare function resolveCssColor(value: string, within: Element): string;
+/** A filesystem-safe name from a title. */
+export declare function fileStem(title: string | undefined, fallback: string): string;

package/dist/components/exportData.js

@@ -0,0 +1,165 @@
+const FORMULA_START = /^[=+\-@\t\r]/;
+function cellText(value) {
+  if (value == null) return "";
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? "" : value.toISOString();
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function csvField(value, options = {}) {
+  const separator = options.separator ?? ",";
+  let text = cellText(value);
+  if ((options.guardFormulas ?? true) && typeof value === "string" && FORMULA_START.test(text)) {
+    text = `'${text}`;
+  }
+  const needsQuotes = text.includes(separator) || /["\r\n]/.test(text) || /^\s|\s$/.test(text);
+  return needsQuotes ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function toCsv(rows, columns, options = {}) {
+  const separator = options.separator ?? ",";
+  const newline = options.newline ?? "\r\n";
+  const line = (cells) => cells.map((c) => csvField(c, options)).join(separator);
+  const out = [line(columns.map((c) => c.label ?? c.key))];
+  for (const row of rows) {
+    out.push(
+      line(columns.map((c) => c.value ? c.value(row) : row[c.key]))
+    );
+  }
+  return (options.bom ? "\uFEFF" : "") + out.join(newline) + newline;
+}
+function downloadFile(name, data, type = "text/plain;charset=utf-8") {
+  if (typeof document === "undefined" || typeof URL === "undefined") return;
+  const blob = typeof data === "string" ? new Blob([data], { type }) : data;
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = name;
+  a.rel = "noopener";
+  a.style.display = "none";
+  document.body.append(a);
+  a.click();
+  a.remove();
+  setTimeout(() => URL.revokeObjectURL(url), 0);
+}
+const PAINT_PROPS = [
+  "fill",
+  "fill-opacity",
+  "fill-rule",
+  "stroke",
+  "stroke-opacity",
+  "stroke-width",
+  "stroke-dasharray",
+  "stroke-dashoffset",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "opacity",
+  "stop-color",
+  "stop-opacity",
+  "color",
+  "font-family",
+  "font-size",
+  "font-weight",
+  "letter-spacing",
+  "text-anchor",
+  "dominant-baseline",
+  "visibility",
+  "display"
+];
+function inlineSvg(svg) {
+  const clone = svg.cloneNode(true);
+  const source = [svg, ...svg.querySelectorAll("*")];
+  const target = [clone, ...clone.querySelectorAll("*")];
+  source.forEach((el, i) => {
+    const copy = target[i];
+    if (!(copy instanceof Element)) return;
+    const computed = getComputedStyle(el);
+    const style = PAINT_PROPS.map((p) => `${p}:${computed.getPropertyValue(p)}`).filter((d) => !d.endsWith(":")).join(";");
+    copy.setAttribute("style", style);
+    copy.removeAttribute("class");
+  });
+  const comments = document.createTreeWalker(clone, NodeFilter.SHOW_COMMENT);
+  const dead = [];
+  while (comments.nextNode()) dead.push(comments.currentNode);
+  for (const node of dead) node.parentNode?.removeChild(node);
+  for (const anim of clone.querySelectorAll("animate")) {
+    const attr = anim.getAttribute("attributeName");
+    const to = anim.getAttribute("to");
+    if (attr && to != null) anim.parentElement?.setAttribute(attr, to);
+    anim.remove();
+  }
+  clone.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+  const { width, height } = svg.getBoundingClientRect();
+  clone.setAttribute("width", String(width));
+  clone.setAttribute("height", String(height));
+  clone.style.overflow = "visible";
+  return clone;
+}
+async function svgToPng(svg, options = {}) {
+  const copy = inlineSvg(svg);
+  const width = Number(copy.getAttribute("width"));
+  const height = Number(copy.getAttribute("height"));
+  const markup = new XMLSerializer().serializeToString(copy);
+  const url = URL.createObjectURL(new Blob([markup], { type: "image/svg+xml;charset=utf-8" }));
+  try {
+    const img = new Image();
+    img.decoding = "async";
+    const loaded = new Promise((resolve, reject) => {
+      img.onload = () => resolve();
+      img.onerror = () => reject(new Error("SVG could not be rasterised"));
+    });
+    img.src = url;
+    await loaded;
+    const scale = options.scale ?? Math.max(2, globalThis.devicePixelRatio || 1);
+    const pad = options.padding ?? 0;
+    const measure = document.createElement("canvas").getContext("2d");
+    const headerHeight = measure && options.header ? options.header(measure, width) : 0;
+    const canvas = document.createElement("canvas");
+    canvas.width = Math.ceil((width + pad * 2) * scale);
+    canvas.height = Math.ceil((height + headerHeight + pad * 2) * scale);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("Canvas 2D is unavailable");
+    ctx.scale(scale, scale);
+    if (options.background) {
+      ctx.fillStyle = options.background;
+      ctx.fillRect(0, 0, width + pad * 2, height + headerHeight + pad * 2);
+    }
+    ctx.translate(pad, pad);
+    if (options.header) options.header(ctx, width);
+    ctx.drawImage(img, 0, headerHeight, width, height);
+    return await new Promise(
+      (resolve, reject) => canvas.toBlob((b) => b ? resolve(b) : reject(new Error("PNG encoding failed")), "image/png")
+    );
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+function backgroundOf(el) {
+  for (let node = el; node; node = node.parentElement) {
+    const bg = getComputedStyle(node).backgroundColor;
+    if (bg && bg !== "transparent" && !/rgba\([^)]*,\s*0\)$/.test(bg)) return bg;
+  }
+  return void 0;
+}
+function resolveCssColor(value, within) {
+  if (!value.includes("var(") && !value.toLowerCase().includes("currentcolor")) return value;
+  const probe = document.createElement("span");
+  probe.style.color = value;
+  probe.style.display = "none";
+  within.append(probe);
+  const resolved = getComputedStyle(probe).color;
+  probe.remove();
+  return resolved || value;
+}
+function fileStem(title, fallback) {
+  const stem = (title ?? "").trim().replace(/[\\/:*?"<>|\u0000-\u001f]+/g, "").replace(/\s+/g, "-");
+  return stem || fallback;
+}
+export {
+  backgroundOf,
+  csvField,
+  downloadFile,
+  fileStem,
+  inlineSvg,
+  resolveCssColor,
+  svgToPng,
+  toCsv
+};