prographs 0.12.0 → 0.13.0

package/dist/{chunk-LHZPAHU3.cjs → chunk-VIK4L2YF.cjs}

@@ -1,16 +1,16 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16;
 
 
-var _chunkUXFWDEP6cjs = require('./chunk-UXFWDEP6.cjs');
 
 
-var _chunkAL4XQZH6cjs = require('./chunk-AL4XQZH6.cjs');
+var _chunkM4IQ5LIZcjs = require('./chunk-M4IQ5LIZ.cjs');
 
 
-var _chunkEEF5WRRZcjs = require('./chunk-EEF5WRRZ.cjs');
 
+var _chunkUXFWDEP6cjs = require('./chunk-UXFWDEP6.cjs');
 
-var _chunkUMEKIIHJcjs = require('./chunk-UMEKIIHJ.cjs');
+
+var _chunkAL4XQZH6cjs = require('./chunk-AL4XQZH6.cjs');
 
 // src/charts/reliabilitycharts/AllanVariance.ts
 var AllanEstimator = /* @__PURE__ */ ((AllanEstimator2) => {
@@ -83,211 +83,6 @@ var AllanVariance = class _AllanVariance {
 
 // src/charts/reliabilitycharts/AllanDeviationPlot.ts
 var _d3 = require('d3');
-
-// src/charts/reliabilitycharts/ReliabilitySamples.ts
-var sig = (value, digits = 2) => +value.toPrecision(digits);
-var ReliabilitySamples = class {
-  /** A cooling-water fault tree: `{ id, parent, label, gate, probability }`, with a probability on each basic event. */
-  static faultTree(seed) {
-    const { u } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const p = (base) => sig(base * (0.6 + 0.8 * u()));
-    const event = (id, parent, label2, base) => ({ id, parent, label: label2, gate: null, probability: p(base) });
-    const gate = (id, parent, label2, kind) => ({ id, parent, label: label2, gate: kind, probability: null });
-    return [
-      gate("TOP", null, "No cooling water flow", "or"),
-      gate("G1", "TOP", "Both pumps fail", "and"),
-      event("E1", "G1", "Pump A fails", 0.04),
-      event("E2", "G1", "Pump B fails", 0.05),
-      event("E3", "TOP", "Suction valve shut", 2e-3),
-      gate("G2", "TOP", "No power", "and"),
-      event("E4", "G2", "Mains supply lost", 0.02),
-      event("E5", "G2", "Generator fails to start", 0.06),
-      ...seed % 2 ? [] : [event("E6", "TOP", "Strainer blocked", 4e-3)]
-    ];
-  }
-  /** A gas-leak event tree: `{ id, parent, system, branch, probability, outcome }`. The first row is the leak and its frequency per year. */
-  static eventTree(seed) {
-    const { u } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const works = (base) => sig(Math.min(0.995, base + 0.04 * (u() - 0.5)), 3);
-    const pair = (id, parent, system, success, outcomes) => [
-      { id: `${id}1`, parent, system, branch: "success", probability: success, outcome: outcomes[0] },
-      { id: `${id}0`, parent, system, branch: "failure", probability: sig(1 - success, 3), outcome: outcomes[1] }
-    ];
-    return [
-      { id: "IE", parent: null, system: "Gas leak", branch: null, probability: sig(0.05 + 0.1 * u()), outcome: null },
-      ...pair("D", "IE", "Detection", works(0.95), [null, null]),
-      ...pair("S", "D1", "Isolation", works(0.9), ["Safe shutdown", null]),
-      ...pair("N", "S0", "No ignition", works(0.8), ["Gas cloud", "Jet fire"]),
-      ...pair("M", "D0", "No ignition", works(0.7), ["Gas cloud", "Explosion"])
-    ];
-  }
-  /** A loss-of-containment bow-tie: `{ side, path, barrier }`, one row per barrier, plus the event and hazard rows. */
-  static bowTie(seed) {
-    const { u } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const lanes = (side, list) => list.flatMap(([path, barriers]) => barriers.slice(0, 1 + Math.floor(u() * barriers.length)).map((barrier) => ({ side, path, barrier })));
-    return [
-      { side: "hazard", path: "LPG storage", barrier: null },
-      { side: "event", path: "Loss of containment", barrier: null },
-      ...lanes("threat", [["Corrosion", ["Coating", "Inspection"]], ["Overpressure", ["Relief valve", "Pressure trip"]], ["Vehicle impact", ["Crash barrier"]], ["Operator error", ["Procedure", "Interlock"]]]),
-      ...lanes("consequence", [["Fire", ["Gas detection", "Deluge"]], ["Explosion", ["Ignition control", "Blast wall"]], ["Injury", ["Evacuation"]], ["Spill to ground", ["Bund"]]])
-    ];
-  }
-  /** A pumping system as stages in series: `{ block, stage, branch, reliability }`. Blocks sharing a stage are redundant unless they share a branch. */
-  static blocks(seed) {
-    const { u } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const r = (base) => sig(1 - (1 - base) * (0.5 + u()), 3);
-    return [
-      { block: "Supply", stage: "Power", branch: null, reliability: r(0.995) },
-      { block: "Pump A", stage: "Pumping", branch: "A", reliability: r(0.93) },
-      { block: "Pump B", stage: "Pumping", branch: "B", reliability: r(0.93) },
-      ...seed % 2 ? [] : [{ block: "Pump C", stage: "Pumping", branch: "C", reliability: r(0.9) }],
-      { block: "PLC", stage: "Control", branch: null, reliability: r(0.99) },
-      { block: "Valve 1", stage: "Delivery", branch: "Line 1", reliability: r(0.97) },
-      { block: "Filter", stage: "Delivery", branch: "Line 1", reliability: r(0.98) },
-      { block: "Valve 2", stage: "Delivery", branch: "Line 2", reliability: r(0.95) }
-    ];
-  }
-  /** 4,096 samples of a rate gyro at rest, 100 Hz: `{ time, rate }` in seconds and °/s, made of white noise, a flicker floor and a slow random walk. */
-  static gyro(seed) {
-    const { n: n12 } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const white = 0.02, flicker = 35e-4, walk = 5e-4;
-    const poles = [4, 16, 64, 256, 1024].map((samples) => Math.exp(-1 / samples)), states = poles.map(() => 0);
-    let wander = 0;
-    return Array.from({ length: 4096 }, (_, i) => {
-      poles.forEach((pole, k) => {
-        states[k] = pole * states[k] + Math.sqrt(1 - pole * pole) * n12();
-      });
-      wander += walk * n12();
-      return { time: +(i * 0.01).toFixed(2), rate: +(white * n12() + flicker * states.reduce((sum, value) => sum + value, 0) + wander).toFixed(5) };
-    });
-  }
-  /** A supply voltage against clock frequency sweep of one device: `{ voltage, frequency, pass }` in volts and GHz, with one stray failure inside the passing region. */
-  static shmoo(seed) {
-    const { u } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const knee = 0.6 + 0.06 * u(), gain = 3.3 + 0.5 * u(), hole = [3 + Math.floor(u() * 5), 1 + Math.floor(u() * 3)];
-    return Array.from({ length: 11 }, (_, i) => Array.from({ length: 10 }, (_2, j) => {
-      const voltage = +(0.8 + i * 0.04).toFixed(2), frequency = +(1 + j * 0.2).toFixed(1);
-      const limit = gain * Math.max(0, voltage - knee) ** 0.75 * (1 + 0.04 * (u() - 0.5));
-      return { voltage, frequency, pass: frequency <= limit && !(i === hole[0] + 3 && j === hole[1]) ? 1 : 0 };
-    })).flat();
-  }
-  /** Probe results for one wafer: `{ x, y, bin, value }` with die indices from 1, a test bin, and threshold voltage in volts. Yield falls toward the edge and around one defect cluster. */
-  static wafer(seed) {
-    const { u, n: n12 } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const across = 19, centre = (across + 1) / 2, radius = across / 2;
-    const angle = u() * 2 * Math.PI, spot = [centre + Math.cos(angle) * radius * 0.5, centre + Math.sin(angle) * radius * 0.5], tilt = (u() - 0.5) * 4e-3;
-    const rows = [];
-    for (let y = 1; y <= across; y++) for (let x = 1; x <= across; x++) {
-      const reach = Math.hypot(Math.abs(x - centre) + 0.5, Math.abs(y - centre) + 0.5) / radius;
-      if (reach > 1) continue;
-      const near = Math.hypot(x - spot[0], y - spot[1]), draw = u();
-      const bin = near < 1.8 && draw < 0.8 ? "Short" : draw < 0.03 + 0.4 * reach ** 5 ? u() < 0.6 ? "Leakage" : "Open" : draw > 0.975 ? "Slow" : "Pass";
-      rows.push({ x, y, bin, value: +(0.45 + 0.035 * reach * reach + tilt * (x - centre) + 6e-3 * n12()).toFixed(4) });
-    }
-    return rows;
-  }
-  /** A bathtub scan of a serial receiver: `{ position, ber }` across one unit interval, from a dual-Dirac jitter model, measured down to 1e-10. */
-  static jitterScan(seed) {
-    const { u, n: n12 } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const sigma = 0.018 + 8e-3 * u(), spread = 0.1 + 0.06 * u();
-    const wall = (x) => 0.25 * (_chunkAL4XQZH6cjs.StatMath.normalCdf(-(x - spread / 2) / sigma) + _chunkAL4XQZH6cjs.StatMath.normalCdf(-(x + spread / 2) / sigma));
-    return Array.from({ length: 41 }, (_, i) => i / 40).flatMap((position) => {
-      const ber = (wall(position) + wall(1 - position)) * Math.exp(0.2 * n12());
-      return ber < 1e-10 ? [] : [{ position: +position.toFixed(3), ber: +Math.min(0.5, ber).toExponential(3) }];
-    });
-  }
-  /** A feed and reaction unit: equipment and instruments as `nodes` (`{ id, kind, label }`), process and signal lines as `links` (`{ source, target, line }`). */
-  static processUnit(seed) {
-    const unit = 100 * (1 + seed % 4), tag = (letters, offset = 1) => `${letters}-${unit + offset}`;
-    const spare = seed % 2 === 1;
-    const nodes = [
-      { id: "tank", kind: "tank", label: tag("T") },
-      { id: "pumpA", kind: "pump", label: `${tag("P")}A` },
-      ...spare ? [{ id: "pumpB", kind: "pump", label: `${tag("P")}B` }] : [],
-      { id: "fv", kind: "control-valve", label: tag("FV") },
-      { id: "heater", kind: "exchanger", label: tag("E") },
-      { id: "reactor", kind: "vessel", label: tag("R") },
-      { id: "outlet", kind: "valve", label: tag("HV", 2) },
-      { id: "ft", kind: "instrument", label: tag("FT") },
-      { id: "fic", kind: "instrument", label: tag("FIC") },
-      { id: "tt", kind: "instrument", label: tag("TT", 2) },
-      { id: "tic", kind: "instrument", label: tag("TIC", 2) }
-    ];
-    const pipe = (source, target) => ({ source, target, line: "process" }), wire = (source, target) => ({ source, target, line: "signal" });
-    const links = [
-      pipe("tank", "pumpA"),
-      pipe("pumpA", "fv"),
-      ...spare ? [pipe("tank", "pumpB"), pipe("pumpB", "fv")] : [],
-      pipe("fv", "heater"),
-      pipe("heater", "reactor"),
-      pipe("reactor", "outlet"),
-      pipe("reactor", "tank"),
-      wire("pumpA", "ft"),
-      wire("ft", "fic"),
-      wire("fic", "fv"),
-      wire("reactor", "tt"),
-      wire("tt", "tic"),
-      wire("tic", "heater")
-    ];
-    return { nodes, links };
-  }
-  /** A small plant network: `{ id, kind, from, label, rating, voltage }`, fed from a grid infeed through one transformer to a bus with four feeders. */
-  static powerNetwork(seed) {
-    const { u } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const pick = (list) => list[Math.floor(u() * list.length)];
-    const high = "33 kV", medium = "11 kV";
-    return [
-      { id: "GRID", kind: "source", from: null, label: "Grid", rating: `${pick([500, 750, 1e3])} MVA`, voltage: high },
-      { id: "CB1", kind: "breaker", from: "GRID", label: "CB1", rating: "1250 A", voltage: high },
-      { id: "T1", kind: "transformer", from: "CB1", label: "T1", rating: `${pick([10, 16, 20])} MVA`, voltage: medium },
-      { id: "BUS", kind: "bus", from: "T1", label: "Main bus", rating: null, voltage: medium },
-      { id: "CB2", kind: "breaker", from: "BUS", label: "CB2", rating: "630 A", voltage: medium },
-      { id: "M1", kind: "motor", from: "CB2", label: "Pump M1", rating: `${pick([0.8, 1.2, 1.6])} MW`, voltage: medium },
-      { id: "CB3", kind: "breaker", from: "BUS", label: "CB3", rating: "630 A", voltage: medium },
-      { id: "G1", kind: "generator", from: "CB3", label: "Standby", rating: `${pick([2, 2.5, 3])} MVA`, voltage: medium },
-      { id: "Q1", kind: "switch", from: "BUS", label: "Q1", rating: "400 A", voltage: medium },
-      { id: "L1", kind: "load", from: "Q1", label: "Process", rating: `${pick([1.5, 2, 2.4])} MW`, voltage: medium },
-      { id: "F1", kind: "fuse", from: "BUS", label: "F1", rating: "63 A", voltage: medium },
-      { id: "L2", kind: "load", from: "F1", label: "Lighting", rating: `${pick([120, 160, 200])} kW`, voltage: medium }
-    ];
-  }
-  /** A motor starter in ladder logic: `{ rung, step, kind, tag, state, preset, comment }`. The seed sets which inputs are on. */
-  static ladder(seed) {
-    const running = seed % 3 !== 0 ? 1 : 0, timed = seed % 2 === 0 && running ? 1 : 0;
-    const contact = (rung, step, kind, tag, state, comment = null) => ({ rung, step, kind, tag, state, preset: null, comment });
-    return [
-      contact(1, 1, "nc", "Stop", 0, "Motor start and stop with seal-in"),
-      contact(1, 2, "no", "Start", 0),
-      contact(1, 2, "no", "M1", running),
-      contact(1, 3, "nc", "OL1", 0),
-      { rung: 1, step: 4, kind: "coil", tag: "M1", state: null, preset: null, comment: null },
-      contact(2, 1, "no", "M1", running, "Run-up delay"),
-      { rung: 2, step: 2, kind: "timer", tag: "T1", state: null, preset: `${3 + seed % 4} s`, comment: null },
-      contact(3, 1, "no", "T1", timed, "Open discharge valve"),
-      contact(3, 2, "nc", "LSH", 0),
-      { rung: 3, step: 3, kind: "coil", tag: "V1", state: null, preset: null, comment: null }
-    ];
-  }
-  /** A single feedback loop with a disturbance: `nodes` (`{ id, kind, label }`) and `links` (`{ source, target, sign }`). */
-  static controlLoop(seed) {
-    const { u } = _chunkUMEKIIHJcjs.SampleData.rng(seed);
-    const whole = (low, high) => low + Math.floor(u() * (high - low + 1));
-    const nodes = [
-      { id: "r", kind: "input", label: "R(s)" },
-      { id: "e", kind: "sum", label: "" },
-      { id: "c", kind: "block", label: `${whole(2, 9)}(s+${whole(1, 4)})/s` },
-      { id: "u", kind: "sum", label: "" },
-      { id: "g", kind: "block", label: `${whole(1, 6)}/(s+${whole(2, 9)})` },
-      { id: "y", kind: "output", label: "Y(s)" },
-      { id: "h", kind: "block", label: `1/(0.${whole(1, 5)}s+1)` },
-      { id: "d", kind: "input", label: "D(s)" }
-    ];
-    const link = (source, target, sign = null) => ({ source, target, sign });
-    return { nodes, links: [link("r", "e", "+"), link("e", "c"), link("c", "u", "+"), link("d", "u", "+"), link("u", "g"), link("g", "y"), link("g", "h"), link("h", "e", "-")] };
-  }
-};
-
-// src/charts/reliabilitycharts/AllanDeviationPlot.ts
 var NOISE = /* @__PURE__ */ new Map([
   [-1, ["Quantisation", "\u22121"]],
   [-0.5, ["White noise", "\u2212\xBD"]],
@@ -304,7 +99,7 @@ var AllanDeviationPlot = (_class = class extends _chunkUXFWDEP6cjs.StatisticalCh
     shape: "table" /* Table */,
     description: "Computes Allan deviation from a sampled rate record and plots it against averaging time on log-log axes, marking the noise type each slope shows. The sample gyro record is invented.",
     tags: ["allan variance", "adev", "stability", "gyro", "clock", "noise", "bias instability", "random walk"],
-    sample: (seed) => ReliabilitySamples.gyro(seed),
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.gyro(seed),
     variants: {
       estimator: Object.values(AllanEstimator),
       regions: [true, false],
@@ -382,79 +177,6 @@ var AllanDeviationPlot = (_class = class extends _chunkUXFWDEP6cjs.StatisticalCh
   }
 }, _class.__initStatic(), _class);
 
-// src/charts/reliabilitycharts/SchematicChart.ts
-var SchematicChart = class extends _chunkEEF5WRRZcjs.Chart2D {
-  plotMargin() {
-    return { top: 8, right: 12, bottom: 8, left: 12 };
-  }
-  rows() {
-    const { data } = this.options;
-    return (Array.isArray(data) ? data : []).filter((row) => row !== null && typeof row === "object");
-  }
-  static word(cell) {
-    return cell === null || cell === void 0 ? "" : String(cell).trim();
-  }
-  static number(cell) {
-    if (cell === null || cell === void 0 || cell === "" || typeof cell === "boolean") return null;
-    const value = +cell;
-    return Number.isFinite(value) ? value : null;
-  }
-  /** A filled triangle with its tip at `x, y`, pointing along `angle` in degrees (0 is right, 90 is down). */
-  static arrow(x, y, angle, size = 7) {
-    const turn = angle * Math.PI / 180, cos = Math.cos(turn), sin = Math.sin(turn), half = size * 0.45;
-    const at = (along, across) => `${+(x + along * cos - across * sin).toFixed(2)},${+(y + along * sin + across * cos).toFixed(2)}`;
-    return `M${at(0, 0)} L${at(-size, -half)} L${at(-size, half)} Z`;
-  }
-  wires(ctx, name, wires) {
-    const paths = ctx.marks(name, "path", wires, (wire) => wire.key).attr("fill", "none").attr("stroke", (wire) => _nullishCoalesce(wire.color, () => ( ctx.theme.inkSecondary))).attr("stroke-width", (wire) => _nullishCoalesce(wire.width, () => ( 1.5))).attr("stroke-dasharray", (wire) => _nullishCoalesce(wire.dash, () => ( null))).attr("stroke-linejoin", "round").attr("stroke-linecap", "round");
-    ctx.set(paths, { d: (wire) => wire.d });
-    paths.style("pointer-events", (wire) => wire.tip ? null : "none");
-    ctx.hover(paths.filter((wire) => !!wire.tip), (wire) => wire.tip);
-    return paths;
-  }
-  notes(ctx, name, notes) {
-    const fills = { ink: ctx.theme.ink, secondary: ctx.theme.inkSecondary, muted: ctx.theme.inkMuted };
-    const marks = ctx.marks(name, "text", notes, (note) => note.key).attr("text-anchor", (note) => _nullishCoalesce(note.anchor, () => ( "middle"))).attr("dominant-baseline", "central").attr("font-size", (note) => _nullishCoalesce(note.size, () => ( 10))).attr("font-weight", (note) => _nullishCoalesce(note.weight, () => ( null))).attr("font-family", ctx.theme.fontFamily).attr("fill", (note) => _nullishCoalesce(note.fill, () => ( fills[_nullishCoalesce(note.tone, () => ( "ink"))]))).attr("stroke", (note) => note.halo ? ctx.theme.surface : null).attr("stroke-width", (note) => note.halo ? 3 : null).attr("paint-order", (note) => note.halo ? "stroke" : null).style("pointer-events", "none").text((note) => note.text);
-    ctx.set(marks, { x: (note) => note.x, y: (note) => note.y });
-  }
-};
-
-// src/charts/reliabilitycharts/SchematicLabel.ts
-var EM = 0.565;
-var SchematicLabel = class _SchematicLabel {
-  static width(text, size = 10) {
-    return text.length * size * EM;
-  }
-  /** `text` cut to `room` px with an ellipsis, or nothing when under two characters would show. */
-  static fit(text, room, size = 10) {
-    if (_SchematicLabel.width(text, size) <= room) return text;
-    const keep = Math.floor(room / (size * EM)) - 1;
-    return keep >= 2 ? `${text.slice(0, keep).trimEnd()}\u2026` : "";
-  }
-  /** Up to `lines` lines broken at spaces, the last one cut to fit. */
-  static wrap(text, room, lines, size = 10) {
-    const out = [];
-    let rest = text.trim();
-    while (rest && out.length < lines) {
-      const cut = rest.lastIndexOf(" ", Math.floor(room / (size * EM)));
-      if (out.length === lines - 1 || _SchematicLabel.width(rest, size) <= room || cut <= 0) {
-        out.push(_SchematicLabel.fit(rest, room, size));
-        break;
-      }
-      out.push(rest.slice(0, cut));
-      rest = rest.slice(cut + 1);
-    }
-    return out.filter(Boolean);
-  }
-  /** A probability, rate or reliability in few characters: 0.95, 0.0125, 2.5e-5, and 0.99962 with every nine kept. */
-  static probability(value) {
-    if (value === null || !Number.isFinite(value)) return "?";
-    if (value === 0) return "0";
-    if (value > 0.99 && value < 1) return value.toFixed(Math.min(8, Math.ceil(-Math.log10(1 - value)) + 1));
-    return Math.abs(value) < 1e-3 ? value.toExponential(1) : `${+value.toPrecision(3)}`;
-  }
-};
-
 // src/charts/reliabilitycharts/BowTieDiagram.ts
 var BowTieLinks = /* @__PURE__ */ ((BowTieLinks2) => {
   BowTieLinks2["Converging"] = "converging";
@@ -468,7 +190,7 @@ var BowTieBarriers = /* @__PURE__ */ ((BowTieBarriers2) => {
 })(BowTieBarriers || {});
 var clamp = (value, low, high) => Math.max(low, Math.min(high, value));
 var n = (value) => +value.toFixed(2);
-var BowTieDiagram = (_class2 = class extends SchematicChart {
+var BowTieDiagram = (_class2 = class extends _chunkM4IQ5LIZcjs.SchematicChart {
   static __initStatic2() {this.meta = {
     id: "bow-tie",
     name: "Bow-tie diagram",
@@ -477,7 +199,7 @@ var BowTieDiagram = (_class2 = class extends SchematicChart {
     shape: "table" /* Table */,
     description: "Places threats and preventive barriers left of a top event, and mitigating barriers and consequences right of it, for barrier-based risk reviews. The sample scenario is invented.",
     tags: ["bowtie", "risk", "safety", "barrier", "threat", "consequence", "hazard"],
-    sample: (seed) => ReliabilitySamples.bowTie(seed),
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.bowTie(seed),
     variants: {
       links: Object.values(BowTieLinks),
       barriers: Object.values(BowTieBarriers)
@@ -491,7 +213,7 @@ var BowTieDiagram = (_class2 = class extends SchematicChart {
     const { side, path, barrier } = this.options;
     const model = { event: "", hazard: "", threats: [], consequences: [] };
     for (const row of this.rows()) {
-      const kind = SchematicChart.word(row[side]).toLowerCase(), name = SchematicChart.word(row[path]), stop = SchematicChart.word(row[barrier]);
+      const kind = _chunkM4IQ5LIZcjs.SchematicChart.word(row[side]).toLowerCase(), name = _chunkM4IQ5LIZcjs.SchematicChart.word(row[path]), stop = _chunkM4IQ5LIZcjs.SchematicChart.word(row[barrier]);
       if (!name) continue;
       if (/^(event|top)/.test(kind)) model.event ||= name;
       else if (kind.startsWith("hazard")) model.hazard ||= name;
@@ -547,19 +269,19 @@ var BowTieDiagram = (_class2 = class extends SchematicChart {
     const knot = ctx.marks("top-event", "circle", model.event || lanes.length ? [model.event || "Top event"] : []).attr("fill", colors.event).attr("stroke", theme.surface).attr("stroke-width", 2);
     ctx.set(knot, { cx, cy, r: radius }, { r: 0 });
     ctx.hover(knot, (name) => tip(name, "Top event", colors.event, model.hazard ? [["Hazard", model.hazard]] : []));
-    const hazardWidth = Math.min(1.7 * (radius + reach), Math.max(radius * 1.6, SchematicLabel.width(model.hazard) + 12));
+    const hazardWidth = Math.min(1.7 * (radius + reach), Math.max(radius * 1.6, _chunkM4IQ5LIZcjs.SchematicLabel.width(model.hazard) + 12));
     const hazard = ctx.marks("hazard", "rect", model.hazard ? [model.hazard] : []).attr("rx", 3).attr("fill", theme.surface).attr("stroke", theme.axis).attr("stroke-width", 1.5).attr("stroke-dasharray", "5 3");
     ctx.set(hazard, { x: cx - hazardWidth / 2, y: 0.75, width: hazardWidth, height: Math.max(0, hazardHeight - 1.5) });
     ctx.hover(hazard, (name) => tip(name, "Hazard", theme.inkSecondary));
     const lines = boxHeight >= 26 ? 2 : 1;
-    const inside = (key, text, x, y, room, fill, count = lines, size = 10) => SchematicLabel.wrap(text, room, count, size).map((line, i, all) => ({ key: `${key}/${i}`, text: line, x, y: y + (i - (all.length - 1) / 2) * (size + 1), size, fill: palette.inkOn(fill) }));
+    const inside = (key, text, x, y, room, fill, count = lines, size = 10) => _chunkM4IQ5LIZcjs.SchematicLabel.wrap(text, room, count, size).map((line, i, all) => ({ key: `${key}/${i}`, text: line, x, y: y + (i - (all.length - 1) / 2) * (size + 1), size, fill: palette.inkOn(fill) }));
     const notes = [
       ...lanes.flatMap((item) => inside(`${item.left}/${item.lane.name}`, item.lane.name, item.left ? side / 2 : width - side / 2, item.y, side - 8, item.left ? colors.threat : colors.consequence)),
       ...model.event ? inside("event", model.event, cx, cy, radius * 1.7, colors.event, Math.max(1, Math.floor(radius * 1.5 / 11))) : [],
-      ...model.hazard ? [{ key: "hazard", text: SchematicLabel.fit(model.hazard, hazardWidth - 8), x: cx, y: hazardHeight / 2 }] : [],
+      ...model.hazard ? [{ key: "hazard", text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(model.hazard, hazardWidth - 8), x: cx, y: hazardHeight / 2 }] : [],
       ...stops.flatMap((item) => {
         if (boxes) return item.width >= 26 ? inside(item.key, item.name, item.x, item.y, item.width - 4, colors.barrier, lines, 9) : [];
-        const text = rowHeight >= 34 && SchematicLabel.width(item.name, 9) <= item.room - 4 ? item.name : "";
+        const text = rowHeight >= 34 && _chunkM4IQ5LIZcjs.SchematicLabel.width(item.name, 9) <= item.room - 4 ? item.name : "";
         return text ? [{ key: item.key, text, x: item.x, y: item.y - item.height / 2 - 6, size: 9, tone: "secondary" }] : [];
       })
     ];
@@ -595,8 +317,8 @@ var ControlBlockLayout = (_class3 = class _ControlBlockLayout {
       const parts = stacked && node.kind === "block" /* Block */ ? _ControlBlockLayout.fraction(node.label) : [node.label];
       if (node.kind === "sum" /* Sum */) return { lines: [], width: SUM, height: SUM };
       const boxed = node.kind === "block" /* Block */, pad = boxed ? 14 : 6;
-      const width = Math.max(boxed ? 30 : 12, Math.min(limit2, Math.max(...parts.map((part) => SchematicLabel.width(part, TEXT))) + pad));
-      return { lines: parts.map((part) => SchematicLabel.fit(part, width - pad + 2, TEXT)), width, height: boxed ? parts.length > 1 ? 34 : 24 : 14 };
+      const width = Math.max(boxed ? 30 : 12, Math.min(limit2, Math.max(...parts.map((part) => _chunkM4IQ5LIZcjs.SchematicLabel.width(part, TEXT))) + pad));
+      return { lines: parts.map((part) => _chunkM4IQ5LIZcjs.SchematicLabel.fit(part, width - pad + 2, TEXT)), width, height: boxed ? parts.length > 1 ? 34 : 24 : 14 };
     };
     const fixed = main.filter((node) => node.kind !== "block" /* Block */).reduce((sum, node) => sum + sized(node, area.width / 4).width, 0);
     const blocks = main.filter((node) => node.kind === "block" /* Block */).length;
@@ -631,8 +353,8 @@ var ControlBlockLayout = (_class3 = class _ControlBlockLayout {
     const edge = (node, toward) => node.x + toward * node.width / 2;
     placed.slice(1).forEach((node, i) => {
       const from = placed[i], link = links.find((item) => item.source === from.id && item.target === node.id);
-      const signs = node.kind === "sum" /* Sum */ && _optionalChain([link, 'optionalAccess', _3 => _3.sign]) ? [{ x: edge(node, -1) - 6, y: line - 8, text: link.sign }] : [];
-      this.signals.push({ key: `main/${i}`, role: "Forward path" /* Forward */, d: `M${n2(edge(from, 1))},${n2(line)} H${n2(edge(node, -1) - 4)}`, arrows: [SchematicChart.arrow(edge(node, -1), line, 0)], signs, takeoff: null });
+      const signs = node.kind === "sum" /* Sum */ && _optionalChain([link, 'optionalAccess', _2 => _2.sign]) ? [{ x: edge(node, -1) - 6, y: line - 8, text: link.sign }] : [];
+      this.signals.push({ key: `main/${i}`, role: "Forward path" /* Forward */, d: `M${n2(edge(from, 1))},${n2(line)} H${n2(edge(node, -1) - 4)}`, arrows: [_chunkM4IQ5LIZcjs.SchematicChart.arrow(edge(node, -1), line, 0)], signs, takeoff: null });
     });
     const leaving = /* @__PURE__ */ new Map(), entering = /* @__PURE__ */ new Map();
     chains.forEach((chain, c) => {
@@ -661,7 +383,7 @@ var ControlBlockLayout = (_class3 = class _ControlBlockLayout {
         const last = i === spots.length - 1 && tap === null;
         if (at !== null) {
           parts.push(`${parts.length && i === 0 ? "" : `M${n2(at)},${n2(y)} `}H${n2(edge(spot, -heading) - heading * 4)}`);
-          arrows.push(SchematicChart.arrow(edge(spot, -heading), y, turn));
+          arrows.push(_chunkM4IQ5LIZcjs.SchematicChart.arrow(edge(spot, -heading), y, turn));
         }
         at = last ? null : edge(spot, heading);
       });
@@ -670,7 +392,7 @@ var ControlBlockLayout = (_class3 = class _ControlBlockLayout {
         const stop = line + chain.side * target.height / 2, lead = spots.at(-1);
         if (tap === null && lead) parts.push(`M${n2(lead.x)},${n2(y - chain.side * lead.height / 2)} V${n2(stop + chain.side * 4)}`);
         else parts.push(`${at !== null && spots.length ? `M${n2(at)},${n2(y)} ` : ""}H${n2(entry)} V${n2(stop + chain.side * 4)}`);
-        arrows.push(SchematicChart.arrow(entry, stop, chain.side > 0 ? -90 : 90));
+        arrows.push(_chunkM4IQ5LIZcjs.SchematicChart.arrow(entry, stop, chain.side > 0 ? -90 : 90));
         if (target.kind === "sum" /* Sum */ && chain.sign) signs.push({ x: entry - 8, y: stop + chain.side * 9, text: chain.sign });
       }
       this.signals.push({ key: `chain/${c}`, role: chain.role, d: parts.join(" "), arrows, signs, takeoff: tap === null ? null : { x: tap, y: line } });
@@ -738,7 +460,7 @@ var ControlBlockLayout = (_class3 = class _ControlBlockLayout {
       }
       const feed = links.find((link) => link.target === run[0].id && column.has(link.source)), exit = links.find((link) => link.source === run.at(-1).id && column.has(link.target));
       const start = feed ? column.get(feed.source) : null, end = exit ? column.get(exit.target) : null;
-      chains.push({ nodes: run, start, end, sign: _nullishCoalesce(_optionalChain([exit, 'optionalAccess', _4 => _4.sign]), () => ( "")), role: role(start, end), lane: 1, side: 1 });
+      chains.push({ nodes: run, start, end, sign: _nullishCoalesce(_optionalChain([exit, 'optionalAccess', _3 => _3.sign]), () => ( "")), role: role(start, end), lane: 1, side: 1 });
     }
     return chains;
   }
@@ -766,7 +488,7 @@ var KINDS = new Map([
 ]);
 var NAME = { ["input" /* Input */]: "Input", ["output" /* Output */]: "Output", ["sum" /* Sum */]: "Summing junction", ["block" /* Block */]: "Transfer function" };
 var n3 = (value) => +value.toFixed(2);
-var ControlBlockDiagram = (_class4 = class extends SchematicChart {
+var ControlBlockDiagram = (_class4 = class extends _chunkM4IQ5LIZcjs.SchematicChart {
   static __initStatic3() {this.meta = {
     id: "control-block-diagram",
     name: "Control block diagram",
@@ -775,7 +497,7 @@ var ControlBlockDiagram = (_class4 = class extends SchematicChart {
     shape: "graph" /* Graph */,
     description: "Lays out a control system as transfer-function blocks, summing junctions and take-off points on a forward path, with feedback and feedforward paths routed around it. The sample loop is invented.",
     tags: ["control", "feedback", "transfer function", "block diagram", "summing junction", "loop", "pid"],
-    sample: (seed) => ReliabilitySamples.controlLoop(seed),
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.controlLoop(seed),
     variants: {
       junction: Object.values(ControlJunction),
       feedback: Object.values(ControlFeedback),
@@ -789,13 +511,13 @@ var ControlBlockDiagram = (_class4 = class extends SchematicChart {
   parts() {
     const { data, kind, label: label2, sign } = this.options;
     const nodes = /* @__PURE__ */ new Map();
-    for (const node of Array.isArray(_optionalChain([data, 'optionalAccess', _5 => _5.nodes])) ? data.nodes : []) {
-      const id = SchematicChart.word(_optionalChain([node, 'optionalAccess', _6 => _6.id]));
-      if (id && !nodes.has(id)) nodes.set(id, { id, kind: _nullishCoalesce(KINDS.get(SchematicChart.word(node[kind]).toLowerCase()), () => ( "block")) /* Block */, label: SchematicChart.word(node[label2]) || id });
+    for (const node of Array.isArray(_optionalChain([data, 'optionalAccess', _4 => _4.nodes])) ? data.nodes : []) {
+      const id = _chunkM4IQ5LIZcjs.SchematicChart.word(_optionalChain([node, 'optionalAccess', _5 => _5.id]));
+      if (id && !nodes.has(id)) nodes.set(id, { id, kind: _nullishCoalesce(KINDS.get(_chunkM4IQ5LIZcjs.SchematicChart.word(node[kind]).toLowerCase()), () => ( "block")) /* Block */, label: _chunkM4IQ5LIZcjs.SchematicChart.word(node[label2]) || id });
     }
-    const links = (Array.isArray(_optionalChain([data, 'optionalAccess', _7 => _7.links])) ? data.links : []).map((link) => {
-      const mark = SchematicChart.word(_optionalChain([link, 'optionalAccess', _8 => _8[sign]]));
-      return { source: SchematicChart.word(_optionalChain([link, 'optionalAccess', _9 => _9.source])), target: SchematicChart.word(_optionalChain([link, 'optionalAccess', _10 => _10.target])), sign: /^(-|−|minus|neg)/i.test(mark) ? "\u2212" : mark ? "+" : "" };
+    const links = (Array.isArray(_optionalChain([data, 'optionalAccess', _6 => _6.links])) ? data.links : []).map((link) => {
+      const mark = _chunkM4IQ5LIZcjs.SchematicChart.word(_optionalChain([link, 'optionalAccess', _7 => _7[sign]]));
+      return { source: _chunkM4IQ5LIZcjs.SchematicChart.word(_optionalChain([link, 'optionalAccess', _8 => _8.source])), target: _chunkM4IQ5LIZcjs.SchematicChart.word(_optionalChain([link, 'optionalAccess', _9 => _9.target])), sign: /^(-|−|minus|neg)/i.test(mark) ? "\u2212" : mark ? "+" : "" };
     }).filter((link) => nodes.has(link.source) && nodes.has(link.target));
     return { nodes: [...nodes.values()], links };
   }
@@ -849,26 +571,26 @@ var EventTreeModel = (_class5 = class {
   constructor(rows, columns) {;_class5.prototype.__init3.call(this);_class5.prototype.__init4.call(this);_class5.prototype.__init5.call(this);
     const byId = /* @__PURE__ */ new Map();
     for (const row of rows) {
-      const id = SchematicChart.word(row[columns.id]);
+      const id = _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.id]);
       if (id && !byId.has(id)) byId.set(id, row);
     }
     const parentOf = (id) => {
-      const parent = SchematicChart.word(byId.get(id)[columns.parent]);
+      const parent = _chunkM4IQ5LIZcjs.SchematicChart.word(byId.get(id)[columns.parent]);
       return parent !== id && byId.has(parent) ? parent : null;
     };
     const start = [...byId.keys()].find((id) => parentOf(id) === null);
     const seen = /* @__PURE__ */ new Set();
     const build = (id) => {
       seen.add(id);
-      const row = byId.get(id), probability = SchematicChart.number(row[columns.probability]);
+      const row = byId.get(id), probability = _chunkM4IQ5LIZcjs.SchematicChart.number(row[columns.probability]);
       const children = [...byId.keys()].filter((child) => !seen.has(child) && parentOf(child) === id).map(build);
       children.sort((a, b) => +b.success - +a.success);
       return {
         id,
-        system: SchematicChart.word(row[columns.system]),
-        success: SUCCESS.test(SchematicChart.word(row[columns.branch])),
+        system: _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.system]),
+        success: SUCCESS.test(_chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.branch])),
         probability: probability === null ? null : Math.max(0, probability),
-        outcome: SchematicChart.word(row[columns.outcome]),
+        outcome: _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.outcome]),
         children,
         column: 0,
         row: 0,
@@ -902,7 +624,7 @@ var EventTreeLinks = /* @__PURE__ */ ((EventTreeLinks2) => {
 })(EventTreeLinks || {});
 var HEAD = 26;
 var n4 = (value) => +value.toFixed(2);
-var EventTreeDiagram = (_class6 = class extends SchematicChart {
+var EventTreeDiagram = (_class6 = class extends _chunkM4IQ5LIZcjs.SchematicChart {
   static __initStatic4() {this.meta = {
     id: "event-tree",
     name: "Event tree",
@@ -911,7 +633,7 @@ var EventTreeDiagram = (_class6 = class extends SchematicChart {
     shape: "table" /* Table */,
     description: "Branches an initiating event through the success and failure of each safety function and multiplies out the frequency of every path. The sample scenario is invented.",
     tags: ["eta", "safety", "risk", "initiating event", "barrier", "path frequency", "pra"],
-    sample: (seed) => ReliabilitySamples.eventTree(seed),
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.eventTree(seed),
     variants: {
       links: Object.values(EventTreeLinks),
       strip: [false, true]
@@ -953,7 +675,7 @@ var EventTreeDiagram = (_class6 = class extends SchematicChart {
     this.wires(ctx, "branches", lines);
     const ends = ctx.marks("outcomes", "circle", paths, (path) => path.id).attr("fill", tone).attr("stroke", theme.surface).attr("stroke-width", 2);
     ctx.set(ends, { cx: treeWidth - 6, cy: y, r: 4 }, { r: 0 }, 20);
-    const tip = (path) => ({ title: path.outcome || path.id, color: tone(path), rows: [["Path frequency", SchematicLabel.probability(path.frequency)]] });
+    const tip = (path) => ({ title: path.outcome || path.id, color: tone(path), rows: [["Path frequency", _chunkM4IQ5LIZcjs.SchematicLabel.probability(path.frequency)]] });
     ctx.hover(ends, tip);
     const known = paths.map((path) => path.frequency).filter((f) => f !== null && f > 0);
     const low = Math.log10(Math.min(...known, 1)) - 0.5, high = Math.log10(Math.max(...known, 1e-12)) + 0.5;
@@ -964,18 +686,18 @@ var EventTreeDiagram = (_class6 = class extends SchematicChart {
     const dots = ctx.marks("strip", "circle", plotted, (path) => path.id).attr("fill", tone).attr("stroke", theme.surface).attr("stroke-width", 2);
     ctx.set(dots, { cx: (path) => along(path.frequency), cy: y, r: 4 }, { r: 0 }, 20);
     ctx.hover(dots, tip);
-    const heading = (key, text, x, room, anchor = "middle") => SchematicLabel.wrap(text, room, 2, 9).map((line, i, all) => ({ key: `${key}/${i}`, text: line, x, y: HEAD / 2 - 3 + (i - (all.length - 1) / 2) * 10, anchor, size: 9, tone: "secondary", weight: 600 }));
+    const heading = (key, text, x, room, anchor = "middle") => _chunkM4IQ5LIZcjs.SchematicLabel.wrap(text, room, 2, 9).map((line, i, all) => ({ key: `${key}/${i}`, text: line, x, y: HEAD / 2 - 3 + (i - (all.length - 1) / 2) * 10, anchor, size: 9, tone: "secondary", weight: 600 }));
     const tall = rowHeight >= 15, right = treeWidth + numberWidth + stripWidth + 6;
     const notes = !root ? [] : [
-      ...heading("head/start", SchematicLabel.width("Initiating", 9) <= column - 4 ? "Initiating event" : "Initiator", column / 2, column - 4),
+      ...heading("head/start", _chunkM4IQ5LIZcjs.SchematicLabel.width("Initiating", 9) <= column - 4 ? "Initiating event" : "Initiator", column / 2, column - 4),
       ...model.systems.map((system, i) => ({ system, at: i + 1 })).filter(({ at }) => at < model.columns).flatMap(({ system, at }) => heading(`head/${system}`, system, (at + 0.5) * column, column - 4)),
       ...heading("head/frequency", "Frequency", treeWidth + 2, numberWidth - 2, "start"),
       ...heading("head/outcome", "Outcome", right, outcomeWidth, "start"),
-      { key: "start/name", text: SchematicLabel.fit(root.system, column - 6), x: 2, y: y(root) - 8, anchor: "start", halo: true },
-      { key: "start/rate", text: SchematicLabel.probability(root.probability), x: 2, y: y(root) + 9, anchor: "start", tone: "secondary", halo: true },
+      { key: "start/name", text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(root.system, column - 6), x: 2, y: y(root) - 8, anchor: "start", halo: true },
+      { key: "start/rate", text: _chunkM4IQ5LIZcjs.SchematicLabel.probability(root.probability), x: 2, y: y(root) + 9, anchor: "start", tone: "secondary", halo: true },
       ...tall ? branches.filter(({ parent }) => parent).map(({ branch }) => ({
         key: `p/${branch.id}`,
-        text: SchematicLabel.fit(SchematicLabel.probability(branch.probability), column - slant - 2, 9),
+        text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(_chunkM4IQ5LIZcjs.SchematicLabel.probability(branch.probability), column - slant - 2, 9),
         x: branch.column * column + slant + 4,
         y: y(branch) - 7,
         anchor: "start",
@@ -984,8 +706,8 @@ var EventTreeDiagram = (_class6 = class extends SchematicChart {
         halo: true
       })) : [],
       ...paths.filter((_, i) => tall || i % Math.ceil(11 / Math.max(1, rowHeight)) === 0).flatMap((path) => [
-        { key: `f/${path.id}`, text: SchematicLabel.probability(path.frequency), x: treeWidth + 2, y: y(path), anchor: "start", weight: 600 },
-        { key: `o/${path.id}`, text: SchematicLabel.fit(path.outcome, outcomeWidth), x: right, y: y(path), anchor: "start" }
+        { key: `f/${path.id}`, text: _chunkM4IQ5LIZcjs.SchematicLabel.probability(path.frequency), x: treeWidth + 2, y: y(path), anchor: "start", weight: 600 },
+        { key: `o/${path.id}`, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(path.outcome, outcomeWidth), x: right, y: y(path), anchor: "start" }
       ])
     ];
     this.notes(ctx, "labels", notes);
@@ -1005,21 +727,21 @@ var FaultTreeModel = class _FaultTreeModel {
   constructor(rows, columns) {
     const byId = /* @__PURE__ */ new Map();
     for (const row of rows) {
-      const id = SchematicChart.word(row[columns.id]);
+      const id = _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.id]);
       if (id && !byId.has(id)) byId.set(id, row);
     }
     const parentOf = (id) => {
-      const parent = SchematicChart.word(byId.get(id)[columns.parent]);
+      const parent = _chunkM4IQ5LIZcjs.SchematicChart.word(byId.get(id)[columns.parent]);
       return parent !== id && byId.has(parent) ? parent : null;
     };
     const root = [...byId.keys()].find((id) => parentOf(id) === null);
     const seen = /* @__PURE__ */ new Set();
     const build = (id) => {
       seen.add(id);
-      const row = byId.get(id), given = SchematicChart.number(row[columns.probability]);
+      const row = byId.get(id), given = _chunkM4IQ5LIZcjs.SchematicChart.number(row[columns.probability]);
       const children = [...byId.keys()].filter((child) => !seen.has(child) && parentOf(child) === id).map(build);
-      const gate = !children.length ? null : SchematicChart.word(row[columns.gate]).toLowerCase() === "and" /* And */ ? "and" /* And */ : "or" /* Or */;
-      return { id, label: SchematicChart.word(row[columns.label]) || id, gate, given: given === null ? null : Math.max(0, Math.min(1, given)), probability: null, importance: 0, children };
+      const gate = !children.length ? null : _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.gate]).toLowerCase() === "and" /* And */ ? "and" /* And */ : "or" /* Or */;
+      return { id, label: _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.label]) || id, gate, given: given === null ? null : Math.max(0, Math.min(1, given)), probability: null, importance: 0, children };
     };
     this.top = root === void 0 ? null : build(root);
     if (this.top) this.#solve(this.top);
@@ -1068,7 +790,7 @@ var LINE = 11;
 var NAME2 = { ["and" /* And */]: "AND gate", ["or" /* Or */]: "OR gate" };
 var clamp2 = (value, low, high) => Math.max(low, Math.min(high, value));
 var n5 = (value) => +value.toFixed(2);
-var FaultTreeDiagram = (_class7 = class _FaultTreeDiagram extends SchematicChart {
+var FaultTreeDiagram = (_class7 = class _FaultTreeDiagram extends _chunkM4IQ5LIZcjs.SchematicChart {
   static __initStatic5() {this.meta = {
     id: "fault-tree",
     name: "Fault tree",
@@ -1077,7 +799,7 @@ var FaultTreeDiagram = (_class7 = class _FaultTreeDiagram extends SchematicChart
     shape: "table" /* Table */,
     description: "Breaks a top event down through AND and OR gates to basic events and computes every probability from the basic ones. The sample system is invented.",
     tags: ["fta", "reliability", "safety", "gate", "top event", "basic event", "risk"],
-    sample: (seed) => ReliabilitySamples.faultTree(seed),
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.faultTree(seed),
     variants: {
       leaves: Object.values(FaultTreeLeaves),
       probabilities: [true, false],
@@ -1113,7 +835,7 @@ var FaultTreeDiagram = (_class7 = class _FaultTreeDiagram extends SchematicChart
     const gap = Math.min(...gaps.values()), box = clamp2(gap * (width - 6) / (1 + gap), 24, 132);
     const wide = (node, x) => {
       const room = Math.min(gaps.get(Math.round(node.y * 1e6)) * (width - box) - 6, 2 * Math.min(x, width - x));
-      return clamp2(Math.min(room, Math.max(box, SchematicLabel.width(node.data.label) + 14)), 24, 132);
+      return clamp2(Math.min(room, Math.max(box, _chunkM4IQ5LIZcjs.SchematicLabel.width(node.data.label) + 14)), 24, 132);
     };
     const row = height / (root.height + 1), lines = row >= 66 ? 2 : 1, tail = probabilities ? LINE : 0;
     const peak = Math.max(...nodes.map((node) => node.data.importance), 1e-12), full = clamp2(row * 0.16, 6, 11);
@@ -1129,7 +851,7 @@ var FaultTreeDiagram = (_class7 = class _FaultTreeDiagram extends SchematicChart
     return { placed, row };
   }
   #tip(event, color) {
-    const rows = [["Type", event.gate ? NAME2[event.gate] : "Basic event"], ["Probability", SchematicLabel.probability(event.probability)]];
+    const rows = [["Type", event.gate ? NAME2[event.gate] : "Basic event"], ["Probability", _chunkM4IQ5LIZcjs.SchematicLabel.probability(event.probability)]];
     if (!event.gate) rows.push(["Criticality importance", `${(event.importance * 100).toFixed(1)}%`]);
     return { title: event.label, rows, color };
   }
@@ -1162,10 +884,10 @@ var FaultTreeDiagram = (_class7 = class _FaultTreeDiagram extends SchematicChart
     this.notes(ctx, "labels", placed.flatMap((item) => {
       const { event } = item, basic = !event.gate;
       const space = basic ? row - (item.out - item.top) - 4 - tail : item.boxHeight - 6 - tail;
-      const lines = SchematicLabel.wrap(event.label, item.width - (basic ? 2 : 6), Math.max(1, Math.floor(space / LINE)));
+      const lines = _chunkM4IQ5LIZcjs.SchematicLabel.wrap(event.label, item.width - (basic ? 2 : 6), Math.max(1, Math.floor(space / LINE)));
       const first = basic ? item.out + 4 + LINE / 2 : item.top + 3 + LINE / 2;
       const text = lines.map((line, i) => ({ key: `${event.id}/${i}`, text: line, x: item.x, y: first + i * LINE }));
-      if (probabilities) text.push({ key: `${event.id}/p`, text: SchematicLabel.probability(event.probability), x: item.x, y: first + lines.length * LINE, tone: "secondary", weight: basic ? void 0 : 600 });
+      if (probabilities) text.push({ key: `${event.id}/p`, text: _chunkM4IQ5LIZcjs.SchematicLabel.probability(event.probability), x: item.x, y: first + lines.length * LINE, tone: "secondary", weight: basic ? void 0 : 600 });
       return text;
     }));
   }
@@ -1226,7 +948,7 @@ var JitterBathtubCurve = (_class8 = class extends _chunkUXFWDEP6cjs.StatisticalC
     shape: "table" /* Table */,
     description: "Plots bit error ratio against sampling position across the unit interval, extends each wall with a fitted Gaussian tail, and reads the eye opening at a target error ratio. The sample scan is invented.",
     tags: ["jitter", "ber", "bathtub", "eye opening", "serdes", "signal integrity", "dual dirac", "timing margin"],
-    sample: (seed) => ReliabilitySamples.jitterScan(seed),
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.jitterScan(seed),
     variants: {
       scale: Object.values(JitterBathtubScale),
       extrapolate: [true, false],
@@ -1341,18 +1063,18 @@ var LadderProgram = (_class9 = class {
   constructor(rows, columns) {;_class9.prototype.__init6.call(this);
     const steps = /* @__PURE__ */ new Map();
     rows.forEach((row, i) => {
-      const kind = KINDS2.get(SchematicChart.word(row[columns.kind]).toLowerCase());
+      const kind = KINDS2.get(_chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.kind]).toLowerCase());
       if (!kind) return;
-      const name = SchematicChart.word(row[columns.rung]) || "1", comment = SchematicChart.word(row[columns.comment]);
+      const name = _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.rung]) || "1", comment = _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.comment]);
       const rung = _nullishCoalesce(this.rungs.find((item) => item.name === name), () => ( this.rungs[this.rungs.push({ name, comment: "", steps: [], outputs: [], reach: 0, energised: false }) - 1]));
       rung.comment ||= comment;
-      const on = !OFF.has(SchematicChart.word(row[columns.state]).toLowerCase());
-      const element = { kind, tag: SchematicChart.word(row[columns.tag]), on, preset: SchematicChart.word(row[columns.preset]), conducts: kind === "nc" /* Closed */ ? !on : on };
+      const on = !OFF.has(_chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.state]).toLowerCase());
+      const element = { kind, tag: _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.tag]), on, preset: _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.preset]), conducts: kind === "nc" /* Closed */ ? !on : on };
       if (!CONTACTS.has(kind)) {
         rung.outputs.push(element);
         return;
       }
-      const at = _nullishCoalesce(steps.get(rung), () => ( steps.set(rung, /* @__PURE__ */ new Map()).get(rung))), key = SchematicChart.word(row[columns.step]) || `row ${i}`;
+      const at = _nullishCoalesce(steps.get(rung), () => ( steps.set(rung, /* @__PURE__ */ new Map()).get(rung))), key = _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.step]) || `row ${i}`;
       at.set(key, [..._nullishCoalesce(at.get(key), () => ( [])), element]);
     });
     for (const rung of this.rungs) {
@@ -1386,7 +1108,7 @@ var NAME3 = {
 var BLOCK = { ["timer" /* Timer */]: "TON", ["counter" /* Counter */]: "CTU" };
 var LETTER = { ["set" /* Set */]: "S", ["reset" /* Reset */]: "R" };
 var n6 = (value) => +value.toFixed(2);
-var LadderLogicDiagram = (_class10 = class _LadderLogicDiagram extends SchematicChart {
+var LadderLogicDiagram = (_class10 = class _LadderLogicDiagram extends _chunkM4IQ5LIZcjs.SchematicChart {
   static __initStatic7() {this.meta = {
     id: "ladder-logic",
     name: "Ladder logic diagram",
@@ -1395,7 +1117,7 @@ var LadderLogicDiagram = (_class10 = class _LadderLogicDiagram extends Schematic
     shape: "table" /* Table */,
     description: "Draws ladder logic as rungs between two rails, with contacts, coils and timers, and traces which rungs the given contact states energise. The sample program is invented.",
     tags: ["ladder", "plc", "relay logic", "rung", "contact", "coil", "timer", "iec 61131"],
-    sample: (seed) => ReliabilitySamples.ladder(seed),
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.ladder(seed),
     variants: {
       outputs: Object.values(LadderOutputs),
       powerFlow: [true, false],
@@ -1438,7 +1160,7 @@ var LadderLogicDiagram = (_class10 = class _LadderLogicDiagram extends Schematic
         if (live) hot.push(d);
       };
       const y = (i) => top + head + i * rowHeight + rowHeight / 2 + 4, main = y(0);
-      if (comments) notes.push({ key: `comment/${r}`, text: SchematicLabel.fit(`${r + 1}  ${rung.comment}`.trimEnd(), right - left - 12), x: left + 6, y: top + COMMENT / 2, anchor: "start", tone: "secondary" });
+      if (comments) notes.push({ key: `comment/${r}`, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(`${r + 1}  ${rung.comment}`.trimEnd(), right - left - 12), x: left + 6, y: top + COMMENT / 2, anchor: "start", tone: "secondary" });
       let from = left;
       rung.steps.forEach((step, k) => {
         const x = left + 8 + (k + 0.5) * slot, reached = k <= rung.reach, passes = reached && k < rung.reach;
@@ -1481,9 +1203,9 @@ var LadderLogicDiagram = (_class10 = class _LadderLogicDiagram extends Schematic
     }));
     for (const mark of marks) {
       const { element } = mark, block = BLOCK[element.kind], letter = LETTER[element.kind];
-      const text = tagged ? SchematicLabel.fit(element.tag, (block ? 2 * BOX + 16 : slot) - 4) : "";
+      const text = tagged ? _chunkM4IQ5LIZcjs.SchematicLabel.fit(element.tag, (block ? 2 * BOX + 16 : slot) - 4) : "";
       if (text) notes.push({ key: `tag/${mark.key}`, text, x: mark.x, y: mark.y - plate - (block ? 9 : 7) });
-      if (block) notes.push({ key: `block/${mark.key}`, text: SchematicLabel.fit(`${block} ${element.preset}`.trimEnd(), 2 * BOX - 4, 8), x: mark.x, y: mark.y, size: 8, weight: 600 });
+      if (block) notes.push({ key: `block/${mark.key}`, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(`${block} ${element.preset}`.trimEnd(), 2 * BOX - 4, 8), x: mark.x, y: mark.y, size: 8, weight: 600 });
       if (letter) notes.push({ key: `letter/${mark.key}`, text: letter, x: mark.x, y: mark.y, size: 8, weight: 600 });
     }
     this.notes(ctx, "labels", notes);
@@ -1588,7 +1310,7 @@ var PidLayout = (_class11 = class _PidLayout {
     const partners = (id) => lines.flatMap((line) => line.source === id ? [line.target] : line.target === id ? [line.source] : []);
     const wish = /* @__PURE__ */ new Map();
     for (let pass = 0; pass < 2; pass++) for (const item of bubbles) {
-      const known = partners(item.id).map((id) => _nullishCoalesce(_optionalChain([placed, 'access', _11 => _11.get, 'call', _12 => _12(id), 'optionalAccess', _13 => _13.x]), () => ( wish.get(id)))).filter((x) => x !== void 0);
+      const known = partners(item.id).map((id) => _nullishCoalesce(_optionalChain([placed, 'access', _10 => _10.get, 'call', _11 => _11(id), 'optionalAccess', _12 => _12.x]), () => ( wish.get(id)))).filter((x) => x !== void 0);
       if (known.length) wish.set(item.id, known.reduce((sum, x) => sum + x, 0) / known.length);
     }
     const queue = bubbles.map((item) => ({ item, x: _nullishCoalesce(wish.get(item.id), () => ( area.width / 2)) })).sort((a, b) => a.x - b.x);
@@ -1613,16 +1335,16 @@ var PidLayout = (_class11 = class _PidLayout {
         return;
       }
       const start = [from.x + from.shape.half, from.y], end = [to.x - to.shape.half, to.y];
-      const head = SchematicChart.arrow(end[0], end[1], 0);
+      const head = _chunkM4IQ5LIZcjs.SchematicChart.arrow(end[0], end[1], 0);
       if (direct) {
         if (to.x > from.x) {
-          this.lines.push({ ...line, key, d: `M${n8(start[0])},${n8(start[1])} L${n8(end[0] - 5)},${n8(end[1])}`, arrow: SchematicChart.arrow(end[0], end[1], Math.atan2(end[1] - start[1], end[0] - start[0]) * 180 / Math.PI) });
+          this.lines.push({ ...line, key, d: `M${n8(start[0])},${n8(start[1])} L${n8(end[0] - 5)},${n8(end[1])}`, arrow: _chunkM4IQ5LIZcjs.SchematicChart.arrow(end[0], end[1], Math.atan2(end[1] - start[1], end[0] - start[0]) * 180 / Math.PI) });
           return;
         }
         const y0 = from.y + from.shape.down, y1 = to.y + to.shape.down, clear = Math.min(area.height - 2, Math.max(...this.items.map((item) => item.y + item.shape.down)) + TAG + 4);
         const dip = Math.max(y0, y1, (4 * clear - y0 - y1) / 2), mid = (from.x + to.x) / 2;
         const angle = Math.atan2(to.y + to.shape.down - dip, to.x - mid) * 180 / Math.PI;
-        this.lines.push({ ...line, key, d: `M${n8(from.x)},${n8(from.y + from.shape.down)} Q${n8(mid)},${n8(dip)} ${n8(to.x)},${n8(to.y + to.shape.down)}`, arrow: SchematicChart.arrow(to.x, to.y + to.shape.down, angle) });
+        this.lines.push({ ...line, key, d: `M${n8(from.x)},${n8(from.y + from.shape.down)} Q${n8(mid)},${n8(dip)} ${n8(to.x)},${n8(to.y + to.shape.down)}`, arrow: _chunkM4IQ5LIZcjs.SchematicChart.arrow(to.x, to.y + to.shape.down, angle) });
         return;
       }
       const lane = lanes.indexOf(line);
@@ -1698,7 +1420,7 @@ var NAME4 = {
   ["instrument" /* Instrument */]: "Instrument",
   ["other" /* Other */]: "Equipment"
 };
-var PipingInstrumentDiagram = (_class12 = class extends SchematicChart {
+var PipingInstrumentDiagram = (_class12 = class extends _chunkM4IQ5LIZcjs.SchematicChart {
   static __initStatic8() {this.meta = {
     id: "piping-instrumentation-diagram",
     name: "P&ID",
@@ -1707,7 +1429,7 @@ var PipingInstrumentDiagram = (_class12 = class extends SchematicChart {
     shape: "graph" /* Graph */,
     description: "Lays out a piping and instrumentation diagram from a list of equipment and connections: vessels, pumps, valves and exchangers on process lines, with tagged instrument bubbles. The sample unit is invented.",
     tags: ["p&id", "piping", "instrumentation", "process", "plant", "schematic", "control loop", "isa"],
-    sample: (seed) => ReliabilitySamples.processUnit(seed),
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.processUnit(seed),
     variants: {
       routing: Object.values(PidRouting),
       instruments: [true, false],
@@ -1720,14 +1442,14 @@ var PipingInstrumentDiagram = (_class12 = class extends SchematicChart {
   /** Items and lines read from the data. Repeated ids keep their first node, and lines to unknown ids are dropped. */
   parts() {
     const { data, kind, label: label2, line } = this.options;
-    const nodes = Array.isArray(_optionalChain([data, 'optionalAccess', _14 => _14.nodes])) ? data.nodes : [], links = Array.isArray(_optionalChain([data, 'optionalAccess', _15 => _15.links])) ? data.links : [];
+    const nodes = Array.isArray(_optionalChain([data, 'optionalAccess', _13 => _13.nodes])) ? data.nodes : [], links = Array.isArray(_optionalChain([data, 'optionalAccess', _14 => _14.links])) ? data.links : [];
     const items = /* @__PURE__ */ new Map();
     for (const node of nodes) {
-      const id = SchematicChart.word(_optionalChain([node, 'optionalAccess', _16 => _16.id]));
-      if (id && !items.has(id)) items.set(id, { id, kind: _nullishCoalesce(KINDS3.get(SchematicChart.word(node[kind]).toLowerCase().replace(/[\s_]+/g, "-")), () => ( "other")) /* Other */, label: SchematicChart.word(node[label2]) || id });
+      const id = _chunkM4IQ5LIZcjs.SchematicChart.word(_optionalChain([node, 'optionalAccess', _15 => _15.id]));
+      if (id && !items.has(id)) items.set(id, { id, kind: _nullishCoalesce(KINDS3.get(_chunkM4IQ5LIZcjs.SchematicChart.word(node[kind]).toLowerCase().replace(/[\s_]+/g, "-")), () => ( "other")) /* Other */, label: _chunkM4IQ5LIZcjs.SchematicChart.word(node[label2]) || id });
     }
     const bubble = (id) => items.get(id).kind === "instrument" /* Instrument */;
-    const lines = links.map((link) => ({ source: SchematicChart.word(_optionalChain([link, 'optionalAccess', _17 => _17.source])), target: SchematicChart.word(_optionalChain([link, 'optionalAccess', _18 => _18.target])), flag: SchematicChart.word(_optionalChain([link, 'optionalAccess', _19 => _19[line]])).toLowerCase() })).filter((link) => items.has(link.source) && items.has(link.target)).map(({ source, target, flag }) => ({ source, target, signal: flag.startsWith("sig") || bubble(source) || bubble(target) }));
+    const lines = links.map((link) => ({ source: _chunkM4IQ5LIZcjs.SchematicChart.word(_optionalChain([link, 'optionalAccess', _16 => _16.source])), target: _chunkM4IQ5LIZcjs.SchematicChart.word(_optionalChain([link, 'optionalAccess', _17 => _17.target])), flag: _chunkM4IQ5LIZcjs.SchematicChart.word(_optionalChain([link, 'optionalAccess', _18 => _18[line]])).toLowerCase() })).filter((link) => items.has(link.source) && items.has(link.target)).map(({ source, target, flag }) => ({ source, target, signal: flag.startsWith("sig") || bubble(source) || bubble(target) }));
     return { items: [...items.values()], lines };
   }
   table() {
@@ -1740,7 +1462,7 @@ var PipingInstrumentDiagram = (_class12 = class extends SchematicChart {
     const layout = new PidLayout(items, lines, ctx.plot, routing === "direct" /* Direct */, instruments);
     const piped = layout.lines.some((link) => !link.signal), wired = layout.lines.some((link) => link.signal);
     const pipe = piped ? palette.color("Process line") : theme.inkMuted, signal = wired ? palette.color("Signal line") : theme.inkMuted;
-    const name = (id) => _nullishCoalesce(_optionalChain([items, 'access', _20 => _20.find, 'call', _21 => _21((item) => item.id === id), 'optionalAccess', _22 => _22.label]), () => ( id));
+    const name = (id) => _nullishCoalesce(_optionalChain([items, 'access', _19 => _19.find, 'call', _20 => _20((item) => item.id === id), 'optionalAccess', _21 => _21.label]), () => ( id));
     this.wires(ctx, "lines", layout.lines.map((link) => ({
       key: link.key,
       d: link.d,
@@ -1757,14 +1479,14 @@ var PipingInstrumentDiagram = (_class12 = class extends SchematicChart {
     ctx.hover(symbols, (item) => ({ title: item.label, rows: [["Type", NAME4[item.kind]], ["Connects to", lines.filter((link) => link.source === item.id).map((link) => name(link.target)).join(", ") || "Nothing"]] }));
     const notes = layout.items.flatMap((item) => {
       if (item.kind !== "instrument" /* Instrument */) {
-        const text = tags ? SchematicLabel.fit(item.label, layout.column - 6) : "";
+        const text = tags ? _chunkM4IQ5LIZcjs.SchematicLabel.fit(item.label, layout.column - 6) : "";
         return text ? [{ key: item.id, text, x: item.x, y: item.y + item.shape.down + 8, halo: true }] : [];
       }
       const [letters, loop] = item.label.split(/[-\s]+/, 2), size = Math.max(7, Math.min(9, item.shape.half * 0.62)), room = item.shape.half * 1.7;
-      if (!tags || !loop) return [{ key: item.id, text: SchematicLabel.fit(_nullishCoalesce(letters, () => ( "")), room, size), x: item.x, y: item.y, size, weight: 600 }];
+      if (!tags || !loop) return [{ key: item.id, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(_nullishCoalesce(letters, () => ( "")), room, size), x: item.x, y: item.y, size, weight: 600 }];
       return [
-        { key: `${item.id}/letters`, text: SchematicLabel.fit(_nullishCoalesce(letters, () => ( "")), room, size), x: item.x, y: item.y - size * 0.55, size, weight: 600 },
-        { key: `${item.id}/loop`, text: SchematicLabel.fit(loop, room, size), x: item.x, y: item.y + size * 0.6, size }
+        { key: `${item.id}/letters`, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(_nullishCoalesce(letters, () => ( "")), room, size), x: item.x, y: item.y - size * 0.55, size, weight: 600 },
+        { key: `${item.id}/loop`, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(loop, room, size), x: item.x, y: item.y + size * 0.6, size }
       ];
     });
     this.notes(ctx, "tags", notes);
@@ -1778,8 +1500,8 @@ var ReliabilityBlockModel = (_class13 = class _ReliabilityBlockModel {
   
   constructor(rows, columns) {;_class13.prototype.__init9.call(this);
     rows.forEach((row, i) => {
-      const name = SchematicChart.word(row[columns.block]) || `Block ${i + 1}`, given = SchematicChart.number(row[columns.reliability]);
-      const stageName = SchematicChart.word(row[columns.stage]) || name, branchName = SchematicChart.word(row[columns.branch]) || `#${i}`;
+      const name = _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.block]) || `Block ${i + 1}`, given = _chunkM4IQ5LIZcjs.SchematicChart.number(row[columns.reliability]);
+      const stageName = _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.stage]) || name, branchName = _chunkM4IQ5LIZcjs.SchematicChart.word(row[columns.branch]) || `#${i}`;
       const stage = _nullishCoalesce(this.stages.find((item) => item.name === stageName), () => ( this.stages[this.stages.push({ name: stageName, branches: [], reliability: null }) - 1]));
       const branch = _nullishCoalesce(stage.branches.find((item) => item.name === branchName), () => ( stage.branches[stage.branches.push({ name: branchName, blocks: [], reliability: null }) - 1]));
       branch.blocks.push({ name, reliability: given === null ? null : Math.max(0, Math.min(1, given)) });
@@ -1803,7 +1525,7 @@ var ReliabilityBlockModel = (_class13 = class _ReliabilityBlockModel {
 var HEAD2 = 18;
 var END = 8;
 var clamp4 = (value, low, high) => Math.max(low, Math.min(high, value));
-var ReliabilityBlockDiagram = (_class14 = class extends SchematicChart {
+var ReliabilityBlockDiagram = (_class14 = class extends _chunkM4IQ5LIZcjs.SchematicChart {
   static __initStatic9() {this.meta = {
     id: "reliability-block-diagram",
     name: "Reliability block diagram",
@@ -1812,7 +1534,7 @@ var ReliabilityBlockDiagram = (_class14 = class extends SchematicChart {
     shape: "table" /* Table */,
     description: "Draws a system as blocks in series and in parallel between an input and an output, and multiplies out the reliability of each stage and of the whole. The sample system is invented.",
     tags: ["rbd", "reliability", "series", "parallel", "redundancy", "availability"],
-    sample: (seed) => ReliabilitySamples.blocks(seed),
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.blocks(seed),
     variants: {
       orientation: ["horizontal" /* Horizontal */, "vertical" /* Vertical */],
       stageTotals: [true, false]
@@ -1857,8 +1579,8 @@ var ReliabilityBlockDiagram = (_class14 = class extends SchematicChart {
         joints.push({ key: `${s}/${key}`, x, y });
       }
       if (stageTotals) {
-        const text = `R ${SchematicLabel.probability(stage.reliability)}`, [x, y] = flat ? at((from + to) / 2, across + side / 2) : at((from + to) / 2, across + 6);
-        notes.push({ key: `total/${s}`, text: SchematicLabel.fit(text, flat ? to - from + gap - 4 : side - 8), x, y, anchor: flat ? "middle" : "start", tone: "secondary" });
+        const text = `R ${_chunkM4IQ5LIZcjs.SchematicLabel.probability(stage.reliability)}`, [x, y] = flat ? at((from + to) / 2, across + side / 2) : at((from + to) / 2, across + 6);
+        notes.push({ key: `total/${s}`, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(text, flat ? to - from + gap - 4 : side - 8), x, y, anchor: flat ? "middle" : "start", tone: "secondary" });
       }
       previous = to;
       cursor = to + gap;
@@ -1876,19 +1598,19 @@ var ReliabilityBlockDiagram = (_class14 = class extends SchematicChart {
     ctx.hover(rects, (box) => ({
       title: box.block.name,
       color: color(box),
-      rows: [["Stage", box.stage.name], ["Reliability", SchematicLabel.probability(box.block.reliability)], ["Stage reliability", SchematicLabel.probability(box.stage.reliability)]]
+      rows: [["Stage", box.stage.name], ["Reliability", _chunkM4IQ5LIZcjs.SchematicLabel.probability(box.block.reliability)], ["Stage reliability", _chunkM4IQ5LIZcjs.SchematicLabel.probability(box.stage.reliability)]]
     }));
     for (const box of boxes) {
-      const fill = palette.inkOn(color(box)), value = SchematicLabel.probability(box.block.reliability);
+      const fill = palette.inkOn(color(box)), value = _chunkM4IQ5LIZcjs.SchematicLabel.probability(box.block.reliability);
       if (flat) {
-        SchematicLabel.wrap(box.block.name, box.width - 4, box.height >= 24 ? 2 : 1, 9).forEach((line, i, all) => notes.push({ key: `name/${box.key}/${i}`, text: line, x: box.x, y: box.y + (i - (all.length - 1) / 2) * 10, size: 9, fill }));
-        notes.push({ key: `value/${box.key}`, text: SchematicLabel.fit(value, box.width + 6, 9), x: box.x, y: box.y + box.height / 2 + 7, size: 9, tone: "secondary", halo: true });
+        _chunkM4IQ5LIZcjs.SchematicLabel.wrap(box.block.name, box.width - 4, box.height >= 24 ? 2 : 1, 9).forEach((line, i, all) => notes.push({ key: `name/${box.key}/${i}`, text: line, x: box.x, y: box.y + (i - (all.length - 1) / 2) * 10, size: 9, fill }));
+        notes.push({ key: `value/${box.key}`, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(value, box.width + 6, 9), x: box.x, y: box.y + box.height / 2 + 7, size: 9, tone: "secondary", halo: true });
       } else {
         const size = box.height >= 13 ? 10 : 8, both = `${box.block.name}  ${value}`;
-        notes.push({ key: `name/${box.key}`, text: SchematicLabel.width(both, size) <= box.width - 6 ? both : SchematicLabel.fit(box.block.name, box.width - 6, size), x: box.x, y: box.y, size, fill });
+        notes.push({ key: `name/${box.key}`, text: _chunkM4IQ5LIZcjs.SchematicLabel.width(both, size) <= box.width - 6 ? both : _chunkM4IQ5LIZcjs.SchematicLabel.fit(box.block.name, box.width - 6, size), x: box.x, y: box.y, size, fill });
       }
     }
-    if (stages.length) notes.push({ key: "system", text: SchematicLabel.fit(`System reliability ${SchematicLabel.probability(model.reliability)}`, width, 11), x: 0, y: HEAD2 / 2 - 3, anchor: "start", size: 11, weight: 600 });
+    if (stages.length) notes.push({ key: "system", text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(`System reliability ${_chunkM4IQ5LIZcjs.SchematicLabel.probability(model.reliability)}`, width, 11), x: 0, y: HEAD2 / 2 - 3, anchor: "start", size: 11, weight: 600 });
     this.notes(ctx, "labels", notes);
   }
 }, _class14.__initStatic9(), _class14);
@@ -1910,7 +1632,7 @@ var ShmooPlot = (_class15 = class _ShmooPlot extends _chunkUXFWDEP6cjs.Statistic
     shape: "table" /* Table */,
     description: "Marks pass or fail at each point of a two-parameter sweep, showing the operating region of a device and its margins. The sample sweep is invented.",
     tags: ["shmoo", "test", "semiconductor", "pass fail", "margin", "voltage", "frequency", "characterisation"],
-    sample: (seed) => ReliabilitySamples.shmoo(seed),
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.shmoo(seed),
     variants: {
       form: Object.values(ShmooForm),
       boundary: [true, false]
@@ -1925,7 +1647,7 @@ var ShmooPlot = (_class15 = class _ShmooPlot extends _chunkUXFWDEP6cjs.Statistic
   }
   /** Bands thinner than their labels keep every nth one. */
   tickFormat(scale) {
-    const names = _nullishCoalesce(_optionalChain([scale, 'access', _23 => _23.domain, 'optionalCall', _24 => _24()]), () => ( [])), step = _nullishCoalesce(_optionalChain([scale, 'access', _25 => _25.step, 'optionalCall', _26 => _26()]), () => ( 0));
+    const names = _nullishCoalesce(_optionalChain([scale, 'access', _22 => _22.domain, 'optionalCall', _23 => _23()]), () => ( [])), step = _nullishCoalesce(_optionalChain([scale, 'access', _24 => _24.step, 'optionalCall', _25 => _25()]), () => ( 0));
     const upright = (_nullishCoalesce(scale.range()[0], () => ( 0))) > (_nullishCoalesce(scale.range()[1], () => ( 0)));
     const need = upright ? 13 : Math.max(...names.map((name) => name.length), 1) * 6.2 + 8;
     const every = Math.max(1, Math.ceil(need / Math.max(1, step)));
@@ -2086,7 +1808,7 @@ var NAME5 = {
 var ENDS = /* @__PURE__ */ new Set(["generator" /* Generator */, "motor" /* Motor */, "load" /* Load */]);
 var clamp5 = (value, low, high) => Math.max(low, Math.min(high, value));
 var n10 = (value) => +value.toFixed(2);
-var SingleLineDiagram = (_class16 = class extends SchematicChart {
+var SingleLineDiagram = (_class16 = class extends _chunkM4IQ5LIZcjs.SchematicChart {
   static __initStatic11() {this.meta = {
     id: "single-line-diagram",
     name: "Single-line diagram",
@@ -2095,7 +1817,7 @@ var SingleLineDiagram = (_class16 = class extends SchematicChart {
     shape: "table" /* Table */,
     description: "Draws an electrical network as one line per circuit, with standard symbols for sources, buses, breakers, transformers, motors and loads, coloured by voltage level. The sample network is invented.",
     tags: ["one-line", "sld", "electrical", "power", "switchgear", "substation", "transformer", "breaker"],
-    sample: (seed) => ReliabilitySamples.powerNetwork(seed),
+    sample: (seed) => _chunkM4IQ5LIZcjs.ReliabilitySamples.powerNetwork(seed),
     variants: {
       symbols: Object.values(SingleLineSymbols),
       orientation: ["vertical" /* Vertical */, "horizontal" /* Horizontal */],
@@ -2110,11 +1832,11 @@ var SingleLineDiagram = (_class16 = class extends SchematicChart {
     const { id, kind, from, label: label2, rating, voltage } = this.options;
     const byId = /* @__PURE__ */ new Map();
     for (const row of this.rows()) {
-      const key = SchematicChart.word(row[id]);
+      const key = _chunkM4IQ5LIZcjs.SchematicChart.word(row[id]);
       if (key && !byId.has(key)) byId.set(key, row);
     }
     const feeder = (key) => {
-      const up = SchematicChart.word(byId.get(key)[from]);
+      const up = _chunkM4IQ5LIZcjs.SchematicChart.word(byId.get(key)[from]);
       return up !== key && byId.has(up) ? up : null;
     };
     const seen = /* @__PURE__ */ new Set(), all = [];
@@ -2124,10 +1846,10 @@ var SingleLineDiagram = (_class16 = class extends SchematicChart {
       const row = byId.get(key);
       const element = {
         id: key,
-        kind: _nullishCoalesce(KINDS4.get(SchematicChart.word(row[kind]).toLowerCase().replace(/[\s_]+/g, "-")), () => ( "load")) /* Load */,
-        label: SchematicChart.word(row[label2]) || key,
-        rating: SchematicChart.word(row[rating]),
-        voltage: SchematicChart.word(row[voltage]) || (_nullishCoalesce(_optionalChain([parent, 'optionalAccess', _27 => _27.voltage]), () => ( ""))),
+        kind: _nullishCoalesce(KINDS4.get(_chunkM4IQ5LIZcjs.SchematicChart.word(row[kind]).toLowerCase().replace(/[\s_]+/g, "-")), () => ( "load")) /* Load */,
+        label: _chunkM4IQ5LIZcjs.SchematicChart.word(row[label2]) || key,
+        rating: _chunkM4IQ5LIZcjs.SchematicChart.word(row[rating]),
+        voltage: _chunkM4IQ5LIZcjs.SchematicChart.word(row[voltage]) || (_nullishCoalesce(_optionalChain([parent, 'optionalAccess', _26 => _26.voltage]), () => ( ""))),
         parent,
         children: [],
         depth: parent ? parent.depth + 1 : 0,
@@ -2171,7 +1893,7 @@ var SingleLineDiagram = (_class16 = class extends SchematicChart {
     const tip = (spot) => ({
       title: spot.element.label,
       color: color(spot.element),
-      rows: [["Type", NAME5[spot.element.kind]], ...spot.element.rating ? [["Rating", spot.element.rating]] : [], ...spot.element.voltage ? [["Voltage", spot.element.voltage]] : [], ["Fed from", _nullishCoalesce(_optionalChain([spot, 'access', _28 => _28.element, 'access', _29 => _29.parent, 'optionalAccess', _30 => _30.label]), () => ( "Nothing"))]]
+      rows: [["Type", NAME5[spot.element.kind]], ...spot.element.rating ? [["Rating", spot.element.rating]] : [], ...spot.element.voltage ? [["Voltage", spot.element.voltage]] : [], ["Fed from", _nullishCoalesce(_optionalChain([spot, 'access', _27 => _27.element, 'access', _28 => _28.parent, 'optionalAccess', _29 => _29.label]), () => ( "Nothing"))]]
     });
     const rails = ctx.marks("buses", "rect", bars, (bar) => bar.element.id).attr("rx", 1.5).attr("fill", (bar) => color(bar.element));
     ctx.set(rails, { x: (bar) => bar.left, y: (bar) => bar.top, width: (bar) => bar.width, height: (bar) => bar.height });
@@ -2189,152 +1911,24 @@ var SingleLineDiagram = (_class16 = class extends SchematicChart {
       const { element } = spot, bar = bars.find((item) => item.element === element), detail = ratings && twoLines && !bar ? element.rating : "";
       if (bar && down) {
         const room = spot.x - bar.left - 6, aside = room < 30;
-        notes.push({ key: element.id, text: SchematicLabel.fit(element.label, aside ? width - bar.left - bar.width - 6 : room), x: aside ? bar.left + bar.width + 4 : bar.left, y: aside ? spot.y : spot.y - 8, anchor: "start", halo: true });
+        notes.push({ key: element.id, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(element.label, aside ? width - bar.left - bar.width - 6 : room), x: aside ? bar.left + bar.width + 4 : bar.left, y: aside ? spot.y : spot.y - 8, anchor: "start", halo: true });
       } else if (bar) {
         const above = bar.top - 7 >= 5;
-        notes.push({ key: element.id, text: SchematicLabel.fit(element.label, step - 6), x: spot.x, y: above ? bar.top - 7 : bar.top + bar.height + 8, halo: true });
+        notes.push({ key: element.id, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(element.label, step - 6), x: spot.x, y: above ? bar.top - 7 : bar.top + bar.height + 8, halo: true });
       } else if (down) {
         const x = spot.x + size / 2 + 4, next = Math.min(width, ...spots.filter((other) => other.element.depth === element.depth && other.x > spot.x).map((other) => other.x - size / 2 - 4));
         const room = next - x;
-        notes.push({ key: element.id, text: SchematicLabel.fit(element.label, room), x, y: spot.y - (detail ? 5 : 0), anchor: "start" });
-        if (detail) notes.push({ key: `${element.id}/rating`, text: SchematicLabel.fit(detail, room, 9), x, y: spot.y + 6, anchor: "start", size: 9, tone: "secondary" });
+        notes.push({ key: element.id, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(element.label, room), x, y: spot.y - (detail ? 5 : 0), anchor: "start" });
+        if (detail) notes.push({ key: `${element.id}/rating`, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(detail, room, 9), x, y: spot.y + 6, anchor: "start", size: 9, tone: "secondary" });
       } else {
-        notes.push({ key: element.id, text: SchematicLabel.fit(element.label, step - 6), x: spot.x, y: spot.y + size / 2 + 8 });
-        if (detail) notes.push({ key: `${element.id}/rating`, text: SchematicLabel.fit(detail, step - 6, 9), x: spot.x, y: spot.y + size / 2 + 19, size: 9, tone: "secondary" });
+        notes.push({ key: element.id, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(element.label, step - 6), x: spot.x, y: spot.y + size / 2 + 8 });
+        if (detail) notes.push({ key: `${element.id}/rating`, text: _chunkM4IQ5LIZcjs.SchematicLabel.fit(detail, step - 6, 9), x: spot.x, y: spot.y + size / 2 + 19, size: 9, tone: "secondary" });
       }
     }
     this.notes(ctx, "labels", notes.filter((note) => note.text));
   }
 }, _class16.__initStatic11(), _class16);
 
-// src/charts/reliabilitycharts/WaferMap.ts
-var WaferMapEncoding = /* @__PURE__ */ ((WaferMapEncoding2) => {
-  WaferMapEncoding2["Bin"] = "bin";
-  WaferMapEncoding2["Value"] = "value";
-  return WaferMapEncoding2;
-})(WaferMapEncoding || {});
-var WaferMapMark = /* @__PURE__ */ ((WaferMapMark2) => {
-  WaferMapMark2["Notch"] = "notch";
-  WaferMapMark2["Flat"] = "flat";
-  return WaferMapMark2;
-})(WaferMapMark || {});
-var ZONES = ["Centre", "Middle", "Edge"];
-var n11 = (value) => +value.toFixed(2);
-var percent = (good, total) => total ? `${(100 * good / total).toFixed(1)}%` : "n/a";
-var WaferMap = (_class17 = class _WaferMap extends SchematicChart {
-  static __initStatic12() {this.meta = {
-    id: "wafer-map",
-    name: "Wafer map",
-    family: "matrix" /* Matrix */,
-    dimension: 2 /* Two */,
-    shape: "table" /* Table */,
-    description: "Draws the dies of a semiconductor wafer in place, coloured by test bin or a measured value, with the notch or flat and the yield overall and by ring. The sample wafer is invented.",
-    tags: ["wafer", "semiconductor", "die", "yield", "bin map", "probe", "defect"],
-    sample: (seed) => ReliabilitySamples.wafer(seed),
-    variants: {
-      encoding: Object.values(WaferMapEncoding),
-      mark: Object.values(WaferMapMark),
-      zones: [false, true]
-    }
-  }}
-  defaults() {
-    return { x: "x", y: "y", bin: "bin", value: "value", passBin: "Pass", encoding: "bin" /* Bin */, mark: "notch" /* Notch */, zones: false };
-  }
-  /** The value ramp has its own key beside the wafer. */
-  legendItems() {
-    return this.options.encoding === "value" /* Value */ ? [] : super.legendItems();
-  }
-  /** Dies, wafer radius and yield. A position given twice keeps its first row. */
-  summary() {
-    const { x, y, bin, value, passBin } = this.options;
-    const seen = /* @__PURE__ */ new Map();
-    for (const row of this.rows()) {
-      const column = SchematicChart.number(row[x]), line = SchematicChart.number(row[y]);
-      if (column === null || line === null || seen.has(`${column}/${line}`)) continue;
-      seen.set(`${column}/${line}`, { x: column, y: line, bin: SchematicChart.word(row[bin]), value: SchematicChart.number(row[value]), reach: 0 });
-    }
-    const dies = [...seen.values()], xs = dies.map((die) => die.x), ys = dies.map((die) => die.y);
-    const centre = dies.length ? [(Math.min(...xs) + Math.max(...xs)) / 2, (Math.min(...ys) + Math.max(...ys)) / 2] : [0, 0];
-    const radius = Math.max(0.5, ...dies.map((die) => Math.hypot(Math.abs(die.x - centre[0]) + 0.5, Math.abs(die.y - centre[1]) + 0.5)));
-    const zones = ZONES.map((name) => ({ name, good: 0, total: 0 }));
-    let good = 0;
-    for (const die of dies) {
-      die.reach = Math.hypot(die.x - centre[0], die.y - centre[1]) / radius;
-      const zone = zones[Math.min(2, Math.floor(die.reach * 3))], pass = die.bin === passBin;
-      zone.total++;
-      if (pass) {
-        zone.good++;
-        good++;
-      }
-    }
-    return { dies, centre, radius, good, zones };
-  }
-  /** The wafer's edge around the origin: a V notch, or a flat no higher than `floor`, the lowest die edge. */
-  static outline(radius, mark, floor = 0) {
-    if (mark === "flat" /* Flat */) {
-      const chord = Math.min(radius * 0.995, Math.max(radius * 0.93, floor + 1)), half2 = Math.sqrt(radius * radius - chord * chord);
-      return `M${n11(half2)},${n11(chord)} A${n11(radius)},${n11(radius)} 0 1 0 ${n11(-half2)},${n11(chord)} Z`;
-    }
-    const depth = Math.max(4, radius * 0.05), half = depth * 0.8, drop = Math.sqrt(radius * radius - half * half);
-    return `M${n11(half)},${n11(drop)} A${n11(radius)},${n11(radius)} 0 1 0 ${n11(-half)},${n11(drop)} L0,${n11(radius - depth)} Z`;
-  }
-  draw(ctx) {
-    const { width, height } = ctx.plot, { encoding, mark, zones, value, bin } = this.options, { theme, palette } = ctx;
-    const { dies, centre, radius, good, zones: rings } = this.summary();
-    const panel = Math.max(84, Math.min(150, width * 0.3)), side = Math.max(20, Math.min(height, width - panel - 10));
-    const reach = side / 2 - 2, pitch = reach / radius, wx = side / 2, wy = height / 2;
-    const byValue = encoding === "value" /* Value */;
-    const values = dies.map((die) => die.value).filter((v) => v !== null);
-    const low = Math.min(...values), span = Math.max(...values) - low || 1;
-    const counts = /* @__PURE__ */ new Map();
-    for (const die of dies) counts.set(die.bin, (_nullishCoalesce(counts.get(die.bin), () => ( 0))) + 1);
-    if (!byValue) [...counts].sort((a, b) => b[1] - a[1]).forEach(([name]) => palette.color(name || "Unbinned"));
-    const color = (die) => byValue ? die.value === null ? theme.grid : palette.sequential((die.value - low) / span) : palette.color(die.bin || "Unbinned");
-    const gap = pitch >= 9 ? 1 : pitch >= 5 ? 0.5 : 0;
-    const cells = ctx.marks("cells", "rect", dies, (die) => `${die.x}/${die.y}`).attr("fill", color).attr("rx", pitch >= 9 ? 1.5 : 0);
-    ctx.set(cells, { x: (die) => wx + (die.x - centre[0] - 0.5) * pitch + gap, y: (die) => wy + (die.y - centre[1] - 0.5) * pitch + gap, width: Math.max(0.5, pitch - 2 * gap), height: Math.max(0.5, pitch - 2 * gap) });
-    ctx.hover(cells, (die) => ({
-      title: `Die ${die.x}, ${die.y}`,
-      color: color(die),
-      rows: [[bin, die.bin || "n/a"], ...die.value === null ? [] : [[value, +die.value.toPrecision(4)]], ["Ring", ZONES[Math.min(2, Math.floor(die.reach * 3))]]]
-    }));
-    const floor = Math.max(0, ...dies.map((die) => (die.y - centre[1] + 0.5) * pitch));
-    const edge = ctx.marks("axis-wafer", "path", dies.length ? [_WaferMap.outline(reach, mark, floor)] : []).attr("fill", "none").attr("stroke", theme.axis).attr("stroke-width", 1.5).attr("transform", `translate(${n11(wx)},${n11(wy)})`);
-    ctx.set(edge, { d: (d) => d });
-    const circles = ctx.marks("rings", "circle", zones && dies.length ? [1 / 3, 2 / 3] : []).attr("fill", "none").attr("stroke", theme.ink).attr("stroke-width", 1.5).attr("stroke-dasharray", "4 3");
-    ctx.set(circles, { cx: wx, cy: wy, r: (share) => share * reach });
-    circles.style("pointer-events", "none");
-    const left = side + 12, room = width - left, notes = [];
-    let y = Math.max(8, height / 2 - (60 + (zones ? 62 : 0) + (byValue ? 44 : 0)) / 2);
-    if (dies.length) {
-      notes.push(
-        { key: "yield/title", text: "Yield", x: left, y: y + 6, anchor: "start", tone: "secondary" },
-        { key: "yield/value", text: percent(good, dies.length), x: left, y: y + 26, anchor: "start", size: Math.min(22, room / 3.6), weight: 600 },
-        { key: "yield/count", text: SchematicLabel.fit(`${good} of ${dies.length} dies`, room), x: left, y: y + 46, anchor: "start", tone: "secondary" }
-      );
-      y += 66;
-      if (zones) {
-        rings.forEach((ring, i) => notes.push(
-          { key: `zone/${ring.name}`, text: ring.name, x: left, y: y + 6 + i * 16, anchor: "start", tone: "secondary" },
-          { key: `zone/${ring.name}/value`, text: percent(ring.good, ring.total), x: left + Math.min(room, 96), y: y + 6 + i * 16, anchor: "end", weight: 600 }
-        ));
-        y += 62;
-      }
-    }
-    const steps = byValue && values.length ? Array.from({ length: 24 }, (_, i) => i) : [], keyWidth = Math.min(room, 110);
-    const ramp = ctx.marks("size-key", "rect", steps, (i) => i).attr("fill", (i) => palette.sequential(i / 23));
-    ctx.set(ramp, { x: (i) => left + i * keyWidth / 24, y: y + 14, width: keyWidth / 24 + 0.5, height: 8 });
-    if (steps.length) {
-      notes.push(
-        { key: "key/title", text: SchematicLabel.fit(value, room), x: left, y: y + 5, anchor: "start", tone: "secondary" },
-        { key: "key/low", text: `${+low.toPrecision(3)}`, x: left, y: y + 31, anchor: "start", size: 9, tone: "secondary" },
-        { key: "key/high", text: `${+(low + span).toPrecision(3)}`, x: left + keyWidth, y: y + 31, anchor: "end", size: 9, tone: "secondary" }
-      );
-    }
-    this.notes(ctx, "labels", notes);
-  }
-}, _class17.__initStatic12(), _class17);
-
 // src/charts/reliabilitycharts/index.ts
 var reliabilitychartsCatalog = [
   FaultTreeDiagram,
@@ -2343,7 +1937,7 @@ var reliabilitychartsCatalog = [
   ReliabilityBlockDiagram,
   AllanDeviationPlot,
   ShmooPlot,
-  WaferMap,
+  _chunkM4IQ5LIZcjs.WaferMap,
   JitterBathtubCurve,
   PipingInstrumentDiagram,
   SingleLineDiagram,
@@ -2386,7 +1980,4 @@ var reliabilitychartsCatalog = [
 
 
 
-
-
-
-exports.AllanEstimator = AllanEstimator; exports.AllanDeviationPlot = AllanDeviationPlot; exports.BowTieLinks = BowTieLinks; exports.BowTieBarriers = BowTieBarriers; exports.BowTieDiagram = BowTieDiagram; exports.ControlBlockKind = ControlBlockKind; exports.ControlSignalRole = ControlSignalRole; exports.ControlJunction = ControlJunction; exports.ControlFeedback = ControlFeedback; exports.ControlBlockDiagram = ControlBlockDiagram; exports.EventTreeModel = EventTreeModel; exports.EventTreeLinks = EventTreeLinks; exports.EventTreeDiagram = EventTreeDiagram; exports.FaultTreeGate = FaultTreeGate; exports.FaultTreeModel = FaultTreeModel; exports.FaultTreeLeaves = FaultTreeLeaves; exports.FaultTreeDiagram = FaultTreeDiagram; exports.JitterBathtubScale = JitterBathtubScale; exports.JitterBathtubCurve = JitterBathtubCurve; exports.LadderKind = LadderKind; exports.LadderProgram = LadderProgram; exports.LadderOutputs = LadderOutputs; exports.LadderLogicDiagram = LadderLogicDiagram; exports.PidSymbolKind = PidSymbolKind; exports.PidRouting = PidRouting; exports.PipingInstrumentDiagram = PipingInstrumentDiagram; exports.ReliabilityBlockModel = ReliabilityBlockModel; exports.ReliabilityBlockDiagram = ReliabilityBlockDiagram; exports.ShmooForm = ShmooForm; exports.ShmooPlot = ShmooPlot; exports.SingleLineKind = SingleLineKind; exports.SingleLineSymbols = SingleLineSymbols; exports.SingleLineDiagram = SingleLineDiagram; exports.WaferMapEncoding = WaferMapEncoding; exports.WaferMapMark = WaferMapMark; exports.WaferMap = WaferMap; exports.reliabilitychartsCatalog = reliabilitychartsCatalog;
+exports.AllanEstimator = AllanEstimator; exports.AllanDeviationPlot = AllanDeviationPlot; exports.BowTieLinks = BowTieLinks; exports.BowTieBarriers = BowTieBarriers; exports.BowTieDiagram = BowTieDiagram; exports.ControlBlockKind = ControlBlockKind; exports.ControlSignalRole = ControlSignalRole; exports.ControlJunction = ControlJunction; exports.ControlFeedback = ControlFeedback; exports.ControlBlockDiagram = ControlBlockDiagram; exports.EventTreeModel = EventTreeModel; exports.EventTreeLinks = EventTreeLinks; exports.EventTreeDiagram = EventTreeDiagram; exports.FaultTreeGate = FaultTreeGate; exports.FaultTreeModel = FaultTreeModel; exports.FaultTreeLeaves = FaultTreeLeaves; exports.FaultTreeDiagram = FaultTreeDiagram; exports.JitterBathtubScale = JitterBathtubScale; exports.JitterBathtubCurve = JitterBathtubCurve; exports.LadderKind = LadderKind; exports.LadderProgram = LadderProgram; exports.LadderOutputs = LadderOutputs; exports.LadderLogicDiagram = LadderLogicDiagram; exports.PidSymbolKind = PidSymbolKind; exports.PidRouting = PidRouting; exports.PipingInstrumentDiagram = PipingInstrumentDiagram; exports.ReliabilityBlockModel = ReliabilityBlockModel; exports.ReliabilityBlockDiagram = ReliabilityBlockDiagram; exports.ShmooForm = ShmooForm; exports.ShmooPlot = ShmooPlot; exports.SingleLineKind = SingleLineKind; exports.SingleLineSymbols = SingleLineSymbols; exports.SingleLineDiagram = SingleLineDiagram; exports.reliabilitychartsCatalog = reliabilitychartsCatalog;