@corbits/react-ui 0.1.0 → 0.2.0

package/dist/lib/chart-geometry.js

@@ -9,7 +9,8 @@
  * bar chart and a line chart actually need is this file, and a library would
  * bring a renderer, a theme layer and an interaction model that then have to be
  * fought to match everything else.
- */ /**
+ */
+/**
  * Axis ticks on round numbers, covering `[0, max]`.
  *
  * Rounds the *step* to 1, 2, 5 or 10 × a power of ten, then extends the top of
@@ -21,20 +22,20 @@
  * Always starts at zero. A bar chart with a truncated baseline overstates
  * differences by whatever fraction you cut off, which is the most effective way
  * to mislead with a chart and the easiest to do by accident.
- */ export function niceTicks(max, count = 4) {
-    if (!Number.isFinite(max) || max <= 0) return [
-        0,
-        1
-    ];
+ */
+export function niceTicks(max, count = 4) {
+    if (!Number.isFinite(max) || max <= 0)
+        return [0, 1];
     const rough = max / count;
     const magnitude = 10 ** Math.floor(Math.log10(rough));
     const normalized = rough / magnitude;
-    const step = (normalized <= 1 ? 1 : normalized <= 2 ? 2 : normalized <= 5 ? 5 : 10) * magnitude;
+    const step = (normalized <= 1 ? 1 : normalized <= 2 ? 2 : normalized <= 5 ? 5 : 10) *
+        magnitude;
     const top = Math.ceil(max / step) * step;
     const ticks = [];
     // Accumulating `value += step` drifts on fractional steps (0.1 + 0.2 …);
     // multiplying an integer index does not.
-    for(let index = 0; index * step <= top + step / 2; index += 1){
+    for (let index = 0; index * step <= top + step / 2; index += 1) {
         ticks.push(index * step);
     }
     return ticks;
@@ -46,9 +47,11 @@
  * is a real thing to plot — "nothing happened" — and one `NaN` in a path
  * attribute makes the entire path vanish, so a flat line at the baseline is both
  * correct and the only readable failure mode.
- */ export function scaleLinear(value, domainMax, rangeMax) {
-    if (domainMax <= 0) return 0;
-    return value / domainMax * rangeMax;
+ */
+export function scaleLinear(value, domainMax, rangeMax) {
+    if (domainMax <= 0)
+        return 0;
+    return (value / domainMax) * rangeMax;
 }
 /**
  * An SVG path through points, as straight segments.
@@ -56,20 +59,27 @@
  * Straight, not smoothed. A spline through data invents values between the
  * points — it will overshoot a local maximum and draw a peak that was never
  * measured. Curves are for decoration; these are measurements.
- */ export function linePath(points) {
-    if (points.length === 0) return "";
-    return points.map((point, index)=>`${index === 0 ? "M" : "L"}${point.x} ${point.y}`).join(" ");
+ */
+export function linePath(points) {
+    if (points.length === 0)
+        return "";
+    return points
+        .map((point, index) => `${index === 0 ? "M" : "L"}${point.x} ${point.y}`)
+        .join(" ");
 }
 /**
  * The filled region under a line: the line itself, then down to `baselineY`
  * and back to the first x, closed. The baseline is passed in rather than
  * assumed to be the box edge so the fill lands on the plot's zero line, inside
  * whatever padding the chart drew around it.
- */ export function areaPath(points, baselineY) {
-    if (points.length === 0) return "";
+ */
+export function areaPath(points, baselineY) {
+    if (points.length === 0)
+        return "";
     const first = points[0];
     const last = points[points.length - 1];
-    if (first === undefined || last === undefined) return "";
+    if (first === undefined || last === undefined)
+        return "";
     return `${linePath(points)} L${last.x} ${baselineY} L${first.x} ${baselineY} Z`;
 }
 /**
@@ -78,9 +88,12 @@
  * Compacts only past a thousand, and keeps one decimal so 12.9K and 13.4K stay
  * distinguishable. Below a thousand the exact number is short enough to show,
  * and rounding it would be a loss with no gain.
- */ export function formatCompact(value) {
+ */
+export function formatCompact(value) {
     const magnitude = Math.abs(value);
-    if (magnitude >= 1_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
-    if (magnitude >= 10_000) return `${(value / 1000).toFixed(1)}K`;
+    if (magnitude >= 1_000_000)
+        return `${(value / 1_000_000).toFixed(1)}M`;
+    if (magnitude >= 10_000)
+        return `${(value / 1000).toFixed(1)}K`;
     return value.toLocaleString();
 }

package/dist/lib/chart-palette.js

@@ -18,37 +18,20 @@
  * legal **only** alongside a second, non-colour channel — which is why every
  * chart in this registry ships a legend, direct labels, a per-slot dash and a
  * data table rather than treating them as polish.
- */ /** How many distinct series the palette can carry. Past this, fold. */ export const CHART_SERIES_SLOTS = 5;
+ */
+/** How many distinct series the palette can carry. Past this, fold. */
+export const CHART_SERIES_SLOTS = 5;
 /**
  * The ramp itself, in slot order, for callers that lay out a legend or paint a
  * stacked mosaic and need the whole sequence rather than one slot. Same rules
  * as `seriesColor`: fixed order, never cycled, orange never appears.
- */ export const CHART_SERIES = [
-    {
-        key: "blue",
-        color: "var(--chart-1)",
-        dash: undefined
-    },
-    {
-        key: "green",
-        color: "var(--chart-2)",
-        dash: "6 3"
-    },
-    {
-        key: "green-deep",
-        color: "var(--chart-3)",
-        dash: "2 3"
-    },
-    {
-        key: "blue-deep",
-        color: "var(--chart-4)",
-        dash: "10 3 2 3"
-    },
-    {
-        key: "red",
-        color: "var(--chart-5)",
-        dash: "1 3"
-    }
+ */
+export const CHART_SERIES = [
+    { key: "blue", color: "var(--chart-1)", dash: undefined },
+    { key: "green", color: "var(--chart-2)", dash: "6 3" },
+    { key: "green-deep", color: "var(--chart-3)", dash: "2 3" },
+    { key: "blue-deep", color: "var(--chart-4)", dash: "10 3 2 3" },
+    { key: "red", color: "var(--chart-5)", dash: "1 3" },
 ];
 /**
  * The CSS colour for series `index`.
@@ -58,7 +41,8 @@
  * misread — and generating a hue would put an unvalidated colour on screen.
  * Grey says "these are lumped together", which is the truth once you are past
  * five; use `foldSeries` so the label says so too.
- */ export function seriesColor(index) {
+ */
+export function seriesColor(index) {
     return CHART_SERIES[index]?.color ?? "var(--muted-foreground)";
 }
 /**
@@ -74,7 +58,8 @@
  * Returned as an SVG `stroke-dasharray`; `undefined` means solid. Out-of-range
  * indices are solid too, matching `seriesColor`'s grey — past five, the tail is
  * one lumped-together thing and does not need a pattern of its own.
- */ export function seriesDash(index) {
+ */
+export function seriesDash(index) {
     return CHART_SERIES[index]?.dash;
 }
 /**
@@ -84,9 +69,10 @@
  * against a legend, and the sixth colour would have to be either a repeat or an
  * unvalidated one. Sum `rest` into an "Other" series, or facet into small
  * multiples — both are better charts than a nine-colour one.
- */ export function foldSeries(series) {
+ */
+export function foldSeries(series) {
     return {
         named: series.slice(0, CHART_SERIES_SLOTS),
-        rest: series.slice(CHART_SERIES_SLOTS)
+        rest: series.slice(CHART_SERIES_SLOTS),
     };
 }

package/dist/lib/chat-message.js

@@ -6,27 +6,39 @@
  * agent reply genuinely interleaves kinds — think, call a tool, think again,
  * answer. Flattening that to `text` plus a `toolCalls` array loses the order,
  * and the order is the only thing that makes a transcript readable.
- */ /** The answer text: every text part joined, thinking and tools excluded. */ export function messageText(message) {
-    return message.parts.filter((part)=>part.type === "text").map((part)=>part.text).join("");
+ */
+/** The answer text: every text part joined, thinking and tools excluded. */
+export function messageText(message) {
+    return message.parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
 }
-/** The turn's thinking, if the agent exposed any. */ export function reasoningText(message) {
-    return message.parts.filter((part)=>part.type === "reasoning").map((part)=>part.text).join("");
+/** The turn's thinking, if the agent exposed any. */
+export function reasoningText(message) {
+    return message.parts
+        .filter((part) => part.type === "reasoning")
+        .map((part) => part.text)
+        .join("");
 }
 export function toolParts(message) {
-    return message.parts.filter((part)=>part.type === "tool");
+    return message.parts.filter((part) => part.type === "tool");
 }
-/** True while any tool in the turn is still running — drives the live marker. */ export function isTurnWorking(message) {
-    return toolParts(message).some((part)=>part.state === "running");
+/** True while any tool in the turn is still running — drives the live marker. */
+export function isTurnWorking(message) {
+    return toolParts(message).some((part) => part.state === "running");
 }
 /**
  * A readable name for a tool id. `slack__post_message` → "Post message
  * (Slack)"; `mail_send` → "Mail send". Never shows a raw snake_case id, and
  * never invents a label for a tool it does not recognise — it only reformats
  * what it was given, so a new tool reads correctly with no table to update.
- */ export function toolLabel(part) {
-    if (part.label !== undefined && part.label.length > 0) return part.label;
+ */
+export function toolLabel(part) {
+    if (part.label !== undefined && part.label.length > 0)
+        return part.label;
     const [provider, ...rest] = part.toolName.split("__");
-    const humanise = (value)=>{
+    const humanise = (value) => {
         const words = value.replace(/[_-]+/g, " ").trim();
         return words.charAt(0).toUpperCase() + words.slice(1);
     };
@@ -35,7 +47,14 @@ export function toolParts(message) {
     }
     return humanise(part.toolName);
 }
-/** Avatar initials from a display name, capped at two characters. */ export function agentInitials(identity) {
-    if (identity.initials !== undefined) return identity.initials;
-    return identity.name.split(/\s+/).map((word)=>word.charAt(0)).join("").slice(0, 2).toUpperCase() || "··";
+/** Avatar initials from a display name, capped at two characters. */
+export function agentInitials(identity) {
+    if (identity.initials !== undefined)
+        return identity.initials;
+    return (identity.name
+        .split(/\s+/)
+        .map((word) => word.charAt(0))
+        .join("")
+        .slice(0, 2)
+        .toUpperCase() || "··");
 }

package/dist/lib/chat-parts.js

@@ -13,4 +13,5 @@
  * host might reach for on its own, because `lib/chat-message.ts` already
  * publishes those names for its own, simpler message model — the two are
  * deliberately separate types.
- */ export { };
+ */
+export {};

package/dist/lib/csv.js

@@ -9,19 +9,24 @@
  * streaming it, caps what it hands back instead of virtualising, and reports
  * "not tabular" instead of guessing — a ragged file rendered as a grid puts
  * cells under the wrong headers, which is a worse failure than showing raw text.
- */ /** Rows past this are dropped; the caller must say so in the UI. */ export const CSV_ROW_CAP = 500;
-/** Columns past this are dropped; the caller must say so in the UI. */ export const CSV_COLUMN_CAP = 40;
+ */
+/** Rows past this are dropped; the caller must say so in the UI. */
+export const CSV_ROW_CAP = 500;
+/** Columns past this are dropped; the caller must say so in the UI. */
+export const CSV_COLUMN_CAP = 40;
 /**
  * Refuse to parse beyond this. 2 MiB of CSV is roughly 20k rows — already far
  * past what anyone reads on screen, and enough DOM to lock the tab.
- */ export const CSV_MAX_PREVIEW_BYTES = 2 * 1024 * 1024;
+ */
+export const CSV_MAX_PREVIEW_BYTES = 2 * 1024 * 1024;
 /**
  * True UTF-8 length, not `string.length`.
  *
  * `"é".length` is 1 but it costs 2 bytes, and a file of CJK text is three times
  * its character count — sizing the guard by character count would let a file
  * three times over budget through.
- */ export function utf8ByteLength(text) {
+ */
+export function utf8ByteLength(text) {
     return new TextEncoder().encode(text).length;
 }
 /**
@@ -33,29 +38,35 @@
  * needs a character-level state machine over the whole document, and embedded
  * newlines show up as an extra ragged row here — which `isTabular` catches and
  * degrades to raw text, the honest outcome.
- */ function splitLine(line) {
+ */
+function splitLine(line) {
     const fields = [];
     let field = "";
     let quoted = false;
-    for(let i = 0; i < line.length; i += 1){
+    for (let i = 0; i < line.length; i += 1) {
         const char = line[i];
         if (quoted) {
             if (char === '"') {
                 if (line[i + 1] === '"') {
                     field += '"';
                     i += 1;
-                } else {
+                }
+                else {
                     quoted = false;
                 }
-            } else {
+            }
+            else {
                 field += char;
             }
-        } else if (char === '"') {
+        }
+        else if (char === '"') {
             quoted = true;
-        } else if (char === ",") {
+        }
+        else if (char === ",") {
             fields.push(field);
             field = "";
-        } else {
+        }
+        else {
             field += char;
         }
     }
@@ -68,17 +79,17 @@
  * `null` rather than a throw: "too big to preview" is an expected outcome of
  * showing a user their own file, not an exceptional one, and the caller's
  * response is to render a different surface rather than to catch.
- */ export function parseCsv(text) {
-    if (utf8ByteLength(text) > CSV_MAX_PREVIEW_BYTES) return null;
-    const lines = text.split(/\r\n|\n|\r/).filter((line)=>line.trim() !== "");
-    if (lines.length === 0) return {
-        headers: [],
-        rows: []
-    };
+ */
+export function parseCsv(text) {
+    if (utf8ByteLength(text) > CSV_MAX_PREVIEW_BYTES)
+        return null;
+    const lines = text.split(/\r\n|\n|\r/).filter((line) => line.trim() !== "");
+    if (lines.length === 0)
+        return { headers: [], rows: [] };
     const [headerLine, ...bodyLines] = lines;
     return {
         headers: splitLine(headerLine ?? ""),
-        rows: bodyLines.map(splitLine)
+        rows: bodyLines.map(splitLine),
     };
 }
 /**
@@ -88,21 +99,26 @@
  * single-column "CSV" is prose that happens to have no commas, and a ragged one
  * has no reliable column alignment — in both cases raw text tells the truth and
  * a table does not.
- */ export function isTabular(parsed) {
-    if (parsed.headers.length < 2) return false;
-    return parsed.rows.every((row)=>row.length === parsed.headers.length);
+ */
+export function isTabular(parsed) {
+    if (parsed.headers.length < 2)
+        return false;
+    return parsed.rows.every((row) => row.length === parsed.headers.length);
 }
-/** Trims a parse to the caps, keeping the original totals so the UI can say so. */ export function capCsv(parsed) {
+/** Trims a parse to the caps, keeping the original totals so the UI can say so. */
+export function capCsv(parsed) {
     const totalRows = parsed.rows.length;
     const totalColumns = parsed.headers.length;
     const columnsTruncated = totalColumns > CSV_COLUMN_CAP;
     const rowsTruncated = totalRows > CSV_ROW_CAP;
     return {
-        headers: columnsTruncated ? parsed.headers.slice(0, CSV_COLUMN_CAP) : parsed.headers,
-        rows: (rowsTruncated ? parsed.rows.slice(0, CSV_ROW_CAP) : parsed.rows).map((row)=>columnsTruncated ? row.slice(0, CSV_COLUMN_CAP) : row),
+        headers: columnsTruncated
+            ? parsed.headers.slice(0, CSV_COLUMN_CAP)
+            : parsed.headers,
+        rows: (rowsTruncated ? parsed.rows.slice(0, CSV_ROW_CAP) : parsed.rows).map((row) => (columnsTruncated ? row.slice(0, CSV_COLUMN_CAP) : row)),
         totalRows,
         totalColumns,
         rowsTruncated,
-        columnsTruncated
+        columnsTruncated,
     };
 }

package/dist/lib/metrics.js

@@ -3,37 +3,24 @@
  * sparkline and mosaic geometry, and zero-filling a sparse daily series. Plain
  * numbers in, plain numbers out — no React, no SVG — so the part of a dashboard
  * that can silently lie is the part you can check by hand.
- */ export { formatCompact } from "./chart-geometry.js";
+ */
+export { formatCompact } from "./chart-geometry.js";
 /**
  * Period-over-period change. `comparable` is false when there is no previous
  * window. `pct` is null when the previous value is absent or zero — there is no
  * meaningful baseline to divide by, so callers render the absolute delta rather
  * than a misleading "∞%".
- */ export function computeDelta(current, previous) {
+ */
+export function computeDelta(current, previous) {
     if (previous === null || previous === undefined) {
-        return {
-            direction: "flat",
-            pct: null,
-            delta: 0,
-            comparable: false
-        };
+        return { direction: "flat", pct: null, delta: 0, comparable: false };
     }
     const delta = current - previous;
     const direction = delta > 0 ? "up" : delta < 0 ? "down" : "flat";
     if (previous === 0) {
-        return {
-            direction,
-            pct: null,
-            delta,
-            comparable: true
-        };
+        return { direction, pct: null, delta, comparable: true };
     }
-    return {
-        direction,
-        pct: delta / previous * 100,
-        delta,
-        comparable: true
-    };
+    return { direction, pct: (delta / previous) * 100, delta, comparable: true };
 }
 /**
  * Maps a value series to polyline coordinates in a `width` × `height` viewBox.
@@ -41,47 +28,42 @@
  * shape is the message, and a zero baseline would flatten every real series in
  * a box this small. A flat series renders along the vertical centre and a
  * single point is centred horizontally.
- */ export function buildSparkline(values, width, height) {
+ */
+export function buildSparkline(values, width, height) {
     if (values.length === 0) {
-        return {
-            points: "",
-            coords: []
-        };
+        return { points: "", coords: [] };
     }
     const max = Math.max(...values);
     const min = Math.min(...values);
     const span = max - min;
     const stepX = values.length > 1 ? width / (values.length - 1) : 0;
-    const coords = values.map((value, index)=>({
-            x: values.length > 1 ? index * stepX : width / 2,
-            y: span === 0 ? height / 2 : height - (value - min) / span * height
-        }));
-    const points = coords.map((c)=>`${round(c.x)},${round(c.y)}`).join(" ");
-    return {
-        points,
-        coords
-    };
+    const coords = values.map((value, index) => ({
+        x: values.length > 1 ? index * stepX : width / 2,
+        y: span === 0 ? height / 2 : height - ((value - min) / span) * height,
+    }));
+    const points = coords.map((c) => `${round(c.x)},${round(c.y)}`).join(" ");
+    return { points, coords };
 }
-/** Shares of a whole, as percentage widths for a stacked strip. */ export function buildMosaic(parts) {
-    const total = parts.reduce((sum, part)=>sum + part.value, 0);
-    return parts.map((part)=>({
-            label: part.label,
-            value: part.value,
-            pct: total <= 0 ? 0 : part.value / total * 100
-        }));
+/** Shares of a whole, as percentage widths for a stacked strip. */
+export function buildMosaic(parts) {
+    const total = parts.reduce((sum, part) => sum + part.value, 0);
+    return parts.map((part) => ({
+        label: part.label,
+        value: part.value,
+        pct: total <= 0 ? 0 : (part.value / total) * 100,
+    }));
 }
-/** Runaway guard: the longest spine `fillDailySeries` will build. */ export const FILL_DAILY_SERIES_MAX_DAYS = 400;
+/** Runaway guard: the longest spine `fillDailySeries` will build. */
+export const FILL_DAILY_SERIES_MAX_DAYS = 400;
 /**
  * Expands a sparse daily series (only days with activity) into a continuous,
  * zero-filled spine from `startDate` to `endDate` inclusive (UTC). Without this
  * a sparkline plots gapped days at equal spacing, drawing a false slope across
  * dates where nothing happened. Returns the input unchanged for an unparseable
  * or inverted range, and caps at `FILL_DAILY_SERIES_MAX_DAYS`.
- */ export function fillDailySeries(series, startDate, endDate, options) {
-    const byDate = new Map(series.map((row)=>[
-            options.dateOf(row),
-            row
-        ]));
+ */
+export function fillDailySeries(series, startDate, endDate, options) {
+    const byDate = new Map(series.map((row) => [options.dateOf(row), row]));
     const msPerDay = 86_400_000;
     let cursor = new Date(`${startDate}T00:00:00.000Z`).getTime();
     const end = new Date(`${endDate}T00:00:00.000Z`).getTime();
@@ -89,7 +71,7 @@
         return series;
     }
     const out = [];
-    while(cursor <= end && out.length < FILL_DAILY_SERIES_MAX_DAYS){
+    while (cursor <= end && out.length < FILL_DAILY_SERIES_MAX_DAYS) {
         const date = new Date(cursor).toISOString().slice(0, 10);
         out.push(byDate.get(date) ?? options.zero(date));
         cursor += msPerDay;

package/dist/lib/now-item.js

@@ -11,49 +11,50 @@
  * `classification` is a free string, not an enum: what counts as a category
  * differs per app, and the label is shown verbatim. Ranking is driven by
  * `priority`, which is fixed, so a new classification never changes ordering.
- */ const PRIORITY_RANK = {
+ */
+const PRIORITY_RANK = {
     now: 0,
     next: 1,
-    later: 2
+    later: 2,
 };
-/** Short band label for the queue's priority column. */ export const PRIORITY_LABEL = {
+/** Short band label for the queue's priority column. */
+export const PRIORITY_LABEL = {
     now: "HIGH",
     next: "MED",
-    later: "LOW"
+    later: "LOW",
 };
-/** Human label for the status marker. */ export const STATUS_LABEL = {
+/** Human label for the status marker. */
+export const STATUS_LABEL = {
     "needs-action": "Needs action",
-    done: "Done"
+    done: "Done",
 };
 /**
  * Priority first, then newest. Sorts a copy — a component handed a frozen or
  * host-owned array must not reorder it in place.
- */ export function sortNowItems(items) {
-    return [
-        ...items
-    ].sort((a, b)=>{
+ */
+export function sortNowItems(items) {
+    return [...items].sort((a, b) => {
         const byPriority = PRIORITY_RANK[a.priority] - PRIORITY_RANK[b.priority];
-        if (byPriority !== 0) return byPriority;
+        if (byPriority !== 0)
+            return byPriority;
         return Date.parse(b.when) - Date.parse(a.when);
     });
 }
 /**
  * Sorted items split into priority bands. Empty bands are dropped rather than
  * returned empty, so a caller can map straight to headings without checking.
- */ export function groupNowItemsByPriority(items) {
+ */
+export function groupNowItemsByPriority(items) {
     const sorted = sortNowItems(items);
-    const order = [
-        "now",
-        "next",
-        "later"
-    ];
-    return order.map((priority)=>({
-            priority,
-            items: sorted.filter((item)=>item.priority === priority)
-        })).filter((group)=>group.items.length > 0);
+    const order = ["now", "next", "later"];
+    return order
+        .map((priority) => ({
+        priority,
+        items: sorted.filter((item) => item.priority === priority),
+    }))
+        .filter((group) => group.items.length > 0);
 }
-/** The classifications present, in first-appearance order — for a filter row. */ export function nowItemClassifications(items) {
-    return [
-        ...new Set(sortNowItems(items).map((item)=>item.classification))
-    ];
+/** The classifications present, in first-appearance order — for a filter row. */
+export function nowItemClassifications(items) {
+    return [...new Set(sortNowItems(items).map((item) => item.classification))];
 }

package/dist/lib/relative-time.js

@@ -1,28 +1,10 @@
 const UNITS = [
-    [
-        "year",
-        365 * 24 * 60 * 60 * 1000
-    ],
-    [
-        "month",
-        30 * 24 * 60 * 60 * 1000
-    ],
-    [
-        "week",
-        7 * 24 * 60 * 60 * 1000
-    ],
-    [
-        "day",
-        24 * 60 * 60 * 1000
-    ],
-    [
-        "hour",
-        60 * 60 * 1000
-    ],
-    [
-        "minute",
-        60 * 1000
-    ]
+    ["year", 365 * 24 * 60 * 60 * 1000],
+    ["month", 30 * 24 * 60 * 60 * 1000],
+    ["week", 7 * 24 * 60 * 60 * 1000],
+    ["day", 24 * 60 * 60 * 1000],
+    ["hour", 60 * 60 * 1000],
+    ["minute", 60 * 1000],
 ];
 /**
  * "3 min ago" / "in 2 days", localised, from an ISO timestamp.
@@ -31,17 +13,20 @@ const UNITS = [
  * a pure function of its inputs — otherwise every list that renders a timestamp
  * is untestable and re-renders to a different string than the server produced.
  * Pass the server's render time when hydrating.
- */ export function formatRelativeTime(iso, now = Date.now()) {
+ */
+export function formatRelativeTime(iso, now = Date.now()) {
     const then = Date.parse(iso);
-    if (Number.isNaN(then)) return "";
+    if (Number.isNaN(then))
+        return "";
     const delta = then - now;
     const magnitude = Math.abs(delta);
     const format = new Intl.RelativeTimeFormat(undefined, {
         numeric: "auto",
-        style: "narrow"
+        style: "narrow",
     });
-    for (const [unit, ms] of UNITS){
-        if (magnitude >= ms) return format.format(Math.round(delta / ms), unit);
+    for (const [unit, ms] of UNITS) {
+        if (magnitude >= ms)
+            return format.format(Math.round(delta / ms), unit);
     }
     return format.format(Math.round(delta / 1000), "second");
 }