gaugeit.js 0.1.0

package/dist/gaugeit.umd.js

@@ -0,0 +1,4713 @@
+/*! Gaugeit.js v0.1.0 | MIT License | https://github.com/kasperikoski/gaugeit.js#readme */
+(function (root, factory) {
+  if (typeof define === "function" && define.amd) define([], factory);
+  else if (typeof module === "object" && module.exports) module.exports = factory();
+  else root.Gaugeit = factory();
+})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+var Gaugeit = (() => {
+  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.js
+  var index_exports = {};
+  __export(index_exports, {
+    Gauge: () => Gauge,
+    GaugeTypeRegistry: () => GaugeTypeRegistry,
+    VERSION: () => VERSION,
+    autoMount: () => autoMount,
+    createGauge: () => createGauge,
+    deepMerge: () => deepMerge,
+    default: () => index_default,
+    defineGaugeitElement: () => defineGaugeitElement,
+    easingNames: () => easingNames,
+    gaugeTypeRegistry: () => gaugeTypeRegistry,
+    geometry: () => geometry,
+    getMountedGauge: () => getMountedGauge,
+    layers: () => layers,
+    registerGaugeType: () => registerGaugeType,
+    types: () => types,
+    unmountGauge: () => unmountGauge
+  });
+
+  // src/core/utils.js
+  function isPlainObject(value) {
+    if (value === null || typeof value !== "object") return false;
+    if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === null || prototype === Object.prototype) return true;
+    const constructor = Object.prototype.hasOwnProperty.call(prototype, "constructor") ? prototype.constructor : null;
+    return typeof constructor === "function" && constructor.name === "Object";
+  }
+  function deepMerge(base, override) {
+    if (!isPlainObject(base)) return cloneValue(override);
+    const result = { ...base };
+    if (!isPlainObject(override)) return result;
+    for (const [key, value] of Object.entries(override)) {
+      if (isUnsafeObjectKey(key)) continue;
+      if (isPlainObject(value) && isPlainObject(result[key])) {
+        result[key] = deepMerge(result[key], value);
+      } else {
+        result[key] = cloneValue(value);
+      }
+    }
+    return result;
+  }
+  function cloneValue(value) {
+    if (Array.isArray(value)) return value.map(cloneValue);
+    if (isPlainObject(value)) {
+      const copy = {};
+      for (const [key, child] of Object.entries(value)) {
+        if (!isUnsafeObjectKey(key)) copy[key] = cloneValue(child);
+      }
+      return copy;
+    }
+    return value;
+  }
+  function isUnsafeObjectKey(key) {
+    return key === "__proto__" || key === "prototype" || key === "constructor";
+  }
+  function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+  }
+  function finiteNumber(value, fallback) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : fallback;
+  }
+  var idCounter = 0;
+  function uniqueId(prefix = "gaugeit") {
+    idCounter += 1;
+    return `${prefix}-${idCounter}`;
+  }
+  function resolveElement(target) {
+    if (typeof target === "string") {
+      const element = document.querySelector(target);
+      if (!element) throw new Error(`Gaugeit target not found: ${target}`);
+      return element;
+    }
+    if (target && typeof target === "object" && target.nodeType === 1) return target;
+    throw new TypeError("Gaugeit target must be an Element or a valid CSS selector.");
+  }
+  function isTransparentColor(color) {
+    if (color === null || color === void 0) return true;
+    const normalized = String(color).trim().toLowerCase();
+    return normalized === "" || normalized === "transparent" || normalized === "none";
+  }
+  function requestFrame(callback) {
+    if (typeof requestAnimationFrame === "function") return requestAnimationFrame(callback);
+    return setTimeout(() => callback(Date.now()), 16);
+  }
+  function cancelFrame(handle) {
+    if (handle === null || handle === void 0) return;
+    if (typeof cancelAnimationFrame === "function") {
+      cancelAnimationFrame(handle);
+      return;
+    }
+    clearTimeout(handle);
+  }
+  function dispatchGaugeEvent(target, name, detail) {
+    if (!target || typeof target.dispatchEvent !== "function" || typeof CustomEvent !== "function") return;
+    target.dispatchEvent(new CustomEvent(`gaugeit:${name}`, { detail }));
+  }
+  function parseJsonObject(value, fallback = {}) {
+    if (typeof value !== "string" || value.trim() === "") return fallback;
+    try {
+      const parsed = JSON.parse(value);
+      return isPlainObject(parsed) ? parsed : fallback;
+    } catch (e) {
+      return fallback;
+    }
+  }
+
+  // src/geometry/scale.js
+  function degreesToRadians(degrees) {
+    return degrees * Math.PI / 180;
+  }
+  function polarPoint(centerX, centerY, radius, angleDegrees) {
+    const radians = degreesToRadians(angleDegrees);
+    return {
+      x: centerX + radius * Math.cos(radians),
+      y: centerY + radius * Math.sin(radians)
+    };
+  }
+  function gaugeSweep(options) {
+    return options.geometry.endAngle - options.geometry.startAngle;
+  }
+  function centeredArcAngles(sweep, centerAngle = 0) {
+    const safeSweep = Math.min(360, Math.max(1e-3, Math.abs(finiteNumber(sweep, 180))));
+    const svgCenter = 270 + finiteNumber(centerAngle, 0);
+    const halfSweep = safeSweep / 2;
+    return {
+      startAngle: svgCenter - halfSweep,
+      endAngle: svgCenter + halfSweep
+    };
+  }
+  function valueToAngle(value, options, clampValue = true) {
+    const min = options.min;
+    const max = options.max;
+    const normalizedValue = clampValue ? clamp(value, min, max) : value;
+    const valueRatio = (normalizedValue - min) / (max - min);
+    const visualRatio = options.invert ? 1 - valueRatio : valueRatio;
+    return options.geometry.startAngle + gaugeSweep(options) * visualRatio;
+  }
+  function angleToValue(angle, options, clampResult = true) {
+    const sweep = gaugeSweep(options);
+    const visualRatio = (angle - options.geometry.startAngle) / sweep;
+    const valueRatio = options.invert ? 1 - visualRatio : visualRatio;
+    const value = options.min + valueRatio * (options.max - options.min);
+    return clampResult ? clamp(value, options.min, options.max) : value;
+  }
+  function arcPath(centerX, centerY, radius, startAngle, endAngle) {
+    const start = polarPoint(centerX, centerY, radius, startAngle);
+    const end = polarPoint(centerX, centerY, radius, endAngle);
+    const delta = endAngle - startAngle;
+    const sweepFlag = delta >= 0 ? 1 : 0;
+    if (Math.abs(delta) >= 360 - 1e-3) {
+      const midpoint = polarPoint(centerX, centerY, radius, startAngle + delta / 2);
+      return [
+        `M ${roundSvg(start.x)} ${roundSvg(start.y)}`,
+        `A ${roundSvg(radius)} ${roundSvg(radius)} 0 1 ${sweepFlag} ${roundSvg(midpoint.x)} ${roundSvg(midpoint.y)}`,
+        `A ${roundSvg(radius)} ${roundSvg(radius)} 0 1 ${sweepFlag} ${roundSvg(end.x)} ${roundSvg(end.y)}`
+      ].join(" ");
+    }
+    const largeArcFlag = Math.abs(delta) > 180 ? 1 : 0;
+    return [
+      `M ${roundSvg(start.x)} ${roundSvg(start.y)}`,
+      `A ${roundSvg(radius)} ${roundSvg(radius)} 0 ${largeArcFlag} ${sweepFlag} ${roundSvg(end.x)} ${roundSvg(end.y)}`
+    ].join(" ");
+  }
+  function taperedArcPath(centerX, centerY, radius, startAngle, endAngle, startWidth, endWidth, segments = 48) {
+    const delta = endAngle - startAngle;
+    const sampleCount = Math.max(2, Math.min(256, Math.ceil(finiteNumber(segments, 48))));
+    const safeRadius = Math.max(0, finiteNumber(radius, 0));
+    const firstWidth = Math.max(0, finiteNumber(startWidth, 0));
+    const lastWidth = Math.max(0, finiteNumber(endWidth, firstWidth));
+    const outer = [];
+    const inner = [];
+    for (let index = 0; index <= sampleCount; index += 1) {
+      const ratio = index / sampleCount;
+      const angle = startAngle + delta * ratio;
+      const width = firstWidth + (lastWidth - firstWidth) * ratio;
+      outer.push(polarPoint(centerX, centerY, safeRadius + width / 2, angle));
+      inner.push(polarPoint(centerX, centerY, Math.max(0, safeRadius - width / 2), angle));
+    }
+    const commands = [`M ${roundSvg(outer[0].x)} ${roundSvg(outer[0].y)}`];
+    for (let index = 1; index < outer.length; index += 1) {
+      commands.push(`L ${roundSvg(outer[index].x)} ${roundSvg(outer[index].y)}`);
+    }
+    for (let index = inner.length - 1; index >= 0; index -= 1) {
+      commands.push(`L ${roundSvg(inner[index].x)} ${roundSvg(inner[index].y)}`);
+    }
+    commands.push("Z");
+    return commands.join(" ");
+  }
+  function niceInterval(range, desiredDivisions = 5) {
+    const safeRange = Math.abs(finiteNumber(range, 1)) || 1;
+    const raw = safeRange / Math.max(1, desiredDivisions);
+    const exponent = Math.floor(Math.log10(raw));
+    const fraction = raw / Math.pow(10, exponent);
+    let niceFraction;
+    if (fraction <= 1) niceFraction = 1;
+    else if (fraction <= 2) niceFraction = 2;
+    else if (fraction <= 2.5) niceFraction = 2.5;
+    else if (fraction <= 5) niceFraction = 5;
+    else niceFraction = 10;
+    return niceFraction * Math.pow(10, exponent);
+  }
+  function buildScaleValues(min, max, interval) {
+    const safeInterval = Math.abs(finiteNumber(interval, 0));
+    if (safeInterval <= 0 || max <= min) return [min, max];
+    const precision = Math.min(12, Math.max(0, decimalPlaces(safeInterval) + 2));
+    const epsilon = safeInterval / 1e6;
+    const values = [];
+    let current = min;
+    let guard = 0;
+    while (current <= max + epsilon && guard < 1e4) {
+      values.push(roundTo(current, precision));
+      current += safeInterval;
+      guard += 1;
+    }
+    if (values.length === 0 || Math.abs(values[values.length - 1] - max) > epsilon) {
+      values.push(max);
+    } else {
+      values[values.length - 1] = max;
+    }
+    return values;
+  }
+  function buildMinorValues(majorValues, subdivisions) {
+    const count = Math.max(0, Math.floor(finiteNumber(subdivisions, 0)));
+    if (count === 0 || majorValues.length < 2) return [];
+    const values = [];
+    for (let index = 0; index < majorValues.length - 1; index += 1) {
+      const start = majorValues[index];
+      const end = majorValues[index + 1];
+      const step = (end - start) / (count + 1);
+      for (let subdivision = 1; subdivision <= count; subdivision += 1) {
+        values.push(start + step * subdivision);
+      }
+    }
+    return values;
+  }
+  function resolveZoneSegments(min, max, zones) {
+    const normalized = Array.isArray(zones) ? zones.filter((zone) => zone && typeof zone === "object").map((zone, index) => ({
+      ...zone,
+      min: clamp(finiteNumber(zone.min, min), min, max),
+      max: clamp(finiteNumber(zone.max, max), min, max),
+      _index: index
+    })).filter((zone) => zone.max > zone.min) : [];
+    const breakpoints = /* @__PURE__ */ new Set([min, max]);
+    for (const zone of normalized) {
+      breakpoints.add(zone.min);
+      breakpoints.add(zone.max);
+    }
+    const points = [...breakpoints].sort((left, right) => left - right);
+    const segments = [];
+    for (let index = 0; index < points.length - 1; index += 1) {
+      const segmentMin = points[index];
+      const segmentMax = points[index + 1];
+      const midpoint = (segmentMin + segmentMax) / 2;
+      const candidates = normalized.filter((zone2) => midpoint >= zone2.min && midpoint <= zone2.max);
+      const zone = candidates.length ? candidates[candidates.length - 1] : null;
+      segments.push({ min: segmentMin, max: segmentMax, zone });
+    }
+    return segments;
+  }
+  function findZoneForValue(value, zones) {
+    if (!Array.isArray(zones)) return null;
+    let match = null;
+    for (const zone of zones) {
+      if (!zone || typeof zone !== "object") continue;
+      if (value >= Number(zone.min) && value <= Number(zone.max)) match = zone;
+    }
+    return match;
+  }
+  function roundSvg(value) {
+    return Math.round(value * 1e3) / 1e3;
+  }
+  function roundTo(value, precision) {
+    const factor = Math.pow(10, precision);
+    return Math.round(value * factor) / factor;
+  }
+  function decimalPlaces(value) {
+    const text = String(value).toLowerCase();
+    if (text.includes("e-")) return Number(text.split("e-")[1]);
+    const decimal = text.split(".")[1];
+    return decimal ? decimal.length : 0;
+  }
+
+  // src/geometry/linear.js
+  function linearYToSvg(y, options) {
+    const linear = options.linear || {};
+    const originY = finiteNumber(linear.originY, 140);
+    return originY - finiteNumber(y, 0);
+  }
+  function linearAxis(options) {
+    const linear = options.linear || {};
+    const startX = finiteNumber(linear.startX, 36);
+    const startY = linearYToSvg(linear.startY, options);
+    let endX = finiteNumber(linear.endX, 284);
+    let endY = linearYToSvg(linear.endY, options);
+    let dx = endX - startX;
+    let dy = endY - startY;
+    let length = Math.hypot(dx, dy);
+    if (length < 1e-3) {
+      endX = startX + 1;
+      endY = startY;
+      dx = 1;
+      dy = 0;
+      length = 1;
+    }
+    const tangentX = dx / length;
+    const tangentY = dy / length;
+    return {
+      startX,
+      startY,
+      endX,
+      endY,
+      dx,
+      dy,
+      length,
+      tangentX,
+      tangentY,
+      normalX: -tangentY,
+      normalY: tangentX,
+      angle: Math.atan2(dy, dx) * 180 / Math.PI
+    };
+  }
+  function valueToLinearRatio(value, options, clampValue = true) {
+    const normalizedValue = clampValue ? clamp(value, options.min, options.max) : value;
+    const valueRatio = (normalizedValue - options.min) / (options.max - options.min);
+    return options.invert ? 1 - valueRatio : valueRatio;
+  }
+  function valueToLinearPoint(value, options, clampValue = true) {
+    const axis = linearAxis(options);
+    const ratio = valueToLinearRatio(value, options, clampValue);
+    return {
+      x: axis.startX + axis.dx * ratio,
+      y: axis.startY + axis.dy * ratio
+    };
+  }
+  function linearPointToValue(x, y, options, clampResult = true) {
+    const axis = linearAxis(options);
+    const relativeX = finiteNumber(x, axis.startX) - axis.startX;
+    const relativeY = finiteNumber(y, axis.startY) - axis.startY;
+    const visualRatio = (relativeX * axis.tangentX + relativeY * axis.tangentY) / axis.length;
+    const boundedVisualRatio = clampResult ? clamp(visualRatio, 0, 1) : visualRatio;
+    const valueRatio = options.invert ? 1 - boundedVisualRatio : boundedVisualRatio;
+    const value = options.min + valueRatio * (options.max - options.min);
+    return clampResult ? clamp(value, options.min, options.max) : value;
+  }
+  function offsetLinearPoint(point, axis, distance) {
+    const amount = finiteNumber(distance, 0);
+    return {
+      x: point.x + axis.normalX * amount,
+      y: point.y + axis.normalY * amount
+    };
+  }
+  function linearNormalOffset(value) {
+    return -finiteNumber(value, 0);
+  }
+  function linearIndicatorNormalOffset(indicator) {
+    return linearNormalOffset(indicator == null ? void 0 : indicator.centerOffset);
+  }
+  function linearNormalSpan(length, position = "cross", offset = 0) {
+    const size = Math.max(0, finiteNumber(length, 0));
+    const shift = finiteNumber(offset, 0);
+    if (position === "negative") return { start: shift - size, end: shift };
+    if (position === "positive") return { start: shift, end: shift + size };
+    return { start: shift - size / 2, end: shift + size / 2 };
+  }
+
+  // src/geometry/tape.js
+  function tapeWindowBox(options) {
+    const tape = options.tape || {};
+    return {
+      x: finiteNumber(tape.x, 64),
+      y: finiteNumber(tape.y, 58),
+      width: Math.max(20, finiteNumber(tape.width, 192)),
+      height: Math.max(20, finiteNumber(tape.height, 210))
+    };
+  }
+  function resolveTapeInterval(options) {
+    var _a, _b, _c;
+    const explicit = finiteNumber((_a = options.tape) == null ? void 0 : _a.interval, 0);
+    if (explicit > 0) return explicit;
+    return niceInterval(options.max - options.min, Math.max(2, ((_c = (_b = options.scale) == null ? void 0 : _b.major) == null ? void 0 : _c.divisions) || 5));
+  }
+  function tapeMinorStep(options) {
+    var _a;
+    const subdivisions = Math.max(0, Math.floor(finiteNumber((_a = options.tape) == null ? void 0 : _a.minorSubdivisions, 4)));
+    return resolveTapeInterval(options) / (subdivisions + 1);
+  }
+  function tapeMinorSpacing(options) {
+    var _a, _b;
+    const subdivisions = Math.max(0, Math.floor(finiteNumber((_a = options.tape) == null ? void 0 : _a.minorSubdivisions, 4)));
+    return Math.max(2, finiteNumber((_b = options.tape) == null ? void 0 : _b.majorSpacing, 54)) / (subdivisions + 1);
+  }
+  function tapeValueOffset(value, currentValue, options) {
+    const step = tapeMinorStep(options);
+    const spacing = tapeMinorSpacing(options);
+    const direction = options.invert ? -1 : 1;
+    return (Number(value) - Number(currentValue)) / step * spacing * direction;
+  }
+
+  // src/geometry/light.js
+  function resolveLightPosition(light, options) {
+    return {
+      x: finiteNumber(light == null ? void 0 : light.x, options.geometry.width / 2),
+      y: options.geometry.mode === "linear" ? linearYToSvg(light == null ? void 0 : light.y, options) : finiteNumber(light == null ? void 0 : light.y, options.geometry.height / 2)
+    };
+  }
+  function lightIsActive(light, value) {
+    if (!(light == null ? void 0 : light.visible)) return false;
+    const trigger = light.trigger || {};
+    const sample = finiteNumber(value, 0);
+    switch (trigger.mode) {
+      case "below":
+        return sample <= finiteNumber(trigger.value, 0);
+      case "above":
+        return sample >= finiteNumber(trigger.value, 0);
+      case "between": {
+        const first = finiteNumber(trigger.min, 0);
+        const second = finiteNumber(trigger.max, first);
+        return sample >= Math.min(first, second) && sample <= Math.max(first, second);
+      }
+      case "manual":
+      default:
+        return light.on === true;
+    }
+  }
+
+  // src/geometry/bounds.js
+  var EPSILON = 1e-3;
+  function createBounds(x = Infinity, y = Infinity, width = -Infinity, height = -Infinity) {
+    if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(width) && Number.isFinite(height)) {
+      return { x, y, width, height };
+    }
+    return { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
+  }
+  function includePoint(bounds, x, y) {
+    if (!Number.isFinite(x) || !Number.isFinite(y)) return bounds;
+    bounds.minX = Math.min(bounds.minX, x);
+    bounds.minY = Math.min(bounds.minY, y);
+    bounds.maxX = Math.max(bounds.maxX, x);
+    bounds.maxY = Math.max(bounds.maxY, y);
+    return bounds;
+  }
+  function includeRect(bounds, x, y, width, height) {
+    includePoint(bounds, x, y);
+    includePoint(bounds, x + Math.max(0, width), y + Math.max(0, height));
+    return bounds;
+  }
+  function finalizeBounds(bounds, fallback = { x: 0, y: 0, width: 1, height: 1 }) {
+    if (!bounds || !Number.isFinite(bounds.minX) || !Number.isFinite(bounds.minY) || !Number.isFinite(bounds.maxX) || !Number.isFinite(bounds.maxY)) {
+      return { ...fallback };
+    }
+    return {
+      x: bounds.minX,
+      y: bounds.minY,
+      width: Math.max(1, bounds.maxX - bounds.minX),
+      height: Math.max(1, bounds.maxY - bounds.minY)
+    };
+  }
+  function padBounds(bounds, padding = 0) {
+    const amount = Math.max(0, finiteNumber(padding, 0));
+    return {
+      x: bounds.x - amount,
+      y: bounds.y - amount,
+      width: Math.max(1, bounds.width + amount * 2),
+      height: Math.max(1, bounds.height + amount * 2)
+    };
+  }
+  function unionBounds(...rectangles) {
+    const accumulator = createBounds();
+    for (const rectangle of rectangles) {
+      if (!rectangle) continue;
+      includeRect(accumulator, rectangle.x, rectangle.y, rectangle.width, rectangle.height);
+    }
+    return finalizeBounds(accumulator);
+  }
+  function isClosedGauge(options) {
+    return Math.abs(gaugeSweep(options)) >= 360 - EPSILON;
+  }
+  function resolveScaleEndpointValues(values, options) {
+    var _a;
+    const mode = ((_a = options.scale) == null ? void 0 : _a.endpointMode) || "auto";
+    if (values.length < 2 || mode === "both") return values;
+    if (mode === "dedupe" || mode === "auto" && isClosedGauge(options)) return values.slice(0, -1);
+    return values;
+  }
+  function resolveReadoutPosition(part, options) {
+    const reference = readoutReferenceBox(options);
+    const fontSize = Math.max(1, finiteNumber(part.fontSize, 12));
+    const margin = Math.max(0, finiteNumber(part.margin, 12));
+    const position = part.position || "top";
+    const automaticX = part.x === "auto";
+    const automaticY = part.y === "auto";
+    const x = automaticX ? reference.x + reference.width / 2 : finiteNumber(part.x, reference.x + reference.width / 2);
+    let y;
+    if (automaticY) {
+      if (position === "bottom") y = reference.y + reference.height - margin - fontSize / 2;
+      else if (position === "center") y = reference.y + reference.height / 2;
+      else y = reference.y + margin + fontSize / 2;
+    } else if (options.geometry.mode === "linear") {
+      y = linearYToSvg(part.y, options);
+    } else {
+      y = finiteNumber(part.y, reference.y + margin + fontSize / 2);
+    }
+    return {
+      // Offsets refine automatic placement. Numeric coordinates are final, absolute
+      // SVG positions and therefore do not inherit a type preset's auto offset.
+      x: x + (automaticX ? finiteNumber(part.offsetX, 0) : 0),
+      y: y + (automaticY ? finiteNumber(part.offsetY, 0) : 0)
+    };
+  }
+  function resolveFaceBox(options, contentBounds = null) {
+    var _a, _b;
+    const face = options.face;
+    const geometry2 = options.geometry;
+    if (face.fit !== "content" || !contentBounds) {
+      return {
+        x: face.x,
+        y: face.y,
+        width: face.width,
+        height: face.height
+      };
+    }
+    const padding = Math.max(0, finiteNumber(face.contentPadding, 8));
+    const configured = { x: face.x, y: face.y, width: face.width, height: face.height };
+    const minimumWidth = (_a = face.minWidth) != null ? _a : configured.width;
+    const minimumHeight = (_b = face.minHeight) != null ? _b : configured.height;
+    if (face.shape === "circle") {
+      const cx = geometry2.centerX;
+      const cy = geometry2.centerY;
+      const configuredRadius = Math.min(minimumWidth, minimumHeight) / 2;
+      const contentRadius = Math.max(
+        cx - contentBounds.x,
+        contentBounds.x + contentBounds.width - cx,
+        cy - contentBounds.y,
+        contentBounds.y + contentBounds.height - cy
+      ) + padding;
+      const radius = Math.max(1, configuredRadius, contentRadius);
+      return { x: cx - radius, y: cy - radius, width: radius * 2, height: radius * 2 };
+    }
+    const padded = {
+      x: contentBounds.x - padding,
+      y: contentBounds.y - padding,
+      width: contentBounds.width + padding * 2,
+      height: contentBounds.height + padding * 2
+    };
+    const horizontalExtent = Math.max(
+      geometry2.centerX - padded.x,
+      padded.x + padded.width - geometry2.centerX
+    );
+    const width = Math.max(1, minimumWidth, horizontalExtent * 2);
+    const height = Math.max(1, minimumHeight, padded.height);
+    const contentCenterY = padded.y + padded.height / 2;
+    return {
+      x: geometry2.centerX - width / 2,
+      y: contentCenterY - height / 2,
+      width,
+      height
+    };
+  }
+  function calculateGaugeBounds(options, configuration = {}) {
+    var _a;
+    const includeFace = configuration.includeFace !== false;
+    const includeBase = configuration.includeBase === void 0 ? ((_a = options.layout) == null ? void 0 : _a.includeGeometry) !== false : configuration.includeBase === true;
+    const contentBounds = configuration.contentBounds || null;
+    const geometry2 = options.geometry;
+    const bounds = createBounds();
+    if (includeBase) includeRect(bounds, 0, 0, geometry2.width, geometry2.height);
+    if (includeFace && options.face.visible) {
+      const box = resolveFaceBox(options, contentBounds);
+      const expansion = options.face.shadow ? 10 : Math.max(0, options.face.strokeWidth / 2);
+      includeRect(bounds, box.x - expansion, box.y - expansion, box.width + expansion * 2, box.height + expansion * 2);
+      if (options.face.clipContent) {
+        return finalizeBounds(bounds, { x: 0, y: 0, width: geometry2.width, height: geometry2.height });
+      }
+    }
+    if (geometry2.mode === "linear") {
+      includeLinearTrackAndZones(bounds, options);
+      includeLinearScale(bounds, options);
+      includeLinearLabels(bounds, options);
+      includeLinearIndicator(bounds, options);
+      includeZeroMarker(bounds, options);
+    } else if (geometry2.mode === "tape") {
+      includeTape(bounds, options);
+    } else {
+      includeTrackAndZones(bounds, options);
+      includeScale(bounds, options);
+      includeLabels(bounds, options);
+      includeZeroMarker(bounds, options);
+      includePointer(bounds, options);
+    }
+    includeReadout(bounds, options);
+    includeLight(bounds, options);
+    return finalizeBounds(bounds, { x: 0, y: 0, width: geometry2.width, height: geometry2.height });
+  }
+  function includeTrackAndZones(bounds, options) {
+    var _a, _b;
+    const { geometry: geometry2, track } = options;
+    if (track.visible) {
+      includeArc(bounds, geometry2.centerX, geometry2.centerY, track.radius, track.width, geometry2.startAngle, geometry2.endAngle);
+    }
+    for (const zone of options.zones || []) {
+      if (isTransparentColor(zone.color)) continue;
+      includeArc(
+        bounds,
+        geometry2.centerX,
+        geometry2.centerY,
+        (_b = (_a = zone.radius) != null ? _a : track.radius) != null ? _b : geometry2.radius,
+        zoneMaximumWidth(zone, track.width),
+        valueToAngle(zone.min, options),
+        valueToAngle(zone.max, options)
+      );
+    }
+  }
+  function zoneMaximumWidth(zone, fallbackWidth) {
+    var _a, _b, _c;
+    if (!(zone == null ? void 0 : zone.taper)) return (_a = zone == null ? void 0 : zone.width) != null ? _a : fallbackWidth;
+    return Math.max(
+      0,
+      finiteNumber(zone.taper.startWidth, (_b = zone.width) != null ? _b : fallbackWidth),
+      finiteNumber(zone.taper.endWidth, (_c = zone.width) != null ? _c : fallbackWidth)
+    );
+  }
+  function includeScale(bounds, options) {
+    const { geometry: geometry2, scale } = options;
+    const lengths = [];
+    if (scale.major.visible) lengths.push(scale.major.length);
+    if (scale.minor.visible) lengths.push(scale.minor.length);
+    if (!lengths.length) return;
+    const length = Math.max(...lengths, 0);
+    let inner = scale.radius;
+    let outer = scale.radius;
+    if (scale.position === "outside") outer += length;
+    else if (scale.position === "cross") {
+      inner -= length / 2;
+      outer += length / 2;
+    } else inner -= length;
+    includeArcSector(bounds, geometry2.centerX, geometry2.centerY, Math.max(0, inner), outer, geometry2.startAngle, geometry2.endAngle);
+  }
+  function includeLabels(bounds, options) {
+    const labels = options.labels;
+    if (!labels.visible) return;
+    const interval = Number(labels.interval) > 0 ? Number(labels.interval) : Math.abs(options.max - options.min) / Math.max(1, options.scale.major.divisions || 5);
+    const values = resolveScaleEndpointValues(buildScaleValues(options.min, options.max, interval), options);
+    for (const value of values) {
+      const point = polarPoint(options.geometry.centerX, options.geometry.centerY, labels.radius, valueToAngle(value, options));
+      let rendered = Number(value).toFixed(labels.fractionDigits);
+      if (typeof labels.formatter === "function") {
+        try {
+          rendered = String(labels.formatter(value, { min: options.min, max: options.max, options }));
+        } catch (e) {
+        }
+      }
+      const halfWidth = Math.max(labels.fontSize * 0.55, rendered.length * labels.fontSize * 0.34);
+      const halfHeight = labels.fontSize * 0.68;
+      includeRect(bounds, point.x - halfWidth, point.y - halfHeight, halfWidth * 2, halfHeight * 2);
+    }
+  }
+  function includePointer(bounds, options) {
+    const { geometry: geometry2, pointer } = options;
+    if (!pointer.visible) return;
+    const expansion = Math.max(pointer.width / 2, pointer.strokeWidth / 2, 1);
+    includeArcSector(
+      bounds,
+      geometry2.centerX,
+      geometry2.centerY,
+      0,
+      pointer.length + expansion,
+      geometry2.startAngle,
+      geometry2.endAngle
+    );
+    if (pointer.tailLength > 0) {
+      includeArcSector(
+        bounds,
+        geometry2.centerX,
+        geometry2.centerY,
+        0,
+        pointer.tailLength + expansion,
+        geometry2.startAngle + 180,
+        geometry2.endAngle + 180
+      );
+    }
+    if (pointer.cap.visible) {
+      const radius = pointer.cap.radius + pointer.cap.strokeWidth / 2;
+      includeRect(bounds, geometry2.centerX - radius, geometry2.centerY - radius, radius * 2, radius * 2);
+    }
+  }
+  function includeLinearTrackAndZones(bounds, options) {
+    var _a, _b;
+    const axis = linearAxis(options);
+    if (options.track.visible) {
+      includeLinearStroke(
+        bounds,
+        axis,
+        valueToLinearPoint(options.min, options),
+        valueToLinearPoint(options.max, options),
+        linearNormalOffset(options.linear.zoneOffset),
+        options.track.width
+      );
+    }
+    for (const zone of options.zones || []) {
+      if (isTransparentColor(zone.color)) continue;
+      includeLinearStroke(
+        bounds,
+        axis,
+        valueToLinearPoint(zone.min, options),
+        valueToLinearPoint(zone.max, options),
+        linearNormalOffset((_a = zone.offset) != null ? _a : options.linear.zoneOffset),
+        (_b = zone.width) != null ? _b : options.track.width
+      );
+    }
+  }
+  function includeLinearScale(bounds, options) {
+    const axis = linearAxis(options);
+    const lengths = [];
+    if (options.scale.major.visible) lengths.push(options.scale.major.length);
+    if (options.scale.minor.visible) lengths.push(options.scale.minor.length);
+    if (!lengths.length) return;
+    const span = linearNormalSpan(Math.max(...lengths, 0), options.linear.tickSide);
+    includeLinearExtent(bounds, axis, span.start, span.end);
+  }
+  function includeLinearLabels(bounds, options) {
+    const labels = options.labels;
+    if (!labels.visible) return;
+    const interval = Number(labels.interval) > 0 ? Number(labels.interval) : Math.abs(options.max - options.min) / Math.max(1, options.scale.major.divisions || 5);
+    const values = buildScaleValues(options.min, options.max, interval);
+    const axis = linearAxis(options);
+    for (const value of values) {
+      const point = offsetLinearPoint(
+        valueToLinearPoint(value, options),
+        axis,
+        linearNormalOffset(options.linear.labelOffset)
+      );
+      let rendered = Number(value).toFixed(labels.fractionDigits);
+      if (typeof labels.formatter === "function") {
+        try {
+          rendered = String(labels.formatter(value, { min: options.min, max: options.max, options }));
+        } catch (e) {
+        }
+      }
+      const halfWidth = Math.max(labels.fontSize * 0.55, rendered.length * labels.fontSize * 0.34);
+      const halfHeight = labels.fontSize * 0.68;
+      includeRect(bounds, point.x - halfWidth, point.y - halfHeight, halfWidth * 2, halfHeight * 2);
+    }
+  }
+  function includeLinearIndicator(bounds, options) {
+    const indicator = options.indicator;
+    if (!indicator.visible) return;
+    const axis = linearAxis(options);
+    const span = linearNormalSpan(
+      indicator.length,
+      indicator.position,
+      linearIndicatorNormalOffset(indicator)
+    );
+    const strokeExpansion = Math.max(indicator.width / 2, indicator.strokeWidth / 2, 1);
+    const normalStart = Math.min(span.start, span.end) - strokeExpansion;
+    const normalEnd = Math.max(span.start, span.end) + strokeExpansion;
+    let tangentExpansion = strokeExpansion;
+    if (indicator.type === "marker") tangentExpansion = Math.max(tangentExpansion, indicator.markerSize);
+    if (indicator.type === "carriage") tangentExpansion = Math.max(tangentExpansion, indicator.carriageWidth / 2);
+    if (indicator.cap.visible) tangentExpansion = Math.max(tangentExpansion, indicator.cap.radius + indicator.cap.strokeWidth / 2);
+    includeLinearExtent(bounds, axis, normalStart, normalEnd, tangentExpansion);
+  }
+  function includeZeroMarker(bounds, options) {
+    var _a, _b;
+    const marker = (_a = options.centerZero) == null ? void 0 : _a.marker;
+    if (!(marker == null ? void 0 : marker.visible)) return;
+    const expansion = Math.max(marker.width / 2, 0.5);
+    if (options.geometry.mode === "linear") {
+      const axis = linearAxis(options);
+      const point = valueToLinearPoint(options.centerZero.zeroValue, options);
+      const span = linearNormalSpan(
+        marker.length,
+        marker.position,
+        linearNormalOffset(marker.centerOffset)
+      );
+      const start2 = offsetLinearPoint(point, axis, span.start);
+      const end2 = offsetLinearPoint(point, axis, span.end);
+      includeRect(
+        bounds,
+        Math.min(start2.x, end2.x) - expansion,
+        Math.min(start2.y, end2.y) - expansion,
+        Math.abs(end2.x - start2.x) + expansion * 2,
+        Math.abs(end2.y - start2.y) + expansion * 2
+      );
+      return;
+    }
+    const angle = valueToAngle(options.centerZero.zeroValue, options);
+    const radius = (_b = marker.radius) != null ? _b : options.scale.radius;
+    const start = polarPoint(
+      options.geometry.centerX,
+      options.geometry.centerY,
+      Math.max(0, radius - marker.length),
+      angle
+    );
+    const end = polarPoint(options.geometry.centerX, options.geometry.centerY, radius, angle);
+    includeRect(
+      bounds,
+      Math.min(start.x, end.x) - expansion,
+      Math.min(start.y, end.y) - expansion,
+      Math.abs(end.x - start.x) + expansion * 2,
+      Math.abs(end.y - start.y) + expansion * 2
+    );
+  }
+  function includeLinearStroke(bounds, axis, startPoint, endPoint, offset, width) {
+    const halfWidth = Math.max(0, finiteNumber(width, 0)) / 2;
+    const start = offsetLinearPoint(startPoint, axis, offset);
+    const end = offsetLinearPoint(endPoint, axis, offset);
+    const minX = Math.min(start.x, end.x) - halfWidth;
+    const minY = Math.min(start.y, end.y) - halfWidth;
+    includeRect(
+      bounds,
+      minX,
+      minY,
+      Math.abs(end.x - start.x) + halfWidth * 2,
+      Math.abs(end.y - start.y) + halfWidth * 2
+    );
+  }
+  function includeLinearExtent(bounds, axis, normalStart, normalEnd, tangentExpansion = 0) {
+    for (const base of [
+      { x: axis.startX, y: axis.startY },
+      { x: axis.endX, y: axis.endY }
+    ]) {
+      for (const normal of [normalStart, normalEnd]) {
+        const point = offsetLinearPoint(base, axis, normal);
+        includePoint(
+          bounds,
+          point.x - axis.tangentX * tangentExpansion,
+          point.y - axis.tangentY * tangentExpansion
+        );
+        includePoint(
+          bounds,
+          point.x + axis.tangentX * tangentExpansion,
+          point.y + axis.tangentY * tangentExpansion
+        );
+      }
+    }
+  }
+  function includeTape(bounds, options) {
+    const box = tapeWindowBox(options);
+    const expansion = Math.max(
+      options.tape.windowStrokeWidth / 2,
+      options.tape.windowInnerStrokeWidth / 2
+    );
+    includeRect(
+      bounds,
+      box.x - expansion,
+      box.y - expansion,
+      box.width + expansion * 2,
+      box.height + expansion * 2
+    );
+  }
+  function includeLight(bounds, options) {
+    const light = options.light;
+    if (!(light == null ? void 0 : light.visible)) return;
+    const point = resolveLightPosition(light, options);
+    const radius = Math.max(1, finiteNumber(light.radius, 8));
+    const halo = light.glow ? radius * 2.96 : radius;
+    const bezel = radius + Math.max(1.5, radius * 0.18);
+    const extent = Math.max(halo, bezel);
+    includeRect(bounds, point.x - extent, point.y - extent, extent * 2, extent * 2);
+  }
+  function includeReadout(bounds, options) {
+    if (!options.readout.visible) return;
+    for (const [kind, part] of Object.entries(options.readout)) {
+      if (kind === "visible" || !(part == null ? void 0 : part.visible)) continue;
+      const text = kind === "value" ? `${part.prefix || ""}${options.max}${part.suffix || ""}` : String(part.text || "");
+      if (!text && kind !== "value") continue;
+      const point = resolveReadoutPosition(part, options);
+      const halfWidth = Math.max(part.fontSize * 0.55, text.length * part.fontSize * 0.34);
+      const halfHeight = part.fontSize * 0.68;
+      includeRect(bounds, point.x - halfWidth, point.y - halfHeight, halfWidth * 2, halfHeight * 2);
+    }
+  }
+  function readoutReferenceBox(options) {
+    const face = options.face;
+    if (face.visible && face.fit !== "content") return { x: face.x, y: face.y, width: face.width, height: face.height };
+    return { x: 0, y: 0, width: options.geometry.width, height: options.geometry.height };
+  }
+  function includeArc(bounds, cx, cy, radius, width, startAngle, endAngle) {
+    const halfWidth = Math.max(0, finiteNumber(width, 0)) / 2;
+    includeArcSector(bounds, cx, cy, Math.max(0, radius - halfWidth), radius + halfWidth, startAngle, endAngle);
+  }
+  function includeArcSector(bounds, cx, cy, innerRadius, outerRadius, startAngle, endAngle) {
+    const angles = [startAngle, endAngle];
+    for (const cardinal of [0, 90, 180, 270]) {
+      if (angleIsWithinSweep(cardinal, startAngle, endAngle)) angles.push(cardinal);
+    }
+    if (innerRadius <= EPSILON) includePoint(bounds, cx, cy);
+    for (const angle of angles) {
+      const outer = polarPoint(cx, cy, Math.max(0, outerRadius), angle);
+      includePoint(bounds, outer.x, outer.y);
+      if (innerRadius > EPSILON) {
+        const inner = polarPoint(cx, cy, innerRadius, angle);
+        includePoint(bounds, inner.x, inner.y);
+      }
+    }
+  }
+  function angleIsWithinSweep(angle, startAngle, endAngle) {
+    const delta = endAngle - startAngle;
+    if (Math.abs(delta) >= 360 - EPSILON) return true;
+    if (delta >= 0) return positiveModulo(angle - startAngle, 360) <= delta + EPSILON;
+    return positiveModulo(startAngle - angle, 360) <= -delta + EPSILON;
+  }
+  function positiveModulo(value, divisor) {
+    return (value % divisor + divisor) % divisor;
+  }
+
+  // src/renderer/svg.js
+  var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+  function svgElement(tagName, attributes = {}, text = null) {
+    const element = document.createElementNS(SVG_NAMESPACE, tagName);
+    setSvgAttributes(element, attributes);
+    if (text !== null && text !== void 0) element.textContent = String(text);
+    return element;
+  }
+  function setSvgAttributes(element, attributes) {
+    for (const [name, value] of Object.entries(attributes || {})) {
+      if (value === null || value === void 0 || value === false) continue;
+      if (name === "className") element.setAttribute("class", String(value));
+      else element.setAttribute(name, String(value));
+    }
+    return element;
+  }
+  var SvgRenderer = class {
+    constructor(host, options) {
+      this.host = host;
+      this.options = options;
+      this.id = uniqueId("gaugeit");
+      this.controllers = [];
+      this.references = /* @__PURE__ */ new Map();
+      this.root = null;
+      this.svg = null;
+      this.content = null;
+      this.contentBounds = null;
+      this.layoutBounds = null;
+      this.contentClipPathId = null;
+    }
+    /** Creates a clean SVG root for a full render. */
+    begin() {
+      this.destroyControllers();
+      this.references.clear();
+      this.contentClipPathId = null;
+      const root = document.createElement("div");
+      root.className = [
+        "gaugeit",
+        `gaugeit--${this.options.type}`,
+        `gaugeit--layout-${this.options.layout.mode}`,
+        this.options.className
+      ].filter(Boolean).join(" ");
+      root.dataset.gaugeitRoot = "true";
+      root.dataset.gaugeitLayout = this.options.layout.mode;
+      this.contentBounds = calculateGaugeBounds(this.options, { includeFace: false, includeBase: false });
+      this.layoutBounds = calculateGaugeBounds(this.options, { contentBounds: this.contentBounds });
+      const initialViewport = padBounds(this.layoutBounds, this.options.layout.padding);
+      const geometry2 = this.options.geometry;
+      const svg = svgElement("svg", {
+        class: "gaugeit__svg",
+        viewBox: viewBoxValue(initialViewport),
+        preserveAspectRatio: geometry2.preserveAspectRatio,
+        focusable: "false"
+      });
+      const title = svgElement("title", { id: `${this.id}-title` }, this.options.accessibility.label);
+      svg.append(title);
+      if (this.options.accessibility.description) {
+        const description = svgElement(
+          "desc",
+          { id: `${this.id}-description` },
+          this.options.accessibility.description
+        );
+        svg.append(description);
+        svg.setAttribute("aria-describedby", description.id);
+      }
+      svg.setAttribute("aria-labelledby", title.id);
+      const content = svgElement("g", {
+        class: "gaugeit__viewport",
+        "data-gaugeit-viewport": "true"
+      });
+      svg.append(content);
+      root.append(svg);
+      this.host.replaceChildren(root);
+      this.host.classList.add("gaugeit-host");
+      this.root = root;
+      this.svg = svg;
+      this.content = content;
+      this.applySizing(initialViewport);
+      return svg;
+    }
+    /** Finalizes the responsive viewBox after all layers have been rendered. */
+    finish() {
+      if (!this.svg || !this.content) return null;
+      const measured = measureContent(this.content);
+      const contentIsClipped = this.options.face.visible && this.options.face.clipContent;
+      const combined = measured && !contentIsClipped ? unionBounds(this.layoutBounds, measured) : this.layoutBounds;
+      const viewport = padBounds(combined, this.options.layout.padding);
+      this.layoutBounds = combined;
+      this.svg.setAttribute("viewBox", viewBoxValue(viewport));
+      this.applySizing(viewport);
+      this.root.dataset.gaugeitViewBox = viewBoxValue(viewport);
+      return viewport;
+    }
+    /** Creates an SVG group for one logical layer. */
+    group(name, attributes = {}) {
+      const clipPath = name !== "face" && this.contentClipPathId ? `url(#${this.contentClipPathId})` : void 0;
+      const group = svgElement("g", {
+        class: `gaugeit__layer gaugeit__layer--${name}`,
+        "data-gaugeit-layer": name,
+        "clip-path": clipPath,
+        ...attributes
+      });
+      this.content.append(group);
+      return group;
+    }
+    /** Clips subsequently created non-face layers to a reusable SVG clip path. */
+    setContentClipPath(clipPathId) {
+      this.contentClipPathId = clipPathId ? String(clipPathId) : null;
+    }
+    /** Returns conservative content bounds available before layer rendering. */
+    getContentBounds() {
+      return this.contentBounds;
+    }
+    /** Stores a generated node or value for later dynamic updates. */
+    setReference(name, value) {
+      this.references.set(name, value);
+      return value;
+    }
+    getReference(name) {
+      return this.references.get(name);
+    }
+    addController(controller) {
+      if (controller && typeof controller.update === "function") this.controllers.push(controller);
+    }
+    update(value, state) {
+      for (const controller of this.controllers) controller.update(value, state);
+    }
+    destroyControllers() {
+      for (const controller of this.controllers) {
+        if (typeof controller.destroy === "function") controller.destroy();
+      }
+      this.controllers = [];
+    }
+    destroy() {
+      this.destroyControllers();
+      this.references.clear();
+      if (this.root && this.root.parentNode === this.host) this.root.remove();
+      this.host.classList.remove("gaugeit-host");
+      this.root = null;
+      this.svg = null;
+      this.content = null;
+      this.contentBounds = null;
+      this.layoutBounds = null;
+      this.contentClipPathId = null;
+    }
+    applySizing(viewport) {
+      const responsive = this.options.responsive;
+      const contain = this.options.layout.mode === "contain";
+      this.root.style.width = responsive ? "100%" : `${viewport.width}px`;
+      this.root.style.maxWidth = "100%";
+      this.root.style.height = contain ? "100%" : "auto";
+      this.svg.style.display = "block";
+      this.svg.style.width = responsive ? "100%" : `${viewport.width}px`;
+      this.svg.style.height = contain ? "100%" : "auto";
+      this.svg.style.maxWidth = "100%";
+      this.svg.style.maxHeight = contain ? "100%" : "none";
+      this.svg.style.overflow = "hidden";
+    }
+  };
+  function viewBoxValue(bounds) {
+    return `${round(bounds.x)} ${round(bounds.y)} ${round(bounds.width)} ${round(bounds.height)}`;
+  }
+  function round(value) {
+    return Math.round(value * 1e3) / 1e3;
+  }
+  function measureContent(content) {
+    if (typeof content.getBBox !== "function") return null;
+    try {
+      const box = content.getBBox();
+      if (![box.x, box.y, box.width, box.height].every(Number.isFinite)) return null;
+      if (box.width <= 0 && box.height <= 0) return null;
+      return { x: box.x, y: box.y, width: Math.max(1, box.width), height: Math.max(1, box.height) };
+    } catch (e) {
+      return null;
+    }
+  }
+
+  // src/core/easing.js
+  var EASINGS = {
+    linear: (t) => t,
+    easeInQuad: (t) => t * t,
+    easeOutQuad: (t) => t * (2 - t),
+    easeInOutQuad: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+    easeOutCubic: (t) => 1 - Math.pow(1 - t, 3),
+    easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2,
+    easeOutBack: (t) => {
+      const c1 = 1.70158;
+      const c3 = c1 + 1;
+      return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+    }
+  };
+  function resolveEasing(easing) {
+    if (typeof easing === "function") return easing;
+    return EASINGS[easing] || EASINGS.easeOutCubic;
+  }
+  var easingNames = Object.freeze(Object.keys(EASINGS));
+
+  // src/core/defaults.js
+  var BASE_DEFAULTS = Object.freeze({
+    type: "arc",
+    min: 0,
+    max: 100,
+    value: 0,
+    invert: false,
+    overflow: "clamp",
+    precision: 3,
+    className: "",
+    layout: {
+      mode: "intrinsic",
+      padding: 8,
+      includeGeometry: true
+    },
+    geometry: {
+      mode: "radial",
+      width: 320,
+      height: 220,
+      centerX: 160,
+      centerY: 174,
+      radius: 120,
+      startAngle: 180,
+      endAngle: 360,
+      preserveAspectRatio: "xMidYMid meet",
+      aspectRatio: null
+    },
+    linear: {
+      originY: 140,
+      startX: 36,
+      startY: 0,
+      endX: 284,
+      endY: 0,
+      tickSide: "negative",
+      labelOffset: 34,
+      zoneOffset: -12
+    },
+    face: {
+      visible: false,
+      shape: "panel",
+      fit: "geometry",
+      contentPadding: 8,
+      minWidth: null,
+      minHeight: null,
+      clipContent: false,
+      x: 6,
+      y: 6,
+      width: 308,
+      height: 208,
+      cornerRadius: 18,
+      color: "#ffffff",
+      strokeColor: "#d1d5db",
+      strokeWidth: 2,
+      innerStrokeColor: "#f3f4f6",
+      innerStrokeWidth: 1,
+      shadow: false,
+      glass: false
+    },
+    track: {
+      visible: true,
+      color: "#e5e7eb",
+      width: 28,
+      radius: 112,
+      opacity: 1,
+      lineCap: "butt",
+      showUnderZones: false
+    },
+    zones: [],
+    scale: {
+      endpointMode: "auto",
+      radius: 112,
+      position: "inside",
+      major: {
+        visible: true,
+        interval: null,
+        divisions: 5,
+        length: 13,
+        width: 2,
+        color: "#111827",
+        opacity: 1
+      },
+      minor: {
+        visible: true,
+        subdivisions: 4,
+        length: 7,
+        width: 1,
+        color: "#6b7280",
+        opacity: 0.9
+      }
+    },
+    labels: {
+      visible: true,
+      interval: null,
+      radius: 84,
+      color: "#111827",
+      fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
+      fontSize: 11,
+      fontWeight: 500,
+      fractionDigits: 0,
+      rotation: "horizontal",
+      formatter: null
+    },
+    pointer: {
+      visible: true,
+      type: "needle",
+      length: 94,
+      shaftLength: null,
+      tailLength: 13,
+      width: 8,
+      color: "#111827",
+      strokeColor: "none",
+      strokeWidth: 0,
+      opacity: 1,
+      colorByZone: false,
+      cap: {
+        visible: true,
+        stackOrder: "above",
+        radius: 8,
+        color: "#111827",
+        strokeColor: "#ffffff",
+        strokeWidth: 2
+      }
+    },
+    indicator: {
+      visible: false,
+      type: "hairline",
+      position: "cross",
+      length: 76,
+      centerOffset: null,
+      offset: 0,
+      width: 2,
+      color: "#b91c1c",
+      strokeColor: "none",
+      strokeWidth: 0,
+      opacity: 1,
+      lineCap: "round",
+      colorByZone: false,
+      markerSize: 8,
+      carriageWidth: 14,
+      carriageRadius: 4,
+      cap: {
+        visible: false,
+        stackOrder: "above",
+        radius: 4,
+        color: "#b91c1c",
+        strokeColor: "#ffffff",
+        strokeWidth: 1
+      }
+    },
+    centerZero: {
+      zeroValue: 0,
+      symmetric: false,
+      marker: {
+        visible: false,
+        radius: null,
+        position: "cross",
+        centerOffset: 0,
+        length: 20,
+        width: 3,
+        color: "#111827",
+        opacity: 1,
+        lineCap: "round"
+      }
+    },
+    tape: {
+      orientation: "vertical",
+      x: 64,
+      y: 58,
+      width: 192,
+      height: 210,
+      cornerRadius: 12,
+      windowColor: "#e5e7eb",
+      windowStrokeColor: "#475569",
+      windowStrokeWidth: 2,
+      windowInnerStrokeColor: "#d1d5db",
+      windowInnerStrokeWidth: 1,
+      stripColor: "#ffffff",
+      textColor: "#111827",
+      tickColor: "#334155",
+      minorTickColor: "#64748b",
+      minorTickOpacity: 0.85,
+      majorTickWidth: 2,
+      minorTickWidth: 1,
+      majorTickLength: 24,
+      minorTickLength: 12,
+      tickInset: 64,
+      labelOffset: 10,
+      interval: null,
+      minorSubdivisions: 4,
+      majorSpacing: 52,
+      indicatorColor: "#b91c1c",
+      indicatorWidth: 2.5,
+      fadeSize: 32,
+      fadeColor: "#ffffff",
+      colorByZone: false
+    },
+    light: {
+      visible: false,
+      x: 160,
+      y: 110,
+      radius: 8,
+      color: "amber",
+      customColor: "",
+      offColor: "#f3ead6",
+      offEdgeColor: "#817768",
+      bezelColor: "#4b5563",
+      bezelHighlightColor: "#f8fafc",
+      opacity: 1,
+      on: false,
+      glow: true,
+      pulse: true,
+      pulseInterval: 2600,
+      blink: false,
+      blinkInterval: 1e3,
+      trigger: {
+        mode: "manual",
+        source: "target",
+        value: 0,
+        min: 0,
+        max: 0
+      }
+    },
+    readout: {
+      visible: true,
+      title: {
+        visible: false,
+        text: "",
+        x: "auto",
+        y: "auto",
+        position: "top",
+        margin: 12,
+        offsetX: 0,
+        offsetY: 0,
+        color: "#374151",
+        fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
+        fontSize: 14,
+        fontWeight: 700,
+        letterSpacing: 0.8
+      },
+      value: {
+        visible: false,
+        x: "auto",
+        y: 54,
+        position: "center",
+        margin: 12,
+        offsetX: 0,
+        offsetY: 0,
+        color: "#111827",
+        fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
+        fontSize: 38,
+        fontWeight: 750,
+        fractionDigits: 0,
+        prefix: "",
+        suffix: "",
+        locale: void 0,
+        formatter: null
+      },
+      unit: {
+        visible: false,
+        text: "",
+        x: "auto",
+        y: 76,
+        position: "bottom",
+        margin: 12,
+        offsetX: 0,
+        offsetY: 0,
+        color: "#6b7280",
+        fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
+        fontSize: 12,
+        fontWeight: 600
+      }
+    },
+    animation: {
+      enabled: true,
+      duration: 850,
+      easing: "easeOutCubic",
+      animateOnInit: true,
+      startFrom: "min",
+      respectReducedMotion: true
+    },
+    effects: {
+      jitter: {
+        enabled: false,
+        amplitude: 0.45,
+        amplitudeUnit: "value",
+        frequency: 4,
+        smoothing: 0.86,
+        whenIdleOnly: true
+      }
+    },
+    accessibility: {
+      label: "Gauge",
+      description: "",
+      valueText: null
+    },
+    performance: {
+      pauseWhenHidden: true,
+      pauseWhenOffscreen: true
+    },
+    responsive: true
+  });
+
+  // src/core/options.js
+  var VALID_OVERFLOW = /* @__PURE__ */ new Set(["clamp", "expand", "allow"]);
+  var VALID_POINTERS = /* @__PURE__ */ new Set(["needle", "line", "arrow", "spear"]);
+  var VALID_POSITIONS = /* @__PURE__ */ new Set(["inside", "outside", "cross"]);
+  var VALID_ROTATIONS = /* @__PURE__ */ new Set(["horizontal", "radial", "tangent"]);
+  var VALID_LAYOUT_MODES = /* @__PURE__ */ new Set(["intrinsic", "contain"]);
+  var VALID_FACE_FITS = /* @__PURE__ */ new Set(["geometry", "content"]);
+  var VALID_FACE_SHAPES = /* @__PURE__ */ new Set(["panel", "circle"]);
+  var VALID_ENDPOINT_MODES = /* @__PURE__ */ new Set(["auto", "both", "dedupe"]);
+  var VALID_READOUT_POSITIONS = /* @__PURE__ */ new Set(["top", "center", "bottom"]);
+  var VALID_GEOMETRY_MODES = /* @__PURE__ */ new Set(["radial", "linear", "tape"]);
+  var VALID_LINEAR_TICK_SIDES = /* @__PURE__ */ new Set(["negative", "positive", "cross"]);
+  var VALID_INDICATOR_TYPES = /* @__PURE__ */ new Set(["hairline", "marker", "carriage"]);
+  var VALID_INDICATOR_POSITIONS = /* @__PURE__ */ new Set(["negative", "positive", "cross"]);
+  var VALID_CAP_STACK_ORDERS = /* @__PURE__ */ new Set(["above", "below"]);
+  var VALID_ORIENTATIONS = /* @__PURE__ */ new Set(["vertical", "horizontal"]);
+  var VALID_LIGHT_COLORS = /* @__PURE__ */ new Set([
+    "red",
+    "green",
+    "blue",
+    "amber",
+    "yellow",
+    "orange",
+    "white",
+    "halogen",
+    "cyan",
+    "brown"
+  ]);
+  var VALID_LIGHT_TRIGGER_MODES = /* @__PURE__ */ new Set(["manual", "below", "above", "between"]);
+  var VALID_LIGHT_TRIGGER_SOURCES = /* @__PURE__ */ new Set(["target", "displayed", "pointer"]);
+  function resolveGaugeOptions(userOptions, registry) {
+    const requested = isPlainObject(userOptions) ? userOptions : {};
+    const requestedType = String(requested.type || BASE_DEFAULTS.type);
+    const typeDefinition = registry.get(requestedType);
+    const fallbacks = deepMerge(BASE_DEFAULTS, typeDefinition.defaults);
+    let options = deepMerge(fallbacks, requested);
+    options.type = requestedType;
+    options = restoreOptionShape(options, fallbacks);
+    if (typeof typeDefinition.configure === "function") {
+      const configured = typeDefinition.configure(options, {
+        requested,
+        typeDefaults: typeDefinition.defaults
+      });
+      if (isPlainObject(configured)) options = configured;
+    }
+    options = restoreOptionShape(options, fallbacks);
+    options.min = finiteNumber(options.min, 0);
+    options.max = finiteNumber(options.max, 100);
+    if (options.max <= options.min) options.max = options.min + 1;
+    options.value = finiteNumber(options.value, options.min);
+    options.invert = options.invert === true;
+    options.precision = Math.max(0, Math.min(12, Math.floor(finiteNumber(options.precision, 3))));
+    options.overflow = VALID_OVERFLOW.has(options.overflow) ? options.overflow : "clamp";
+    validateLayout(options.layout);
+    validateGeometry(options.geometry);
+    validateLinear(options.linear);
+    validateFace(options.face);
+    validateScale(options);
+    validatePointer(options.pointer);
+    validateIndicator(options.indicator, requested.indicator);
+    validateCenterZero(options.centerZero, options);
+    validateTape(options.tape);
+    validateLight(options.light);
+    validateLabels(options.labels);
+    validateReadout(options.readout);
+    validateAnimation(options.animation);
+    validateJitter(options.effects.jitter);
+    options.zones = normalizeZones(options.zones, options.min, options.max, options.track.width);
+    return options;
+  }
+  function resolveMajorInterval(options) {
+    const explicit = finiteNumber(options.scale.major.interval, 0);
+    if (explicit > 0) return explicit;
+    const divisions = Math.max(1, Math.floor(finiteNumber(options.scale.major.divisions, 5)));
+    return niceInterval(options.max - options.min, divisions);
+  }
+  function mergeUserOptions(currentUserOptions, patch) {
+    return deepMerge(currentUserOptions || {}, patch || {});
+  }
+  function validateLayout(layout) {
+    layout.mode = VALID_LAYOUT_MODES.has(layout.mode) ? layout.mode : "intrinsic";
+    layout.padding = Math.max(0, finiteNumber(layout.padding, 8));
+    layout.includeGeometry = layout.includeGeometry !== false;
+  }
+  function validateGeometry(geometry2) {
+    geometry2.mode = VALID_GEOMETRY_MODES.has(geometry2.mode) ? geometry2.mode : "radial";
+    geometry2.width = Math.max(40, finiteNumber(geometry2.width, 320));
+    geometry2.height = Math.max(40, finiteNumber(geometry2.height, 220));
+    geometry2.centerX = finiteNumber(geometry2.centerX, geometry2.width / 2);
+    geometry2.centerY = finiteNumber(geometry2.centerY, geometry2.height * 0.78);
+    geometry2.radius = Math.max(1, finiteNumber(geometry2.radius, Math.min(geometry2.width, geometry2.height) * 0.4));
+    geometry2.startAngle = finiteNumber(geometry2.startAngle, 180);
+    geometry2.endAngle = finiteNumber(geometry2.endAngle, 360);
+    if (Math.abs(geometry2.endAngle - geometry2.startAngle) < 1e-3) geometry2.endAngle = geometry2.startAngle + 180;
+    if (Math.abs(geometry2.endAngle - geometry2.startAngle) > 360) {
+      geometry2.endAngle = geometry2.startAngle + Math.sign(geometry2.endAngle - geometry2.startAngle) * 360;
+    }
+    geometry2.preserveAspectRatio = String(geometry2.preserveAspectRatio || "xMidYMid meet");
+    geometry2.aspectRatio = geometry2.aspectRatio === null || geometry2.aspectRatio === void 0 ? null : Math.max(1e-6, finiteNumber(geometry2.aspectRatio, geometry2.width / geometry2.height));
+  }
+  function validateLinear(linear) {
+    linear.originY = finiteNumber(linear.originY, 140);
+    linear.startX = finiteNumber(linear.startX, 36);
+    linear.startY = finiteNumber(linear.startY, 0);
+    linear.endX = finiteNumber(linear.endX, 284);
+    linear.endY = finiteNumber(linear.endY, linear.startY);
+    if (Math.hypot(linear.endX - linear.startX, linear.endY - linear.startY) < 1e-3) {
+      linear.endX = linear.startX + 1;
+      linear.endY = linear.startY;
+    }
+    linear.tickSide = VALID_LINEAR_TICK_SIDES.has(linear.tickSide) ? linear.tickSide : "negative";
+    linear.labelOffset = finiteNumber(linear.labelOffset, 34);
+    linear.zoneOffset = finiteNumber(linear.zoneOffset, -12);
+  }
+  function validateFace(face) {
+    face.shape = VALID_FACE_SHAPES.has(face.shape) ? face.shape : "panel";
+    face.fit = VALID_FACE_FITS.has(face.fit) ? face.fit : "geometry";
+    face.contentPadding = Math.max(0, finiteNumber(face.contentPadding, 8));
+    face.minWidth = face.minWidth === null || face.minWidth === void 0 ? null : Math.max(1, finiteNumber(face.minWidth, 1));
+    face.minHeight = face.minHeight === null || face.minHeight === void 0 ? null : Math.max(1, finiteNumber(face.minHeight, 1));
+    face.clipContent = face.clipContent === true;
+    face.x = finiteNumber(face.x, 6);
+    face.y = finiteNumber(face.y, 6);
+    face.width = Math.max(1, finiteNumber(face.width, 308));
+    face.height = Math.max(1, finiteNumber(face.height, 208));
+    face.cornerRadius = Math.max(0, finiteNumber(face.cornerRadius, 18));
+    face.strokeWidth = Math.max(0, finiteNumber(face.strokeWidth, 2));
+    face.innerStrokeWidth = Math.max(0, finiteNumber(face.innerStrokeWidth, 1));
+  }
+  function validateScale(options) {
+    options.scale.endpointMode = VALID_ENDPOINT_MODES.has(options.scale.endpointMode) ? options.scale.endpointMode : "auto";
+    options.scale.radius = Math.max(1, finiteNumber(options.scale.radius, options.geometry.radius));
+    options.scale.position = VALID_POSITIONS.has(options.scale.position) ? options.scale.position : "inside";
+    options.scale.major.divisions = Math.max(1, Math.floor(finiteNumber(options.scale.major.divisions, 5)));
+    options.scale.major.length = Math.max(0, finiteNumber(options.scale.major.length, 13));
+    options.scale.major.width = Math.max(0, finiteNumber(options.scale.major.width, 2));
+    options.scale.minor.subdivisions = Math.max(0, Math.floor(finiteNumber(options.scale.minor.subdivisions, 4)));
+    options.scale.minor.length = Math.max(0, finiteNumber(options.scale.minor.length, 7));
+    options.scale.minor.width = Math.max(0, finiteNumber(options.scale.minor.width, 1));
+  }
+  function validatePointer(pointer) {
+    pointer.type = VALID_POINTERS.has(pointer.type) ? pointer.type : "needle";
+    pointer.length = Math.max(0, finiteNumber(pointer.length, 94));
+    pointer.shaftLength = pointer.shaftLength === null || pointer.shaftLength === void 0 ? null : Math.min(pointer.length, Math.max(0, finiteNumber(pointer.shaftLength, pointer.length)));
+    pointer.tailLength = Math.max(0, finiteNumber(pointer.tailLength, 13));
+    pointer.width = Math.max(0.5, finiteNumber(pointer.width, 8));
+    pointer.strokeWidth = Math.max(0, finiteNumber(pointer.strokeWidth, 0));
+    pointer.cap.radius = Math.max(0, finiteNumber(pointer.cap.radius, 8));
+    pointer.cap.strokeWidth = Math.max(0, finiteNumber(pointer.cap.strokeWidth, 2));
+    pointer.cap.stackOrder = VALID_CAP_STACK_ORDERS.has(pointer.cap.stackOrder) ? pointer.cap.stackOrder : "above";
+  }
+  function validateIndicator(indicator, requestedIndicator = {}) {
+    indicator.visible = indicator.visible === true;
+    indicator.type = VALID_INDICATOR_TYPES.has(indicator.type) ? indicator.type : "hairline";
+    indicator.position = VALID_INDICATOR_POSITIONS.has(indicator.position) ? indicator.position : "cross";
+    indicator.length = Math.max(0, finiteNumber(indicator.length, 76));
+    const explicitCenterOffset = isPlainObject(requestedIndicator) && Object.prototype.hasOwnProperty.call(requestedIndicator, "centerOffset");
+    const explicitLegacyOffset = isPlainObject(requestedIndicator) && Object.prototype.hasOwnProperty.call(requestedIndicator, "offset");
+    if (explicitCenterOffset) indicator.centerOffset = finiteNumber(requestedIndicator.centerOffset, 0);
+    else if (explicitLegacyOffset) indicator.centerOffset = -finiteNumber(requestedIndicator.offset, 0);
+    else if (indicator.centerOffset === null || indicator.centerOffset === void 0) {
+      indicator.centerOffset = -finiteNumber(indicator.offset, 0);
+    } else indicator.centerOffset = finiteNumber(indicator.centerOffset, 0);
+    indicator.offset = -indicator.centerOffset;
+    indicator.width = Math.max(0.5, finiteNumber(indicator.width, 2));
+    indicator.strokeWidth = Math.max(0, finiteNumber(indicator.strokeWidth, 0));
+    indicator.opacity = Math.min(1, Math.max(0, finiteNumber(indicator.opacity, 1)));
+    indicator.markerSize = Math.max(1, finiteNumber(indicator.markerSize, 8));
+    indicator.carriageWidth = Math.max(1, finiteNumber(indicator.carriageWidth, 14));
+    indicator.carriageRadius = Math.max(0, finiteNumber(indicator.carriageRadius, 4));
+    indicator.cap.radius = Math.max(0, finiteNumber(indicator.cap.radius, 4));
+    indicator.cap.strokeWidth = Math.max(0, finiteNumber(indicator.cap.strokeWidth, 1));
+    indicator.cap.stackOrder = VALID_CAP_STACK_ORDERS.has(indicator.cap.stackOrder) ? indicator.cap.stackOrder : "above";
+  }
+  function validateCenterZero(centerZero, options) {
+    centerZero.zeroValue = finiteNumber(centerZero.zeroValue, 0);
+    centerZero.symmetric = centerZero.symmetric === true;
+    if (centerZero.symmetric) {
+      const magnitude = Math.max(
+        Math.abs(options.min - centerZero.zeroValue),
+        Math.abs(options.max - centerZero.zeroValue),
+        1
+      );
+      options.min = centerZero.zeroValue - magnitude;
+      options.max = centerZero.zeroValue + magnitude;
+    }
+    centerZero.marker.visible = centerZero.marker.visible === true;
+    centerZero.marker.radius = centerZero.marker.radius === null || centerZero.marker.radius === void 0 ? null : Math.max(0, finiteNumber(centerZero.marker.radius, options.scale.radius));
+    centerZero.marker.position = VALID_INDICATOR_POSITIONS.has(centerZero.marker.position) ? centerZero.marker.position : "cross";
+    centerZero.marker.centerOffset = finiteNumber(centerZero.marker.centerOffset, 0);
+    centerZero.marker.length = Math.max(0, finiteNumber(centerZero.marker.length, 20));
+    centerZero.marker.width = Math.max(0.5, finiteNumber(centerZero.marker.width, 3));
+    centerZero.marker.opacity = Math.min(1, Math.max(0, finiteNumber(centerZero.marker.opacity, 1)));
+    centerZero.marker.lineCap = String(centerZero.marker.lineCap || "round");
+  }
+  function validateTape(tape) {
+    tape.orientation = VALID_ORIENTATIONS.has(tape.orientation) ? tape.orientation : "vertical";
+    tape.x = finiteNumber(tape.x, 64);
+    tape.y = finiteNumber(tape.y, 58);
+    tape.width = Math.max(20, finiteNumber(tape.width, 192));
+    tape.height = Math.max(20, finiteNumber(tape.height, 210));
+    tape.cornerRadius = Math.max(0, finiteNumber(tape.cornerRadius, 12));
+    tape.windowStrokeWidth = Math.max(0, finiteNumber(tape.windowStrokeWidth, 2));
+    tape.windowInnerStrokeWidth = Math.max(0, finiteNumber(tape.windowInnerStrokeWidth, 1));
+    tape.minorTickOpacity = Math.min(1, Math.max(0, finiteNumber(tape.minorTickOpacity, 0.85)));
+    tape.majorTickWidth = Math.max(0.5, finiteNumber(tape.majorTickWidth, 2));
+    tape.minorTickWidth = Math.max(0.5, finiteNumber(tape.minorTickWidth, 1));
+    tape.majorTickLength = Math.max(0, finiteNumber(tape.majorTickLength, 24));
+    tape.minorTickLength = Math.max(0, finiteNumber(tape.minorTickLength, 12));
+    tape.tickInset = finiteNumber(tape.tickInset, 64);
+    tape.labelOffset = finiteNumber(tape.labelOffset, 10);
+    tape.interval = tape.interval === null || tape.interval === void 0 ? null : Math.max(1e-6, finiteNumber(tape.interval, 1));
+    tape.minorSubdivisions = Math.max(0, Math.floor(finiteNumber(tape.minorSubdivisions, 4)));
+    tape.majorSpacing = Math.max(2, finiteNumber(tape.majorSpacing, 52));
+    tape.indicatorWidth = Math.max(0.5, finiteNumber(tape.indicatorWidth, 2.5));
+    const fadeAxisSize = tape.orientation === "horizontal" ? tape.width : tape.height;
+    tape.fadeSize = Math.min(fadeAxisSize / 2, Math.max(0, finiteNumber(tape.fadeSize, 32)));
+    tape.colorByZone = tape.colorByZone === true;
+  }
+  function validateLight(light) {
+    light.visible = light.visible === true;
+    light.x = finiteNumber(light.x, 160);
+    light.y = finiteNumber(light.y, 110);
+    light.radius = Math.max(1, finiteNumber(light.radius, 8));
+    light.color = VALID_LIGHT_COLORS.has(light.color) ? light.color : "amber";
+    light.customColor = light.customColor === null || light.customColor === void 0 ? "" : String(light.customColor).trim();
+    light.offColor = normalizeColor(light.offColor, "#f3ead6");
+    light.offEdgeColor = normalizeColor(light.offEdgeColor, "#817768");
+    light.bezelColor = normalizeColor(light.bezelColor, "#4b5563");
+    light.bezelHighlightColor = normalizeColor(light.bezelHighlightColor, "#f8fafc");
+    light.opacity = Math.min(1, Math.max(0, finiteNumber(light.opacity, 1)));
+    light.on = light.on === true;
+    light.glow = light.glow !== false;
+    light.pulse = light.pulse !== false;
+    light.pulseInterval = Math.max(400, finiteNumber(light.pulseInterval, 2600));
+    light.blink = light.blink === true;
+    light.blinkInterval = Math.max(100, finiteNumber(light.blinkInterval, 1e3));
+    light.trigger = isPlainObject(light.trigger) ? light.trigger : {};
+    light.trigger.mode = VALID_LIGHT_TRIGGER_MODES.has(light.trigger.mode) ? light.trigger.mode : "manual";
+    light.trigger.source = VALID_LIGHT_TRIGGER_SOURCES.has(light.trigger.source) ? light.trigger.source : "target";
+    light.trigger.value = finiteNumber(light.trigger.value, 0);
+    light.trigger.min = finiteNumber(light.trigger.min, light.trigger.value);
+    light.trigger.max = finiteNumber(light.trigger.max, light.trigger.value);
+    if (light.trigger.max < light.trigger.min) {
+      [light.trigger.min, light.trigger.max] = [light.trigger.max, light.trigger.min];
+    }
+  }
+  function normalizeColor(value, fallback) {
+    if (value === null || value === void 0) return fallback;
+    const normalized = String(value).trim();
+    return normalized || fallback;
+  }
+  function validateLabels(labels) {
+    labels.radius = Math.max(0, finiteNumber(labels.radius, 84));
+    labels.fontSize = Math.max(1, finiteNumber(labels.fontSize, 11));
+    labels.fractionDigits = Math.max(0, Math.min(12, Math.floor(finiteNumber(labels.fractionDigits, 0))));
+    labels.rotation = VALID_ROTATIONS.has(labels.rotation) ? labels.rotation : "horizontal";
+  }
+  function validateReadout(readout) {
+    readout.visible = readout.visible !== false;
+    validateReadoutPart(readout.title, 14);
+    validateReadoutPart(readout.value, 38);
+    validateReadoutPart(readout.unit, 12);
+    readout.value.fractionDigits = Math.max(
+      0,
+      Math.min(12, Math.floor(finiteNumber(readout.value.fractionDigits, 0)))
+    );
+  }
+  function validateReadoutPart(part, defaultFontSize) {
+    part.visible = part.visible === true;
+    part.x = part.x === "auto" ? "auto" : finiteNumber(part.x, 160);
+    part.y = part.y === "auto" ? "auto" : finiteNumber(part.y, 0);
+    part.position = VALID_READOUT_POSITIONS.has(part.position) ? part.position : "top";
+    part.margin = Math.max(0, finiteNumber(part.margin, 12));
+    part.offsetX = finiteNumber(part.offsetX, 0);
+    part.offsetY = finiteNumber(part.offsetY, 0);
+    part.fontSize = Math.max(1, finiteNumber(part.fontSize, defaultFontSize));
+    part.letterSpacing = finiteNumber(part.letterSpacing, 0);
+  }
+  function validateAnimation(animation) {
+    animation.duration = Math.max(0, finiteNumber(animation.duration, 850));
+    if (typeof animation.startFrom !== "number" && !["min", "max", "value"].includes(animation.startFrom)) {
+      animation.startFrom = "min";
+    }
+  }
+  function validateJitter(jitter) {
+    jitter.amplitude = Math.max(0, finiteNumber(jitter.amplitude, 0.45));
+    jitter.amplitudeUnit = jitter.amplitudeUnit === "percent" ? "percent" : "value";
+    jitter.frequency = Math.max(0.1, finiteNumber(jitter.frequency, 4));
+    jitter.smoothing = Math.min(0.999, Math.max(0, finiteNumber(jitter.smoothing, 0.86)));
+  }
+  function normalizeZones(zones, min, max, defaultWidth) {
+    if (!Array.isArray(zones)) return [];
+    return zones.filter(isPlainObject).map((zone) => {
+      var _a, _b;
+      const width = zone.width === void 0 ? void 0 : Math.max(0, finiteNumber(zone.width, 0));
+      const taper = normalizeZoneTaper(zone.taper, width != null ? width : defaultWidth);
+      return {
+        ...zone,
+        min: Math.max(min, finiteNumber(zone.min, min)),
+        max: Math.min(max, finiteNumber(zone.max, max)),
+        color: (_b = (_a = zone.color) != null ? _a : zone.strokeStyle) != null ? _b : "transparent",
+        width,
+        taper,
+        radius: zone.radius === void 0 ? void 0 : Math.max(0, finiteNumber(zone.radius, 0)),
+        offset: zone.offset === void 0 ? void 0 : finiteNumber(zone.offset, 0),
+        opacity: zone.opacity === void 0 ? 1 : Math.min(1, Math.max(0, finiteNumber(zone.opacity, 1)))
+      };
+    }).filter((zone) => zone.max > zone.min);
+  }
+  function restoreOptionShape(options, fallbacks) {
+    if (!isPlainObject(options)) return cloneValue(fallbacks);
+    for (const [key, fallback] of Object.entries(fallbacks)) {
+      if (!isPlainObject(fallback)) continue;
+      options[key] = restoreOptionShape(options[key], fallback);
+    }
+    return options;
+  }
+  function normalizeZoneTaper(taper, fallbackWidth) {
+    var _a;
+    if (!isPlainObject(taper)) return void 0;
+    const startWidth = taper.startWidth === void 0 ? fallbackWidth : Math.max(0, finiteNumber(taper.startWidth, fallbackWidth != null ? fallbackWidth : 0));
+    const endWidth = taper.endWidth === void 0 ? fallbackWidth : Math.max(0, finiteNumber(taper.endWidth, (_a = fallbackWidth != null ? fallbackWidth : startWidth) != null ? _a : 0));
+    return {
+      startWidth,
+      endWidth,
+      segments: Math.max(2, Math.min(256, Math.floor(finiteNumber(taper.segments, 48))))
+    };
+  }
+
+  // src/core/gauge.js
+  var Gauge = class {
+    constructor(target, userOptions, registry, lifecycle = {}) {
+      this.host = resolveElement(target);
+      this.registry = registry;
+      this._onDestroy = typeof lifecycle.onDestroy === "function" ? lifecycle.onDestroy : null;
+      this.userOptions = mergeUserOptions({}, userOptions || {});
+      this.options = resolveGaugeOptions(this.userOptions, registry);
+      this.renderer = new SvgRenderer(this.host, this.options);
+      this._destroyed = false;
+      this._paused = false;
+      this._pausedAt = 0;
+      this._lifecycleSuspendedAt = 0;
+      this._onscreen = true;
+      this._frameHandle = null;
+      this._animation = null;
+      this._targetValue = this._normalizeIncomingValue(this.options.value);
+      this._baseValue = this._targetValue;
+      this._displayValue = this._targetValue;
+      this._pointerValue = this._targetValue;
+      this._jitterOffset = 0;
+      this._jitterTarget = 0;
+      this._lastJitterTargetAt = 0;
+      this._lastFrameAt = 0;
+      this._visibilityHandler = null;
+      this._intersectionObserver = null;
+      this._syncLifecycleObservers();
+      this.render();
+      this._initializeValue();
+    }
+    /** Fully rebuilds static layers and dynamic controllers. */
+    render() {
+      this._assertAlive();
+      this.renderer.options = this.options;
+      this.renderer.begin();
+      const definition = this.registry.get(this.options.type);
+      const context = {
+        gauge: this,
+        options: this.options,
+        renderer: this.renderer,
+        registry: this.registry
+      };
+      for (const layer of definition.layers) {
+        const controller = layer.render(context);
+        this.renderer.addController(controller);
+      }
+      this._updateDynamic(this._displayValue, true, this._pointerValue);
+      this.renderer.finish();
+      dispatchGaugeEvent(this.host, "render", {
+        gauge: this,
+        type: this.options.type,
+        value: this._targetValue
+      });
+      return this;
+    }
+    /** Sets a new gauge value. */
+    setValue(value, updateOptions = {}) {
+      this._assertAlive();
+      const normalized = this._normalizeIncomingValue(value);
+      const duration = Math.max(0, finiteNumber(updateOptions.duration, this.options.animation.duration));
+      const animate = updateOptions.animate !== false && this.options.animation.enabled && duration > 0 && !this._prefersReducedMotion();
+      this._targetValue = normalized;
+      this.options.value = normalized;
+      if (!animate) {
+        this._animation = null;
+        this._baseValue = normalized;
+        this._displayValue = normalized;
+        this._pointerValue = normalized;
+        this._jitterOffset = 0;
+        this._updateDynamic(normalized, true, normalized);
+        this._ensureLoop();
+        this._emitChange();
+        return this;
+      }
+      const easing = resolveEasing(updateOptions.easing || this.options.animation.easing);
+      const now = performanceNow();
+      this._animation = {
+        from: this._baseValue,
+        to: normalized,
+        startedAt: now,
+        duration,
+        easing
+      };
+      dispatchGaugeEvent(this.host, "animationstart", {
+        gauge: this,
+        from: this._animation.from,
+        to: normalized,
+        duration
+      });
+      this._ensureLoop();
+      this._emitChange();
+      return this;
+    }
+    /** Gauge.js-compatible convenience alias. */
+    set(value, updateOptions = {}) {
+      return this.setValue(value, updateOptions);
+    }
+    /** Updates options by recursively merging a partial patch into the current user options. */
+    updateOptions(patch, behavior = {}) {
+      this._assertAlive();
+      const requested = patch || {};
+      return this._applyUserOptions(
+        mergeUserOptions(this.userOptions, requested),
+        Object.prototype.hasOwnProperty.call(requested, "value"),
+        behavior
+      );
+    }
+    /** Replaces the complete user-option object while preserving the current value unless supplied. */
+    replaceOptions(options = {}, behavior = {}) {
+      this._assertAlive();
+      const requested = options || {};
+      return this._applyUserOptions(
+        mergeUserOptions({}, requested),
+        Object.prototype.hasOwnProperty.call(requested, "value"),
+        behavior
+      );
+    }
+    /** Gauge.js-style alias for updateOptions. */
+    setOptions(patch, behavior = {}) {
+      return this.updateOptions(patch, behavior);
+    }
+    _applyUserOptions(nextUserOptions, hadExplicitValue, behavior) {
+      const previousType = this.options.type;
+      this.userOptions = nextUserOptions;
+      this.options = resolveGaugeOptions(this.userOptions, this.registry);
+      this.renderer.options = this.options;
+      this._syncLifecycleObservers();
+      const value = hadExplicitValue ? this.options.value : this._targetValue;
+      this._targetValue = this._normalizeIncomingValue(value);
+      if (hadExplicitValue && !behavior.animateToValue) {
+        this._animation = null;
+        this._baseValue = this._targetValue;
+        this._displayValue = this._targetValue;
+        this._pointerValue = this._targetValue;
+        this._jitterOffset = 0;
+      } else {
+        this._baseValue = this._normalizeIncomingValue(this._baseValue);
+        this._displayValue = this._normalizeIncomingValue(this._displayValue);
+        this._pointerValue = this._displayClamp(this._baseValue + this._jitterOffset);
+      }
+      this.options.value = this._targetValue;
+      this.render();
+      if (behavior.animateToValue) this.setValue(this._targetValue, { animate: true });
+      else this._updateDynamic(this._displayValue, true, this._pointerValue);
+      if (previousType !== this.options.type) {
+        dispatchGaugeEvent(this.host, "typechange", {
+          gauge: this,
+          previousType,
+          type: this.options.type
+        });
+      }
+      this._ensureLoop();
+      return this;
+    }
+    /** Returns the last requested stable value. */
+    getValue() {
+      return this._targetValue;
+    }
+    /** Returns the currently rendered base value; visual pointer jitter is excluded. */
+    getDisplayedValue() {
+      return this._displayValue;
+    }
+    /** Temporarily stops animation and jitter work. */
+    pause() {
+      if (this._destroyed || this._paused) return this;
+      this._paused = true;
+      this._pausedAt = performanceNow();
+      cancelFrame(this._frameHandle);
+      this._frameHandle = null;
+      dispatchGaugeEvent(this.host, "pause", { gauge: this });
+      return this;
+    }
+    /** Resumes pending animation and jitter work. */
+    resume() {
+      if (this._destroyed || !this._paused) return this;
+      const now = performanceNow();
+      const suspensionStartedAt = this._lifecycleSuspendedAt > 0 ? Math.min(this._pausedAt, this._lifecycleSuspendedAt) : this._pausedAt;
+      this._paused = false;
+      if (this._animation && suspensionStartedAt > 0) {
+        this._animation.startedAt += Math.max(0, now - suspensionStartedAt);
+      }
+      this._pausedAt = 0;
+      this._lifecycleSuspendedAt = this._isLifecycleBlocked() ? now : 0;
+      this._lastFrameAt = 0;
+      this._ensureLoop();
+      dispatchGaugeEvent(this.host, "resume", { gauge: this });
+      return this;
+    }
+    /** Re-renders after custom CSS variables, fonts, or plugin state changed. */
+    refresh() {
+      return this.render();
+    }
+    /** Releases frames, observers, listeners, and generated DOM. */
+    destroy() {
+      if (this._destroyed) return;
+      this._destroyed = true;
+      cancelFrame(this._frameHandle);
+      this._frameHandle = null;
+      this._animation = null;
+      this._removeLifecycleObservers();
+      this.renderer.destroy();
+      const onDestroy = this._onDestroy;
+      this._onDestroy = null;
+      if (onDestroy) onDestroy(this);
+      dispatchGaugeEvent(this.host, "destroy", { gauge: this });
+    }
+    _initializeValue() {
+      const animation = this.options.animation;
+      if (!animation.enabled || !animation.animateOnInit || animation.duration <= 0 || this._prefersReducedMotion()) {
+        this._baseValue = this._targetValue;
+        this._displayValue = this._targetValue;
+        this._pointerValue = this._targetValue;
+        this._updateDynamic(this._targetValue, true, this._targetValue);
+        this._ensureLoop();
+        return;
+      }
+      const start = this._resolveInitialValue(animation.startFrom);
+      if (Object.is(start, this._targetValue)) {
+        this._updateDynamic(this._targetValue, true);
+        this._ensureLoop();
+        return;
+      }
+      const target = this._targetValue;
+      this._baseValue = start;
+      this._displayValue = start;
+      this._pointerValue = start;
+      this._updateDynamic(start, true, start);
+      this.setValue(target, { animate: true });
+    }
+    _resolveInitialValue(startFrom) {
+      if (typeof startFrom === "number") return this._normalizeIncomingValue(startFrom);
+      if (startFrom === "max") return this.options.max;
+      if (startFrom === "value") return this._targetValue;
+      return this.options.min;
+    }
+    _normalizeIncomingValue(value) {
+      const number = finiteNumber(value, this.options.min);
+      if (this.options.overflow === "allow") return number;
+      if (this.options.overflow === "expand") {
+        let changed = false;
+        if (number < this.options.min) {
+          this.userOptions.min = number;
+          changed = true;
+        }
+        if (number > this.options.max) {
+          this.userOptions.max = number;
+          changed = true;
+        }
+        if (changed) {
+          this.options = resolveGaugeOptions(this.userOptions, this.registry);
+          if (this.renderer) {
+            this.renderer.options = this.options;
+            if (this.renderer.svg) this.render();
+          }
+        }
+        return number;
+      }
+      return clamp(number, this.options.min, this.options.max);
+    }
+    _ensureLoop() {
+      if (this._destroyed || this._paused || this._frameHandle !== null) return;
+      if (!this._shouldRun()) return;
+      this._frameHandle = requestFrame((timestamp) => this._frame(timestamp));
+    }
+    _frame(timestamp) {
+      this._frameHandle = null;
+      if (this._destroyed || this._paused || !this._shouldRun()) return;
+      const now = Number.isFinite(timestamp) ? timestamp : performanceNow();
+      const delta = this._lastFrameAt > 0 ? Math.min(100, Math.max(0, now - this._lastFrameAt)) : 16.667;
+      this._lastFrameAt = now;
+      let animationCompleted = false;
+      if (this._animation) {
+        const elapsed = now - this._animation.startedAt;
+        const progress = this._animation.duration <= 0 ? 1 : clamp(elapsed / this._animation.duration, 0, 1);
+        const eased = this._animation.easing(progress);
+        this._baseValue = this._animation.from + (this._animation.to - this._animation.from) * eased;
+        if (progress >= 1) {
+          const completed = this._animation;
+          this._baseValue = completed.to;
+          this._animation = null;
+          animationCompleted = true;
+          dispatchGaugeEvent(this.host, "animationend", {
+            gauge: this,
+            value: completed.to
+          });
+        }
+      }
+      const jitter = this.options.effects.jitter;
+      const jitterActive = jitter.enabled && (!jitter.whenIdleOnly || !this._animation);
+      if (jitterActive) {
+        const interval = 1e3 / jitter.frequency;
+        if (this._lastJitterTargetAt === 0 || now - this._lastJitterTargetAt >= interval) {
+          this._jitterTarget = (Math.random() * 2 - 1) * this._jitterAmplitude();
+          this._lastJitterTargetAt = now;
+        }
+        const smoothingFactor = 1 - Math.pow(jitter.smoothing, delta / 16.667);
+        this._jitterOffset += (this._jitterTarget - this._jitterOffset) * smoothingFactor;
+      } else {
+        this._jitterTarget = 0;
+        const smoothingFactor = 1 - Math.pow(jitter.smoothing, delta / 16.667);
+        this._jitterOffset += (0 - this._jitterOffset) * smoothingFactor;
+        if (Math.abs(this._jitterOffset) < 1e-6) this._jitterOffset = 0;
+      }
+      const nextDisplay = this._displayClamp(this._baseValue);
+      const nextPointer = this._displayClamp(this._baseValue + this._jitterOffset);
+      this._updateDynamic(nextDisplay, false, nextPointer);
+      if (animationCompleted) this._emitSettled();
+      if (this._needsAnotherFrame()) this._ensureLoop();
+    }
+    _needsAnotherFrame() {
+      if (this._animation) return true;
+      const jitter = this.options.effects.jitter;
+      if (jitter.enabled) return true;
+      return Math.abs(this._jitterOffset) > 1e-6;
+    }
+    _jitterAmplitude() {
+      const jitter = this.options.effects.jitter;
+      if (jitter.amplitudeUnit === "percent") {
+        return (this.options.max - this.options.min) * jitter.amplitude / 100;
+      }
+      return jitter.amplitude;
+    }
+    _displayClamp(value) {
+      return this.options.overflow === "allow" ? value : clamp(value, this.options.min, this.options.max);
+    }
+    _updateDynamic(value, force, pointerValue = value) {
+      const rounded = roundValue(value, this.options.precision);
+      const displayChanged = !Object.is(rounded, this._displayValue);
+      const pointerChanged = !Object.is(pointerValue, this._pointerValue);
+      if (!force && !displayChanged && !pointerChanged) return;
+      this._displayValue = rounded;
+      this._pointerValue = pointerValue;
+      this.renderer.update(rounded, {
+        gauge: this,
+        targetValue: this._targetValue,
+        baseValue: this._baseValue,
+        pointerValue,
+        animated: Boolean(this._animation),
+        jitterOffset: this._jitterOffset
+      });
+      if (force || displayChanged) {
+        this._updateAccessibility(rounded);
+        dispatchGaugeEvent(this.host, "displaychange", {
+          gauge: this,
+          value: this._targetValue,
+          displayedValue: rounded
+        });
+      }
+    }
+    _updateAccessibility(value) {
+      const root = this.renderer.root;
+      if (!root) return;
+      root.setAttribute("role", "meter");
+      root.setAttribute("aria-label", this.options.accessibility.label);
+      root.setAttribute("aria-valuemin", String(this.options.min));
+      root.setAttribute("aria-valuemax", String(this.options.max));
+      root.setAttribute("aria-valuenow", String(value));
+      const valueText = this.options.accessibility.valueText;
+      if (typeof valueText === "function") {
+        root.setAttribute("aria-valuetext", String(valueText(value, this.options)));
+      } else if (typeof valueText === "string" && valueText) {
+        root.setAttribute("aria-valuetext", valueText);
+      } else {
+        root.removeAttribute("aria-valuetext");
+      }
+    }
+    _emitChange() {
+      dispatchGaugeEvent(this.host, "change", {
+        gauge: this,
+        value: this._targetValue,
+        displayedValue: this._displayValue
+      });
+    }
+    _emitSettled() {
+      dispatchGaugeEvent(this.host, "settled", {
+        gauge: this,
+        value: this._targetValue,
+        displayedValue: this._displayValue
+      });
+    }
+    _syncLifecycleObservers() {
+      this._removeLifecycleObservers();
+      this._onscreen = true;
+      this._lifecycleSuspendedAt = 0;
+      this._installLifecycleObservers();
+    }
+    _removeLifecycleObservers() {
+      if (this._visibilityHandler && typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", this._visibilityHandler);
+      }
+      this._visibilityHandler = null;
+      if (this._intersectionObserver) this._intersectionObserver.disconnect();
+      this._intersectionObserver = null;
+    }
+    _installLifecycleObservers() {
+      if (typeof document !== "undefined" && this.options.performance.pauseWhenHidden) {
+        this._visibilityHandler = () => {
+          if (document.hidden) {
+            this._suspendForLifecycle();
+            return;
+          }
+          this._resumeFromLifecycle();
+        };
+        document.addEventListener("visibilitychange", this._visibilityHandler, { passive: true });
+        if (document.hidden) this._suspendForLifecycle();
+      }
+      if (typeof IntersectionObserver === "function" && this.options.performance.pauseWhenOffscreen) {
+        this._intersectionObserver = new IntersectionObserver((entries) => {
+          const entry = entries[0];
+          this._onscreen = Boolean(entry && entry.isIntersecting);
+          if (!this._onscreen) {
+            this._suspendForLifecycle();
+          } else {
+            this._resumeFromLifecycle();
+          }
+        }, { rootMargin: "100px" });
+        this._intersectionObserver.observe(this.host);
+      }
+    }
+    _shouldRun() {
+      if (this._isLifecycleBlocked()) return false;
+      return this._needsAnotherFrame();
+    }
+    _isLifecycleBlocked() {
+      if (typeof document !== "undefined" && this.options.performance.pauseWhenHidden && document.hidden) return true;
+      return this.options.performance.pauseWhenOffscreen && !this._onscreen;
+    }
+    _suspendForLifecycle() {
+      if (this._lifecycleSuspendedAt === 0) this._lifecycleSuspendedAt = performanceNow();
+      cancelFrame(this._frameHandle);
+      this._frameHandle = null;
+    }
+    _resumeFromLifecycle() {
+      if (typeof document !== "undefined" && this.options.performance.pauseWhenHidden && document.hidden) return;
+      if (this.options.performance.pauseWhenOffscreen && !this._onscreen) return;
+      if (this._paused) return;
+      if (this._lifecycleSuspendedAt > 0 && this._animation) {
+        this._animation.startedAt += Math.max(0, performanceNow() - this._lifecycleSuspendedAt);
+      }
+      this._lifecycleSuspendedAt = 0;
+      this._lastFrameAt = 0;
+      this._ensureLoop();
+    }
+    _prefersReducedMotion() {
+      if (!this.options.animation.respectReducedMotion || typeof matchMedia !== "function") return false;
+      return matchMedia("(prefers-reduced-motion: reduce)").matches;
+    }
+    _assertAlive() {
+      if (this._destroyed) throw new Error("This Gaugeit instance has been destroyed.");
+    }
+  };
+  function performanceNow() {
+    if (typeof performance !== "undefined" && typeof performance.now === "function") return performance.now();
+    return Date.now();
+  }
+  function roundValue(value, precision) {
+    const factor = Math.pow(10, precision);
+    return Math.round(value * factor) / factor;
+  }
+
+  // src/core/registry.js
+  var GaugeTypeRegistry = class {
+    constructor() {
+      this._types = /* @__PURE__ */ new Map();
+    }
+    /** Registers or replaces a gauge type. */
+    register(name, definition) {
+      const normalizedName = String(name || "").trim();
+      if (!normalizedName) throw new TypeError("Gauge type name must be a non-empty string.");
+      if (!isPlainObject(definition)) throw new TypeError(`Gauge type "${normalizedName}" must be an object.`);
+      if (!Array.isArray(definition.layers) || definition.layers.length === 0) {
+        throw new TypeError(`Gauge type "${normalizedName}" must define at least one layer.`);
+      }
+      const normalizedLayers = definition.layers.map((layer, index) => {
+        if (!layer || typeof layer.render !== "function") {
+          throw new TypeError(`Layer ${index} in gauge type "${normalizedName}" must expose render(context).`);
+        }
+        return layer;
+      });
+      this._types.set(normalizedName, {
+        name: normalizedName,
+        defaults: cloneValue(definition.defaults || {}),
+        layers: normalizedLayers,
+        description: String(definition.description || ""),
+        configure: typeof definition.configure === "function" ? definition.configure : null
+      });
+      return this;
+    }
+    /** Returns a registered gauge type definition. */
+    get(name) {
+      const definition = this._types.get(String(name));
+      if (!definition) throw new Error(`Unknown Gaugeit gauge type: ${name}`);
+      return definition;
+    }
+    /** Returns whether a type exists. */
+    has(name) {
+      return this._types.has(String(name));
+    }
+    /** Returns registered type names. */
+    names() {
+      return [...this._types.keys()];
+    }
+    /** Returns a serializable description of the registry. */
+    describe() {
+      return [...this._types.values()].map((definition) => ({
+        name: definition.name,
+        description: definition.description
+      }));
+    }
+  };
+  var gaugeTypeRegistry = new GaugeTypeRegistry();
+
+  // src/layers/face.js
+  var faceLayer = {
+    id: "face",
+    render(context) {
+      const { options, renderer } = context;
+      const face = options.face;
+      if (!face.visible) return null;
+      const group = renderer.group("face", { "aria-hidden": "true" });
+      const box = resolveFaceBox(options, renderer.getContentBounds());
+      const shadowId = `${renderer.id}-face-shadow`;
+      const glassId = `${renderer.id}-glass`;
+      const clipId = `${renderer.id}-face-content-clip`;
+      const inset = Math.max(3, face.strokeWidth + 2);
+      const innerBox = insetFaceBox(box, inset);
+      const defs = svgElement("defs");
+      if (face.shadow) {
+        const filter = svgElement("filter", {
+          id: shadowId,
+          x: "-20%",
+          y: "-20%",
+          width: "140%",
+          height: "140%"
+        });
+        filter.append(svgElement("feDropShadow", {
+          dx: 0,
+          dy: 3,
+          stdDeviation: 4,
+          "flood-color": "#000000",
+          "flood-opacity": 0.18
+        }));
+        defs.append(filter);
+      }
+      if (face.glass) {
+        const gradient = svgElement("linearGradient", {
+          id: glassId,
+          x1: "0%",
+          y1: "0%",
+          x2: "0%",
+          y2: "100%"
+        });
+        gradient.append(
+          svgElement("stop", { offset: "0%", "stop-color": "#ffffff", "stop-opacity": 0.38 }),
+          svgElement("stop", { offset: "48%", "stop-color": "#ffffff", "stop-opacity": 0.06 }),
+          svgElement("stop", { offset: "100%", "stop-color": "#ffffff", "stop-opacity": 0 })
+        );
+        defs.append(gradient);
+      }
+      if (face.clipContent) {
+        const clipPath = svgElement("clipPath", {
+          id: clipId,
+          clipPathUnits: "userSpaceOnUse"
+        });
+        clipPath.append(createFaceShape(face, innerBox, {
+          fill: "#ffffff",
+          stroke: "none"
+        }, Math.max(0, face.cornerRadius - inset)));
+        defs.append(clipPath);
+        renderer.setContentClipPath(clipId);
+      }
+      if (defs.children.length > 0) group.append(defs);
+      const base = createFaceShape(face, box, {
+        fill: face.color,
+        stroke: face.strokeColor,
+        "stroke-width": face.strokeWidth,
+        filter: face.shadow ? `url(#${shadowId})` : void 0
+      });
+      base.classList.add("gaugeit__face");
+      group.append(base);
+      group.append(createFaceShape(face, innerBox, {
+        class: "gaugeit__face-inner",
+        fill: "none",
+        stroke: face.innerStrokeColor,
+        "stroke-width": face.innerStrokeWidth
+      }, Math.max(0, face.cornerRadius - inset)));
+      if (face.glass) {
+        if (face.shape === "circle") {
+          const radius = Math.min(box.width, box.height) / 2;
+          group.append(svgElement("ellipse", {
+            class: "gaugeit__glass",
+            cx: box.x + box.width / 2,
+            cy: box.y + box.height / 2 - radius * 0.27,
+            rx: radius * 0.68,
+            ry: radius * 0.32,
+            fill: `url(#${glassId})`,
+            "pointer-events": "none"
+          }));
+        } else {
+          group.append(svgElement("path", {
+            class: "gaugeit__glass",
+            d: `M ${box.x + 14} ${box.y + 14} H ${box.x + box.width - 14} V ${box.y + box.height * 0.52} Q ${box.x + box.width / 2} ${box.y + box.height * 0.38} ${box.x + 14} ${box.y + box.height * 0.52} Z`,
+            fill: `url(#${glassId})`,
+            "pointer-events": "none"
+          }));
+        }
+      }
+      return null;
+    }
+  };
+  function insetFaceBox(box, inset) {
+    return {
+      x: box.x + inset,
+      y: box.y + inset,
+      width: Math.max(1, box.width - inset * 2),
+      height: Math.max(1, box.height - inset * 2)
+    };
+  }
+  function createFaceShape(face, box, attributes = {}, cornerRadius = face.cornerRadius) {
+    if (face.shape === "circle") {
+      return svgElement("circle", {
+        cx: box.x + box.width / 2,
+        cy: box.y + box.height / 2,
+        r: Math.max(1, Math.min(box.width, box.height) / 2),
+        ...attributes
+      });
+    }
+    const radius = Math.max(0, Math.min(cornerRadius, box.width / 2, box.height / 2));
+    return svgElement("rect", {
+      x: box.x,
+      y: box.y,
+      width: box.width,
+      height: box.height,
+      rx: radius,
+      ry: radius,
+      ...attributes
+    });
+  }
+
+  // src/layers/zones.js
+  var zonesLayer = {
+    id: "zones",
+    render(context) {
+      const { options, renderer } = context;
+      const group = renderer.group("zones", { "aria-hidden": "true" });
+      const segments = resolveZoneSegments(options.min, options.max, options.zones);
+      if (options.track.showUnderZones && options.track.visible) {
+        appendArc(group, options.min, options.max, options.track, "gaugeit__track");
+      }
+      for (const segment of segments) {
+        const style = segment.zone || options.track;
+        const shouldDraw = segment.zone ? !isTransparentColor(segment.zone.color) : options.track.visible && !options.track.showUnderZones;
+        if (!shouldDraw) continue;
+        appendArc(
+          group,
+          segment.min,
+          segment.max,
+          style,
+          segment.zone ? "gaugeit__zone" : "gaugeit__track"
+        );
+      }
+      return null;
+      function appendArc(parent, min, max, style, className) {
+        const nodes = createArcNodes(min, max, style, className, options);
+        for (const node of nodes) {
+          if (style.className) node.classList.add(String(style.className));
+          parent.append(node);
+        }
+      }
+    }
+  };
+  function createArcNodes(min, max, style, className, options) {
+    var _a, _b, _c, _d, _e;
+    const geometry2 = options.geometry;
+    const radius = (_b = (_a = style.radius) != null ? _a : options.track.radius) != null ? _b : geometry2.radius;
+    const fallbackWidth = (_c = style.width) != null ? _c : options.track.width;
+    const color = (_d = style.color) != null ? _d : options.track.color;
+    const opacity = (_e = style.opacity) != null ? _e : 1;
+    const lineCap = style.lineCap || options.track.lineCap || "butt";
+    const startAngle = valueToAngle(min, options);
+    const endAngle = valueToAngle(max, options);
+    if (!style.taper) {
+      return [svgElement("path", {
+        class: className,
+        d: arcPath(geometry2.centerX, geometry2.centerY, radius, startAngle, endAngle),
+        fill: "none",
+        stroke: color,
+        "stroke-width": fallbackWidth,
+        "stroke-linecap": lineCap,
+        opacity
+      })];
+    }
+    const startWidth = widthAtValue(style, min, fallbackWidth);
+    const endWidth = widthAtValue(style, max, fallbackWidth);
+    const nodes = [svgElement("path", {
+      class: `${className} ${className}--tapered`,
+      d: taperedArcPath(
+        geometry2.centerX,
+        geometry2.centerY,
+        radius,
+        startAngle,
+        endAngle,
+        startWidth,
+        endWidth,
+        style.taper.segments
+      ),
+      fill: color,
+      stroke: "none",
+      opacity
+    })];
+    if (lineCap === "round") {
+      const start = polarPoint(geometry2.centerX, geometry2.centerY, radius, startAngle);
+      const end = polarPoint(geometry2.centerX, geometry2.centerY, radius, endAngle);
+      const atZoneStart = Math.abs(min - style.min) < 1e-9;
+      const atZoneEnd = Math.abs(max - style.max) < 1e-9;
+      if (atZoneStart && startWidth > 0) nodes.push(capNode(className, start, startWidth, color, opacity, "start"));
+      if (atZoneEnd && endWidth > 0) nodes.push(capNode(className, end, endWidth, color, opacity, "end"));
+    }
+    return nodes;
+  }
+  function widthAtValue(zone, value, fallbackWidth) {
+    const taper = zone.taper || {};
+    const startWidth = Math.max(0, finiteNumber(taper.startWidth, fallbackWidth));
+    const endWidth = Math.max(0, finiteNumber(taper.endWidth, fallbackWidth));
+    const range = Math.max(1e-12, zone.max - zone.min);
+    const ratio = Math.min(1, Math.max(0, (value - zone.min) / range));
+    return startWidth + (endWidth - startWidth) * ratio;
+  }
+  function capNode(className, point, width, color, opacity, edge) {
+    return svgElement("circle", {
+      class: `${className} ${className}--taper-cap`,
+      "data-gaugeit-zone-cap": edge,
+      cx: point.x,
+      cy: point.y,
+      r: width / 2,
+      fill: color,
+      opacity
+    });
+  }
+
+  // src/layers/ticks.js
+  var ticksLayer = {
+    id: "ticks",
+    render(context) {
+      const { options, renderer } = context;
+      const scale = options.scale;
+      if (!scale.major.visible && !scale.minor.visible) return null;
+      const group = renderer.group("ticks", { "aria-hidden": "true" });
+      const interval = resolveMajorInterval(options);
+      const completeMajorValues = buildScaleValues(options.min, options.max, interval);
+      const majorValues = resolveScaleEndpointValues(completeMajorValues, options);
+      const minorValues = buildMinorValues(completeMajorValues, scale.minor.subdivisions);
+      if (scale.minor.visible && scale.minor.length > 0 && scale.minor.width > 0 && minorValues.length) {
+        group.append(svgElement("path", {
+          class: "gaugeit__ticks gaugeit__ticks--minor",
+          d: tickPath(minorValues, scale.minor.length),
+          fill: "none",
+          stroke: scale.minor.color,
+          "stroke-width": scale.minor.width,
+          "stroke-linecap": "butt",
+          opacity: scale.minor.opacity
+        }));
+      }
+      if (scale.major.visible && scale.major.length > 0 && scale.major.width > 0) {
+        group.append(svgElement("path", {
+          class: "gaugeit__ticks gaugeit__ticks--major",
+          d: tickPath(majorValues, scale.major.length),
+          fill: "none",
+          stroke: scale.major.color,
+          "stroke-width": scale.major.width,
+          "stroke-linecap": "butt",
+          opacity: scale.major.opacity
+        }));
+      }
+      renderer.setReference("majorValues", majorValues);
+      return null;
+      function tickPath(values, length) {
+        const commands = [];
+        for (const value of values) {
+          const angle = valueToAngle(value, options);
+          const radii = tickRadii(scale.radius, length, scale.position);
+          const start = polarPoint(options.geometry.centerX, options.geometry.centerY, radii.start, angle);
+          const end = polarPoint(options.geometry.centerX, options.geometry.centerY, radii.end, angle);
+          commands.push(`M ${roundSvg(start.x)} ${roundSvg(start.y)} L ${roundSvg(end.x)} ${roundSvg(end.y)}`);
+        }
+        return commands.join(" ");
+      }
+    }
+  };
+  function tickRadii(radius, length, position) {
+    if (position === "outside") return { start: radius, end: radius + length };
+    if (position === "cross") return { start: radius - length / 2, end: radius + length / 2 };
+    return { start: radius, end: radius - length };
+  }
+
+  // src/layers/labels.js
+  var labelsLayer = {
+    id: "labels",
+    render(context) {
+      const { options, renderer } = context;
+      const labels = options.labels;
+      if (!labels.visible) return null;
+      const group = renderer.group("labels", { "aria-hidden": "true" });
+      const interval = Number(labels.interval) > 0 ? Number(labels.interval) : resolveMajorInterval(options);
+      const values = resolveScaleEndpointValues(
+        buildScaleValues(options.min, options.max, interval),
+        options
+      );
+      for (const value of values) {
+        const angle = valueToAngle(value, options);
+        const point = polarPoint(options.geometry.centerX, options.geometry.centerY, labels.radius, angle);
+        const text = svgElement("text", {
+          class: "gaugeit__label",
+          x: point.x,
+          y: point.y,
+          fill: labels.color,
+          "font-family": labels.fontFamily,
+          "font-size": labels.fontSize,
+          "font-weight": labels.fontWeight,
+          "text-anchor": "middle",
+          "dominant-baseline": "middle",
+          transform: labelTransform(labels.rotation, angle, point)
+        }, formatLabel(value, labels, options));
+        group.append(text);
+      }
+      return null;
+    }
+  };
+  function labelTransform(rotation, angle, point) {
+    if (rotation === "radial") return `rotate(${angle} ${point.x} ${point.y})`;
+    if (rotation === "tangent") return `rotate(${angle + 90} ${point.x} ${point.y})`;
+    return void 0;
+  }
+  function formatLabel(value, labels, options) {
+    if (typeof labels.formatter === "function") {
+      return labels.formatter(value, { min: options.min, max: options.max, options });
+    }
+    return Number(value).toFixed(labels.fractionDigits);
+  }
+
+  // src/layers/pointer.js
+  var pointerLayer = {
+    id: "pointer",
+    render(context) {
+      const { options, renderer } = context;
+      const pointer = options.pointer;
+      if (!pointer.visible) return null;
+      const geometry2 = options.geometry;
+      const group = renderer.group("pointer", { "aria-hidden": "true" });
+      const rotating = svgElement("g", { class: "gaugeit__pointer-rotating" });
+      const shape = createPointerShape(pointer, geometry2);
+      rotating.append(shape);
+      let cap = null;
+      if (pointer.cap.visible) {
+        cap = svgElement("circle", {
+          class: "gaugeit__pointer-cap",
+          cx: geometry2.centerX,
+          cy: geometry2.centerY,
+          r: pointer.cap.radius,
+          fill: pointer.cap.color,
+          stroke: pointer.cap.strokeColor,
+          "stroke-width": pointer.cap.strokeWidth
+        });
+      }
+      appendVisualStack(group, rotating, cap, pointer.cap.stackOrder);
+      return {
+        update(value, state = {}) {
+          const pointerValue = Number.isFinite(state.pointerValue) ? state.pointerValue : value;
+          const angle = valueToAngle(pointerValue, options, options.overflow !== "allow");
+          rotating.setAttribute("transform", `rotate(${angle} ${geometry2.centerX} ${geometry2.centerY})`);
+          if (pointer.colorByZone) {
+            const zone = findZoneForValue(pointerValue, options.zones);
+            const color = zone && !isTransparentColor(zone.color) ? zone.color : pointer.color;
+            if (shape.tagName.toLowerCase() === "line") shape.setAttribute("stroke", color);
+            else shape.setAttribute("fill", color);
+          }
+        }
+      };
+    }
+  };
+  function appendVisualStack(group, pointer, cap, capStackOrder) {
+    if (cap && capStackOrder === "below") group.append(cap, pointer);
+    else if (cap) group.append(pointer, cap);
+    else group.append(pointer);
+  }
+  function createPointerShape(pointer, geometry2) {
+    const cx = geometry2.centerX;
+    const cy = geometry2.centerY;
+    const front = pointer.length;
+    const tail = pointer.tailLength;
+    const half = pointer.width / 2;
+    const shaft = resolveShaftLength(pointer);
+    let shape;
+    if (pointer.type === "line") {
+      shape = svgElement("line", {
+        class: "gaugeit__pointer gaugeit__pointer--line",
+        x1: cx - tail,
+        y1: cy,
+        x2: cx + front,
+        y2: cy,
+        stroke: pointer.color,
+        "stroke-width": pointer.width,
+        "stroke-linecap": "round"
+      });
+    } else {
+      let points;
+      if (pointer.type === "arrow") {
+        points = [
+          [cx - tail, cy - half * 0.55],
+          [cx + shaft, cy - half * 0.55],
+          [cx + shaft, cy - half * 1.5],
+          [cx + front, cy],
+          [cx + shaft, cy + half * 1.5],
+          [cx + shaft, cy + half * 0.55],
+          [cx - tail, cy + half * 0.55]
+        ];
+      } else if (pointer.type === "spear") {
+        const shoulder = shaft + (front - shaft) * 0.56;
+        points = [
+          [cx - tail, cy - half * 0.45],
+          [cx + shaft, cy - half * 0.38],
+          [cx + shoulder, cy - half * 0.85],
+          [cx + front, cy],
+          [cx + shoulder, cy + half * 0.85],
+          [cx + shaft, cy + half * 0.38],
+          [cx - tail, cy + half * 0.45]
+        ];
+      } else {
+        points = [
+          [cx - tail, cy - half * 0.65],
+          [cx + shaft, cy - half * 0.22],
+          [cx + front, cy],
+          [cx + shaft, cy + half * 0.22],
+          [cx - tail, cy + half * 0.65]
+        ];
+      }
+      const path = points.map((point, index) => `${index === 0 ? "M" : "L"} ${point[0]} ${point[1]}`).join(" ");
+      shape = svgElement("path", {
+        class: `gaugeit__pointer gaugeit__pointer--${pointer.type}`,
+        d: `${path} Z`,
+        fill: pointer.color
+      });
+    }
+    setSvgAttributes(shape, {
+      opacity: pointer.opacity,
+      stroke: pointer.type === "line" ? pointer.color : pointer.strokeColor,
+      "stroke-width": pointer.type === "line" ? pointer.width : pointer.strokeWidth
+    });
+    return shape;
+  }
+  function resolveShaftLength(pointer) {
+    if (Number.isFinite(pointer.shaftLength)) return Math.min(pointer.length, Math.max(0, pointer.shaftLength));
+    if (pointer.type === "arrow") return pointer.length * 0.7;
+    if (pointer.type === "spear") return pointer.length * 0.68;
+    return pointer.length * 0.86;
+  }
+
+  // src/layers/readout.js
+  var readoutLayer = {
+    id: "readout",
+    render(context) {
+      const { options, renderer } = context;
+      const readout = options.readout;
+      if (!readout.visible) return null;
+      const group = renderer.group("readout");
+      if (readout.title.visible && readout.title.text) {
+        group.append(textNode("title", readout.title, readout.title.text, options));
+      }
+      let valueNode = null;
+      const valueFormatter = createValueFormatter(readout.value, options);
+      if (readout.value.visible) {
+        valueNode = textNode("value", readout.value, "", options);
+        valueNode.setAttribute("aria-hidden", "true");
+        group.append(valueNode);
+      }
+      if (readout.unit.visible && readout.unit.text) {
+        group.append(textNode("unit", readout.unit, readout.unit.text, options));
+      }
+      return {
+        update(value) {
+          if (valueNode) valueNode.textContent = valueFormatter(value);
+        }
+      };
+    }
+  };
+  function textNode(kind, config, value, options) {
+    const position = resolveReadoutPosition(config, options);
+    return svgElement("text", {
+      class: `gaugeit__readout gaugeit__readout--${kind}`,
+      x: position.x,
+      y: position.y,
+      fill: config.color,
+      "font-family": config.fontFamily,
+      "font-size": config.fontSize,
+      "font-weight": config.fontWeight,
+      "letter-spacing": config.letterSpacing,
+      "text-anchor": "middle",
+      "dominant-baseline": "middle"
+    }, value);
+  }
+  function createValueFormatter(config, options) {
+    if (typeof config.formatter === "function") {
+      return (value) => String(config.formatter(value, { min: options.min, max: options.max, options }));
+    }
+    const formatter = new Intl.NumberFormat(config.locale, {
+      minimumFractionDigits: config.fractionDigits,
+      maximumFractionDigits: config.fractionDigits
+    });
+    return (value) => `${config.prefix || ""}${formatter.format(value)}${config.suffix || ""}`;
+  }
+
+  // src/layers/light.js
+  var LIGHT_PALETTES = Object.freeze({
+    red: { core: "#ef4444", highlight: "#fecaca", glow: "#f87171", rim: "#7f1d1d" },
+    green: { core: "#22c55e", highlight: "#bbf7d0", glow: "#4ade80", rim: "#14532d" },
+    blue: { core: "#3b82f6", highlight: "#bfdbfe", glow: "#60a5fa", rim: "#1e3a8a" },
+    amber: { core: "#f59e0b", highlight: "#fde68a", glow: "#fb923c", rim: "#92400e" },
+    yellow: { core: "#fde047", highlight: "#fef9c3", glow: "#facc15", rim: "#a16207" },
+    orange: { core: "#f97316", highlight: "#fed7aa", glow: "#fb923c", rim: "#9a3412" },
+    white: { core: "#f8fafc", highlight: "#ffffff", glow: "#e2e8f0", rim: "#64748b" },
+    halogen: { core: "#fff2bf", highlight: "#fffdf0", glow: "#ffe79a", rim: "#9a7b24" },
+    cyan: { core: "#22d3ee", highlight: "#cffafe", glow: "#67e8f9", rim: "#155e75" },
+    brown: { core: "#a16207", highlight: "#f5d0a1", glow: "#d6a56b", rim: "#5b3b10" }
+  });
+  var lightLayer = {
+    id: "light",
+    render({ options, renderer }) {
+      const light = options.light;
+      if (!(light == null ? void 0 : light.visible)) return null;
+      const { x, y } = resolveLightPosition(light, options);
+      const palette = resolvePalette(light);
+      const colorName = Object.prototype.hasOwnProperty.call(LIGHT_PALETTES, light.color) ? light.color : "amber";
+      const glowFilterId = `${renderer.id}-light-glow`;
+      const onGradientId = `${renderer.id}-light-on`;
+      const offGradientId = `${renderer.id}-light-off`;
+      const bezelGradientId = `${renderer.id}-light-bezel`;
+      const defs = svgElement("defs");
+      defs.append(
+        createGlowFilter(glowFilterId, light.radius),
+        createBulbGradient(onGradientId, {
+          center: "#ffffff",
+          highlight: palette.highlight,
+          middle: palette.core,
+          edge: palette.rim
+        }),
+        createBulbGradient(offGradientId, {
+          center: "#fffdf7",
+          highlight: light.offColor,
+          middle: light.offColor,
+          edge: light.offEdgeColor
+        }),
+        createBezelGradient(bezelGradientId, light)
+      );
+      const group = renderer.group("light", { "aria-hidden": "true" });
+      group.append(defs);
+      const lamp = svgElement("g", {
+        class: `gaugeit__light gaugeit__light--${colorName}`,
+        transform: `translate(${x} ${y})`,
+        "data-gaugeit-light-color": colorName,
+        "data-gaugeit-light-state": "off"
+      });
+      lamp.style.setProperty("--gaugeit-light-blink-duration", `${light.blinkInterval}ms`);
+      lamp.style.setProperty("--gaugeit-light-pulse-duration", `${light.pulseInterval}ms`);
+      lamp.style.setProperty("--gaugeit-light-opacity", String(light.opacity));
+      const bezel = svgElement("circle", {
+        class: "gaugeit__light-bezel",
+        cx: 0,
+        cy: 0,
+        r: light.radius + Math.max(1.8, light.radius * 0.2),
+        fill: `url(#${bezelGradientId})`
+      });
+      const bezelHighlight = svgElement("circle", {
+        class: "gaugeit__light-bezel-highlight",
+        cx: 0,
+        cy: 0,
+        r: light.radius + Math.max(0.75, light.radius * 0.08),
+        fill: "none",
+        stroke: light.bezelHighlightColor,
+        "stroke-width": Math.max(0.55, light.radius * 0.075),
+        "stroke-opacity": 0.65
+      });
+      const offVisual = createLampVisual({
+        state: "off",
+        radius: light.radius,
+        gradientId: offGradientId,
+        edgeColor: light.offEdgeColor,
+        glowColor: null,
+        glowFilterId: null,
+        sparkleOpacity: 0.58,
+        shadeOpacity: 0.14
+      });
+      const onVisual = createLampVisual({
+        state: "on",
+        radius: light.radius,
+        gradientId: onGradientId,
+        edgeColor: palette.rim,
+        glowColor: palette.glow,
+        glowFilterId,
+        sparkleOpacity: 0.72,
+        shadeOpacity: 0.1
+      });
+      lamp.append(bezel, bezelHighlight, offVisual, onVisual);
+      group.append(lamp);
+      return {
+        update(value, state = {}) {
+          var _a;
+          const sample = resolveTriggerSample((_a = light.trigger) == null ? void 0 : _a.source, value, state);
+          const active = lightIsActive(light, sample);
+          const blinking = active && light.blink;
+          const pulsing = active && light.pulse && !blinking;
+          lamp.classList.toggle("is-on", active);
+          lamp.classList.toggle("is-blinking", blinking);
+          lamp.classList.toggle("is-pulsing", pulsing);
+          lamp.classList.toggle("has-glow", light.glow);
+          lamp.setAttribute("data-gaugeit-light-state", active ? "on" : "off");
+        }
+      };
+    }
+  };
+  function createLampVisual({
+    state,
+    radius,
+    gradientId,
+    edgeColor,
+    glowColor,
+    glowFilterId,
+    sparkleOpacity,
+    shadeOpacity
+  }) {
+    const visual = svgElement("g", {
+      class: `gaugeit__light-emission gaugeit__light-emission--${state}`,
+      "data-gaugeit-light-visual": state
+    });
+    if (glowColor && glowFilterId) {
+      visual.append(svgElement("circle", {
+        class: "gaugeit__light-glow",
+        cx: 0,
+        cy: 0,
+        r: radius * 1.82,
+        fill: glowColor,
+        filter: `url(#${glowFilterId})`
+      }));
+    }
+    visual.append(
+      svgElement("circle", {
+        class: `gaugeit__light-bulb gaugeit__light-bulb--${state}`,
+        cx: 0,
+        cy: 0,
+        r: radius,
+        fill: `url(#${gradientId})`,
+        stroke: edgeColor,
+        "stroke-width": Math.max(0.8, radius * 0.13)
+      }),
+      svgElement("path", {
+        class: `gaugeit__light-lens-shade gaugeit__light-lens-shade--${state}`,
+        d: lowerLensShadePath(radius),
+        fill: edgeColor,
+        opacity: shadeOpacity
+      }),
+      svgElement("ellipse", {
+        class: `gaugeit__light-sparkle gaugeit__light-sparkle--${state}`,
+        cx: -radius * 0.29,
+        cy: -radius * 0.35,
+        rx: Math.max(0.8, radius * 0.36),
+        ry: Math.max(0.6, radius * 0.2),
+        fill: "#ffffff",
+        opacity: sparkleOpacity
+      })
+    );
+    return visual;
+  }
+  function resolvePalette(light) {
+    const named = LIGHT_PALETTES[light.color] || LIGHT_PALETTES.amber;
+    const custom = String(light.customColor || "").trim();
+    if (!custom) return named;
+    return {
+      core: custom,
+      highlight: "#ffffff",
+      glow: custom,
+      rim: custom
+    };
+  }
+  function createGlowFilter(id, radius) {
+    const filter = svgElement("filter", {
+      id,
+      x: "-120%",
+      y: "-120%",
+      width: "340%",
+      height: "340%"
+    });
+    filter.append(svgElement("feGaussianBlur", {
+      stdDeviation: Math.max(1.4, radius * 0.38)
+    }));
+    return filter;
+  }
+  function createBulbGradient(id, colors) {
+    const gradient = svgElement("radialGradient", {
+      id,
+      cx: "31%",
+      cy: "27%",
+      r: "74%"
+    });
+    gradient.append(
+      svgElement("stop", { offset: "0%", "stop-color": colors.center, "stop-opacity": 0.98 }),
+      svgElement("stop", { offset: "23%", "stop-color": colors.highlight, "stop-opacity": 0.96 }),
+      svgElement("stop", { offset: "62%", "stop-color": colors.middle, "stop-opacity": 1 }),
+      svgElement("stop", { offset: "100%", "stop-color": colors.edge, "stop-opacity": 1 })
+    );
+    return gradient;
+  }
+  function createBezelGradient(id, light) {
+    const gradient = svgElement("linearGradient", {
+      id,
+      x1: "0%",
+      y1: "0%",
+      x2: "100%",
+      y2: "100%"
+    });
+    gradient.append(
+      svgElement("stop", { offset: "0%", "stop-color": light.bezelHighlightColor, "stop-opacity": 0.92 }),
+      svgElement("stop", { offset: "34%", "stop-color": light.bezelColor, "stop-opacity": 0.9 }),
+      svgElement("stop", { offset: "72%", "stop-color": light.bezelColor, "stop-opacity": 1 }),
+      svgElement("stop", { offset: "100%", "stop-color": "#1f2937", "stop-opacity": 0.92 })
+    );
+    return gradient;
+  }
+  function lowerLensShadePath(radius) {
+    const r = Math.max(1, radius);
+    return [
+      `M ${-r * 0.86} ${r * 0.42}`,
+      `A ${r} ${r} 0 0 0 ${r * 0.86} ${r * 0.42}`,
+      `A ${r} ${r} 0 0 1 ${-r * 0.86} ${r * 0.42}`,
+      "Z"
+    ].join(" ");
+  }
+  function resolveTriggerSample(source, displayedValue, state) {
+    if (source === "pointer" && Number.isFinite(state.pointerValue)) return state.pointerValue;
+    if (source === "displayed") return displayedValue;
+    if (Number.isFinite(state.targetValue)) return state.targetValue;
+    return displayedValue;
+  }
+
+  // src/types/arc.js
+  var arcGaugeType = {
+    description: "A lightweight semicircular arc with zones, labels, and an animated pointer.",
+    defaults: {
+      geometry: {
+        width: 320,
+        height: 220,
+        centerX: 160,
+        centerY: 176,
+        radius: 120,
+        startAngle: 180,
+        endAngle: 360
+      },
+      face: { visible: false },
+      track: {
+        visible: true,
+        color: "#e5e7eb",
+        width: 28,
+        radius: 112,
+        lineCap: "butt"
+      },
+      scale: {
+        radius: 112,
+        position: "inside",
+        major: { visible: false },
+        minor: { visible: false }
+      },
+      labels: {
+        visible: true,
+        radius: 82,
+        fontSize: 11,
+        fontWeight: 600
+      },
+      pointer: {
+        type: "needle",
+        length: 91,
+        tailLength: 12,
+        width: 8,
+        cap: { radius: 7, stackOrder: "above" }
+      },
+      light: {
+        visible: false,
+        x: 160,
+        y: 142,
+        radius: 7,
+        color: "amber"
+      },
+      readout: {
+        title: { visible: false, x: "auto", y: 35 },
+        value: { visible: false, x: 160, y: 130, fontSize: 30 },
+        unit: { visible: false, x: 160, y: 150 }
+      }
+    },
+    // SVG paint order: readout first, pointer above it, cap above the pointer.
+    layers: [faceLayer, zonesLayer, ticksLayer, labelsLayer, lightLayer, readoutLayer, pointerLayer]
+  };
+
+  // src/types/classic.js
+  var classicGaugeType = {
+    description: "A framed white analog instrument inspired by vintage electrical and pressure meters.",
+    defaults: {
+      layout: {
+        includeGeometry: false
+      },
+      geometry: {
+        width: 320,
+        height: 260,
+        centerX: 160,
+        centerY: 183,
+        radius: 124,
+        startAngle: 195,
+        endAngle: 345
+      },
+      face: {
+        visible: true,
+        shape: "panel",
+        fit: "content",
+        clipContent: true,
+        x: 7,
+        y: 7,
+        width: 306,
+        height: 246,
+        cornerRadius: 20,
+        color: "#fffef8",
+        strokeColor: "#4b5563",
+        strokeWidth: 3,
+        innerStrokeColor: "#d1d5db",
+        innerStrokeWidth: 1.2,
+        shadow: true,
+        glass: true
+      },
+      track: {
+        visible: false,
+        width: 8,
+        radius: 119
+      },
+      scale: {
+        radius: 119,
+        position: "inside",
+        major: {
+          visible: true,
+          divisions: 5,
+          length: 17,
+          width: 2.4,
+          color: "#111827"
+        },
+        minor: {
+          visible: true,
+          subdivisions: 4,
+          length: 9,
+          width: 1,
+          color: "#4b5563"
+        }
+      },
+      labels: {
+        visible: true,
+        radius: 89,
+        fontSize: 12,
+        fontWeight: 650
+      },
+      pointer: {
+        type: "spear",
+        length: 99,
+        tailLength: 15,
+        width: 9,
+        color: "#111827",
+        cap: {
+          visible: true,
+          stackOrder: "above",
+          radius: 10,
+          color: "#20242a",
+          strokeColor: "#d1d5db",
+          strokeWidth: 2
+        }
+      },
+      light: {
+        visible: false,
+        x: 112,
+        y: 112,
+        radius: 8,
+        color: "amber"
+      },
+      readout: {
+        title: {
+          visible: true,
+          text: "ANALOG",
+          x: "auto",
+          y: "auto",
+          position: "top",
+          margin: 12,
+          offsetY: 18,
+          fontSize: 13,
+          letterSpacing: 1.6
+        },
+        value: {
+          visible: false,
+          x: 160,
+          y: 224,
+          fontSize: 24,
+          fontWeight: 750
+        },
+        unit: {
+          visible: false,
+          x: 160,
+          y: 242,
+          fontSize: 10
+        }
+      }
+    },
+    // SVG paint order: readout first, pointer above it, cap above the pointer.
+    layers: [faceLayer, zonesLayer, ticksLayer, labelsLayer, lightLayer, readoutLayer, pointerLayer]
+  };
+
+  // src/types/line-scale.js
+  var lineScaleGaugeType = {
+    description: "A dense line-scale gauge with independently configurable major and minor ticks.",
+    defaults: {
+      geometry: {
+        width: 320,
+        height: 225,
+        centerX: 160,
+        centerY: 184,
+        radius: 127,
+        startAngle: 180,
+        endAngle: 360
+      },
+      face: { visible: false },
+      track: {
+        visible: true,
+        color: "#cbd5e1",
+        width: 2,
+        radius: 126,
+        lineCap: "round"
+      },
+      scale: {
+        radius: 124,
+        position: "inside",
+        major: {
+          visible: true,
+          divisions: 8,
+          length: 23,
+          width: 2.4,
+          color: "#0f172a"
+        },
+        minor: {
+          visible: true,
+          subdivisions: 4,
+          length: 11,
+          width: 1,
+          color: "#475569"
+        }
+      },
+      labels: {
+        visible: true,
+        radius: 88,
+        fontSize: 10,
+        fontWeight: 650
+      },
+      pointer: {
+        type: "line",
+        length: 101,
+        tailLength: 10,
+        width: 4,
+        color: "#b91c1c",
+        cap: {
+          visible: true,
+          stackOrder: "above",
+          radius: 7,
+          color: "#b91c1c",
+          strokeColor: "#ffffff",
+          strokeWidth: 2
+        }
+      },
+      light: {
+        visible: false,
+        x: 160,
+        y: 151,
+        radius: 7,
+        color: "amber"
+      },
+      readout: {
+        title: { visible: false, x: "auto", y: 140 },
+        value: { visible: false, x: 160, y: 220, fontSize: 33 },
+        unit: { visible: false, x: 160, y: 240 }
+      }
+    },
+    // SVG paint order: readout first, pointer above it, cap above the pointer.
+    layers: [faceLayer, zonesLayer, ticksLayer, labelsLayer, lightLayer, readoutLayer, pointerLayer]
+  };
+
+  // src/types/heritage-round.js
+  var heritageRoundGaugeType = {
+    description: "A circular, glass-fronted vintage instrument with a 270-degree scale.",
+    defaults: {
+      geometry: {
+        width: 320,
+        height: 320,
+        centerX: 160,
+        centerY: 160,
+        radius: 132,
+        startAngle: 225,
+        endAngle: 495
+      },
+      face: {
+        visible: true,
+        shape: "circle",
+        fit: "geometry",
+        clipContent: true,
+        x: 8,
+        y: 8,
+        width: 304,
+        height: 304,
+        cornerRadius: 0,
+        color: "#fffdf5",
+        strokeColor: "#374151",
+        strokeWidth: 4,
+        innerStrokeColor: "#c7bfae",
+        innerStrokeWidth: 1.4,
+        shadow: true,
+        glass: true
+      },
+      track: {
+        visible: false,
+        width: 7,
+        radius: 124
+      },
+      scale: {
+        endpointMode: "auto",
+        radius: 124,
+        position: "inside",
+        major: {
+          visible: true,
+          divisions: 9,
+          length: 18,
+          width: 2.6,
+          color: "#171717"
+        },
+        minor: {
+          visible: true,
+          subdivisions: 4,
+          length: 9,
+          width: 1,
+          color: "#57534e"
+        }
+      },
+      labels: {
+        visible: true,
+        radius: 92,
+        fontSize: 11,
+        fontWeight: 700
+      },
+      pointer: {
+        type: "spear",
+        length: 104,
+        tailLength: 18,
+        width: 9,
+        color: "#7f1d1d",
+        cap: {
+          visible: true,
+          stackOrder: "above",
+          radius: 11,
+          color: "#292524",
+          strokeColor: "#d6d3d1",
+          strokeWidth: 2
+        }
+      },
+      light: {
+        visible: false,
+        x: 108,
+        y: 110,
+        radius: 10,
+        color: "amber",
+        blink: false,
+        blinkInterval: 1e3,
+        trigger: { mode: "below", source: "target", value: 15, min: 0, max: 15 }
+      },
+      readout: {
+        title: {
+          visible: true,
+          text: "HERITAGE",
+          x: "auto",
+          y: "auto",
+          position: "top",
+          margin: 14,
+          offsetY: 85,
+          fontSize: 13,
+          letterSpacing: 1.8
+        },
+        value: {
+          visible: false,
+          x: "auto",
+          y: 224,
+          fontSize: 25,
+          fontWeight: 750
+        },
+        unit: {
+          visible: false,
+          x: "auto",
+          y: 244,
+          fontSize: 10
+        }
+      }
+    },
+    // SVG paint order: readout first, pointer above it, cap above the pointer.
+    layers: [faceLayer, zonesLayer, ticksLayer, labelsLayer, lightLayer, readoutLayer, pointerLayer]
+  };
+
+  // src/layers/linear-zones.js
+  var linearZonesLayer = {
+    id: "linear-zones",
+    render(context) {
+      const { options, renderer } = context;
+      const group = renderer.group("linear-zones", { "aria-hidden": "true" });
+      const segments = resolveZoneSegments(options.min, options.max, options.zones);
+      if (options.track.showUnderZones && options.track.visible) {
+        group.append(createSegment(options.min, options.max, options.track, "gaugeit__track"));
+      }
+      for (const segment of segments) {
+        const style = segment.zone || options.track;
+        const shouldDraw = segment.zone ? !isTransparentColor(segment.zone.color) : options.track.visible && !options.track.showUnderZones;
+        if (!shouldDraw) continue;
+        const className = segment.zone ? "gaugeit__zone" : "gaugeit__track";
+        const line = createSegment(segment.min, segment.max, style, className);
+        if (segment.zone && segment.zone.className) line.classList.add(String(segment.zone.className));
+        group.append(line);
+      }
+      return null;
+      function createSegment(min, max, style, className) {
+        var _a, _b, _c, _d;
+        const axis = linearAxis(options);
+        const offset = linearNormalOffset((_a = style.offset) != null ? _a : options.linear.zoneOffset);
+        const start = offsetLinearPoint(valueToLinearPoint(min, options), axis, offset);
+        const end = offsetLinearPoint(valueToLinearPoint(max, options), axis, offset);
+        return svgElement("line", {
+          class: className,
+          x1: start.x,
+          y1: start.y,
+          x2: end.x,
+          y2: end.y,
+          stroke: (_b = style.color) != null ? _b : options.track.color,
+          "stroke-width": (_c = style.width) != null ? _c : options.track.width,
+          "stroke-linecap": style.lineCap || options.track.lineCap || "butt",
+          opacity: (_d = style.opacity) != null ? _d : 1
+        });
+      }
+    }
+  };
+
+  // src/layers/linear-ticks.js
+  var linearTicksLayer = {
+    id: "linear-ticks",
+    render(context) {
+      const { options, renderer } = context;
+      const scale = options.scale;
+      if (!scale.major.visible && !scale.minor.visible) return null;
+      const group = renderer.group("linear-ticks", { "aria-hidden": "true" });
+      const interval = resolveMajorInterval(options);
+      const majorValues = buildScaleValues(options.min, options.max, interval);
+      const minorValues = buildMinorValues(majorValues, scale.minor.subdivisions);
+      if (scale.minor.visible && scale.minor.length > 0 && scale.minor.width > 0 && minorValues.length) {
+        group.append(svgElement("path", {
+          class: "gaugeit__ticks gaugeit__ticks--minor gaugeit__linear-ticks",
+          d: tickPath(minorValues, scale.minor.length),
+          fill: "none",
+          stroke: scale.minor.color,
+          "stroke-width": scale.minor.width,
+          "stroke-linecap": "butt",
+          opacity: scale.minor.opacity
+        }));
+      }
+      if (scale.major.visible && scale.major.length > 0 && scale.major.width > 0) {
+        group.append(svgElement("path", {
+          class: "gaugeit__ticks gaugeit__ticks--major gaugeit__linear-ticks",
+          d: tickPath(majorValues, scale.major.length),
+          fill: "none",
+          stroke: scale.major.color,
+          "stroke-width": scale.major.width,
+          "stroke-linecap": "butt",
+          opacity: scale.major.opacity
+        }));
+      }
+      renderer.setReference("majorValues", majorValues);
+      return null;
+      function tickPath(values, length) {
+        const axis = linearAxis(options);
+        const span = linearNormalSpan(length, options.linear.tickSide);
+        const commands = [];
+        for (const value of values) {
+          const point = valueToLinearPoint(value, options);
+          const start = offsetLinearPoint(point, axis, span.start);
+          const end = offsetLinearPoint(point, axis, span.end);
+          commands.push(`M ${roundSvg(start.x)} ${roundSvg(start.y)} L ${roundSvg(end.x)} ${roundSvg(end.y)}`);
+        }
+        return commands.join(" ");
+      }
+    }
+  };
+
+  // src/layers/linear-labels.js
+  var linearLabelsLayer = {
+    id: "linear-labels",
+    render(context) {
+      const { options, renderer } = context;
+      const labels = options.labels;
+      if (!labels.visible) return null;
+      const group = renderer.group("linear-labels", { "aria-hidden": "true" });
+      const interval = Number(labels.interval) > 0 ? Number(labels.interval) : resolveMajorInterval(options);
+      const values = buildScaleValues(options.min, options.max, interval);
+      const axis = linearAxis(options);
+      for (const value of values) {
+        const point = offsetLinearPoint(
+          valueToLinearPoint(value, options),
+          axis,
+          linearNormalOffset(options.linear.labelOffset)
+        );
+        const text = svgElement("text", {
+          class: "gaugeit__label gaugeit__linear-label",
+          x: point.x,
+          y: point.y,
+          fill: labels.color,
+          "font-family": labels.fontFamily,
+          "font-size": labels.fontSize,
+          "font-weight": labels.fontWeight,
+          "text-anchor": "middle",
+          "dominant-baseline": "middle",
+          transform: labelTransform2(labels.rotation, axis.angle, point)
+        }, formatLabel2(value, labels, options));
+        group.append(text);
+      }
+      return null;
+    }
+  };
+  function labelTransform2(rotation, axisAngle, point) {
+    if (rotation === "radial") return `rotate(${axisAngle + 90} ${point.x} ${point.y})`;
+    if (rotation === "tangent") return `rotate(${axisAngle} ${point.x} ${point.y})`;
+    return void 0;
+  }
+  function formatLabel2(value, labels, options) {
+    if (typeof labels.formatter === "function") {
+      return labels.formatter(value, { min: options.min, max: options.max, options });
+    }
+    return Number(value).toFixed(labels.fractionDigits);
+  }
+
+  // src/layers/linear-indicator.js
+  var linearIndicatorLayer = {
+    id: "linear-indicator",
+    render(context) {
+      const { options, renderer } = context;
+      const indicator = options.indicator;
+      if (!indicator.visible) return null;
+      const axis = linearAxis(options);
+      const normalOffset = linearIndicatorNormalOffset(indicator);
+      const group = renderer.group("linear-indicator", { "aria-hidden": "true" });
+      const moving = svgElement("g", {
+        class: "gaugeit__linear-indicator-moving"
+      });
+      const shape = createIndicatorShape(indicator, normalOffset);
+      moving.append(shape);
+      let cap = null;
+      if (indicator.cap.visible) {
+        cap = svgElement("circle", {
+          class: "gaugeit__linear-indicator-cap",
+          cx: 0,
+          cy: normalOffset,
+          r: indicator.cap.radius,
+          fill: indicator.cap.color,
+          stroke: indicator.cap.strokeColor,
+          "stroke-width": indicator.cap.strokeWidth
+        });
+        if (indicator.cap.stackOrder === "below") moving.prepend(cap);
+        else moving.append(cap);
+      }
+      group.append(moving);
+      return {
+        update(value, state = {}) {
+          const visualValue = Number.isFinite(state.pointerValue) ? state.pointerValue : value;
+          const point = valueToLinearPoint(visualValue, options, options.overflow !== "allow");
+          moving.setAttribute("transform", `translate(${point.x} ${point.y}) rotate(${axis.angle})`);
+          if (indicator.colorByZone) {
+            const zone = findZoneForValue(visualValue, options.zones);
+            const color = zone && !isTransparentColor(zone.color) ? zone.color : indicator.color;
+            setIndicatorColor(shape, indicator, color);
+          }
+        }
+      };
+    }
+  };
+  function createIndicatorShape(indicator, normalOffset) {
+    const span = linearNormalSpan(indicator.length, indicator.position, normalOffset);
+    let shape;
+    if (indicator.type === "marker") {
+      const direction = markerDirection(indicator.position);
+      if (direction === 0) {
+        const size = indicator.markerSize;
+        const centerY = normalOffset;
+        shape = svgElement("path", {
+          class: "gaugeit__linear-indicator gaugeit__linear-indicator--marker",
+          d: `M 0 ${centerY - size} L ${size * 0.72} ${centerY} L 0 ${centerY + size} L ${-size * 0.72} ${centerY} Z`,
+          fill: indicator.color
+        });
+      } else {
+        const tipY = normalOffset;
+        const baseY = tipY + direction * indicator.markerSize;
+        const halfWidth = indicator.markerSize * 0.72;
+        shape = svgElement("path", {
+          class: "gaugeit__linear-indicator gaugeit__linear-indicator--marker",
+          d: `M 0 ${tipY} L ${halfWidth} ${baseY} L ${-halfWidth} ${baseY} Z`,
+          fill: indicator.color
+        });
+      }
+    } else if (indicator.type === "carriage") {
+      const y = Math.min(span.start, span.end);
+      shape = svgElement("rect", {
+        class: "gaugeit__linear-indicator gaugeit__linear-indicator--carriage",
+        x: -indicator.carriageWidth / 2,
+        y,
+        width: indicator.carriageWidth,
+        height: Math.max(1, Math.abs(span.end - span.start)),
+        rx: indicator.carriageRadius,
+        ry: indicator.carriageRadius,
+        fill: indicator.color
+      });
+    } else {
+      shape = svgElement("line", {
+        class: "gaugeit__linear-indicator gaugeit__linear-indicator--hairline",
+        x1: 0,
+        y1: span.start,
+        x2: 0,
+        y2: span.end,
+        stroke: indicator.color,
+        "stroke-width": indicator.width,
+        "stroke-linecap": indicator.lineCap
+      });
+    }
+    setSvgAttributes(shape, {
+      opacity: indicator.opacity,
+      stroke: indicator.type === "hairline" ? indicator.color : indicator.strokeColor,
+      "stroke-width": indicator.type === "hairline" ? indicator.width : indicator.strokeWidth
+    });
+    return shape;
+  }
+  function markerDirection(position) {
+    if (position === "negative") return -1;
+    if (position === "positive") return 1;
+    return 0;
+  }
+  function setIndicatorColor(shape, indicator, color) {
+    if (indicator.type === "hairline") shape.setAttribute("stroke", color);
+    else shape.setAttribute("fill", color);
+  }
+
+  // src/types/instrument-sizing.js
+  function resolveIntrinsicGeometrySize(options, context) {
+    var _a, _b;
+    const requestedGeometry = isPlainObject((_a = context.requested) == null ? void 0 : _a.geometry) ? context.requested.geometry : {};
+    const typeGeometry = ((_b = context.typeDefaults) == null ? void 0 : _b.geometry) || {};
+    const widthExplicit = hasOwn(requestedGeometry, "width");
+    const heightExplicit = hasOwn(requestedGeometry, "height");
+    const ratioExplicit = hasOwn(requestedGeometry, "aspectRatio");
+    const ratio = finiteNumber(requestedGeometry.aspectRatio, 0);
+    if (ratioExplicit && ratio > 0) {
+      if (widthExplicit && !heightExplicit) options.geometry.height = options.geometry.width / ratio;
+      else if (heightExplicit && !widthExplicit) options.geometry.width = options.geometry.height * ratio;
+      else if (!widthExplicit && !heightExplicit) {
+        const baseWidth = finiteNumber(typeGeometry.width, options.geometry.width);
+        options.geometry.width = baseWidth;
+        options.geometry.height = baseWidth / ratio;
+      }
+    }
+    options.geometry.aspectRatio = ratioExplicit && ratio > 0 ? ratio : null;
+    return {
+      requestedGeometry,
+      widthExplicit: widthExplicit || ratioExplicit && ratio > 0 && !heightExplicit,
+      heightExplicit: heightExplicit || ratioExplicit && ratio > 0,
+      baseWidth: Math.max(1, finiteNumber(typeGeometry.width, options.geometry.width)),
+      baseHeight: Math.max(1, finiteNumber(typeGeometry.height, options.geometry.height))
+    };
+  }
+  function configureClassicLinearSize(options, context) {
+    const sizing = resolveIntrinsicGeometrySize(options, context);
+    if (!sizing.widthExplicit && !sizing.heightExplicit) return options;
+    const scaleX = options.geometry.width / sizing.baseWidth;
+    const scaleY = options.geometry.height / sizing.baseHeight;
+    const uniform = Math.min(scaleX, scaleY);
+    scalePaths(options, context, scaleX, [
+      "geometry.centerX",
+      "face.x",
+      "face.width",
+      "face.minWidth",
+      "linear.startX",
+      "linear.endX",
+      "readout.title.x",
+      "readout.value.x",
+      "readout.unit.x"
+    ]);
+    scalePaths(options, context, scaleY, [
+      "geometry.centerY",
+      "face.y",
+      "face.height",
+      "face.minHeight",
+      "linear.originY",
+      "linear.startY",
+      "linear.endY",
+      "linear.labelOffset",
+      "linear.zoneOffset",
+      "scale.major.length",
+      "scale.minor.length",
+      "indicator.length",
+      "indicator.centerOffset",
+      "indicator.markerSize",
+      "indicator.carriageWidth",
+      "indicator.carriageRadius",
+      "indicator.cap.radius",
+      "centerZero.marker.length",
+      "centerZero.marker.centerOffset",
+      "readout.title.y",
+      "readout.value.y",
+      "readout.unit.y"
+    ]);
+    scalePaths(options, context, uniform, [
+      "face.contentPadding",
+      "face.cornerRadius"
+    ]);
+    return options;
+  }
+  function configureRollingTapeSize(options, context) {
+    const sizing = resolveIntrinsicGeometrySize(options, context);
+    if (!sizing.widthExplicit && !sizing.heightExplicit) return options;
+    const scaleX = options.geometry.width / sizing.baseWidth;
+    const scaleY = options.geometry.height / sizing.baseHeight;
+    const uniform = Math.min(scaleX, scaleY);
+    const vertical = options.tape.orientation !== "horizontal";
+    scalePaths(options, context, scaleX, [
+      "geometry.centerX",
+      "face.x",
+      "face.width",
+      "face.minWidth",
+      "tape.x",
+      "tape.width",
+      "readout.title.x",
+      "readout.value.x",
+      "readout.unit.x"
+    ]);
+    scalePaths(options, context, scaleY, [
+      "geometry.centerY",
+      "face.y",
+      "face.height",
+      "face.minHeight",
+      "tape.y",
+      "tape.height",
+      "readout.title.y",
+      "readout.value.y",
+      "readout.unit.y"
+    ]);
+    scalePaths(options, context, vertical ? scaleX : scaleY, [
+      "tape.tickInset",
+      "tape.labelOffset",
+      "tape.majorTickLength",
+      "tape.minorTickLength"
+    ]);
+    scalePaths(options, context, vertical ? scaleY : scaleX, [
+      "tape.majorSpacing",
+      "tape.fadeSize"
+    ]);
+    scalePaths(options, context, uniform, [
+      "face.cornerRadius",
+      "tape.cornerRadius"
+    ]);
+    return options;
+  }
+  function scalePaths(options, context, factor, paths) {
+    if (!Number.isFinite(factor) || factor <= 0 || Math.abs(factor - 1) < 1e-9) return;
+    for (const path of paths) {
+      if (hasPath(context.requested, path)) continue;
+      const baseValue = getPath(context.typeDefaults, path);
+      if (!Number.isFinite(baseValue)) continue;
+      setPath(options, path, baseValue * factor);
+    }
+  }
+  function hasOwn(value, key) {
+    return isPlainObject(value) && Object.prototype.hasOwnProperty.call(value, key);
+  }
+  function hasPath(value, path) {
+    const keys = path.split(".");
+    let cursor = value;
+    for (const key of keys) {
+      if (!isPlainObject(cursor) || !Object.prototype.hasOwnProperty.call(cursor, key)) return false;
+      cursor = cursor[key];
+    }
+    return true;
+  }
+  function getPath(value, path) {
+    let cursor = value;
+    for (const key of path.split(".")) {
+      if (cursor === null || cursor === void 0) return void 0;
+      cursor = cursor[key];
+    }
+    return cursor;
+  }
+  function setPath(value, path, nextValue) {
+    const keys = path.split(".");
+    let cursor = value;
+    for (let index = 0; index < keys.length - 1; index += 1) {
+      const key = keys[index];
+      if (!isPlainObject(cursor[key])) cursor[key] = {};
+      cursor = cursor[key];
+    }
+    cursor[keys[keys.length - 1]] = nextValue;
+  }
+
+  // src/types/classic-linear.js
+  var classicLinearDefaults = {
+    layout: {
+      includeGeometry: false
+    },
+    geometry: {
+      mode: "linear",
+      width: 320,
+      height: 220,
+      centerX: 160,
+      centerY: 110
+    },
+    face: {
+      visible: true,
+      shape: "panel",
+      fit: "content",
+      contentPadding: 14,
+      minWidth: 1,
+      minHeight: 1,
+      clipContent: true,
+      x: 7,
+      y: 7,
+      width: 306,
+      height: 206,
+      cornerRadius: 20,
+      color: "#fffef8",
+      strokeColor: "#4b5563",
+      strokeWidth: 3,
+      innerStrokeColor: "#d1d5db",
+      innerStrokeWidth: 1.2,
+      shadow: true,
+      glass: true
+    },
+    linear: {
+      originY: 142,
+      startX: 38,
+      startY: 0,
+      endX: 282,
+      endY: 0,
+      tickSide: "negative",
+      labelOffset: 38,
+      zoneOffset: -16
+    },
+    track: {
+      visible: true,
+      color: "#a8a29e",
+      width: 5,
+      opacity: 0.85,
+      lineCap: "round",
+      showUnderZones: false
+    },
+    scale: {
+      major: {
+        visible: true,
+        divisions: 5,
+        length: 20,
+        width: 2.4,
+        color: "#111827"
+      },
+      minor: {
+        visible: true,
+        subdivisions: 4,
+        length: 10,
+        width: 1,
+        color: "#57534e"
+      }
+    },
+    labels: {
+      visible: true,
+      fontSize: 11,
+      fontWeight: 700,
+      rotation: "horizontal"
+    },
+    pointer: {
+      visible: false
+    },
+    indicator: {
+      visible: true,
+      type: "hairline",
+      position: "cross",
+      length: 84,
+      centerOffset: 0,
+      width: 2.4,
+      color: "#991b1b",
+      strokeColor: "#fffef8",
+      strokeWidth: 0.8,
+      cap: {
+        visible: false,
+        stackOrder: "above",
+        radius: 4.5,
+        color: "#991b1b",
+        strokeColor: "#fffef8",
+        strokeWidth: 1.2
+      }
+    },
+    light: {
+      visible: false,
+      x: 72,
+      y: 60,
+      radius: 8,
+      color: "amber"
+    },
+    readout: {
+      title: {
+        visible: true,
+        text: "LINEAR",
+        x: "auto",
+        y: 60,
+        fontSize: 13,
+        letterSpacing: 1.6
+      },
+      value: {
+        visible: false,
+        x: "auto",
+        y: -42,
+        fontSize: 24,
+        fontWeight: 750
+      },
+      unit: {
+        visible: false,
+        x: "auto",
+        y: -60,
+        fontSize: 10
+      }
+    }
+  };
+  var classicLinearLayers = [
+    faceLayer,
+    linearZonesLayer,
+    linearTicksLayer,
+    linearLabelsLayer,
+    lightLayer,
+    readoutLayer,
+    linearIndicatorLayer
+  ];
+  var classicLinearGaugeType = {
+    description: "A framed vintage linear instrument with zones, ticks, labels, and a moving hairline.",
+    defaults: classicLinearDefaults,
+    configure: configureClassicLinearSize,
+    layers: classicLinearLayers
+  };
+
+  // src/layers/zero-marker.js
+  var zeroMarkerLayer = {
+    id: "zero-marker",
+    render(context) {
+      var _a;
+      const { options, renderer } = context;
+      const marker = (_a = options.centerZero) == null ? void 0 : _a.marker;
+      if (!(marker == null ? void 0 : marker.visible)) return null;
+      const group = renderer.group("zero-marker", { "aria-hidden": "true" });
+      const line = options.geometry.mode === "linear" ? linearZeroLine(options, marker) : radialZeroLine(options, marker);
+      group.append(svgElement("line", {
+        class: "gaugeit__zero-marker",
+        ...line,
+        stroke: marker.color,
+        "stroke-width": marker.width,
+        "stroke-linecap": marker.lineCap,
+        opacity: marker.opacity
+      }));
+      return null;
+    }
+  };
+  function radialZeroLine(options, marker) {
+    var _a;
+    const angle = valueToAngle(options.centerZero.zeroValue, options);
+    const radius = (_a = marker.radius) != null ? _a : options.scale.radius;
+    const start = polarPoint(
+      options.geometry.centerX,
+      options.geometry.centerY,
+      Math.max(0, radius - marker.length),
+      angle
+    );
+    const end = polarPoint(options.geometry.centerX, options.geometry.centerY, radius, angle);
+    return { x1: start.x, y1: start.y, x2: end.x, y2: end.y };
+  }
+  function linearZeroLine(options, marker) {
+    const axis = linearAxis(options);
+    const point = valueToLinearPoint(options.centerZero.zeroValue, options);
+    const span = linearNormalSpan(
+      marker.length,
+      marker.position,
+      linearNormalOffset(marker.centerOffset)
+    );
+    const start = offsetLinearPoint(point, axis, span.start);
+    const end = offsetLinearPoint(point, axis, span.end);
+    return { x1: start.x, y1: start.y, x2: end.x, y2: end.y };
+  }
+
+  // src/types/classic-linear-zero.js
+  var defaults = deepMerge(classicLinearDefaults, {
+    min: -100,
+    max: 100,
+    value: 0,
+    centerZero: {
+      zeroValue: 0,
+      symmetric: true,
+      marker: {
+        visible: true,
+        position: "cross",
+        centerOffset: 0,
+        length: 34,
+        width: 3.2,
+        color: "#111827",
+        opacity: 1,
+        lineCap: "butt"
+      }
+    },
+    zones: [
+      { min: -100, max: -35, color: "#b91c1c", width: 7 },
+      { min: -35, max: 35, color: "transparent" },
+      { min: 35, max: 100, color: "#15803d", width: 7 }
+    ],
+    readout: {
+      title: {
+        visible: true,
+        text: "DEVIATION"
+      }
+    }
+  });
+  var classicLinearZeroGaugeType = {
+    description: "A classic linear instrument with a fixed center-zero reference and signed travel.",
+    defaults,
+    configure: configureClassicLinearSize,
+    layers: [
+      ...classicLinearLayers.slice(0, 3),
+      zeroMarkerLayer,
+      ...classicLinearLayers.slice(3)
+    ]
+  };
+
+  // src/types/center-zero.js
+  var centerZeroGaugeType = {
+    description: "A heritage-styled bidirectional center-zero dial for deviation, balance, and signed values.",
+    defaults: {
+      min: -100,
+      max: 100,
+      value: 0,
+      geometry: {
+        width: 320,
+        height: 320,
+        centerX: 160,
+        centerY: 160,
+        radius: 132,
+        startAngle: 150,
+        endAngle: 390
+      },
+      centerZero: {
+        zeroValue: 0,
+        symmetric: true,
+        marker: {
+          visible: true,
+          radius: 124,
+          length: 25,
+          width: 3.2,
+          color: "#292524",
+          opacity: 1,
+          lineCap: "round"
+        }
+      },
+      face: {
+        visible: true,
+        shape: "circle",
+        fit: "geometry",
+        clipContent: true,
+        x: 8,
+        y: 8,
+        width: 304,
+        height: 304,
+        color: "#fffdf5",
+        strokeColor: "#374151",
+        strokeWidth: 4,
+        innerStrokeColor: "#c7bfae",
+        innerStrokeWidth: 1.4,
+        shadow: true,
+        glass: true
+      },
+      track: {
+        visible: true,
+        color: "#d6d0c2",
+        width: 10,
+        radius: 123,
+        opacity: 1,
+        lineCap: "round",
+        showUnderZones: true
+      },
+      zones: [
+        { min: -100, max: -35, color: "#b91c1c", width: 8, radius: 123, opacity: 0.92, lineCap: "round" },
+        { min: -35, max: 35, color: "transparent" },
+        { min: 35, max: 100, color: "#b45309", width: 8, radius: 123, opacity: 0.92, lineCap: "round" }
+      ],
+      scale: {
+        radius: 119,
+        position: "inside",
+        major: {
+          visible: true,
+          interval: 25,
+          divisions: 8,
+          length: 18,
+          width: 2.4,
+          color: "#292524"
+        },
+        minor: {
+          visible: true,
+          subdivisions: 4,
+          length: 9,
+          width: 1,
+          color: "#78716c"
+        }
+      },
+      labels: {
+        visible: true,
+        interval: 25,
+        radius: 88,
+        color: "#292524",
+        fontSize: 11,
+        fontWeight: 700
+      },
+      pointer: {
+        type: "spear",
+        length: 101,
+        shaftLength: 78,
+        tailLength: 18,
+        width: 8,
+        color: "#7f1d1d",
+        strokeColor: "#fffdf5",
+        strokeWidth: 0.8,
+        cap: {
+          visible: true,
+          stackOrder: "above",
+          radius: 10,
+          color: "#292524",
+          strokeColor: "#d6d3d1",
+          strokeWidth: 2
+        }
+      },
+      light: {
+        visible: false,
+        x: 112,
+        y: 205,
+        radius: 8,
+        color: "amber"
+      },
+      readout: {
+        title: {
+          visible: true,
+          text: "BALANCE",
+          x: "auto",
+          y: 205,
+          color: "#44403c",
+          fontSize: 13,
+          letterSpacing: 1.8
+        },
+        value: {
+          visible: true,
+          x: "auto",
+          y: 238,
+          color: "#292524",
+          fontSize: 28,
+          fontWeight: 760,
+          prefix: ""
+        },
+        unit: {
+          visible: false,
+          text: "",
+          x: "auto",
+          y: 258,
+          color: "#78716c",
+          fontSize: 10
+        }
+      }
+    },
+    layers: [faceLayer, zonesLayer, ticksLayer, labelsLayer, zeroMarkerLayer, lightLayer, readoutLayer, pointerLayer]
+  };
+
+  // src/layers/rolling-tape.js
+  var rollingTapeLayer = {
+    id: "rolling-tape",
+    render(context) {
+      const { options, renderer } = context;
+      const tape = options.tape;
+      const windowBox = tapeWindowBox(options);
+      const vertical = tape.orientation !== "horizontal";
+      const group = renderer.group("rolling-tape", { "aria-hidden": "true" });
+      const clipId = `${renderer.id}-rolling-tape-clip`;
+      const fadeStartId = `${renderer.id}-rolling-tape-fade-start`;
+      const fadeEndId = `${renderer.id}-rolling-tape-fade-end`;
+      const defs = svgElement("defs");
+      const clip = svgElement("clipPath", { id: clipId, clipPathUnits: "userSpaceOnUse" });
+      clip.append(svgElement("rect", {
+        x: windowBox.x,
+        y: windowBox.y,
+        width: windowBox.width,
+        height: windowBox.height,
+        rx: tape.cornerRadius,
+        ry: tape.cornerRadius
+      }));
+      defs.append(clip);
+      defs.append(fadeGradient(fadeStartId, vertical, true, tape.fadeColor));
+      defs.append(fadeGradient(fadeEndId, vertical, false, tape.fadeColor));
+      group.append(defs);
+      group.append(svgElement("rect", {
+        class: "gaugeit__tape-window-background",
+        x: windowBox.x,
+        y: windowBox.y,
+        width: windowBox.width,
+        height: windowBox.height,
+        rx: tape.cornerRadius,
+        ry: tape.cornerRadius,
+        fill: tape.windowColor,
+        stroke: "none"
+      }));
+      const strip = svgElement("g", {
+        class: "gaugeit__tape-strip",
+        "clip-path": `url(#${clipId})`
+      });
+      strip.append(svgElement("rect", {
+        x: windowBox.x,
+        y: windowBox.y,
+        width: windowBox.width,
+        height: windowBox.height,
+        fill: tape.stripColor
+      }));
+      group.append(strip);
+      const minorStep = tapeMinorStep(options);
+      const minorSpacing = tapeMinorSpacing(options);
+      const majorEvery = Math.max(1, Math.floor(resolveTapeInterval(options) / minorStep + 0.5));
+      const visibleLength = vertical ? windowBox.height : windowBox.width;
+      const slotCount = Math.max(9, Math.ceil(visibleLength / minorSpacing) + 8);
+      const halfSlots = Math.ceil(slotCount / 2);
+      const slots = [];
+      for (let index = 0; index < slotCount; index += 1) {
+        const slot = createSlot(vertical, options);
+        strip.append(slot.group);
+        slots.push(slot);
+      }
+      drawFades(group, windowBox, tape, fadeStartId, fadeEndId, vertical);
+      drawFixedIndicator(group, windowBox, tape, vertical);
+      drawWindowBorder(group, windowBox, tape);
+      return {
+        update(value, state = {}) {
+          const current = Number.isFinite(state.pointerValue) ? state.pointerValue : value;
+          const centerIndex = Math.floor((current - options.min) / minorStep);
+          for (let slotIndex = 0; slotIndex < slots.length; slotIndex += 1) {
+            const tapeIndex = centerIndex + slotIndex - halfSlots;
+            const slotValue = options.min + tapeIndex * minorStep;
+            const slot = slots[slotIndex];
+            if (slotValue < options.min - minorStep * 0.25 || slotValue > options.max + minorStep * 0.25) {
+              slot.group.setAttribute("display", "none");
+              continue;
+            }
+            const offset = tapeValueOffset(slotValue, current, options);
+            const coordinate = vertical ? { x: windowBox.x + windowBox.width / 2, y: windowBox.y + windowBox.height / 2 - offset } : { x: windowBox.x + windowBox.width / 2 + offset, y: windowBox.y + windowBox.height / 2 };
+            slot.group.removeAttribute("display");
+            slot.group.setAttribute("transform", `translate(${coordinate.x} ${coordinate.y})`);
+            const isMajor = positiveModulo2(tapeIndex, majorEvery) === 0;
+            updateSlot(slot, slotValue, isMajor, options);
+          }
+        }
+      };
+    }
+  };
+  function createSlot(vertical, options) {
+    const group = svgElement("g", { class: "gaugeit__tape-slot" });
+    const tick = svgElement("line", { class: "gaugeit__tape-tick" });
+    const text = svgElement("text", {
+      class: "gaugeit__label gaugeit__tape-label",
+      fill: options.tape.textColor,
+      "font-family": options.labels.fontFamily,
+      "font-size": options.labels.fontSize,
+      "font-weight": options.labels.fontWeight,
+      "text-anchor": "middle",
+      "dominant-baseline": "middle"
+    });
+    group.append(tick, text);
+    group.dataset.vertical = vertical ? "true" : "false";
+    return { group, tick, text, vertical };
+  }
+  function updateSlot(slot, value, major, options) {
+    const tape = options.tape;
+    const tickLength = major ? tape.majorTickLength : tape.minorTickLength;
+    const zone = tape.colorByZone ? findZoneForValue(value, options.zones) : null;
+    const zoneColor = zone && !isTransparentColor(zone.color) ? zone.color : null;
+    const tickColor = zoneColor || (major ? tape.tickColor : tape.minorTickColor);
+    const textColor = zoneColor || tape.textColor;
+    const lineWidth = major ? tape.majorTickWidth : tape.minorTickWidth;
+    if (slot.vertical) {
+      setSvgAttributes(slot.tick, {
+        x1: -tape.tickInset,
+        y1: 0,
+        x2: -tape.tickInset - tickLength,
+        y2: 0
+      });
+      setSvgAttributes(slot.text, { x: tape.labelOffset, y: 0 });
+    } else {
+      setSvgAttributes(slot.tick, {
+        x1: 0,
+        y1: tape.tickInset,
+        x2: 0,
+        y2: tape.tickInset + tickLength
+      });
+      setSvgAttributes(slot.text, { x: 0, y: -tape.labelOffset });
+    }
+    setSvgAttributes(slot.tick, {
+      stroke: tickColor,
+      "stroke-width": lineWidth,
+      "stroke-linecap": "butt",
+      opacity: major ? 1 : tape.minorTickOpacity
+    });
+    slot.text.setAttribute("fill", textColor);
+    slot.text.style.display = major && options.labels.visible ? "" : "none";
+    slot.text.textContent = formatLabel3(value, options);
+  }
+  function drawFixedIndicator(group, box, tape, vertical) {
+    const centerX = box.x + box.width / 2;
+    const centerY = box.y + box.height / 2;
+    const edgeInset = Math.max(0, tape.windowStrokeWidth / 2);
+    if (vertical) {
+      group.append(svgElement("line", {
+        class: "gaugeit__tape-indicator",
+        x1: box.x + edgeInset,
+        y1: centerY,
+        x2: box.x + box.width - edgeInset,
+        y2: centerY,
+        stroke: tape.indicatorColor,
+        "stroke-width": tape.indicatorWidth,
+        "stroke-linecap": "butt"
+      }));
+    } else {
+      group.append(svgElement("line", {
+        class: "gaugeit__tape-indicator",
+        x1: centerX,
+        y1: box.y + edgeInset,
+        x2: centerX,
+        y2: box.y + box.height - edgeInset,
+        stroke: tape.indicatorColor,
+        "stroke-width": tape.indicatorWidth,
+        "stroke-linecap": "butt"
+      }));
+    }
+  }
+  function drawWindowBorder(group, box, tape) {
+    const outerRadius = Math.max(0, Math.min(tape.cornerRadius, box.width / 2, box.height / 2));
+    const innerInset = Math.max(tape.windowStrokeWidth, tape.windowInnerStrokeWidth, 0);
+    group.append(svgElement("rect", {
+      class: "gaugeit__tape-window",
+      x: box.x,
+      y: box.y,
+      width: box.width,
+      height: box.height,
+      rx: outerRadius,
+      ry: outerRadius,
+      fill: "none",
+      stroke: tape.windowStrokeColor,
+      "stroke-width": tape.windowStrokeWidth
+    }));
+    if (tape.windowInnerStrokeWidth > 0 && box.width > innerInset * 2 && box.height > innerInset * 2) {
+      group.append(svgElement("rect", {
+        class: "gaugeit__tape-window-inner",
+        x: box.x + innerInset,
+        y: box.y + innerInset,
+        width: box.width - innerInset * 2,
+        height: box.height - innerInset * 2,
+        rx: Math.max(0, outerRadius - innerInset),
+        ry: Math.max(0, outerRadius - innerInset),
+        fill: "none",
+        stroke: tape.windowInnerStrokeColor,
+        "stroke-width": tape.windowInnerStrokeWidth,
+        "pointer-events": "none"
+      }));
+    }
+  }
+  function drawFades(group, box, tape, startId, endId, vertical) {
+    if (tape.fadeSize <= 0) return;
+    if (vertical) {
+      group.append(
+        svgElement("rect", { x: box.x, y: box.y, width: box.width, height: tape.fadeSize, fill: `url(#${startId})`, "pointer-events": "none" }),
+        svgElement("rect", { x: box.x, y: box.y + box.height - tape.fadeSize, width: box.width, height: tape.fadeSize, fill: `url(#${endId})`, "pointer-events": "none" })
+      );
+    } else {
+      group.append(
+        svgElement("rect", { x: box.x, y: box.y, width: tape.fadeSize, height: box.height, fill: `url(#${startId})`, "pointer-events": "none" }),
+        svgElement("rect", { x: box.x + box.width - tape.fadeSize, y: box.y, width: tape.fadeSize, height: box.height, fill: `url(#${endId})`, "pointer-events": "none" })
+      );
+    }
+  }
+  function fadeGradient(id, vertical, start, color) {
+    const gradient = svgElement("linearGradient", {
+      id,
+      x1: "0%",
+      y1: "0%",
+      x2: vertical ? "0%" : "100%",
+      y2: vertical ? "100%" : "0%"
+    });
+    const firstOpacity = start ? 0.96 : 0;
+    const secondOpacity = start ? 0 : 0.96;
+    gradient.append(
+      svgElement("stop", { offset: "0%", "stop-color": color, "stop-opacity": firstOpacity }),
+      svgElement("stop", { offset: "100%", "stop-color": color, "stop-opacity": secondOpacity })
+    );
+    return gradient;
+  }
+  function formatLabel3(value, options) {
+    if (typeof options.labels.formatter === "function") {
+      return String(options.labels.formatter(value, { min: options.min, max: options.max, options }));
+    }
+    return Number(value).toFixed(options.labels.fractionDigits);
+  }
+  function positiveModulo2(value, divisor) {
+    return (value % divisor + divisor) % divisor;
+  }
+
+  // src/types/rolling-tape.js
+  var rollingTapeGaugeType = {
+    description: "A cream-faced rolling numeric tape with a fixed edge-to-edge aircraft reference line.",
+    defaults: {
+      geometry: {
+        mode: "tape",
+        width: 320,
+        height: 340,
+        centerX: 160,
+        centerY: 170
+      },
+      face: {
+        visible: true,
+        shape: "panel",
+        fit: "geometry",
+        clipContent: true,
+        x: 8,
+        y: 8,
+        width: 304,
+        height: 324,
+        cornerRadius: 23,
+        color: "#fffdf4",
+        strokeColor: "#4b5563",
+        strokeWidth: 4,
+        innerStrokeColor: "#c8bfaa",
+        innerStrokeWidth: 1.4,
+        shadow: true,
+        glass: true
+      },
+      pointer: { visible: false },
+      indicator: { visible: false },
+      track: { visible: false },
+      tape: {
+        orientation: "vertical",
+        x: 62,
+        y: 69,
+        width: 196,
+        height: 212,
+        cornerRadius: 12,
+        windowColor: "#fff9ea",
+        windowStrokeColor: "#544f45",
+        windowStrokeWidth: 2,
+        windowInnerStrokeColor: "#d8cfbd",
+        windowInnerStrokeWidth: 1,
+        stripColor: "#fff9ea",
+        textColor: "#211f1a",
+        tickColor: "#3f3a32",
+        minorTickColor: "#817867",
+        minorTickOpacity: 0.86,
+        majorTickWidth: 2.2,
+        minorTickWidth: 1,
+        majorTickLength: 26,
+        minorTickLength: 13,
+        tickInset: 66,
+        labelOffset: 10,
+        interval: 20,
+        minorSubdivisions: 4,
+        majorSpacing: 54,
+        indicatorColor: "#991b1b",
+        indicatorWidth: 2.8,
+        fadeSize: 38,
+        fadeColor: "#fffdf4",
+        colorByZone: true
+      },
+      scale: {
+        major: { visible: true, interval: 20, divisions: 5 },
+        minor: { visible: true, subdivisions: 4 }
+      },
+      labels: {
+        visible: true,
+        color: "#211f1a",
+        fontSize: 15,
+        fontWeight: 760,
+        fractionDigits: 0
+      },
+      zones: [
+        { min: 0, max: 20, color: "#b91c1c" },
+        { min: 20, max: 80, color: "transparent" },
+        { min: 80, max: 100, color: "#15803d" }
+      ],
+      light: {
+        visible: false,
+        x: 72,
+        y: 46,
+        radius: 8,
+        color: "amber"
+      },
+      readout: {
+        title: {
+          visible: true,
+          text: "ALTITUDE",
+          x: "auto",
+          y: 42,
+          color: "#3f3a32",
+          fontSize: 13,
+          letterSpacing: 1.8
+        },
+        value: {
+          visible: false,
+          x: "auto",
+          y: 303,
+          color: "#211f1a",
+          fontSize: 24,
+          fontWeight: 760
+        },
+        unit: {
+          visible: true,
+          text: "FT",
+          x: "auto",
+          y: 307,
+          color: "#6b6253",
+          fontSize: 10,
+          letterSpacing: 1.2
+        }
+      }
+    },
+    configure: configureRollingTapeSize,
+    layers: [faceLayer, rollingTapeLayer, lightLayer, readoutLayer]
+  };
+
+  // src/types/register-builtins.js
+  function registerBuiltInTypes(registry) {
+    registry.register("arc", arcGaugeType).register("classic", classicGaugeType).register("classic-linear", classicLinearGaugeType).register("classic-linear-zero", classicLinearZeroGaugeType).register("center-zero", centerZeroGaugeType).register("heritage-round", heritageRoundGaugeType).register("rolling-tape", rollingTapeGaugeType).register("line-scale", lineScaleGaugeType);
+    return registry;
+  }
+  var builtInTypes = Object.freeze({
+    arc: arcGaugeType,
+    classic: classicGaugeType,
+    "classic-linear": classicLinearGaugeType,
+    "classic-linear-zero": classicLinearZeroGaugeType,
+    "center-zero": centerZeroGaugeType,
+    "heritage-round": heritageRoundGaugeType,
+    "rolling-tape": rollingTapeGaugeType,
+    "line-scale": lineScaleGaugeType
+  });
+
+  // src/core/auto-mount.js
+  var mountedInstances = /* @__PURE__ */ new WeakMap();
+  function createManagedGauge(target, options, GaugeClass, registry) {
+    const existing = mountedInstances.get(target);
+    if (existing) existing.destroy();
+    const gauge = new GaugeClass(target, options, registry, managedLifecycle(target));
+    mountedInstances.set(target, gauge);
+    return gauge;
+  }
+  function autoMountElements(selector, GaugeClass, registry, root = document) {
+    const elements = [...root.querySelectorAll(selector || "[data-gaugeit]")];
+    return elements.map((element) => {
+      const existing = mountedInstances.get(element);
+      if (existing) return existing;
+      const options = optionsFromDataset(element);
+      const gauge = new GaugeClass(element, options, registry, managedLifecycle(element));
+      mountedInstances.set(element, gauge);
+      return gauge;
+    });
+  }
+  function getMountedGauge(element) {
+    return mountedInstances.get(element) || null;
+  }
+  function unmountGauge(element) {
+    const gauge = mountedInstances.get(element);
+    if (!gauge) return false;
+    gauge.destroy();
+    mountedInstances.delete(element);
+    return true;
+  }
+  function optionsFromDataset(element) {
+    const options = parseJsonObject(element.dataset.gaugeitOptions, {});
+    if (element.dataset.gaugeitType) options.type = element.dataset.gaugeitType;
+    if (element.dataset.gaugeitValue !== void 0) options.value = Number(element.dataset.gaugeitValue);
+    if (element.dataset.gaugeitMin !== void 0) options.min = Number(element.dataset.gaugeitMin);
+    if (element.dataset.gaugeitMax !== void 0) options.max = Number(element.dataset.gaugeitMax);
+    return options;
+  }
+  function managedLifecycle(element) {
+    return {
+      onDestroy(gauge) {
+        if (mountedInstances.get(element) === gauge) mountedInstances.delete(element);
+      }
+    };
+  }
+
+  // src/web-component.js
+  function defineCustomElement(createGauge2, tagName = "gauge-it") {
+    if (typeof customElements === "undefined" || typeof HTMLElement === "undefined") return null;
+    if (customElements.get(tagName)) return customElements.get(tagName);
+    class GaugeitElement extends HTMLElement {
+      static get observedAttributes() {
+        return ["value", "min", "max", "type", "options"];
+      }
+      constructor() {
+        super();
+        this._gauge = null;
+        this._mount = document.createElement("div");
+        this._mount.className = "gaugeit-element__mount";
+      }
+      connectedCallback() {
+        if (!this._mount.isConnected) this.append(this._mount);
+        if (!this._gauge) this._gauge = createGauge2(this._mount, this._readOptions());
+      }
+      disconnectedCallback() {
+        if (this._gauge) {
+          this._gauge.destroy();
+          this._gauge = null;
+        }
+      }
+      attributeChangedCallback() {
+        if (this._gauge) this._gauge.replaceOptions(this._readOptions());
+      }
+      get value() {
+        return this._gauge ? this._gauge.getValue() : Number(this.getAttribute("value") || 0);
+      }
+      set value(nextValue) {
+        this.setAttribute("value", String(nextValue));
+      }
+      get gauge() {
+        return this._gauge;
+      }
+      _readOptions() {
+        const options = parseJsonObject(this.getAttribute("options"), {});
+        if (this.hasAttribute("type")) options.type = this.getAttribute("type");
+        if (this.hasAttribute("value")) options.value = Number(this.getAttribute("value"));
+        if (this.hasAttribute("min")) options.min = Number(this.getAttribute("min"));
+        if (this.hasAttribute("max")) options.max = Number(this.getAttribute("max"));
+        return options;
+      }
+    }
+    customElements.define(tagName, GaugeitElement);
+    return GaugeitElement;
+  }
+
+  // src/index.js
+  registerBuiltInTypes(gaugeTypeRegistry);
+  function createGauge(target, options = {}) {
+    const element = typeof target === "string" ? document.querySelector(target) : target;
+    if (!element) throw new Error(`Gaugeit target not found: ${target}`);
+    return createManagedGauge(element, options, Gauge, gaugeTypeRegistry);
+  }
+  function registerGaugeType(name, definition) {
+    gaugeTypeRegistry.register(name, definition);
+    return Gaugeit;
+  }
+  function autoMount(selector = "[data-gaugeit]", root = document) {
+    return autoMountElements(selector, Gauge, gaugeTypeRegistry, root);
+  }
+  function defineGaugeitElement(tagName = "gauge-it") {
+    return defineCustomElement(createGauge, tagName);
+  }
+  var layers = Object.freeze({
+    face: faceLayer,
+    zones: zonesLayer,
+    ticks: ticksLayer,
+    labels: labelsLayer,
+    pointer: pointerLayer,
+    readout: readoutLayer,
+    linearZones: linearZonesLayer,
+    linearTicks: linearTicksLayer,
+    linearLabels: linearLabelsLayer,
+    linearIndicator: linearIndicatorLayer,
+    zeroMarker: zeroMarkerLayer,
+    rollingTape: rollingTapeLayer,
+    light: lightLayer
+  });
+  var geometry = Object.freeze({
+    angleToValue,
+    arcPath,
+    calculateGaugeBounds,
+    buildMinorValues,
+    buildScaleValues,
+    centeredArcAngles,
+    findZoneForValue,
+    gaugeSweep,
+    isClosedGauge,
+    linearAxis,
+    linearIndicatorNormalOffset,
+    linearNormalOffset,
+    linearNormalSpan,
+    linearYToSvg,
+    linearPointToValue,
+    niceInterval,
+    offsetLinearPoint,
+    padBounds,
+    polarPoint,
+    resolveFaceBox,
+    resolveReadoutPosition,
+    resolveScaleEndpointValues,
+    resolveZoneSegments,
+    taperedArcPath,
+    unionBounds,
+    valueToAngle,
+    valueToLinearPoint,
+    valueToLinearRatio,
+    resolveTapeInterval,
+    tapeMinorSpacing,
+    tapeMinorStep,
+    tapeValueOffset,
+    tapeWindowBox,
+    lightIsActive,
+    resolveLightPosition
+  });
+  var types = builtInTypes;
+  var VERSION = "0.1.0";
+  var Gaugeit = Object.freeze({
+    VERSION,
+    Gauge,
+    GaugeTypeRegistry,
+    createGauge,
+    registerGaugeType,
+    autoMount,
+    defineGaugeitElement,
+    getMountedGauge,
+    unmountGauge,
+    registry: gaugeTypeRegistry,
+    types,
+    layers,
+    geometry,
+    deepMerge,
+    easingNames
+  });
+  var index_default = Gaugeit;
+  return __toCommonJS(index_exports);
+})();
+  return Gaugeit;
+});