bamtigraph 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3161 @@
+/*! BamtiGraph 0.1.0 | BSD-3-Clause | See LICENSE */
+"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, {
+  Chart: () => Chart,
+  LIMITS: () => LIMITS,
+  RenderResult: () => RenderResult,
+  VERSION: () => VERSION,
+  aggregate: () => aggregate,
+  color: () => color,
+  compareImages: () => compareImages,
+  counterRate: () => counterRate,
+  daily: () => daily,
+  dashboard: () => dashboard,
+  decodeImage: () => decodeImage,
+  default: () => index_default,
+  defaults: () => defaults,
+  differenceImage: () => differenceImage,
+  downloadBytes: () => downloadBytes,
+  drawImageToCanvas: () => drawImageToCanvas,
+  encodePNG: () => encodePNG,
+  epoch: () => epoch,
+  formatTime: () => formatTime,
+  formatValue: () => formatValue,
+  monthly: () => monthly,
+  parseCSV: () => parseCSV,
+  readCanvas: () => readCanvas,
+  regularSeries: () => regularSeries,
+  render: () => render,
+  series: () => series,
+  toCSV: () => toCSV,
+  traffic: () => traffic,
+  weekly: () => weekly,
+  yearly: () => yearly
+});
+module.exports = __toCommonJS(index_exports);
+var VERSION = "0.1.0";
+var LIMITS = Object.freeze({
+  pixels: 16e6,
+  layerPixels: 4e7,
+  ticks: 5e3,
+  series: 128,
+  samples: 2e6,
+  text: 4096
+});
+var finite = (v) => Number.isFinite(v);
+var round = (v) => Math.floor(v + 0.5);
+var clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+var own = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+var missing = (v) => v === null || v === void 0 || typeof v === "number" && Number.isNaN(v);
+function check(ok, message) {
+  if (!ok) throw new RangeError(message);
+}
+function text(s, name) {
+  check(
+    typeof s === "string" && s.length <= LIMITS.text && !/[\r\n\u0000]/.test(s),
+    name + " must be a single-line string."
+  );
+  return s;
+}
+function number(v, name, lo = -Infinity, hi = Infinity) {
+  check(
+    finite(v) && v >= lo && v <= hi,
+    name + " is outside its finite range."
+  );
+  return v;
+}
+function integer(v, name, lo, hi) {
+  check(Number.isInteger(v), name + " must be an integer.");
+  return number(v, name, lo, hi);
+}
+function record(o) {
+  return o !== null && typeof o === "object" && (Object.getPrototypeOf(o) === Object.prototype || Object.getPrototypeOf(o) === null);
+}
+function clone(v) {
+  if (Array.isArray(v) || ArrayBuffer.isView(v))
+    return Array.from(v, (value) => clone(value));
+  if (v instanceof Date) return new Date(v.getTime());
+  if (record(v)) {
+    const r = {};
+    for (const k of Object.keys(v)) {
+      check(
+        !["__proto__", "prototype", "constructor"].includes(k),
+        "Unsafe property name."
+      );
+      r[k] = clone(v[k]);
+    }
+    return r;
+  }
+  return v;
+}
+function merge(a, b) {
+  check(record(b), "Options must be a plain object.");
+  const r = clone(a);
+  for (const k of Object.keys(b)) {
+    check(
+      !["__proto__", "prototype", "constructor"].includes(k),
+      "Unsafe property name."
+    );
+    const previous = r[k], next = b[k];
+    r[k] = record(previous) && record(next) ? merge(previous, next) : clone(next);
+  }
+  return r;
+}
+function freeze(o) {
+  if (o && typeof o === "object") {
+    for (const v of Object.values(o)) freeze(v);
+    Object.freeze(o);
+  }
+  return o;
+}
+function color(value) {
+  if (Array.isArray(value) || ArrayBuffer.isView(value)) {
+    check(
+      value.length === 3 || value.length === 4,
+      "Color needs 3 or 4 channels."
+    );
+    const c = Array.from(value);
+    c.forEach((v) => integer(v, "Color channel", 0, 255));
+    if (c.length === 3) c.push(255);
+    return c;
+  }
+  const named = {
+    black: "#000000",
+    white: "#ffffff",
+    red: "#ff0000",
+    green: "#008000",
+    blue: "#0000ff",
+    transparent: "#00000000"
+  };
+  check(
+    typeof value === "string",
+    "Color must be hexadecimal or an RGB(A) array."
+  );
+  let h = named[value.toLowerCase()] || value;
+  check(
+    /^#(?:[0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(h),
+    "Invalid color: " + value
+  );
+  h = h.slice(1);
+  if (h.length <= 4) h = [...h].map((c) => c + c).join("");
+  if (h.length === 6) h += "ff";
+  return [0, 2, 4, 6].map((i) => parseInt(h.slice(i, i + 2), 16));
+}
+function epoch(value) {
+  if (value instanceof Date) value = value.getTime() / 1e3;
+  if (typeof value === "string") {
+    const v = value.trim();
+    if (/^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i.test(v)) value = Number(v);
+    else {
+      const m = /^(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d)(?::(\d\d)(\.\d{1,3})?)?(Z|[+-]\d\d:\d\d)$/i.exec(
+        v
+      );
+      check(
+        m,
+        "Datetime strings require ISO 8601 with an explicit offset; numeric timestamps are seconds."
+      );
+      const [y, mo, d, h, mi, s] = [
+        m[1],
+        m[2],
+        m[3],
+        m[4],
+        m[5],
+        m[6] || "0"
+      ].map(Number);
+      check(
+        y >= 1 && mo >= 1 && mo <= 12 && d >= 1 && h < 24 && mi < 60 && s < 60,
+        "Invalid calendar date."
+      );
+      const test = /* @__PURE__ */ new Date(0);
+      test.setUTCFullYear(y, mo - 1, d);
+      test.setUTCHours(h, mi, s, 0);
+      check(
+        test.getUTCMonth() === mo - 1 && test.getUTCDate() === d,
+        "Invalid calendar date."
+      );
+      if (m[8].toUpperCase() !== "Z")
+        check(
+          Number(m[8].slice(1, 3)) <= 23 && Number(m[8].slice(4)) <= 59,
+          "Invalid timezone offset."
+        );
+      value = Date.parse(v) / 1e3;
+    }
+  }
+  return number(value, "Timestamp", -62135596800, 253402300799999e-3);
+}
+function samples(timestamps, values) {
+  check(
+    (Array.isArray(timestamps) || ArrayBuffer.isView(timestamps)) && (Array.isArray(values) || ArrayBuffer.isView(values)),
+    "Timestamps and values must be arrays."
+  );
+  check(
+    timestamps.length === values.length && timestamps.length <= LIMITS.samples,
+    "Sample lengths must match and stay within the sample limit."
+  );
+  const ts = Array.from(timestamps, epoch), vs = Array.from(
+    values,
+    (v, i) => missing(v) ? NaN : number(v, "Value at " + i)
+  );
+  for (let i = 1; i < ts.length; i++)
+    check(
+      ts[i] > ts[i - 1],
+      "Timestamps must be strictly increasing (index " + i + ")."
+    );
+  return { timestamps: ts, values: vs };
+}
+var DEFAULTS = freeze({
+  title: "",
+  verticalLabel: "",
+  watermark: "",
+  series: [],
+  timeAxis: {
+    start: null,
+    end: null,
+    mode: "auto",
+    timezone: "UTC",
+    minorSeconds: null,
+    majorSeconds: null,
+    labelSeconds: null,
+    labelFormat: null,
+    ticks: null,
+    majorTicks: null,
+    minorTicks: null,
+    labelOffsetSeconds: 0
+  },
+  yAxis: {
+    minimum: 0,
+    maximum: null,
+    majorStep: null,
+    minorDivisions: 5,
+    base: 1e3,
+    scaleFactor: null,
+    suffix: null,
+    decimals: null,
+    legendDecimals: 2,
+    showZeroSuffix: false
+  },
+  layout: {
+    width: 595,
+    plotHeight: 122,
+    left: 64,
+    right: 31,
+    top: 34,
+    titleY: 8,
+    titleOffsetX: 27,
+    unitX: 5,
+    xLabelGap: 5,
+    yLabelGap: 6,
+    legendGap: 20,
+    legendRowHeight: 14,
+    legendBottom: 7,
+    legend: "reference",
+    antialias: 4,
+    pixelScale: 1,
+    legendLayout: {
+      nameX: 30,
+      swatchX: 15,
+      swatchWidth: 9,
+      swatchHeight: 10,
+      referenceWidth: 595,
+      autoScaleColumns: true,
+      compact: [
+        [102, 228],
+        [244, 370],
+        [386, 512]
+      ],
+      expanded: [
+        [124, 250],
+        [289, 415],
+        [454, 580]
+      ],
+      aligned: [
+        [102, 250],
+        [267, 415],
+        [432, 580]
+      ]
+    }
+  },
+  theme: {
+    background: "#f3f3f3",
+    canvas: "#ffffff",
+    shadeLight: "#cfcfcf",
+    shadeDark: "#9e9e9e",
+    text: "#000000",
+    minorGrid: "#8f8f8f3c",
+    majorGrid: "#df4f4f3c",
+    axis: "#777777",
+    arrow: "#7f1f1f",
+    watermark: "#aaaaaa",
+    frame: "#000000",
+    gridFront: true,
+    gridDash: [1, 1],
+    titleSize: 14,
+    axisSize: 11,
+    unitSize: 10,
+    legendSize: 11,
+    watermarkSize: 8,
+    captionSize: 11,
+    titleAdvance: 8,
+    axisAdvance: 6,
+    legendAdvance: 7
+  },
+  fonts: {
+    mode: "system",
+    family: '"DejaVu Sans Mono", "Liberation Mono", Consolas, monospace',
+    titleFamily: null,
+    unitFamily: null,
+    captionFamily: "Arial, sans-serif",
+    strictGlyphs: true
+  },
+  legendLabels: ["Current:", "Average:", "Maximum:"],
+  missingLabel: "NaN",
+  hRules: [],
+  vRules: []
+});
+function series(name, timestamps, values, options = {}) {
+  const s = merge(
+    {
+      name,
+      timestamps,
+      values,
+      kind: "line",
+      color: "#0000cc",
+      lineWidth: 0.7,
+      outline: null,
+      baseline: 0,
+      interpolation: "linear",
+      gapAfter: 0,
+      legendValues: null
+    },
+    options
+  );
+  text(s.name, "Series name");
+  const data = samples(s.timestamps, s.values);
+  s.timestamps = data.timestamps;
+  s.values = data.values;
+  check(["line", "area"].includes(s.kind), "Series kind must be line or area.");
+  check(
+    ["linear", "step-post"].includes(s.interpolation),
+    "Interpolation must be linear or step-post."
+  );
+  number(s.lineWidth, "Line width", 0.01, 128);
+  number(s.baseline, "Baseline");
+  number(s.gapAfter, "Gap threshold", 0);
+  s.color = color(s.color);
+  if (s.outline !== null) s.outline = color(s.outline);
+  if (s.legendValues !== null) {
+    check(record(s.legendValues), "Legend overrides must be an object.");
+    for (const k of ["current", "average", "maximum"])
+      s.legendValues[k] = missing(s.legendValues[k]) ? null : number(s.legendValues[k], "Legend override");
+  }
+  return freeze(s);
+}
+function regularSeries(name, values, start, step = 300, options = {}) {
+  start = epoch(start);
+  number(step, "Step", Number.MIN_VALUE);
+  const first = start;
+  return series(
+    name,
+    Array.from(values, (_, i) => first + i * step),
+    values,
+    options
+  );
+}
+function modeAxis(mode, options = {}) {
+  return merge(
+    DEFAULTS.timeAxis,
+    merge(
+      { mode },
+      typeof options === "string" ? { timezone: options } : options
+    )
+  );
+}
+function daily(options = {}) {
+  return modeAxis("daily", options);
+}
+function weekly(options = {}) {
+  return modeAxis("weekly", options);
+}
+function monthly(options = {}) {
+  return modeAxis("monthly", options);
+}
+function yearly(options = {}) {
+  return modeAxis("yearly", options);
+}
+function dimensions(c) {
+  const l = c.layout;
+  return [
+    l.width,
+    l.top + l.plotHeight + (l.legend === "none" ? 18 : l.legendGap + Math.max(1, c.series.length) * l.legendRowHeight + l.legendBottom)
+  ];
+}
+function dash(d) {
+  if (d === null) return;
+  check(Array.isArray(d) && d.length === 2, "Dash must be null or [on, off].");
+  d.forEach((v) => integer(v, "Dash interval", 1, 16384));
+}
+function normalize(options) {
+  const c = merge(DEFAULTS, options);
+  check(
+    Array.isArray(c.series) && c.series.length <= LIMITS.series,
+    "Invalid series count."
+  );
+  c.series = c.series.map((s) => series(s.name, s.timestamps, s.values, s));
+  for (const k of [
+    "title",
+    "verticalLabel",
+    "watermark",
+    "missingLabel"
+  ])
+    text(c[k], k);
+  check(
+    Array.isArray(c.legendLabels) && c.legendLabels.length === 3,
+    "Three statistic labels are required."
+  );
+  c.legendLabels.forEach((v) => text(v, "Statistic label"));
+  const a = c.timeAxis, l = c.layout, y = c.yAxis, t = c.theme, f = c.fonts;
+  check(
+    ["auto", "daily", "weekly", "monthly", "yearly", "custom"].includes(a.mode),
+    "Unknown time axis mode."
+  );
+  text(a.timezone, "Timezone");
+  zoneFormatter(a.timezone);
+  for (const k of ["start", "end"])
+    if (a[k] !== null) a[k] = epoch(a[k]);
+  if (a.start !== null && a.end !== null)
+    check(
+      a.end > a.start,
+      "Time end must exceed start."
+    );
+  for (const k of ["minorSeconds", "majorSeconds", "labelSeconds"])
+    if (a[k] !== null) number(a[k], k, 1e-3);
+  number(a.labelOffsetSeconds, "Label offset", -31622400, 31622400);
+  if (a.labelFormat !== null) {
+    text(a.labelFormat, "Label format");
+    formatTime(0, "UTC", a.labelFormat);
+  }
+  if (a.ticks !== null) {
+    check(
+      Array.isArray(a.ticks) && a.ticks.length <= LIMITS.ticks,
+      "Too many or invalid ticks."
+    );
+    const ticks = a.ticks.map((v) => ({
+      time: epoch(v.time),
+      label: text(v.label, "Tick label")
+    }));
+    for (let i = 1; i < ticks.length; i++)
+      check(
+        ticks[i].time > ticks[i - 1].time,
+        "Explicit ticks must be strictly increasing."
+      );
+    a.ticks = ticks;
+  }
+  for (const k of ["minorTicks", "majorTicks"])
+    if (a[k] !== null) {
+      const input = a[k];
+      check(
+        Array.isArray(input) && input.length <= LIMITS.ticks,
+        "Too many or invalid ticks."
+      );
+      const ticks = input.map(epoch);
+      for (let i = 1; i < ticks.length; i++)
+        check(
+          ticks[i] > ticks[i - 1],
+          "Explicit ticks must be strictly increasing."
+        );
+      a[k] = ticks;
+    }
+  for (const k of ["minimum", "maximum", "majorStep", "scaleFactor"])
+    if (y[k] !== null) number(y[k], k);
+  for (const k of ["majorStep", "scaleFactor"])
+    if (y[k] !== null) check(y[k] > 0, k + " must be positive.");
+  if (y.minimum !== null && y.maximum !== null)
+    check(y.maximum > y.minimum, "Y maximum must exceed minimum.");
+  check(y.base === 1e3 || y.base === 1024, "Unit base must be 1000 or 1024.");
+  integer(y.minorDivisions, "Minor divisions", 1, 100);
+  integer(y.legendDecimals, "Legend decimals", 0, 12);
+  if (y.decimals !== null) integer(y.decimals, "Decimals", 0, 12);
+  if (y.suffix !== null) text(y.suffix, "Suffix");
+  integer(l.width, "Width", 400, 8192);
+  integer(l.plotHeight, "Plot height", 30, 4096);
+  for (const k of [
+    "left",
+    "right",
+    "top",
+    "titleY",
+    "unitX",
+    "xLabelGap",
+    "yLabelGap",
+    "legendGap",
+    "legendRowHeight",
+    "legendBottom"
+  ])
+    integer(l[k], k, 0, 16384);
+  check(
+    l.left >= 20 && l.right >= 12 && l.top >= 12 && l.width - l.left - l.right >= 100,
+    "Insufficient plot margins."
+  );
+  number(l.titleOffsetX, "Title offset", -8192, 8192);
+  check(
+    ["reference", "aligned", "none"].includes(l.legend),
+    "Invalid legend mode."
+  );
+  if (l.legend !== "none")
+    check(
+      l.legendGap >= 14 && l.legendRowHeight >= 10,
+      "Legend spacing is insufficient."
+    );
+  integer(l.antialias, "Antialias", 1, 8);
+  integer(l.pixelScale, "Pixel scale", 1, 8);
+  const ll = l.legendLayout;
+  for (const k of [
+    "nameX",
+    "swatchX",
+    "swatchWidth",
+    "swatchHeight",
+    "referenceWidth"
+  ])
+    integer(ll[k], k, 0, 16384);
+  check(
+    ll.swatchWidth >= 3 && ll.swatchHeight >= 3 && ll.referenceWidth > ll.nameX,
+    "Invalid legend geometry."
+  );
+  for (const key of ["compact", "expanded", "aligned"]) {
+    const cols = ll[key];
+    check(Array.isArray(cols) && cols.length === 3, "Invalid legend columns.");
+    let last = ll.nameX;
+    for (const p of cols) {
+      check(
+        Array.isArray(p) && p.length === 2 && finite(p[0]) && finite(p[1]) && last < p[0] && p[0] < p[1] && p[1] < ll.referenceWidth,
+        "Legend columns must not overlap."
+      );
+      last = p[1];
+    }
+  }
+  for (const k of [
+    "background",
+    "canvas",
+    "shadeLight",
+    "shadeDark",
+    "text",
+    "minorGrid",
+    "majorGrid",
+    "axis",
+    "arrow",
+    "watermark",
+    "frame"
+  ])
+    t[k] = color(t[k]);
+  check(
+    t.background[3] === 255 && t.canvas[3] === 255,
+    "Background and canvas must be opaque."
+  );
+  dash(t.gridDash);
+  check(t.gridDash !== null, "Grid dash is required.");
+  for (const k of [
+    "titleSize",
+    "axisSize",
+    "unitSize",
+    "legendSize",
+    "watermarkSize",
+    "captionSize",
+    "titleAdvance",
+    "axisAdvance",
+    "legendAdvance"
+  ])
+    number(t[k], k, 1, 128);
+  check(
+    ["system", "bitmap"].includes(f.mode),
+    "Font mode must be system or bitmap."
+  );
+  text(f.family, "Font family");
+  for (const k of ["titleFamily", "unitFamily", "captionFamily"])
+    if (f[k] !== null) text(f[k], k);
+  function rule(input, field) {
+    const r = merge(
+      { color: "#990000", width: 1, dash: [3, 2] },
+      input
+    );
+    if (field === "time") r.time = epoch(r.time);
+    else r.value = number(r.value, "Rule value");
+    number(r.width, "Rule width", 0.1, 128);
+    dash(r.dash);
+    r.color = color(r.color);
+    return r;
+  }
+  check(
+    Array.isArray(c.hRules) && c.hRules.length <= 1e3,
+    "Invalid rule count."
+  );
+  c.hRules = c.hRules.map((r) => rule(r, "value"));
+  check(
+    Array.isArray(c.vRules) && c.vRules.length <= 1e3,
+    "Invalid rule count."
+  );
+  c.vRules = c.vRules.map((r) => rule(r, "time"));
+  const [w, h] = dimensions(c);
+  check(
+    w * h * l.pixelScale ** 2 <= LIMITS.pixels,
+    "Output allocation exceeds the pixel limit."
+  );
+  check(
+    (l.width - l.left - l.right + 1) * (l.plotHeight + 1) * l.antialias ** 2 <= LIMITS.layerPixels,
+    "Supersampled layer exceeds the pixel limit."
+  );
+  return freeze(c);
+}
+var Surface = class _Surface {
+  width;
+  height;
+  data;
+  constructor(width, height, fill = null) {
+    integer(width, "Image width", 1, 65536);
+    integer(height, "Image height", 1, 65536);
+    check(width * height <= LIMITS.layerPixels, "Image is too large.");
+    this.width = width;
+    this.height = height;
+    this.data = new Uint8ClampedArray(width * height * 4);
+    if (fill) this.rect(0, 0, width, height, fill);
+  }
+  pixel(x, y, c, blend = false) {
+    if (x < 0 || y < 0 || x >= this.width || y >= this.height) return;
+    const i = (y * this.width + x) * 4, d = this.data;
+    if (!blend || c[3] === 255) {
+      d[i] = c[0];
+      d[i + 1] = c[1];
+      d[i + 2] = c[2];
+      d[i + 3] = c[3];
+      return;
+    }
+    if (c[3] === 0) return;
+    const sa = c[3], da = d[i + 3], alpha = sa * 255 + da * (255 - sa);
+    for (let k = 0; k < 3; k++)
+      d[i + k] = Math.floor(
+        (c[k] * sa * 255 + d[i + k] * da * (255 - sa) + alpha / 2) / alpha
+      );
+    d[i + 3] = Math.floor((alpha + 127) / 255);
+  }
+  rect(x0, y0, x1, y1, c) {
+    x0 = Math.max(0, Math.ceil(x0));
+    y0 = Math.max(0, Math.ceil(y0));
+    x1 = Math.min(this.width, Math.ceil(x1));
+    y1 = Math.min(this.height, Math.ceil(y1));
+    for (let y = y0; y < y1; y++)
+      for (let x = x0, i = (y * this.width + x0) * 4; x < x1; x++, i += 4) {
+        this.data[i] = c[0];
+        this.data[i + 1] = c[1];
+        this.data[i + 2] = c[2];
+        this.data[i + 3] = c[3];
+      }
+  }
+  over(src, dx = 0, dy = 0) {
+    const p = [0, 0, 0, 0];
+    for (let y = Math.max(0, -dy); y < Math.min(src.height, this.height - dy); y++)
+      for (let x = Math.max(0, -dx); x < Math.min(src.width, this.width - dx); x++) {
+        const i = (y * src.width + x) * 4;
+        if (src.data[i + 3]) {
+          p[0] = src.data[i];
+          p[1] = src.data[i + 1];
+          p[2] = src.data[i + 2];
+          p[3] = src.data[i + 3];
+          this.pixel(x + dx, y + dy, p, true);
+        }
+      }
+  }
+  polygon(points, c) {
+    if (points.length < 3) return;
+    let lo = Infinity, hi = -Infinity;
+    for (const p of points) {
+      lo = Math.min(lo, p[1]);
+      hi = Math.max(hi, p[1]);
+    }
+    for (let y = Math.max(0, Math.ceil(lo)); y <= Math.min(this.height - 1, Math.floor(hi)); y++) {
+      const xs = [];
+      let a = points[points.length - 1];
+      for (const b of points) {
+        if (a[1] === b[1]) {
+          if (y === a[1])
+            this.rect(
+              Math.ceil(Math.min(a[0], b[0])),
+              y,
+              Math.floor(Math.max(a[0], b[0])) + 1,
+              y + 1,
+              c
+            );
+        } else if (a[1] <= y && y < b[1] || b[1] <= y && y < a[1])
+          xs.push(a[0] + (y - a[1]) / (b[1] - a[1]) * (b[0] - a[0]));
+        a = b;
+      }
+      xs.sort((a2, b) => a2 - b);
+      for (let i = 0; i + 1 < xs.length; i += 2)
+        this.rect(
+          Math.ceil(xs[i] - 1e-9),
+          y,
+          Math.floor(xs[i + 1] + 1e-9) + 1,
+          y + 1,
+          c
+        );
+    }
+  }
+  line(a, b, c, width = 1) {
+    let x = round(a[0]), y = round(a[1]), x1 = round(b[0]), y1 = round(b[1]);
+    width = Math.max(1, round(width));
+    if (width > 1) {
+      const r = (width - 1) / 2;
+      if (x === x1) {
+        this.rect(
+          x - Math.floor(width / 2),
+          Math.min(y, y1),
+          x + Math.floor((width - 1) / 2) + 1,
+          Math.max(y, y1) + 1,
+          c
+        );
+        return;
+      }
+      if (y === y1) {
+        this.rect(
+          Math.min(x, x1),
+          y - Math.floor(width / 2),
+          Math.max(x, x1) + 1,
+          y + Math.floor((width - 1) / 2) + 1,
+          c
+        );
+        return;
+      }
+      const len = Math.hypot(x1 - x, y1 - y), ox = -(y1 - y) / len * r, oy = (x1 - x) / len * r;
+      this.polygon(
+        [
+          [x + ox, y + oy],
+          [x1 + ox, y1 + oy],
+          [x1 - ox, y1 - oy],
+          [x - ox, y - oy]
+        ].map((p) => [round(p[0]), round(p[1])]),
+        c
+      );
+      return;
+    }
+    const dx = Math.abs(x1 - x), dy = -Math.abs(y1 - y), sx = x < x1 ? 1 : -1, sy = y < y1 ? 1 : -1;
+    let err = dx + dy;
+    for (; ; ) {
+      this.pixel(x, y, c);
+      if (x === x1 && y === y1) break;
+      const e = 2 * err;
+      if (e >= dy) {
+        err += dy;
+        x += sx;
+      }
+      if (e <= dx) {
+        err += dx;
+        y += sy;
+      }
+    }
+  }
+  dashed(a, b, c, pattern = [1, 1], width = 1) {
+    if (pattern === null) {
+      this.line(a, b, c, width);
+      return;
+    }
+    const len = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    if (!len) {
+      this.pixel(round(a[0]), round(a[1]), c);
+      return;
+    }
+    const dx = (b[0] - a[0]) / len, dy = (b[1] - a[1]) / len;
+    for (let s = 0; s <= Math.ceil(len); s += pattern[0] + pattern[1]) {
+      const e = Math.min(len, s + pattern[0] - 1);
+      this.line(
+        [a[0] + dx * s, a[1] + dy * s],
+        [a[0] + dx * e, a[1] + dy * e],
+        c,
+        width
+      );
+    }
+  }
+  circle(x, y, r, c) {
+    for (let yy = Math.max(0, Math.floor(y - r)); yy <= Math.min(this.height - 1, Math.ceil(y + r)); yy++)
+      for (let xx = Math.max(0, Math.floor(x - r)); xx <= Math.min(this.width - 1, Math.ceil(x + r)); xx++)
+        if ((xx - x) ** 2 + (yy - y) ** 2 <= r * r) this.pixel(xx, yy, c);
+  }
+  down(scale) {
+    if (scale === 1) return this;
+    const out = new _Surface(this.width / scale, this.height / scale), p = [0, 0, 0, 0], n = scale * scale;
+    for (let y = 0; y < out.height; y++)
+      for (let x = 0; x < out.width; x++) {
+        let a = 0, r = 0, g = 0, b = 0;
+        for (let sy = 0; sy < scale; sy++)
+          for (let sx = 0; sx < scale; sx++) {
+            const i = ((y * scale + sy) * this.width + x * scale + sx) * 4, ca = this.data[i + 3];
+            a += ca;
+            r += this.data[i] * ca;
+            g += this.data[i + 1] * ca;
+            b += this.data[i + 2] * ca;
+          }
+        if (a) {
+          p[0] = Math.floor(r / a + 0.5);
+          p[1] = Math.floor(g / a + 0.5);
+          p[2] = Math.floor(b / a + 0.5);
+          p[3] = Math.floor(a / n + 0.5);
+          out.pixel(x, y, p);
+        }
+      }
+    return out;
+  }
+  scale(n) {
+    if (n === 1) return this;
+    const out = new _Surface(this.width * n, this.height * n);
+    for (let y = 0; y < out.height; y++)
+      for (let x = 0; x < out.width; x++) {
+        const s = (Math.floor(y / n) * this.width + Math.floor(x / n)) * 4, i = (y * out.width + x) * 4;
+        out.data[i] = this.data[s];
+        out.data[i + 1] = this.data[s + 1];
+        out.data[i + 2] = this.data[s + 2];
+        out.data[i + 3] = this.data[s + 3];
+      }
+    return out;
+  }
+};
+function clipLine(a, b, w, h) {
+  let lo = 0, hi = 1;
+  const dx = b[0] - a[0], dy = b[1] - a[1];
+  for (const [p, q] of [
+    [-dx, a[0]],
+    [dx, w - a[0]],
+    [-dy, a[1]],
+    [dy, h - a[1]]
+  ]) {
+    if (p === 0) {
+      if (q < 0) return null;
+    } else {
+      const u = q / p;
+      if (p < 0) lo = Math.max(lo, u);
+      else hi = Math.min(hi, u);
+      if (lo > hi) return null;
+    }
+  }
+  return [
+    [a[0] + lo * dx, a[1] + lo * dy],
+    [a[0] + hi * dx, a[1] + hi * dy]
+  ];
+}
+function clipPolygon(points, w, h) {
+  let ps = points;
+  for (const [axis, bound, greater] of [
+    [0, 0, true],
+    [0, w, false],
+    [1, 0, true],
+    [1, h, false]
+  ]) {
+    if (!ps.length) break;
+    const out = [], inside = (p) => greater ? p[axis] >= bound : p[axis] <= bound;
+    let a = ps[ps.length - 1], ai = inside(a);
+    for (const b of ps) {
+      const bi = inside(b);
+      if (ai !== bi) {
+        const q = (bound - a[axis]) / (b[axis] - a[axis]);
+        const p = [a[0] + q * (b[0] - a[0]), a[1] + q * (b[1] - a[1])];
+        p[axis] = bound;
+        out.push(p);
+      }
+      if (bi) out.push(b);
+      a = b;
+      ai = bi;
+    }
+    ps = out;
+  }
+  return ps;
+}
+function lowerBound(a, x) {
+  let l = 0, r = a.length;
+  while (l < r) {
+    const m = l + r >>> 1;
+    if (a[m] < x) l = m + 1;
+    else r = m;
+  }
+  return l;
+}
+function upperBound(a, x) {
+  let l = 0, r = a.length;
+  while (l < r) {
+    const m = l + r >>> 1;
+    if (a[m] <= x) l = m + 1;
+    else r = m;
+  }
+  return l;
+}
+function visibleRuns(s, start, end) {
+  const ts = s.timestamps, vs = s.values, result = [];
+  let run = [];
+  const push = () => {
+    if (run.length) {
+      result.push(run);
+      run = [];
+    }
+  };
+  const left = Math.max(0, lowerBound(ts, start) - 1), right = Math.min(ts.length, upperBound(ts, end) + 1);
+  for (let i = left; i < right; i++) {
+    if (!finite(vs[i])) {
+      push();
+      continue;
+    }
+    if (i > left && s.gapAfter > 0 && ts[i] - ts[i - 1] > s.gapAfter) push();
+    if (run.length && s.interpolation === "step-post")
+      run.push([ts[i], run[run.length - 1][1]]);
+    run.push([ts[i], vs[i]]);
+  }
+  push();
+  const clipped = [];
+  for (const r of result) {
+    const out = [];
+    if (r.length === 1) {
+      if (r[0][0] >= start && r[0][0] <= end) out.push(r[0]);
+    }
+    for (let i = 1; i < r.length; i++) {
+      const a = r[i - 1], b = r[i];
+      if (b[0] < start || a[0] > end) continue;
+      const interp = (x) => a[1] * (1 - (x - a[0]) / (b[0] - a[0])) + b[1] * ((x - a[0]) / (b[0] - a[0]));
+      const p = a[0] < start ? [start, interp(start)] : a, q = b[0] > end ? [end, interp(end)] : b;
+      if (!out.length || out[out.length - 1][0] !== p[0] || out[out.length - 1][1] !== p[1])
+        out.push(p);
+      out.push(q);
+    }
+    if (out.length) clipped.push(out);
+  }
+  return clipped;
+}
+function decimate(ps, start, end, width) {
+  if (ps.length <= width * 4) return ps;
+  const out = [];
+  let pos = 0;
+  while (pos < ps.length) {
+    const col = Math.floor((ps[pos][0] - start) / (end - start) * width), first = pos;
+    let mn = pos, mx = pos;
+    while (pos + 1 < ps.length && Math.floor((ps[pos + 1][0] - start) / (end - start) * width) === col) {
+      pos++;
+      if (ps[pos][1] < ps[mn][1]) mn = pos;
+      if (ps[pos][1] > ps[mx][1]) mx = pos;
+    }
+    for (const i of [.../* @__PURE__ */ new Set([first, mn, mx, pos])].sort((a, b) => a - b))
+      out.push(ps[i]);
+    pos++;
+  }
+  return out;
+}
+function stableMean(values) {
+  if (!values.length) return null;
+  let max = 0;
+  for (const v of values) max = Math.max(max, Math.abs(v));
+  if (max === 0) return 0;
+  let sum = 0, c = 0;
+  for (const v of values) {
+    const a = v / max - c, t = sum + a;
+    c = t - sum - a;
+    sum = t;
+  }
+  return clamp(sum / values.length, -1, 1) * max;
+}
+function statistics(s, start, end) {
+  const a = lowerBound(s.timestamps, start), b = upperBound(s.timestamps, end), values = [];
+  let mn = Infinity, mx = -Infinity, miss = 0;
+  for (let i = a; i < b; i++) {
+    const v = s.values[i];
+    if (!finite(v)) miss++;
+    else {
+      values.push(v);
+      mn = Math.min(mn, v);
+      mx = Math.max(mx, v);
+    }
+  }
+  return {
+    name: s.name,
+    current: b > a && finite(s.values[b - 1]) ? s.values[b - 1] : null,
+    average: stableMean(values),
+    maximum: values.length ? mx : null,
+    minimum: values.length ? mn : null,
+    count: values.length,
+    missing: miss,
+    displayOverride: s.legendValues
+  };
+}
+function multiples(lo, hi, step) {
+  check(
+    finite(step) && step > 0 && finite((hi - lo) / step) && (hi - lo) / step <= LIMITS.ticks,
+    "Too many ticks or invalid step."
+  );
+  const a = Math.ceil(lo / step - 1e-10), b = Math.floor(hi / step + 1e-10);
+  check(
+    Math.abs(a) < 9e15 && Math.abs(b) < 9e15 && b - a <= LIMITS.ticks,
+    "Tick precision limit exceeded."
+  );
+  return Array.from(
+    { length: Math.max(0, b - a + 1) },
+    (_, i) => (a + i) * step || 0
+  );
+}
+function nice(v) {
+  check(finite(v) && v >= 1e-300, "Unsupported numeric axis span.");
+  const p = 10 ** Math.floor(Math.log10(v));
+  for (const m of [1, 2, 5, 10]) if (v <= m * p * (1 + 1e-12)) return m * p;
+  return 10 * p;
+}
+function unitFor(v, base) {
+  if (!v) return { factor: 1, suffix: "" };
+  let i = Math.floor(Math.log(Math.abs(v)) / Math.log(base) + 1e-12);
+  i = clamp(i, base === 1024 ? 0 : -8, 8);
+  return {
+    factor: base ** i,
+    suffix: (base === 1024 ? ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi"] : [
+      "y",
+      "z",
+      "a",
+      "f",
+      "p",
+      "n",
+      "u",
+      "m",
+      "",
+      "k",
+      "M",
+      "G",
+      "T",
+      "P",
+      "E",
+      "Z",
+      "Y"
+    ])[base === 1024 ? i : i + 8]
+  };
+}
+function resolveY(a, loData, hiData) {
+  let lo = a.minimum === null ? Math.min(0, loData) : a.minimum, hi = a.maximum === null ? Math.max(0, hiData) : a.maximum;
+  if (a.maximum === null && hi <= lo)
+    hi = lo + Math.max(Math.abs(lo) * 0.05, 1);
+  if (a.minimum === null && lo >= hi)
+    lo = hi - Math.max(Math.abs(hi) * 0.05, 1);
+  const span = hi - lo;
+  check(finite(span) && span > 0, "Invalid Y span.");
+  const af = a.scaleFactor === null ? unitFor(Math.max(Math.abs(lo), Math.abs(hi)), a.base).factor : a.scaleFactor;
+  const step = a.majorStep === null ? nice(span / af / 5) * af : a.majorStep, q = step / a.minorDivisions;
+  check(finite(q) && q > 0, "Invalid Y quantum.");
+  if (a.minimum === null && lo < 0) lo = Math.floor((lo - span * 0.02) / q) * q;
+  if (a.maximum === null) hi = Math.ceil((hi + span * 0.02) / q) * q;
+  check(finite(hi - lo) && hi > lo, "Degenerate Y range.");
+  const major = multiples(lo, hi, step), minor = multiples(lo, hi, q).filter(
+    (v) => Math.abs(v / step - round(v / step)) > 1e-8
+  );
+  const unit = unitFor(Math.max(Math.abs(lo), Math.abs(hi)), a.base);
+  if (a.scaleFactor !== null) {
+    unit.factor = a.scaleFactor;
+    if (a.suffix === null) unit.suffix = "";
+  }
+  if (a.suffix !== null) unit.suffix = a.suffix;
+  let decimals = a.decimals;
+  if (decimals === null) {
+    const s = step / unit.factor;
+    decimals = 9;
+    for (let d = 0; d < 10; d++)
+      if (Math.abs(s - round(s * 10 ** d) / 10 ** d) <= Math.max(1e-10, Math.abs(s) * 1e-9)) {
+        decimals = d;
+        break;
+      }
+  }
+  return { minimum: lo, maximum: hi, step, major, minor, ...unit, decimals };
+}
+function formatValue(value, unit, decimals = 2, missingText = "NaN") {
+  if (!finite(value)) return missingText;
+  let v = value / unit.factor;
+  if (Math.abs(v) < 0.5 * 10 ** -decimals) v = 0;
+  return v.toFixed(decimals) + (unit.suffix ? " " + unit.suffix : "");
+}
+var formatterCache = /* @__PURE__ */ new Map();
+function zoneFormatter(zone) {
+  if (formatterCache.has(zone)) return formatterCache.get(zone);
+  let f;
+  try {
+    f = new Intl.DateTimeFormat("en-GB-u-ca-gregory-nu-latn", {
+      timeZone: zone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23"
+    });
+  } catch (e) {
+    throw new RangeError("Unsupported time zone: " + zone);
+  }
+  if (formatterCache.size >= 32)
+    formatterCache.delete(formatterCache.keys().next().value);
+  formatterCache.set(zone, f);
+  return f;
+}
+function utcFromParts(y, m, d, h = 0, mi = 0, s = 0) {
+  const t = /* @__PURE__ */ new Date(0);
+  t.setUTCFullYear(y, m - 1, d);
+  t.setUTCHours(h, mi, s, 0);
+  return t.getTime() / 1e3;
+}
+function wallParts(t, zone) {
+  if (zone === "UTC") {
+    const d = new Date(t * 1e3);
+    return {
+      year: d.getUTCFullYear(),
+      month: d.getUTCMonth() + 1,
+      day: d.getUTCDate(),
+      hour: d.getUTCHours(),
+      minute: d.getUTCMinutes(),
+      second: d.getUTCSeconds()
+    };
+  }
+  const r = {};
+  for (const p of zoneFormatter(zone).formatToParts(new Date(t * 1e3)))
+    if (p.type !== "literal") r[p.type] = Number(p.value);
+  if (r.hour === 24) r.hour = 0;
+  return r;
+}
+function wallEpoch(t, zone) {
+  const p = wallParts(t, zone);
+  return utcFromParts(p.year, p.month, p.day, p.hour, p.minute, p.second) + (t - Math.floor(t));
+}
+function offsetAt(t, zone) {
+  return Math.round(wallEpoch(t, zone) - t);
+}
+function localCandidates(w, zone) {
+  if (zone === "UTC") return [w];
+  const offsets = new Set(
+    [-172800, -86400, 0, 86400, 172800].map((d) => offsetAt(w + d, zone))
+  ), out = [];
+  for (const off of offsets) {
+    const t = w - off;
+    if (Math.abs(wallEpoch(t, zone) - w) < 1e-3) out.push(t);
+  }
+  return out.sort((a, b) => a - b);
+}
+function wallTicks(start, end, step, zone) {
+  if (zone === "UTC") return multiples(start, end, step);
+  const sa = wallEpoch(start, zone), sb = wallEpoch(end, zone), a = Math.floor(Math.min(sa, sb) / step) - 2, b = Math.ceil(Math.max(sa, sb) / step) + 2;
+  check(
+    finite(b - a) && b - a <= LIMITS.ticks && Math.abs(a) < 9e15 && Math.abs(b) < 9e15,
+    "Too many time ticks; increase the interval."
+  );
+  const offsets = /* @__PURE__ */ new Set();
+  const probe = Math.max(43200, (end - start) / 4096);
+  for (let t = start - 172800; t <= end + 172800; t += probe)
+    offsets.add(offsetAt(t, zone));
+  offsets.add(offsetAt(end, zone));
+  const out = /* @__PURE__ */ new Set();
+  for (let i = 0; i <= b - a; i++) {
+    const w = (a + i) * step;
+    for (const off of offsets) {
+      const t = w - off;
+      if (t >= start && t <= end && Math.abs(wallEpoch(t, zone) - w) < 1e-3)
+        out.add(t);
+    }
+  }
+  return [...out].sort((a2, b2) => a2 - b2);
+}
+function monthTicks(start, end, zone, stride = 1) {
+  const a = wallParts(start, zone), b = wallParts(end, zone), first = Math.floor((a.year * 12 + a.month - 1) / stride) * stride, last = b.year * 12 + b.month - 1 + stride;
+  check((last - first) / stride <= LIMITS.ticks, "Too many calendar ticks.");
+  const out = [];
+  for (let i = first; i <= last; i += stride) {
+    const y = Math.floor(i / 12), m = i % 12 + 1;
+    if (y < 1 || y > 9999) continue;
+    for (const t of localCandidates(utcFromParts(y, m, 1), zone))
+      if (t >= start && t <= end) out.push(t);
+  }
+  return out.sort((a2, b2) => a2 - b2);
+}
+var MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+var DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var pad = (v, n = 2) => String(v).padStart(n, "0");
+function formatTime(t, zone = "UTC", format = "%H:%M") {
+  t = epoch(t);
+  const p = wallParts(t, zone), d = new Date(utcFromParts(p.year, p.month, p.day) * 1e3), off = offsetAt(t, zone), day = d.getUTCDay();
+  const fields = {
+    H: pad(p.hour),
+    I: pad(p.hour % 12 || 12),
+    M: pad(p.minute),
+    S: pad(p.second),
+    d: pad(p.day),
+    e: String(p.day).padStart(2, " "),
+    m: pad(p.month),
+    Y: pad(p.year, 4),
+    y: pad(p.year % 100),
+    a: DAYS[day],
+    A: [
+      "Sunday",
+      "Monday",
+      "Tuesday",
+      "Wednesday",
+      "Thursday",
+      "Friday",
+      "Saturday"
+    ][day],
+    b: MONTHS[p.month - 1],
+    h: MONTHS[p.month - 1],
+    B: [
+      "January",
+      "February",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "August",
+      "September",
+      "October",
+      "November",
+      "December"
+    ][p.month - 1],
+    p: p.hour < 12 ? "AM" : "PM",
+    w: String(day),
+    u: String(day || 7),
+    j: pad(
+      Math.floor((d.getTime() / 1e3 - utcFromParts(p.year, 1, 1)) / 86400) + 1,
+      3
+    ),
+    z: (off < 0 ? "-" : "+") + pad(Math.floor(Math.abs(off) / 3600)) + pad(Math.floor(Math.abs(off) % 3600 / 60)),
+    Z: zone,
+    "%": "%"
+  };
+  fields.F = fields.Y + "-" + fields.m + "-" + fields.d;
+  fields.T = fields.H + ":" + fields.M + ":" + fields.S;
+  fields.R = fields.H + ":" + fields.M;
+  let out = "";
+  for (let i = 0; i < format.length; i++) {
+    if (format[i] !== "%") {
+      out += format[i];
+      continue;
+    }
+    const k = format[++i];
+    check(own(fields, k), "Unsupported date directive: %" + (k || ""));
+    out += fields[k];
+  }
+  return out;
+}
+function resolveX(a, start, end, width) {
+  const span = end - start, zone = a.timezone, mode = a.mode === "auto" ? span <= 172800 ? "daily" : span <= 864e3 ? "weekly" : span <= 5356800 ? "monthly" : "yearly" : a.mode;
+  let minor = [], major = [], labelTimes = [], format = "%H:%M";
+  if (mode === "yearly") {
+    const stride = span > 550 * 86400 ? Math.max(1, Math.ceil(span / (365.25 * 86400))) : 1;
+    format = stride > 1 ? "%b %Y" : "%b";
+    if (a.majorTicks === null || a.ticks === null) {
+      major = monthTicks(start, end, zone, stride);
+      labelTimes = major;
+    }
+    if (a.minorTicks === null) minor = monthTicks(start, end, zone, 1);
+    if (a.majorTicks === null && a.majorSeconds !== null)
+      major = wallTicks(start, end, a.majorSeconds, zone);
+    if (a.minorTicks === null && a.minorSeconds !== null)
+      minor = wallTicks(start, end, a.minorSeconds, zone);
+    if (a.ticks === null && a.labelSeconds !== null)
+      labelTimes = wallTicks(start, end, a.labelSeconds, zone);
+  } else {
+    let mi = 1800, ma = 7200, ls = 7200;
+    if (mode === "weekly") {
+      mi = 21600;
+      ma = ls = 86400;
+      format = "%d";
+    }
+    if (mode === "monthly") {
+      mi = 86400;
+      ma = ls = 604800;
+      format = "%d %b";
+    }
+    if (a.mode === "auto" && span < 43200) {
+      const target = span / Math.max(2, Math.floor(width / 48));
+      ls = [1, 5, 10, 15, 30, 60, 120, 300, 600, 900, 1800, 3600, 7200].find(
+        (v) => v >= target
+      ) || 7200;
+      mi = Math.max(1, ls / 4);
+      ma = ls;
+      if (ls < 60) format = "%H:%M:%S";
+    }
+    mi = Math.max(mi, span / 2e3);
+    if (a.minorSeconds !== null) mi = a.minorSeconds;
+    if (a.majorSeconds !== null) ma = a.majorSeconds;
+    if (a.labelSeconds !== null) ls = a.labelSeconds;
+    if (a.minorTicks === null) minor = wallTicks(start, end, mi, zone);
+    if (a.majorTicks === null) major = wallTicks(start, end, ma, zone);
+    if (a.ticks === null) labelTimes = wallTicks(start, end, ls, zone);
+  }
+  if (a.minorTicks !== null)
+    minor = a.minorTicks.filter((v) => v >= start && v <= end);
+  if (a.majorTicks !== null)
+    major = a.majorTicks.filter((v) => v >= start && v <= end);
+  if (a.labelFormat !== null) format = a.labelFormat;
+  let labels = [];
+  if (a.ticks !== null)
+    labels = a.ticks.filter((v) => v.time >= start && v.time <= end);
+  else if (mode === "weekly" && a.labelSeconds === null && a.labelOffsetSeconds === 0) {
+    for (const t of wallTicks(start - 172800, end, 86400, zone)) {
+      const w = wallEpoch(t, zone), next = localCandidates(w + 86400, zone);
+      if (t < start || !next.length || next[next.length - 1] > end) continue;
+      for (const noon of localCandidates(w + 43200, zone))
+        if (noon >= start && noon <= end)
+          labels.push({ time: noon, label: formatTime(t, zone, format) });
+    }
+  } else
+    for (const t of labelTimes) {
+      const pos = t + a.labelOffsetSeconds;
+      if (pos >= start && pos <= end)
+        labels.push({ time: pos, label: formatTime(t, zone, format) });
+    }
+  labels.sort((a2, b) => a2.time - b.time);
+  if (a.ticks === null && mode === "daily" && span <= 95040) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const t of labels) {
+      if (!seen.has(t.label)) seen.set(t.label, /* @__PURE__ */ new Set());
+      seen.get(t.label).add(offsetAt(t.time, zone));
+    }
+    labels = labels.map(
+      (t) => seen.get(t.label).size > 1 ? {
+        time: t.time,
+        label: t.label + " " + formatTime(t.time, zone, "%z")
+      } : t
+    );
+  }
+  const majorSet = new Set(major);
+  minor = minor.filter((v) => !majorSet.has(v));
+  return { minor, major, labels, mode };
+}
+function timeRange(c) {
+  let start = Infinity, end = -Infinity;
+  for (const s of c.series)
+    if (s.timestamps.length) {
+      start = Math.min(start, s.timestamps[0]);
+      end = Math.max(end, s.timestamps[s.timestamps.length - 1]);
+    }
+  if (c.timeAxis.start !== null) start = c.timeAxis.start;
+  if (c.timeAxis.end !== null) end = c.timeAxis.end;
+  if (start === end && c.timeAxis.start === null && c.timeAxis.end === null) {
+    start -= 150;
+    end += 150;
+  }
+  epoch(start);
+  epoch(end);
+  check(
+    end > start,
+    "Empty data needs explicit start and end; range must be nonzero."
+  );
+  return [start, end];
+}
+var PIXEL_GLYPHS = {
+  " ": ["00000", "00000", "00000", "00000", "00000", "00000", "00000"],
+  "0": ["01110", "10001", "10011", "10101", "11001", "10001", "01110"],
+  "1": ["00100", "01100", "00100", "00100", "00100", "00100", "01110"],
+  "2": ["01110", "10001", "00001", "00010", "00100", "01000", "11111"],
+  "3": ["11110", "00001", "00001", "01110", "00001", "00001", "11110"],
+  "4": ["00010", "00110", "01010", "10010", "11111", "00010", "00010"],
+  "5": ["11111", "10000", "10000", "11110", "00001", "00001", "11110"],
+  "6": ["01110", "10000", "10000", "11110", "10001", "10001", "01110"],
+  "7": ["11111", "00001", "00010", "00100", "01000", "01000", "01000"],
+  "8": ["01110", "10001", "10001", "01110", "10001", "10001", "01110"],
+  "9": ["01110", "10001", "10001", "01111", "00001", "00001", "01110"],
+  A: ["01110", "10001", "10001", "11111", "10001", "10001", "10001"],
+  B: ["11110", "10001", "10001", "11110", "10001", "10001", "11110"],
+  C: ["01111", "10000", "10000", "10000", "10000", "10000", "01111"],
+  D: ["11110", "10001", "10001", "10001", "10001", "10001", "11110"],
+  E: ["11111", "10000", "10000", "11110", "10000", "10000", "11111"],
+  F: ["11111", "10000", "10000", "11110", "10000", "10000", "10000"],
+  G: ["01110", "10001", "10000", "10111", "10001", "10001", "01111"],
+  H: ["10001", "10001", "10001", "11111", "10001", "10001", "10001"],
+  I: ["01110", "00100", "00100", "00100", "00100", "00100", "01110"],
+  J: ["00111", "00010", "00010", "00010", "00010", "10010", "01100"],
+  K: ["10001", "10010", "10100", "11000", "10100", "10010", "10001"],
+  L: ["10000", "10000", "10000", "10000", "10000", "10000", "11111"],
+  M: ["10001", "11011", "10101", "10101", "10001", "10001", "10001"],
+  N: ["10001", "11001", "10101", "10011", "10001", "10001", "10001"],
+  O: ["01110", "10001", "10001", "10001", "10001", "10001", "01110"],
+  P: ["11110", "10001", "10001", "11110", "10000", "10000", "10000"],
+  Q: ["01110", "10001", "10001", "10001", "10101", "10010", "01101"],
+  R: ["11110", "10001", "10001", "11110", "10100", "10010", "10001"],
+  S: ["01111", "10000", "10000", "01110", "00001", "00001", "11110"],
+  T: ["11111", "00100", "00100", "00100", "00100", "00100", "00100"],
+  U: ["10001", "10001", "10001", "10001", "10001", "10001", "01110"],
+  V: ["10001", "10001", "10001", "10001", "10001", "01010", "00100"],
+  W: ["10001", "10001", "10001", "10101", "10101", "11011", "10001"],
+  X: ["10001", "10001", "01010", "00100", "01010", "10001", "10001"],
+  Y: ["10001", "10001", "01010", "00100", "00100", "00100", "00100"],
+  Z: ["11111", "00001", "00010", "00100", "01000", "10000", "11111"],
+  a: ["00000", "00000", "01110", "00001", "01111", "10001", "01111"],
+  b: ["10000", "10000", "10110", "11001", "10001", "10001", "11110"],
+  c: ["00000", "00000", "01111", "10000", "10000", "10000", "01111"],
+  d: ["00001", "00001", "01101", "10011", "10001", "10001", "01111"],
+  e: ["00000", "00000", "01110", "10001", "11111", "10000", "01110"],
+  f: ["00110", "01001", "01000", "11100", "01000", "01000", "01000"],
+  g: ["00000", "01111", "10001", "10001", "01111", "00001", "01110"],
+  h: ["10000", "10000", "10110", "11001", "10001", "10001", "10001"],
+  i: ["00100", "00000", "01100", "00100", "00100", "00100", "01110"],
+  j: ["00010", "00000", "00110", "00010", "00010", "10010", "01100"],
+  k: ["10000", "10000", "10010", "10100", "11000", "10100", "10010"],
+  l: ["01100", "00100", "00100", "00100", "00100", "00100", "01110"],
+  m: ["00000", "00000", "11010", "10101", "10101", "10101", "10101"],
+  n: ["00000", "00000", "10110", "11001", "10001", "10001", "10001"],
+  o: ["00000", "00000", "01110", "10001", "10001", "10001", "01110"],
+  p: ["00000", "00000", "11110", "10001", "11110", "10000", "10000"],
+  q: ["00000", "00000", "01111", "10001", "01111", "00001", "00001"],
+  r: ["00000", "00000", "10111", "11000", "10000", "10000", "10000"],
+  s: ["00000", "00000", "01111", "10000", "01110", "00001", "11110"],
+  t: ["01000", "01000", "11100", "01000", "01000", "01001", "00110"],
+  u: ["00000", "00000", "10001", "10001", "10001", "10011", "01101"],
+  v: ["00000", "00000", "10001", "10001", "10001", "01010", "00100"],
+  w: ["00000", "00000", "10001", "10001", "10101", "10101", "01010"],
+  x: ["00000", "00000", "10001", "01010", "00100", "01010", "10001"],
+  y: ["00000", "00000", "10001", "10001", "01111", "00001", "01110"],
+  z: ["00000", "00000", "11111", "00010", "00100", "01000", "11111"],
+  "-": ["00000", "00000", "00000", "11111", "00000", "00000", "00000"],
+  _: ["00000", "00000", "00000", "00000", "00000", "00000", "11111"],
+  ":": ["00000", "00100", "00100", "00000", "00100", "00100", "00000"],
+  ".": ["00000", "00000", "00000", "00000", "00000", "00100", "00100"],
+  ",": ["00000", "00000", "00000", "00000", "00100", "00100", "01000"],
+  "/": ["00001", "00010", "00010", "00100", "01000", "01000", "10000"],
+  "\\": ["10000", "01000", "01000", "00100", "00010", "00010", "00001"],
+  "(": ["00010", "00100", "01000", "01000", "01000", "00100", "00010"],
+  ")": ["01000", "00100", "00010", "00010", "00010", "00100", "01000"],
+  "[": ["01110", "01000", "01000", "01000", "01000", "01000", "01110"],
+  "]": ["01110", "00010", "00010", "00010", "00010", "00010", "01110"],
+  "+": ["00000", "00100", "00100", "11111", "00100", "00100", "00000"],
+  "=": ["00000", "00000", "11111", "00000", "11111", "00000", "00000"],
+  "%": ["11001", "11010", "00010", "00100", "01000", "01011", "10011"],
+  "?": ["01110", "10001", "00001", "00010", "00100", "00000", "00100"],
+  "!": ["00100", "00100", "00100", "00100", "00100", "00000", "00100"],
+  "#": ["01010", "01010", "11111", "01010", "11111", "01010", "01010"],
+  "*": ["00000", "10101", "01110", "11111", "01110", "10101", "00000"],
+  "<": ["00010", "00100", "01000", "10000", "01000", "00100", "00010"],
+  ">": ["01000", "00100", "00010", "00001", "00010", "00100", "01000"],
+  "|": ["00100", "00100", "00100", "00100", "00100", "00100", "00100"],
+  '"': ["01010", "01010", "00000", "00000", "00000", "00000", "00000"],
+  "'": ["00100", "00100", "00000", "00000", "00000", "00000", "00000"],
+  ";": ["00000", "00100", "00100", "00000", "00100", "00100", "01000"],
+  "@": ["01110", "10001", "10111", "10101", "10111", "10000", "01111"],
+  $: ["00100", "01111", "10100", "01110", "00101", "11110", "00100"],
+  "&": ["01100", "10010", "10100", "01000", "10101", "10010", "01101"],
+  "^": ["00100", "01010", "10001", "00000", "00000", "00000", "00000"],
+  "`": ["01000", "00100", "00000", "00000", "00000", "00000", "00000"],
+  "~": ["00000", "00000", "01001", "10110", "00000", "00000", "00000"],
+  "{": ["00011", "00100", "00100", "01000", "00100", "00100", "00011"],
+  "}": ["11000", "00100", "00100", "00010", "00100", "00100", "11000"]
+};
+function createCanvas(w, h) {
+  let canvas;
+  if (typeof document !== "undefined" && document.createElement)
+    canvas = document.createElement("canvas");
+  else if (typeof OffscreenCanvas !== "undefined")
+    canvas = new OffscreenCanvas(w, h);
+  else
+    throw new Error(
+      'System fonts need Canvas 2D. Use fonts: { mode: "bitmap" } in a DOM-free runtime.'
+    );
+  canvas.width = w;
+  canvas.height = h;
+  return canvas;
+}
+function wide(ch) {
+  const n = ch.codePointAt(0);
+  return n >= 4352 && (n <= 4447 || n >= 11904 && n <= 42191 || n >= 44032 && n <= 55203 || n >= 63744 && n <= 64255 || n >= 65280 && n <= 65376 || n >= 127744);
+}
+var Fonts = class {
+  config;
+  theme;
+  cache;
+  canvas;
+  ctx;
+  constructor(config, theme) {
+    this.config = config;
+    this.theme = theme;
+    this.cache = /* @__PURE__ */ new Map();
+    if (config.mode === "system") {
+      this.canvas = createCanvas(8, 8);
+      const ctx = this.canvas.getContext("2d", {
+        willReadFrequently: true
+      });
+      check(ctx, "Canvas 2D is unavailable.");
+      this.ctx = ctx;
+    }
+  }
+  size(role, scale = 1) {
+    return this.theme[`${role}Size`] * scale;
+  }
+  family(role) {
+    return (role === "title" || role === "unit" || role === "caption" ? this.config[`${role}Family`] : null) || this.config.family;
+  }
+  setup(role, size) {
+    this.ctx.font = (role === "caption" ? "bold " : "") + size + "px " + this.family(role);
+    this.ctx.textBaseline = "alphabetic";
+    this.ctx.fillStyle = "#000000";
+    if ("fontKerning" in this.ctx) this.ctx.fontKerning = "none";
+  }
+  width(value, role, advance = 0, scale = 1) {
+    if (advance > 0)
+      return [...value].reduce((n, ch) => n + advance * (wide(ch) ? 2 : 1), 0);
+    if (this.config.mode === "bitmap")
+      return [...value].length * this.size(role, scale) * 0.6;
+    this.setup(role, this.size(role, scale));
+    return this.ctx.measureText(value).width;
+  }
+  fit(value, maxWidth, role, advance, scale = 1) {
+    if (this.width(value, role, advance, scale) <= maxWidth) return value;
+    const end = "...";
+    if (this.width(end, role, advance, scale) > maxWidth) return "";
+    const a = [...value];
+    while (a.length && this.width(a.join("") + end, role, advance, scale) > maxWidth)
+      a.pop();
+    return a.join("") + end;
+  }
+  raster(value, role, advance = 0, scale = 1) {
+    const key = JSON.stringify([value, role, advance, scale]);
+    if (this.cache.has(key)) return this.cache.get(key);
+    const size = this.size(role, scale), w = Math.max(1, Math.ceil(this.width(value, role, advance, scale)) + 4);
+    let out;
+    check(
+      w <= 32768 && w * size < LIMITS.pixels,
+      "Text allocation limit exceeded."
+    );
+    if (this.config.mode === "bitmap") {
+      const h = Math.max(1, round(size * 0.72));
+      out = new Surface(w, h + 2);
+      let x = 1;
+      for (const ch of value) {
+        let rows = PIXEL_GLYPHS[ch];
+        if (!rows) {
+          check(
+            !this.config.strictGlyphs,
+            "Bitmap text supports printable ASCII only: " + ch
+          );
+          rows = PIXEL_GLYPHS["?"];
+        }
+        const cell = advance > 0 ? advance : size * 0.6, gw = Math.max(1, Math.min(round(size * 0.5), Math.floor(cell) - 1));
+        for (let yy = 0; yy < h; yy++)
+          for (let xx = 0; xx < gw; xx++)
+            if (rows[Math.min(6, Math.floor(yy / h * 7))][Math.min(4, Math.floor(xx / gw * 5))] === "1")
+              out.pixel(round(x) + xx, yy + 1, [0, 0, 0, 255]);
+        x += cell * (wide(ch) ? 2 : 1);
+      }
+    } else {
+      this.setup(role, size);
+      const metric = this.ctx.measureText(value || "0");
+      const ascent = Math.ceil(metric.actualBoundingBoxAscent || size * 0.8), descent = Math.ceil(metric.actualBoundingBoxDescent || 0), h = Math.max(1, ascent + descent) + 2;
+      this.canvas.width = w;
+      this.canvas.height = h;
+      this.setup(role, size);
+      let x = 1;
+      for (const ch of value) {
+        this.ctx.fillText(ch, round(x), 1 + ascent);
+        x += advance > 0 ? advance * (wide(ch) ? 2 : 1) : this.ctx.measureText(ch).width;
+      }
+      const d = this.ctx.getImageData(0, 0, w, h);
+      out = new Surface(w, h);
+      out.data.set(d.data);
+    }
+    if (this.cache.size >= 512)
+      this.cache.delete(this.cache.keys().next().value);
+    this.cache.set(key, out);
+    return out;
+  }
+  draw(im, x, y, value, role, fill, advance = 0, align = "left", centerY = false, scale = 1) {
+    if (!value) return;
+    const r = this.raster(value, role, advance, scale), width = this.width(value, role, advance, scale);
+    if (align === "center") x -= width / 2;
+    else if (align === "right") x -= width;
+    if (centerY) y -= (r.height - 2) / 2;
+    const xx = round(x) - 1, yy = round(y) - 1, p = [fill[0], fill[1], fill[2], 0];
+    for (let sy = 0; sy < r.height; sy++)
+      for (let sx = 0; sx < r.width; sx++) {
+        const a = r.data[(sy * r.width + sx) * 4 + 3];
+        if (a) {
+          p[3] = round(a * fill[3] / 255);
+          im.pixel(xx + sx, yy + sy, p, true);
+        }
+      }
+  }
+  rotated(value, role, fill, clockwise = false) {
+    const r = this.raster(value, role), out = new Surface(r.height, r.width), p = [fill[0], fill[1], fill[2], 0];
+    for (let y = 0; y < r.height; y++)
+      for (let x = 0; x < r.width; x++) {
+        p[3] = round(r.data[(y * r.width + x) * 4 + 3] * fill[3] / 255);
+        if (p[3])
+          out.pixel(
+            clockwise ? r.height - 1 - y : y,
+            clockwise ? x : r.width - 1 - x,
+            p
+          );
+      }
+    return out;
+  }
+};
+function renderChart(c) {
+  const l = c.layout, t = c.theme, [width, height] = dimensions(c), left = l.left, top = l.top, right = l.width - l.right, bottom = l.top + l.plotHeight, pw = right - left, ph = bottom - top;
+  const [start, end] = timeRange(c);
+  const runs = c.series.map((s) => visibleRuns(s, start, end));
+  let loData = Infinity, hiData = -Infinity;
+  for (let i = 0; i < runs.length; i++) {
+    for (const run of runs[i])
+      for (const p of run) {
+        check(finite(p[1]), "Interpolated value overflow.");
+        loData = Math.min(loData, p[1]);
+        hiData = Math.max(hiData, p[1]);
+      }
+    if (c.series[i].kind === "area") {
+      loData = Math.min(loData, c.series[i].baseline);
+      hiData = Math.max(hiData, c.series[i].baseline);
+    }
+  }
+  if (loData === Infinity) loData = hiData = 0;
+  const ys = resolveY(c.yAxis, loData, hiData), xs = resolveX(c.timeAxis, start, end, pw), fonts = new Fonts(c.fonts, t), im = new Surface(width, height, t.background);
+  im.rect(left, top, right + 1, bottom + 1, t.canvas);
+  const xx = (v) => (v - start) / (end - start) * pw, yy = (v) => ph * (1 - (v / (ys.maximum - ys.minimum) - ys.minimum / (ys.maximum - ys.minimum)));
+  const projected = runs.map(
+    (rr) => rr.map(
+      (r) => decimate(r, start, end, pw).map((p) => {
+        const x = xx(p[0]), y = yy(p[1]);
+        check(
+          finite(x) && finite(y) && Math.abs(y) < 1e15,
+          "Data magnitude is too large relative to the Y axis."
+        );
+        return [x, y];
+      })
+    )
+  );
+  function grid() {
+    const lay = new Surface(pw + 1, ph + 1);
+    for (const [values, col] of [
+      [ys.minor, t.minorGrid],
+      [ys.major, t.majorGrid]
+    ])
+      for (const v of values) {
+        const y = round(yy(v));
+        if (y >= 0 && y <= ph) lay.dashed([0, y], [pw, y], col, t.gridDash);
+      }
+    for (const [values, col] of [
+      [xs.minor, t.minorGrid],
+      [xs.major, t.majorGrid]
+    ])
+      for (const v of values) {
+        const x = round(xx(v));
+        lay.dashed([x, 0], [x, ph], col, t.gridDash);
+      }
+    im.over(lay, left, top);
+  }
+  const aa = l.antialias, layerWidth = (pw + 1) * aa, layerHeight = (ph + 1) * aa;
+  if (!t.gridFront) grid();
+  for (let i = 0; i < c.series.length; i++) {
+    const s = c.series[i];
+    if (s.kind !== "area") continue;
+    const base = yy(s.baseline);
+    check(
+      finite(base) && Math.abs(base) < 1e15,
+      "Baseline magnitude is too large."
+    );
+    const layer = new Surface(layerWidth, layerHeight);
+    for (const ps of projected[i])
+      if (ps.length > 1) {
+        const poly = clipPolygon(
+          [[ps[0][0], base], ...ps, [ps[ps.length - 1][0], base]],
+          pw,
+          ph
+        ).map((p) => [round(p[0] * aa), round(p[1] * aa)]);
+        layer.polygon(poly, s.color);
+      }
+    im.over(layer.down(aa), left, top);
+  }
+  if (t.gridFront) grid();
+  for (let i = 0; i < c.series.length; i++) {
+    const s = c.series[i], col = s.kind === "line" ? s.color : s.outline;
+    if (col === null) continue;
+    const layer = new Surface(layerWidth, layerHeight), lw = Math.max(1, round(s.lineWidth * aa));
+    for (const ps of projected[i]) {
+      if (ps.length === 1) {
+        const p = ps[0];
+        if (p[0] >= 0 && p[0] <= pw && p[1] >= 0 && p[1] <= ph)
+          layer.circle(p[0] * aa, p[1] * aa, Math.max(aa / 2, lw / 2), col);
+      }
+      for (let k = 1; k < ps.length; k++) {
+        const seg = clipLine(ps[k - 1], ps[k], pw, ph);
+        if (seg)
+          layer.line(
+            [round(seg[0][0] * aa), round(seg[0][1] * aa)],
+            [round(seg[1][0] * aa), round(seg[1][1] * aa)],
+            col,
+            lw
+          );
+      }
+    }
+    im.over(layer.down(aa), left, top);
+  }
+  const rules = new Surface(pw + 1, ph + 1);
+  for (const r of c.hRules)
+    if (r.value >= ys.minimum && r.value <= ys.maximum)
+      rules.dashed(
+        [0, round(yy(r.value))],
+        [pw, round(yy(r.value))],
+        r.color,
+        r.dash,
+        Math.max(1, round(r.width))
+      );
+  for (const r of c.vRules)
+    if (r.time >= start && r.time <= end)
+      rules.dashed(
+        [round(xx(r.time)), 0],
+        [round(xx(r.time)), ph],
+        r.color,
+        r.dash,
+        Math.max(1, round(r.width))
+      );
+  im.over(rules, left, top);
+  im.line([left, top - 3], [left, bottom + 4], t.axis);
+  im.line([left - 4, bottom], [right + 4, bottom], t.axis);
+  im.polygon(
+    [
+      [left, top - 5],
+      [left - 3, top],
+      [left + 3, top]
+    ],
+    t.arrow
+  );
+  im.polygon(
+    [
+      [right + 7, bottom],
+      [right + 2, bottom - 3],
+      [right + 2, bottom + 3]
+    ],
+    t.arrow
+  );
+  for (const v of ys.major) {
+    const y = top + yy(v), unit = v === 0 && !c.yAxis.showZeroSuffix ? { factor: ys.factor, suffix: "" } : ys, label = formatValue(v, unit, ys.decimals);
+    check(
+      fonts.width(label, "axis", t.axisAdvance) <= left - l.yLabelGap - 20,
+      "Y labels overlap the vertical label. Increase layout.left or adjust units."
+    );
+    im.line([left - 3, round(y)], [left, round(y)], t.axis);
+    fonts.draw(
+      im,
+      left - l.yLabelGap,
+      y,
+      label,
+      "axis",
+      t.text,
+      t.axisAdvance,
+      "right",
+      true
+    );
+  }
+  const xLabels = [];
+  let lastRight = -Infinity;
+  for (const tick of xs.labels) {
+    const x = left + xx(tick.time), tw = fonts.width(tick.label, "axis", t.axisAdvance), a = x - tw / 2, b = x + tw / 2;
+    if (c.timeAxis.ticks === null && a < lastRight + 3) continue;
+    if (a < 2 || b > width - 3) continue;
+    im.line(
+      [round(x), bottom],
+      [round(x), bottom + 3],
+      [t.majorGrid[0], t.majorGrid[1], t.majorGrid[2], 255]
+    );
+    fonts.draw(
+      im,
+      x,
+      bottom + l.xLabelGap,
+      tick.label,
+      "axis",
+      t.text,
+      t.axisAdvance,
+      "center"
+    );
+    lastRight = b;
+    xLabels.push({ ...tick, x });
+  }
+  const titleX = (left + right) / 2 + l.titleOffsetX, title = fonts.fit(
+    c.title,
+    2 * Math.min(titleX - 5, width - 14 - titleX),
+    "title",
+    t.titleAdvance
+  );
+  fonts.draw(
+    im,
+    titleX,
+    l.titleY,
+    title,
+    "title",
+    t.text,
+    t.titleAdvance,
+    "center"
+  );
+  if (c.verticalLabel) {
+    const unit = fonts.rotated(c.verticalLabel, "unit", t.text);
+    check(
+      unit.height <= ph + 18 && l.unitX + unit.width <= left - l.yLabelGap,
+      "Vertical label does not fit."
+    );
+    im.over(unit, l.unitX, round((top + bottom - unit.height) / 2));
+  }
+  if (c.watermark) {
+    const mark = fonts.rotated(c.watermark, "watermark", t.watermark, true);
+    check(
+      mark.height <= height - 8 && mark.width <= l.right - 9,
+      "Watermark does not fit."
+    );
+    im.over(mark, width - mark.width - 4, 4);
+  }
+  const stats = c.series.map((s) => statistics(s, start, end));
+  if (l.legend !== "none") {
+    const scale = Math.min(1, (width - 40) / 555), advance = t.legendAdvance * scale, ll = l.legendLayout, factor = ll.autoScaleColumns ? (width - ll.nameX) / (ll.referenceWidth - ll.nameX) : 1, anchor = (x) => ll.nameX + (x - ll.nameX) * factor;
+    c.series.forEach((s, i) => {
+      const pairs = l.legend === "aligned" ? ll.aligned : l.legend === "reference" && i === c.series.length - 1 && i > 0 ? ll.expanded : ll.compact, y = bottom + l.legendGap + i * l.legendRowHeight;
+      check(
+        ll.swatchHeight <= l.legendRowHeight && ll.swatchX + ll.swatchWidth < width && y + ll.swatchHeight <= height - 2,
+        "Legend swatch does not fit."
+      );
+      im.rect(
+        ll.swatchX,
+        y,
+        ll.swatchX + ll.swatchWidth,
+        y + ll.swatchHeight,
+        t.frame
+      );
+      const swatch = new Surface(
+        ll.swatchWidth - 2,
+        ll.swatchHeight - 2,
+        s.color
+      );
+      im.over(swatch, ll.swatchX + 1, y + 1);
+      const name = fonts.fit(
+        s.name,
+        anchor(pairs[0][0]) - ll.nameX - 12,
+        "legend",
+        advance,
+        scale
+      );
+      fonts.draw(
+        im,
+        ll.nameX,
+        y,
+        name,
+        "legend",
+        t.text,
+        advance,
+        "left",
+        false,
+        scale
+      );
+      const display = s.legendValues || stats[i];
+      ["current", "average", "maximum"].forEach((key, j) => {
+        const label = c.legendLabels[j], value = formatValue(
+          display[key],
+          ys,
+          c.yAxis.legendDecimals,
+          c.missingLabel
+        ), a = anchor(pairs[j][0]), b = anchor(pairs[j][1]);
+        check(b < width - 3, "Legend column is outside the panel.");
+        check(
+          fonts.width(label, "legend", advance, scale) + fonts.width(value, "legend", advance, scale) + 7 * scale <= b - a + 1,
+          "Legend statistic does not fit. Increase width, adjust anchors or reduce legendDecimals."
+        );
+        fonts.draw(
+          im,
+          a,
+          y,
+          label,
+          "legend",
+          t.text,
+          advance,
+          "left",
+          false,
+          scale
+        );
+        fonts.draw(
+          im,
+          b,
+          y,
+          value,
+          "legend",
+          t.text,
+          advance,
+          "right",
+          false,
+          scale
+        );
+      });
+    });
+  }
+  for (const [a, b] of [
+    [
+      [0, 0],
+      [width - 1, 0]
+    ],
+    [
+      [1, 1],
+      [width - 2, 1]
+    ],
+    [
+      [0, 0],
+      [0, height - 1]
+    ],
+    [
+      [1, 1],
+      [1, height - 2]
+    ]
+  ])
+    im.line(a, b, t.shadeLight);
+  for (const [a, b] of [
+    [
+      [width - 2, 1],
+      [width - 2, height - 1]
+    ],
+    [
+      [width - 1, 0],
+      [width - 1, height - 1]
+    ],
+    [
+      [1, height - 2],
+      [width - 1, height - 2]
+    ],
+    [
+      [0, height - 1],
+      [width - 1, height - 1]
+    ]
+  ])
+    im.line(a, b, t.shadeDark);
+  for (let i = 3; i < im.data.length; i += 4) im.data[i] = 255;
+  const out = im.scale(l.pixelScale);
+  const metadata = {
+    version: VERSION,
+    imageSize: [out.width, out.height],
+    logicalSize: [width, height],
+    plotBox: [left, top, right, bottom],
+    pixelScale: l.pixelScale,
+    title: c.title,
+    verticalLabel: c.verticalLabel,
+    watermark: c.watermark,
+    timeRange: [start, end],
+    timezone: c.timeAxis.timezone,
+    timeMode: xs.mode,
+    yRange: [ys.minimum, ys.maximum],
+    yStep: ys.step,
+    yUnit: { factor: ys.factor, suffix: ys.suffix },
+    xLabels,
+    statistics: stats,
+    statisticsPolicy: "inclusive viewport; original sample arithmetic mean; current includes final missing sample",
+    font: {
+      mode: c.fonts.mode,
+      family: c.fonts.mode === "system" ? c.fonts.family : null,
+      pixelAlphabet: c.fonts.mode === "bitmap" ? "ascii-5x7-v1" : null
+    },
+    layout: clone(l),
+    theme: clone(t),
+    warnings: c.fonts.mode === "system" ? ["System font selection and glyph rasterization depend on the host."] : []
+  };
+  return new RenderResult(out, metadata);
+}
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let j = 0; j < 8; j++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[i] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(bytes) {
+  let c = 4294967295;
+  for (const b of bytes) c = CRC_TABLE[(c ^ b) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function adler32(bytes) {
+  let a = 1, b = 0;
+  for (let i = 0; i < bytes.length; ) {
+    const end = Math.min(i + 5552, bytes.length);
+    for (; i < end; i++) {
+      a += bytes[i];
+      b += a;
+    }
+    a %= 65521;
+    b %= 65521;
+  }
+  return (b << 16 | a) >>> 0;
+}
+function concat(parts) {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let at = 0;
+  for (const p of parts) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+function u32(n) {
+  return new Uint8Array([
+    n >>> 24 & 255,
+    n >>> 16 & 255,
+    n >>> 8 & 255,
+    n & 255
+  ]);
+}
+function chunk(type, data) {
+  const code = Uint8Array.from(type, (c) => c.charCodeAt(0)), body = concat([code, data]);
+  return concat([u32(data.length), body, u32(crc32(body))]);
+}
+function reverseBits(n, bits) {
+  let out = 0;
+  for (let i = 0; i < bits; i++) {
+    out = out << 1 | n & 1;
+    n >>>= 1;
+  }
+  return out;
+}
+var FIXED = (() => {
+  const out = [];
+  for (let i = 0; i < 288; i++) {
+    let code, bits;
+    if (i <= 143) {
+      bits = 8;
+      code = 48 + i;
+    } else if (i <= 255) {
+      bits = 9;
+      code = 400 + i - 144;
+    } else if (i <= 279) {
+      bits = 7;
+      code = i - 256;
+    } else {
+      bits = 8;
+      code = 192 + i - 280;
+    }
+    out.push([reverseBits(code, bits), bits]);
+  }
+  return out;
+})();
+var LEN_BASE = [
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  13,
+  15,
+  17,
+  19,
+  23,
+  27,
+  31,
+  35,
+  43,
+  51,
+  59,
+  67,
+  83,
+  99,
+  115,
+  131,
+  163,
+  195,
+  227,
+  258
+];
+var LEN_EXTRA = [
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0
+];
+var DIST_BASE = [
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577
+];
+var DIST_EXTRA = [
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13
+];
+function deflate(data) {
+  let bytes = new Uint8Array(Math.max(128, data.length + 64)), len = 0, buffer = 0, count = 0;
+  function byte(b) {
+    if (len === bytes.length) {
+      const next = new Uint8Array(bytes.length * 2);
+      next.set(bytes);
+      bytes = next;
+    }
+    bytes[len++] = b;
+  }
+  function bits(value, n) {
+    buffer |= value << count;
+    count += n;
+    while (count >= 8) {
+      byte(buffer & 255);
+      buffer >>>= 8;
+      count -= 8;
+    }
+  }
+  const sym = (v) => bits(FIXED[v][0], FIXED[v][1]);
+  byte(120);
+  byte(1);
+  bits(3, 3);
+  const head = new Int32Array(65536).fill(-1), prev = new Int32Array(32768).fill(-1);
+  const hash = (i) => (data[i] * 251 + data[i + 1]) * 251 + data[i + 2] & 65535;
+  function insert(i) {
+    if (i + 2 >= data.length) return;
+    const h = hash(i);
+    prev[i & 32767] = head[h];
+    head[h] = i;
+  }
+  for (let i = 0; i < data.length; ) {
+    let best = 0, dist = 0;
+    if (i + 2 < data.length) {
+      let candidate = head[hash(i)], tries = 64;
+      const max = Math.min(258, data.length - i);
+      while (candidate >= 0 && i - candidate <= 32768 && candidate < i && tries--) {
+        if (data[candidate] === data[i] && data[candidate + best] === data[i + best]) {
+          let n = 0;
+          while (n < max && data[candidate + n] === data[i + n]) n++;
+          if (n > best && n >= 3) {
+            best = n;
+            dist = i - candidate;
+            if (n === max) break;
+          }
+        }
+        const next = prev[candidate & 32767];
+        if (next >= candidate) break;
+        candidate = next;
+      }
+    }
+    if (best >= 3) {
+      let lc = 0;
+      while (lc < 28 && LEN_BASE[lc + 1] <= best) lc++;
+      sym(257 + lc);
+      bits(best - LEN_BASE[lc], LEN_EXTRA[lc]);
+      let dc = 0;
+      while (dc < 29 && DIST_BASE[dc + 1] <= dist) dc++;
+      bits(reverseBits(dc, 5), 5);
+      bits(dist - DIST_BASE[dc], DIST_EXTRA[dc]);
+      for (let j = 0; j < best; j++) insert(i + j);
+      i += best;
+    } else {
+      sym(data[i]);
+      insert(i);
+      i++;
+    }
+  }
+  sym(256);
+  if (count) byte(buffer & 255);
+  const sum = adler32(data);
+  for (const b of u32(sum)) byte(b);
+  return bytes.slice(0, len);
+}
+function paeth(a, b, c) {
+  const p = a + b - c, pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);
+  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+function encodePNG(image, metadata = null) {
+  validateImage(image);
+  check(
+    image.width * image.height <= LIMITS.pixels,
+    "PNG image exceeds output limit."
+  );
+  const w = image.width, h = image.height, stride = w * 4, raw = new Uint8Array((stride + 1) * h), candidates = Array.from({ length: 5 }, () => new Uint8Array(stride));
+  for (let y = 0; y < h; y++) {
+    const scores = [0, 0, 0, 0, 0], off = y * stride;
+    for (let x = 0; x < stride; x++) {
+      const v = image.data[off + x], a = x >= 4 ? image.data[off + x - 4] : 0, b = y ? image.data[off + x - stride] : 0, c = y && x >= 4 ? image.data[off + x - stride - 4] : 0, predict = [0, a, b, Math.floor((a + b) / 2), paeth(a, b, c)];
+      for (let f = 0; f < 5; f++) {
+        const n = v - predict[f] & 255;
+        candidates[f][x] = n;
+        scores[f] += Math.min(n, 256 - n);
+      }
+    }
+    let best = 0;
+    for (let f = 1; f < 5; f++) if (scores[f] < scores[best]) best = f;
+    raw[y * (stride + 1)] = best;
+    raw.set(candidates[best], y * (stride + 1) + 1);
+  }
+  const ihdr = concat([u32(w), u32(h), new Uint8Array([8, 6, 0, 0, 0])]), parts = [
+    new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]),
+    chunk("IHDR", ihdr),
+    chunk("sRGB", new Uint8Array([0]))
+  ];
+  if (metadata !== null) {
+    const json = JSON.stringify(metadata);
+    check(json.length <= 1048576, "PNG metadata is too large.");
+    parts.push(
+      chunk(
+        "iTXt",
+        concat([
+          new TextEncoder().encode("chart"),
+          new Uint8Array([0, 0, 0, 0, 0]),
+          new TextEncoder().encode(json)
+        ])
+      )
+    );
+  }
+  parts.push(chunk("IDAT", deflate(raw)), chunk("IEND", new Uint8Array(0)));
+  return concat(parts);
+}
+function validateImage(im) {
+  check(
+    im && Number.isInteger(im.width) && Number.isInteger(im.height) && im.width > 0 && im.height > 0 && im.width * im.height <= LIMITS.layerPixels && im.data && im.data.length === im.width * im.height * 4,
+    "Expected an RGBA image with matching dimensions."
+  );
+}
+function drawImageToCanvas(image, canvas) {
+  validateImage(image);
+  check(
+    canvas && typeof canvas.getContext === "function",
+    "Expected a canvas element."
+  );
+  const ctx = canvas.getContext("2d");
+  check(ctx, "Canvas 2D context is unavailable.");
+  canvas.width = image.width;
+  canvas.height = image.height;
+  const data = ctx.createImageData(image.width, image.height);
+  data.data.set(image.data);
+  ctx.putImageData(data, 0, 0);
+  return canvas;
+}
+function downloadBytes(bytes, name, type = "application/octet-stream") {
+  check(
+    typeof document !== "undefined",
+    "Downloads require a browser document."
+  );
+  text(name, "Filename");
+  check(
+    !/[\\/\x00-\x1f]/.test(name),
+    "Filename must not contain path separators or controls."
+  );
+  const data = bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
+  const blob = new Blob([data], { type }), url = URL.createObjectURL(blob), a = document.createElement("a");
+  a.href = url;
+  a.download = name;
+  a.hidden = true;
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  setTimeout(() => URL.revokeObjectURL(url), 3e4);
+}
+var RenderResult = class {
+  /** Pixels intentionally remain mutable; exports observe subsequent edits. */
+  image;
+  /** Immutable metadata captured at rendering time. */
+  metadata;
+  constructor(image, metadata) {
+    this.image = image;
+    this.metadata = freeze(metadata);
+  }
+  get width() {
+    return this.image.width;
+  }
+  get height() {
+    return this.image.height;
+  }
+  get data() {
+    return this.image.data;
+  }
+  draw(canvas) {
+    return drawImageToCanvas(this.image, canvas);
+  }
+  toPNG(options = {}) {
+    return encodePNG(
+      this.image,
+      options.metadata === false ? null : this.metadata
+    );
+  }
+  toBlob(options = {}) {
+    return new Blob([this.toPNG(options)], { type: "image/png" });
+  }
+  download(filename = "chart.png", options = {}) {
+    downloadBytes(this.toPNG(options), filename, "image/png");
+  }
+};
+var Chart = class _Chart {
+  /** Fully normalized, deeply frozen options used by every render. */
+  config;
+  constructor(options = {}) {
+    this.config = normalize(options);
+    Object.freeze(this);
+  }
+  with(patch) {
+    return new _Chart(merge(this.config, patch));
+  }
+  render() {
+    return renderChart(this.config);
+  }
+  draw(canvas) {
+    const r = this.render();
+    r.draw(canvas);
+    return r;
+  }
+  toPNG(options = {}) {
+    return this.render().toPNG(options);
+  }
+  mount(canvas, options = {}) {
+    return new BrowserController(this, canvas, options);
+  }
+  nearest(input) {
+    const time = epoch(input);
+    const [start, end] = timeRange(this.config);
+    return this.config.series.map((s) => {
+      const lo = lowerBound(s.timestamps, start), hi = upperBound(s.timestamps, end);
+      if (lo === hi)
+        return { name: s.name, index: null, time: null, value: null };
+      let i = clamp(lowerBound(s.timestamps, time), lo, hi - 1);
+      if (i > lo && Math.abs(s.timestamps[i - 1] - time) <= Math.abs(s.timestamps[i] - time))
+        i--;
+      return {
+        name: s.name,
+        index: i,
+        time: s.timestamps[i],
+        value: finite(s.values[i]) ? s.values[i] : null
+      };
+    });
+  }
+};
+function traffic(timestamps, inbound, outbound, options = {}) {
+  const gap = options.gapAfter === void 0 ? 0 : options.gapAfter, opts = { ...options };
+  delete opts.gapAfter;
+  return new Chart(
+    merge(
+      {
+        title: "Traffic - ether1",
+        verticalLabel: "bits per second",
+        series: [
+          series("Inbound", timestamps, inbound, {
+            kind: "area",
+            color: "#00cc00",
+            outline: "#003000",
+            gapAfter: gap
+          }),
+          series("Outbound", timestamps, outbound, {
+            kind: "line",
+            color: "#0000cc",
+            gapAfter: gap
+          })
+        ]
+      },
+      opts
+    )
+  );
+}
+function dashboard(panels, options = {}) {
+  check(
+    Array.isArray(panels) && panels.length > 0 && panels.length <= 128,
+    "Dashboard requires 1..128 panels."
+  );
+  const o = merge(
+    { gap: 24, padding: [4, 3, 6, 6], background: "#f3f3f3", cropHeight: null },
+    options
+  );
+  integer(o.gap, "Panel gap", 0, 4096);
+  check(
+    Array.isArray(o.padding) && o.padding.length === 4,
+    "Padding is [left, top, right, bottom]."
+  );
+  o.padding.forEach((v) => integer(v, "Padding", 0, 4096));
+  if (o.cropHeight !== null) integer(o.cropHeight, "Crop height", 1, 65536);
+  const pp = panels.map(
+    (p) => p instanceof Chart ? { chart: p, caption: "" } : p
+  );
+  for (const p of pp) {
+    check(p.chart instanceof Chart, "Panel needs a Chart.");
+    text(p.caption || "", "Caption");
+  }
+  const scale = pp[0].chart.config.layout.pixelScale;
+  check(
+    pp.every((p) => p.chart.config.layout.pixelScale === scale),
+    "Dashboard panels must have equal pixelScale."
+  );
+  const rendered = pp.map((p) => p.chart.render()), left = o.padding[0] * scale, top = o.padding[1] * scale, gap = o.gap * scale;
+  const width = Math.max(...rendered.map((r) => r.width)) + (o.padding[0] + o.padding[2]) * scale;
+  let height = rendered.reduce((n, r) => n + r.height, 0) + (o.padding[1] + o.padding[3]) * scale + gap * (pp.length - 1 + (pp[pp.length - 1].caption ? 1 : 0));
+  if (o.cropHeight !== null) height = Math.min(height, o.cropHeight * scale);
+  check(width * height <= LIMITS.pixels, "Dashboard is too large.");
+  const out = new Surface(width, height, color(o.background));
+  let y = top;
+  const meta = [];
+  for (let i = 0; i < pp.length; i++) {
+    const r = rendered[i], p = pp[i];
+    out.over(r.image, left, y);
+    meta.push({
+      position: [left, y],
+      caption: p.caption || "",
+      chart: r.metadata
+    });
+    y += r.height;
+    if (p.caption) {
+      const f = new Fonts(p.chart.config.fonts, p.chart.config.theme), w = f.width(p.caption, "caption"), h = p.chart.config.theme.captionSize;
+      check(
+        w <= width / scale - 8 && h + 4 <= o.gap,
+        "Caption does not fit the dashboard gap."
+      );
+      const line = new Surface(width / scale, o.gap);
+      f.draw(
+        line,
+        width / scale / 2,
+        4,
+        p.caption,
+        "caption",
+        p.chart.config.theme.text,
+        0,
+        "center"
+      );
+      out.over(line.scale(scale), 0, y);
+    }
+    y += gap;
+  }
+  return new RenderResult(out, {
+    version: VERSION,
+    imageSize: [width, height],
+    pixelScale: scale,
+    panels: meta
+  });
+}
+function counterRate(timestamps, counters, options = {}) {
+  const o = merge(
+    { factor: 1, onDecrease: "gap", counterBits: null, maxRate: null },
+    options
+  );
+  number(o.factor, "Rate factor", Number.MIN_VALUE);
+  check(
+    ["gap", "wrap"].includes(o.onDecrease),
+    "Decrease policy must be gap or wrap."
+  );
+  if (o.counterBits !== null) integer(o.counterBits, "Counter bits", 1, 128);
+  if (o.maxRate !== null) number(o.maxRate, "Maximum rate", 0);
+  check(
+    o.onDecrease !== "wrap" || o.counterBits !== null,
+    "Wrapping requires an explicit counterBits."
+  );
+  check(
+    (Array.isArray(counters) || ArrayBuffer.isView(counters)) && counters.length === timestamps.length,
+    "Counter and timestamp lengths must match."
+  );
+  const s = samples(
+    timestamps,
+    Array.from(counters, () => 0)
+  ), max = (1n << BigInt(o.counterBits || 128)) - 1n;
+  const cs = Array.from(counters, (v, i) => {
+    if (missing(v)) return null;
+    if (typeof v === "number") {
+      check(
+        Number.isSafeInteger(v) && v >= 0,
+        "Counter " + i + " must be a safe nonnegative integer; use BigInt for large counters."
+      );
+      v = BigInt(v);
+    }
+    check(
+      typeof v === "bigint" && v >= 0n && v <= max,
+      "Counter must fit the configured unsigned bit width."
+    );
+    return v;
+  });
+  s.values.fill(NaN);
+  for (let i = 1; i < cs.length; i++) {
+    const current = cs[i], previous = cs[i - 1];
+    if (current === null || previous === null) continue;
+    let d = current - previous;
+    if (d < 0n) {
+      if (o.onDecrease === "gap") continue;
+      d += max + 1n;
+    }
+    const v = Number(d) * o.factor / (s.timestamps[i] - s.timestamps[i - 1]);
+    check(finite(v), "Counter rate overflow.");
+    if (o.maxRate === null || v <= o.maxRate) s.values[i] = v;
+  }
+  return s;
+}
+function aggregate(timestamps, values, options = {}) {
+  const o = merge(
+    {
+      interval: 300,
+      method: "mean",
+      origin: 0,
+      minCoverage: 0,
+      expectedStep: null,
+      maxBuckets: 1e6
+    },
+    options
+  );
+  number(o.interval, "Aggregation interval", 1e-3);
+  number(o.origin, "Aggregation origin");
+  number(o.minCoverage, "Minimum coverage", 0, 1);
+  if (o.expectedStep !== null)
+    number(o.expectedStep, "Expected step", Number.MIN_VALUE);
+  integer(o.maxBuckets, "Maximum buckets", 1, 1e6);
+  check(
+    ["mean", "min", "max", "last", "sum"].includes(o.method),
+    "Unknown aggregation method."
+  );
+  const s = samples(timestamps, values);
+  if (!s.timestamps.length) return s;
+  const bucket = (t) => Math.floor((t - o.origin) / o.interval), a = bucket(s.timestamps[0]), b = bucket(s.timestamps[s.timestamps.length - 1]);
+  check(
+    Number.isSafeInteger(a) && Number.isSafeInteger(b) && b - a + 1 <= o.maxBuckets,
+    "Aggregation bucket limit or precision exceeded."
+  );
+  const out = { timestamps: [], values: [] };
+  let i = 0;
+  for (let k = a; k <= b; k++) {
+    const ts = o.origin + k * o.interval;
+    epoch(ts);
+    out.timestamps.push(ts);
+    let total = 0, last = NaN, mn = Infinity, mx = -Infinity;
+    const finiteValues = [];
+    while (i < s.timestamps.length && bucket(s.timestamps[i]) === k) {
+      const v = s.values[i++];
+      total++;
+      last = v;
+      if (finite(v)) {
+        finiteValues.push(v);
+        mn = Math.min(mn, v);
+        mx = Math.max(mx, v);
+      }
+    }
+    const denominator = Math.max(
+      total,
+      o.expectedStep === null ? 0 : o.interval / o.expectedStep
+    );
+    if (!finiteValues.length || finiteValues.length / denominator < o.minCoverage) {
+      out.values.push(NaN);
+      continue;
+    }
+    let value;
+    if (o.method === "mean") value = stableMean(finiteValues);
+    else if (o.method === "min") value = mn;
+    else if (o.method === "max") value = mx;
+    else if (o.method === "last") value = last;
+    else {
+      value = stableMean(finiteValues) * finiteValues.length;
+      check(finite(value), "Aggregation sum overflow.");
+    }
+    out.values.push(value);
+  }
+  return out;
+}
+function parseCSV(input, options = {}) {
+  const o = merge(
+    {
+      timestampColumn: "timestamp",
+      columns: [
+        {
+          column: "inbound",
+          name: "Inbound",
+          kind: "area",
+          color: "#00cc00",
+          outline: "#003000"
+        },
+        {
+          column: "outbound",
+          name: "Outbound",
+          kind: "line",
+          color: "#0000cc"
+        }
+      ],
+      maxRows: 1e6,
+      maxBytes: 16777216
+    },
+    options
+  );
+  check(typeof input === "string", "CSV must be a string.");
+  integer(o.maxRows, "Maximum CSV rows", 1, 2e6);
+  integer(o.maxBytes, "Maximum CSV bytes", 1, 67108864);
+  check(
+    input.length <= o.maxBytes && new TextEncoder().encode(input).length <= o.maxBytes,
+    "CSV exceeds the configured byte limit."
+  );
+  check(
+    Array.isArray(o.columns) && o.columns.length > 0 && o.columns.length <= 128,
+    "CSV needs at least one column mapping."
+  );
+  if (input.charCodeAt(0) === 65279) input = input.slice(1);
+  const rows = [];
+  let row = [], cell = "", quoted = false, closed = false;
+  function endCell() {
+    row.push(cell);
+    cell = "";
+    closed = false;
+  }
+  function endRow() {
+    endCell();
+    if (row.some((v) => v !== "")) rows.push(row);
+    row = [];
+    check(rows.length <= o.maxRows + 1, "CSV row limit exceeded.");
+  }
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (quoted) {
+      if (ch === '"') {
+        if (input[i + 1] === '"') {
+          cell += '"';
+          i++;
+        } else {
+          quoted = false;
+          closed = true;
+        }
+      } else cell += ch;
+      continue;
+    }
+    if (closed) {
+      check(
+        ch === "," || ch === "\r" || ch === "\n",
+        "Unexpected text after a closing CSV quote."
+      );
+    }
+    if (ch === '"') {
+      check(
+        cell === "" && !closed,
+        "Unexpected quote in an unquoted CSV field."
+      );
+      quoted = true;
+    } else if (ch === ",") endCell();
+    else if (ch === "\n" || ch === "\r") {
+      if (ch === "\r" && input[i + 1] === "\n") i++;
+      endRow();
+    } else cell += ch;
+  }
+  check(!quoted, "Unterminated quoted CSV field.");
+  if (cell !== "" || row.length || closed) endRow();
+  check(rows.length >= 1, "CSV header is missing.");
+  const header = rows.shift().map((v) => v.trim());
+  check(
+    header.every(Boolean) && new Set(header).size === header.length,
+    "CSV headers must be nonempty and unique."
+  );
+  const ti = header.indexOf(o.timestampColumn);
+  check(ti >= 0, "Timestamp column not found: " + o.timestampColumn);
+  const ids = o.columns.map((v) => {
+    const i = header.indexOf(v.column);
+    check(i >= 0, "Column not found: " + v.column);
+    return i;
+  });
+  const ts = [], vv = o.columns.map(() => []);
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i];
+    check(
+      r.length === header.length,
+      "CSV row " + (i + 2) + " has the wrong number of columns."
+    );
+    try {
+      ts.push(epoch(r[ti]));
+    } catch (e) {
+      throw new RangeError(
+        "CSV row " + (i + 2) + ": " + (e instanceof Error ? e.message : String(e))
+      );
+    }
+    ids.forEach((id, j) => {
+      const v = r[id].trim();
+      if (/^(?:nan|none|null)?$/i.test(v)) {
+        vv[j].push(NaN);
+        return;
+      }
+      check(
+        /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i.test(v),
+        "Invalid numeric CSV value at row " + (i + 2) + "."
+      );
+      vv[j].push(number(Number(v), "CSV value"));
+    });
+  }
+  return o.columns.map((v, j) => series(v.name || v.column, ts, vv[j], v));
+}
+function toCSV(list, options = {}) {
+  check(
+    Array.isArray(list) && list.length <= 128,
+    "Expected an array of series."
+  );
+  const escaped = options.escapeFormulas !== false;
+  const ss = list.map((s) => series(s.name, s.timestamps, s.values, s));
+  let total = 0;
+  for (const s of ss) total += s.timestamps.length;
+  check(
+    total <= LIMITS.samples,
+    "CSV export exceeds the combined sample limit."
+  );
+  const times = [...new Set(ss.flatMap((s) => s.timestamps))].sort(
+    (a, b) => a - b
+  );
+  check(
+    new Set(ss.map((s) => s.name)).size === ss.length && !ss.some((s) => s.name === "timestamp"),
+    "CSV series names must be unique and not timestamp."
+  );
+  const quote = (v) => {
+    v = String(v);
+    if (escaped && /^[=+\-@\t\r]/.test(v)) v = "'" + v;
+    return /[,"\r\n]/.test(v) ? '"' + v.replace(/"/g, '""') + '"' : v;
+  };
+  const lines = [["timestamp", ...ss.map((s) => s.name)].map(quote).join(",")], indexes = ss.map(() => 0);
+  for (const t of times) {
+    const cells = [String(t)];
+    ss.forEach((s, j) => {
+      while (indexes[j] < s.timestamps.length && s.timestamps[indexes[j]] < t)
+        indexes[j]++;
+      const i = indexes[j];
+      cells.push(
+        i < s.timestamps.length && s.timestamps[i] === t && finite(s.values[i]) ? String(s.values[i]) : ""
+      );
+    });
+    lines.push(cells.join(","));
+  }
+  return lines.join("\r\n") + "\r\n";
+}
+function compareImages(reference, actual, options = {}) {
+  const a = reference instanceof RenderResult ? reference.image : reference, b = actual instanceof RenderResult ? actual.image : actual;
+  validateImage(a);
+  validateImage(b);
+  check(
+    a.width === b.width && a.height === b.height,
+    "Image sizes must match; comparison never aligns or resizes."
+  );
+  const tolerance = options.tolerance === void 0 ? 0 : options.tolerance;
+  integer(tolerance, "Tolerance", 0, 255);
+  const box = options.box || [0, 0, a.width, a.height];
+  check(
+    Array.isArray(box) && box.length === 4,
+    "Comparison box needs four coordinates."
+  );
+  box.forEach((v) => integer(v, "Comparison coordinate", 0, 65536));
+  const [x0, y0, x1, y1] = box;
+  check(
+    x1 > x0 && y1 > y0 && x1 <= a.width && y1 <= a.height,
+    "Comparison box is out of bounds."
+  );
+  let exact = 0, within = 0, sum = 0, square = 0, maxError = 0, loX = Infinity, loY = Infinity, hiX = -Infinity, hiY = -Infinity;
+  for (let y = y0; y < y1; y++)
+    for (let x = x0; x < x1; x++) {
+      const i = (y * a.width + x) * 4;
+      let err = 0;
+      for (let k = 0; k < 3; k++) {
+        const d = Math.abs(a.data[i + k] - b.data[i + k]);
+        sum += d;
+        square += d * d;
+        err = Math.max(err, d);
+      }
+      maxError = Math.max(maxError, err);
+      if (err === 0) exact++;
+      else {
+        loX = Math.min(loX, x - x0);
+        loY = Math.min(loY, y - y0);
+        hiX = Math.max(hiX, x - x0);
+        hiY = Math.max(hiY, y - y0);
+      }
+      if (err <= tolerance) within++;
+    }
+  const count = (x1 - x0) * (y1 - y0);
+  return {
+    pixels: count,
+    exactPixels: exact,
+    exactRatio: exact / count,
+    toleranceRatio: within / count,
+    meanAbsoluteError: sum / (count * 3),
+    rootMeanSquareError: Math.sqrt(square / (count * 3)),
+    maxError,
+    differenceBox: loX === Infinity ? null : [loX, loY, hiX + 1, hiY + 1]
+  };
+}
+function differenceImage(reference, actual, amplify = 4) {
+  number(amplify, "Difference amplification", 0, 255);
+  const a = reference instanceof RenderResult ? reference.image : reference, b = actual instanceof RenderResult ? actual.image : actual;
+  compareImages(a, b);
+  const out = new Surface(a.width, a.height);
+  for (let i = 0; i < a.data.length; i += 4) {
+    for (let k = 0; k < 3; k++)
+      out.data[i + k] = Math.min(
+        255,
+        round(Math.abs(a.data[i + k] - b.data[i + k]) * amplify)
+      );
+    out.data[i + 3] = 255;
+  }
+  return new RenderResult(out, { imageSize: [out.width, out.height], amplify });
+}
+function readCanvas(canvas) {
+  check(
+    canvas && typeof canvas.getContext === "function",
+    "Expected a canvas."
+  );
+  const c = canvas.getContext("2d");
+  check(c, "Canvas 2D is unavailable.");
+  const data = c.getImageData(0, 0, canvas.width, canvas.height);
+  const out = new Surface(data.width, data.height);
+  out.data.set(data.data);
+  return out;
+}
+async function decodeImage(blob) {
+  check(
+    typeof Blob !== "undefined" && blob instanceof Blob,
+    "decodeImage expects a Blob or File."
+  );
+  check(blob.size <= 67108864, "Image file exceeds 64 MiB.");
+  const head = new Uint8Array(await blob.slice(0, 24).arrayBuffer());
+  check(
+    head.length >= 24 && [137, 80, 78, 71, 13, 10, 26, 10].every((v, i) => head[i] === v) && head[12] === 73 && head[13] === 72 && head[14] === 68 && head[15] === 82,
+    "decodeImage accepts PNG files only."
+  );
+  const headerView = new DataView(head.buffer), width = headerView.getUint32(16), height = headerView.getUint32(20);
+  check(
+    width > 0 && height > 0 && width * height <= LIMITS.pixels,
+    "Decoded PNG exceeds the pixel limit."
+  );
+  check(
+    typeof createImageBitmap === "function",
+    "This browser does not expose createImageBitmap."
+  );
+  const bitmap = await createImageBitmap(blob);
+  try {
+    check(
+      bitmap.width * bitmap.height <= LIMITS.pixels,
+      "Decoded image exceeds the pixel limit."
+    );
+    const canvas = createCanvas(bitmap.width, bitmap.height);
+    const ctx = canvas.getContext("2d");
+    check(ctx, "Canvas 2D is unavailable.");
+    ctx.drawImage(bitmap, 0, 0);
+    return readCanvas(canvas);
+  } finally {
+    bitmap.close();
+  }
+}
+var BrowserController = class {
+  chart;
+  canvas;
+  options;
+  destroyed;
+  result;
+  handlers;
+  cursorTime;
+  saved;
+  marker;
+  wrap;
+  overlay;
+  tip;
+  status;
+  constructor(chart, canvas, options = {}) {
+    check(
+      typeof document !== "undefined" && canvas && canvas.ownerDocument,
+      "mount requires an HTML canvas in a document."
+    );
+    check(canvas.parentNode, "Attach the canvas to the document before mount.");
+    check(
+      !canvas.__bamtiGraphController,
+      "A controller is already mounted on this canvas."
+    );
+    this.chart = chart;
+    this.canvas = canvas;
+    this.options = { interactive: true, ...options };
+    this.destroyed = false;
+    this.handlers = [];
+    this.cursorTime = null;
+    this.result = chart.render();
+    this.saved = {
+      style: canvas.getAttribute("style"),
+      role: canvas.getAttribute("role"),
+      label: canvas.getAttribute("aria-label"),
+      tab: canvas.getAttribute("tabindex")
+    };
+    this.marker = document.createComment("canvas position");
+    canvas.parentNode.insertBefore(this.marker, canvas);
+    this.wrap = document.createElement("span");
+    this.wrap.style.cssText = "position:relative;display:inline-block;vertical-align:top;line-height:0;max-width:none;";
+    canvas.parentNode.insertBefore(this.wrap, canvas);
+    this.wrap.appendChild(canvas);
+    canvas.style.display = "block";
+    canvas.style.maxWidth = "none";
+    canvas.setAttribute("role", "img");
+    this.overlay = document.createElement("canvas");
+    this.overlay.setAttribute("aria-hidden", "true");
+    this.overlay.style.cssText = "position:absolute;left:0;top:0;pointer-events:none;";
+    this.wrap.appendChild(this.overlay);
+    this.tip = document.createElement("div");
+    this.tip.hidden = true;
+    this.tip.setAttribute("role", "status");
+    this.tip.style.cssText = "position:absolute;z-index:5;pointer-events:none;background:#111827;color:#fff;border:1px solid #4b5563;padding:9px 11px;border-radius:5px;font:11px/1.65 ui-monospace,monospace;white-space:pre;box-shadow:0 4px 18px #0003;text-align:left;";
+    this.wrap.appendChild(this.tip);
+    this.status = document.createElement("span");
+    this.status.setAttribute("aria-live", "polite");
+    this.status.style.cssText = "position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;";
+    this.wrap.appendChild(this.status);
+    this.apply(this.result);
+    canvas.__bamtiGraphController = this;
+    if (this.options.interactive) {
+      canvas.tabIndex = 0;
+      this.on(canvas, "pointermove", (e) => {
+        const rect = canvas.getBoundingClientRect(), x = (e.clientX - rect.left) * canvas.width / rect.width, y = (e.clientY - rect.top) * canvas.height / rect.height, m = this.result.metadata, s = m.pixelScale, [l, t, r, b] = m.plotBox;
+        if (x < l * s || x > r * s || y < t * s || y > b * s) {
+          this.clear();
+          return;
+        }
+        const time = m.timeRange[0] + (x / s - l) / (r - l) * (m.timeRange[1] - m.timeRange[0]);
+        this.show(time, false);
+      });
+      this.on(canvas, "pointerleave", () => this.clear());
+      this.on(canvas, "blur", () => this.clear());
+      this.on(canvas, "keydown", (e) => {
+        if (!["ArrowLeft", "ArrowRight", "Home", "End", "Escape"].includes(e.key))
+          return;
+        e.preventDefault();
+        if (e.key === "Escape") {
+          this.clear();
+          return;
+        }
+        const [a, b] = this.result.metadata.timeRange, s = this.chart.config.series.find((s2) => s2.timestamps.length), visible = s ? s.timestamps.slice(
+          lowerBound(s.timestamps, a),
+          upperBound(s.timestamps, b)
+        ) : [];
+        let time;
+        if (e.key === "Home") time = visible[0] === void 0 ? a : visible[0];
+        else if (e.key === "End")
+          time = visible.length ? visible[visible.length - 1] : b;
+        else if (visible.length) {
+          let i = this.cursorTime === null ? e.key === "ArrowRight" ? -1 : visible.length : lowerBound(visible, this.cursorTime);
+          i = clamp(
+            i + (e.key === "ArrowRight" ? 1 : -1) * (e.shiftKey ? 10 : 1),
+            0,
+            visible.length - 1
+          );
+          time = visible[i];
+        } else
+          time = clamp(
+            (this.cursorTime === null ? a : this.cursorTime) + (e.key === "ArrowRight" ? 1 : -1) * (b - a) / 100,
+            a,
+            b
+          );
+        this.show(time, true);
+      });
+    }
+  }
+  on(target, type, fn) {
+    target.addEventListener(type, fn);
+    this.handlers.push([target, type, fn]);
+  }
+  apply(r) {
+    this.result = r;
+    r.draw(this.canvas);
+    this.overlay.width = r.width;
+    this.overlay.height = r.height;
+    const m = r.metadata;
+    this.canvas.setAttribute(
+      "aria-label",
+      this.options.ariaLabel || [
+        m.title || "Time-series chart",
+        m.verticalLabel,
+        ...m.statistics.map(
+          (s) => s.name + ": current " + (s.current === null ? "missing" : formatValue(s.current, m.yUnit, 2))
+        )
+      ].join(". ")
+    );
+    this.wrap.style.width = r.width + "px";
+    this.wrap.style.height = r.height + "px";
+    this.clear();
+  }
+  show(time, announce) {
+    if (this.destroyed) return;
+    const m = this.result.metadata, s = m.pixelScale, [left, top, right, bottom] = m.plotBox, ctx = this.overlay.getContext("2d"), x = (left + (time - m.timeRange[0]) / (m.timeRange[1] - m.timeRange[0]) * (right - left)) * s;
+    ctx.clearRect(0, 0, this.overlay.width, this.overlay.height);
+    ctx.beginPath();
+    ctx.strokeStyle = "#555";
+    ctx.lineWidth = 1;
+    ctx.setLineDash([2, 2]);
+    ctx.moveTo(round(x) + 0.5, top * s);
+    ctx.lineTo(round(x) + 0.5, bottom * s);
+    ctx.stroke();
+    const nearest = this.chart.nearest(time), rows = ["Nearest samples"];
+    for (const p of nearest)
+      rows.push(
+        p.name + ": " + formatValue(p.value, m.yUnit, 2, this.chart.config.missingLabel) + (p.time !== null ? "  " + formatTime(p.time, m.timezone, "%H:%M:%S") : "  no observation")
+      );
+    this.tip.textContent = rows.join("\n");
+    this.tip.hidden = false;
+    this.tip.style.left = Math.max(
+      4,
+      Math.min(this.result.width - this.tip.offsetWidth - 4, x + 12)
+    ) + "px";
+    this.tip.style.top = top * s + 8 + "px";
+    this.cursorTime = time;
+    if (announce) this.status.textContent = rows.join(". ");
+    if (typeof this.options.onHover === "function")
+      this.options.onHover({ time, samples: nearest });
+  }
+  clear() {
+    if (this.overlay)
+      this.overlay.getContext("2d").clearRect(0, 0, this.overlay.width, this.overlay.height);
+    if (this.tip) this.tip.hidden = true;
+    this.cursorTime = null;
+  }
+  update(patch) {
+    check(!this.destroyed, "Controller has been destroyed.");
+    const next = patch instanceof Chart ? patch : this.chart.with(patch), result = next.render();
+    this.chart = next;
+    this.apply(result);
+    return result;
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    for (const [el, type, fn] of this.handlers)
+      el.removeEventListener(type, fn);
+    this.handlers.length = 0;
+    if (this.marker.parentNode) {
+      this.marker.parentNode.insertBefore(this.canvas, this.marker);
+      this.marker.remove();
+    } else this.wrap.removeChild(this.canvas);
+    this.wrap.remove();
+    for (const [key, attr] of [
+      ["style", "style"],
+      ["role", "role"],
+      ["label", "aria-label"],
+      ["tab", "tabindex"]
+    ]) {
+      if (this.saved[key] === null) this.canvas.removeAttribute(attr);
+      else this.canvas.setAttribute(attr, this.saved[key]);
+    }
+    delete this.canvas.__bamtiGraphController;
+  }
+};
+function defaults() {
+  return clone(DEFAULTS);
+}
+function render(options = {}) {
+  return new Chart(options).render();
+}
+var BamtiGraph = Object.freeze({
+  VERSION,
+  LIMITS,
+  Chart,
+  RenderResult,
+  series,
+  regularSeries,
+  traffic,
+  daily,
+  weekly,
+  monthly,
+  yearly,
+  dashboard,
+  counterRate,
+  aggregate,
+  parseCSV,
+  toCSV,
+  compareImages,
+  differenceImage,
+  encodePNG,
+  decodeImage,
+  readCanvas,
+  drawImageToCanvas,
+  downloadBytes,
+  formatTime,
+  formatValue,
+  epoch,
+  color,
+  defaults,
+  render
+});
+var index_default = BamtiGraph;
+//# sourceMappingURL=index.cjs.map