@graphty/graph-io 0.3.43 → 0.3.45

package/dist/chunks/generic-BGO71QBv.js

@@ -0,0 +1,1347 @@
+import { aQ as keptForStyles } from "./format-BpQBx8MZ.js";
+import { S as StyleBudget } from "./emit-DZy6JgdA.js";
+import { B as STYLE_PROPERTIES, I as interpolate, J as within, t as StyleNotes, C as toolDefaults, q as isStyleValue, K as describeFeature, a as STYLE_ISSUE, L as refSource, N as isShortPredicate, O as resolveRules, P as matches, Q as evalContinuous, R as numberOf, d as canonicalFor, s as styleFingerprint, u as parseStyleBlock, v as blockStyles, y as featuresOf, p as plainCell, S as STYLE_BLOCK_NAME, U as styleLengthUnit, g as canonColor, x as colorOpacity, l as canonEnum, o as canonText, m as canonBoolean, j as canonOpacity, h as canonNumber, H as DOT_POINTS_PER_INCH } from "./block-CPCHkX42.js";
+function valueKey(v) {
+  return v === null || v === void 0 ? "\0null" : `${typeof v}:${String(v)}`;
+}
+function partition(values) {
+  const ids = /* @__PURE__ */ new Map();
+  const blocks = new Int32Array(values.length);
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i];
+    if (v === null) {
+      continue;
+    }
+    const key = valueKey(v);
+    let id = ids.get(key);
+    if (id === void 0) {
+      id = ids.size + 1;
+      ids.set(key, id);
+    }
+    blocks[i] = id;
+  }
+  return { blocks, k: ids.size };
+}
+function hashBlocks(blocks) {
+  let h = 2166136261;
+  for (const b of blocks) {
+    h = Math.imul(h ^ b, 16777619);
+  }
+  return h >>> 0;
+}
+function sameBlocks(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function familiesOf(props) {
+  const byHash = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const [p, values] of props) {
+    const { blocks, k } = partition(values);
+    const h = hashBlocks(blocks);
+    const list = byHash.get(h) ?? [];
+    const hit = list.find((f) => sameBlocks(f.blocks, blocks));
+    if (hit !== void 0) {
+      hit.props.push(p);
+      continue;
+    }
+    const styled = [];
+    for (let i = 0; i < blocks.length; i++) {
+      if (blocks[i] !== 0) {
+        styled.push(i);
+      }
+    }
+    const fam = { props: [p], blocks, k, styled };
+    list.push(fam);
+    byHash.set(h, list);
+    out.push(fam);
+  }
+  return out;
+}
+const MIN_MAPPED = 8;
+const MAX_KEYS = 256;
+const MAX_EXCEPTION_SHARE = 0.2;
+function discreteCandidate(fam, info, n, spend) {
+  const nF = fam.styled.length;
+  if (!info.categorical || info.raw || nF < MIN_MAPPED) {
+    return null;
+  }
+  if (info.distinct < 2 || info.distinct > Math.min(MAX_KEYS, nF / 2) || info.distinct >= 0.9 * n) {
+    return null;
+  }
+  spend(n);
+  const { values } = info.feature;
+  const { votes, nullBlocks } = votesOf(fam, values);
+  const { table, exceptions: wrong } = tableOf(votes);
+  let exceptions = wrong;
+  const unstyledMissing = unstyledOf(fam, values, table, n);
+  if (unstyledMissing === null) {
+    return null;
+  }
+  let bucket = null;
+  if (nullBlocks.size === 1 && !unstyledMissing) {
+    bucket = nullBlocks.keys().next().value ?? null;
+  } else {
+    for (const c of nullBlocks.values()) {
+      exceptions += c;
+    }
+  }
+  if (exceptions > Math.max(2, MAX_EXCEPTION_SHARE * nF)) {
+    return null;
+  }
+  const cost = 50 + table.size * fam.props.length + (exceptions > 0 ? 50 + exceptions : 0) + (bucket === null ? 0 : 50);
+  return { type: "discrete", info, table, bucket, cost };
+}
+function votesOf(fam, values) {
+  const votes = /* @__PURE__ */ new Map();
+  const nullBlocks = /* @__PURE__ */ new Map();
+  for (const i of fam.styled) {
+    const b = fam.blocks[i];
+    const kv = values[i];
+    if (kv === null) {
+      nullBlocks.set(b, (nullBlocks.get(b) ?? 0) + 1);
+      continue;
+    }
+    const key = valueKey(kv);
+    let vote = votes.get(key);
+    if (vote === void 0) {
+      vote = { raw: kv, counts: /* @__PURE__ */ new Map() };
+      votes.set(key, vote);
+    }
+    vote.counts.set(b, (vote.counts.get(b) ?? 0) + 1);
+  }
+  return { votes, nullBlocks };
+}
+function tableOf(votes) {
+  const table = /* @__PURE__ */ new Map();
+  let exceptions = 0;
+  for (const [key, { raw, counts }] of votes) {
+    let best = -1;
+    let bestCount = -1;
+    let total = 0;
+    for (const [b, c] of counts) {
+      total += c;
+      if (c > bestCount) {
+        bestCount = c;
+        best = b;
+      }
+    }
+    table.set(key, { raw, block: best });
+    exceptions += total - bestCount;
+  }
+  return { table, exceptions };
+}
+function unstyledOf(fam, values, table, n) {
+  let missing = false;
+  for (let i = 0; i < n; i++) {
+    const v = values[i];
+    if (fam.blocks[i] !== 0) {
+      continue;
+    }
+    if (v !== null && table.has(valueKey(v))) {
+      return null;
+    }
+    missing ||= v === null || v === false;
+  }
+  return missing;
+}
+const MAX_CLASSES = 64;
+const MAX_CLASS_RULES = 4;
+const SIZES = /* @__PURE__ */ new Set(["width", "height"]);
+const CLASS_COLUMN = "class";
+function fewValues(values) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const v of values) {
+    seen.add(valueKey(v));
+    if (seen.size > MAX_CLASSES + 1) {
+      return false;
+    }
+  }
+  return true;
+}
+function tupleKey(classable, truth, i) {
+  let key = "";
+  let any = false;
+  for (const p of classable) {
+    const v = (truth.get(p) ?? [])[i] ?? null;
+    any ||= v !== null;
+    key += `${valueKey(v)}
`;
+  }
+  return any ? key : null;
+}
+function styleClasses(target, props, truth, n, spend) {
+  const classable = props.filter(
+    (p) => STYLE_PROPERTIES[target].get(p) !== "text" && !SIZES.has(p) && fewValues(truth.get(p) ?? [])
+  );
+  if (classable.length === 0) {
+    return null;
+  }
+  spend(n * (classable.length + 1));
+  const counts = /* @__PURE__ */ new Map();
+  const tupleOf = new Array(n).fill(null);
+  let withTuple = 0;
+  for (let i = 0; i < n; i++) {
+    const key = tupleKey(classable, truth, i);
+    if (key === null) {
+      continue;
+    }
+    withTuple++;
+    tupleOf[i] = key;
+    const c = counts.get(key);
+    if (c === void 0) {
+      counts.set(key, { count: 1, rep: i });
+      if (counts.size > MAX_CLASSES) {
+        return null;
+      }
+    } else {
+      c.count++;
+    }
+  }
+  if (counts.size === 0 || withTuple < MIN_MAPPED || counts.size * 2 > withTuple) {
+    return null;
+  }
+  const order = Array.from(counts.entries()).sort((a, b) => b[1].count - a[1].count);
+  const rank = new Map(order.map(([key], j) => [key, j + 1]));
+  const column = tupleOf.map((t) => t === null ? null : rank.get(t) ?? null);
+  const ref = { style: CLASS_COLUMN };
+  const valueOf = (p, rep) => (truth.get(p) ?? [])[rep] ?? null;
+  const rules = [];
+  if (order.length <= Math.min(MAX_CLASS_RULES, Math.floor(withTuple / 4))) {
+    order.forEach(([, { count: count2, rep }], j) => {
+      const set = {};
+      for (const p of classable) {
+        const v = valueOf(p, rep);
+        if (v !== null) {
+          set[p] = v;
+        }
+      }
+      rules.push({
+        id: `${target}.class.${String(j + 1)}`,
+        target,
+        role: "group",
+        origin: "inferred",
+        where: { eq: [ref, j + 1] },
+        set,
+        facts: { elements: count2, reason: "STYLE_CLASS" }
+      });
+    });
+  } else {
+    const map = {};
+    for (const p of classable) {
+      const table = [];
+      order.forEach(([, { rep }], j) => {
+        const v = valueOf(p, rep);
+        if (v !== null) {
+          table.push([j + 1, v]);
+        }
+      });
+      map[p] = { kind: "discrete", by: ref, table };
+    }
+    rules.push({
+      id: `${target}.classes`,
+      target,
+      role: "mapping",
+      origin: "inferred",
+      where: { all: true },
+      map,
+      facts: { classes: order.length, elements: withTuple, reason: "STYLE_CLASS" }
+    });
+  }
+  return { classed: classable, column, rules };
+}
+const MAX_PIECES = 8;
+const MAX_DISTINCT_X = 4096;
+const HEX6 = /^#[0-9a-f]{6}$/;
+function interpolable(v) {
+  return typeof v === "number" || typeof v === "string" && HEX6.test(v);
+}
+function fitPieces(xs, ys, tolerant, spend) {
+  const pieces = [];
+  let a = 0;
+  while (a < xs.length) {
+    let b = a;
+    while (b + 1 < xs.length) {
+      const ok = lineFits(xs, ys, a, b + 1, tolerant);
+      spend(b + 1 - a);
+      if (!ok) {
+        break;
+      }
+      b++;
+    }
+    pieces.push([a, b]);
+    if (pieces.length > MAX_PIECES) {
+      return null;
+    }
+    a = b + 1;
+  }
+  return pieces;
+}
+function lineFits(xs, ys, a, c, tolerant) {
+  for (let j = a + 1; j < c; j++) {
+    const v = interpolate(ys[a], ys[c], (xs[j] - xs[a]) / (xs[c] - xs[a]));
+    if (tolerant ? !within(v, ys[j]) : v !== ys[j]) {
+      return false;
+    }
+  }
+  return true;
+}
+function piecesToPoints(xs, ys, pieces) {
+  const out = [];
+  for (const [a, b] of pieces) {
+    out.push({ at: xs[a], below: ys[a], value: ys[a], above: ys[a] });
+    if (b !== a) {
+      out.push({ at: xs[b], below: ys[b], value: ys[b], above: ys[b] });
+    }
+  }
+  return out;
+}
+function continuousCandidate(fam, info, truth, spend) {
+  if (!info.numeric || info.raw || fam.styled.length < MIN_MAPPED) {
+    return null;
+  }
+  const { values } = info.feature;
+  spend(values.length);
+  if (values.some((v, i) => fam.blocks[i] === 0 === (typeof v === "number"))) {
+    return null;
+  }
+  for (const tolerant of [false, true]) {
+    const points = rampsOf(fam, values, truth, tolerant, spend);
+    if (points !== null) {
+      const entries = Array.from(points.values()).reduce((sum, pts) => sum + pts.length, 0);
+      return { type: "continuous", info, points, tolerant, cost: 50 + entries + (tolerant ? 10 : 0) };
+    }
+  }
+  return null;
+}
+function rampsOf(fam, values, truth, tolerant, spend) {
+  const points = /* @__PURE__ */ new Map();
+  for (const p of fam.props) {
+    const pts = rampOf(fam, values, truth.get(p) ?? [], tolerant, spend);
+    if (pts === null) {
+      return null;
+    }
+    points.set(p, pts);
+  }
+  return points;
+}
+function rampOf(fam, values, ys0, tolerant, spend) {
+  const byX = /* @__PURE__ */ new Map();
+  let good = true;
+  for (const i of fam.styled) {
+    const y = ys0[i];
+    const x = values[i];
+    const seen = byX.get(x);
+    if (!interpolable(y) || seen !== void 0 && seen !== y) {
+      good = false;
+      break;
+    }
+    byX.set(x, y);
+  }
+  spend(fam.styled.length);
+  if (!good || byX.size < 2 || byX.size > MAX_DISTINCT_X || new Set(byX.values()).size < 3) {
+    return null;
+  }
+  const xs = Array.from(byX.keys()).sort((a, b) => a - b);
+  const ys = xs.map((x) => byX.get(x));
+  const pieces = fitPieces(xs, ys, tolerant, spend);
+  return pieces === null || pieces.length * 3 > xs.length ? null : piecesToPoints(xs, ys, pieces);
+}
+const MAX_STYLE_RULES = 16;
+const MAX_FEATURES = 64;
+const LENGTHS = /* @__PURE__ */ new Set(["width", "height", "borderWidth", "labelSize"]);
+function planStyles(values, features, options = {}) {
+  const notes = options.notes ?? new StyleNotes();
+  const budget = options.budget ?? new StyleBudget();
+  const defaults = options.toolDefaults !== false && values.tool !== void 0 && values.tool !== null ? toolDefaults(values.tool) : null;
+  const units = values.units ?? "px";
+  const rules = [];
+  const columns = { node: /* @__PURE__ */ new Map(), edge: /* @__PURE__ */ new Map() };
+  const allFeatures = { node: [], edge: [] };
+  for (const target of ["node", "edge"]) {
+    const given = values[target];
+    const out = options.toolDefaults === false && given?.rules !== void 0 ? { ...given, rules: given.rules.filter((r) => r.origin !== "tool") } : given;
+    allFeatures[target] = [...features[target], ...out?.features ?? []];
+    const toolSet = defaults === null ? null : toolSetOf(defaults, target, units);
+    const plan = {
+      target,
+      n: target === "node" ? values.fingerprint.nodes : values.fingerprint.edges,
+      notes,
+      budget,
+      spend: (ops) => {
+        budget.spend(target, ops);
+      },
+      columns: columns[target],
+      ids: /* @__PURE__ */ new Set()
+    };
+    rules.push(
+      ...planTarget(
+        plan,
+        out,
+        allFeatures[target],
+        new Set(options.rawColumns?.[target] ?? []),
+        toolSet,
+        options.signal
+      )
+    );
+  }
+  const graph = graphStyles(defaults, values.graph ?? {});
+  return {
+    styles: {
+      version: 1,
+      source: {
+        format: values.format,
+        dialect: values.dialect ?? null,
+        tool: defaults === null ? null : defaults.tool
+      },
+      units: { length: units },
+      graph,
+      rules,
+      notes: notes.list()
+    },
+    columns,
+    features: allFeatures,
+    fingerprint: values.fingerprint
+  };
+}
+function toolSetOf(defaults, target, units) {
+  const toolSet = {};
+  for (const [p, d] of Object.entries(defaults[target])) {
+    const fits = d !== void 0 && isStyleValue(target, p, d.value);
+    if (fits && !(LENGTHS.has(p) && defaults.units !== units)) {
+      toolSet[p] = d.value;
+    }
+  }
+  return Object.keys(toolSet).length === 0 ? null : toolSet;
+}
+function graphStyles(defaults, given) {
+  const graph = {};
+  const own = Object.entries(defaults?.graph ?? {});
+  for (const [p, d] of own) {
+    if (d !== void 0 && isStyleValue("graph", p, d.value)) {
+      graph[p] = d.value;
+    }
+  }
+  for (const [p, v] of Object.entries(given)) {
+    if (isStyleValue("graph", p, v)) {
+      graph[p] = v;
+    }
+  }
+  return graph;
+}
+function uniqueId(plan, base) {
+  let id = base;
+  let k = 2;
+  while (plan.ids.has(id)) {
+    id = `${base}#${String(k)}`;
+    k++;
+  }
+  plan.ids.add(id);
+  return id;
+}
+function setMapping(rule, property, mapping) {
+  rule.map ??= {};
+  rule.map[property] = mapping;
+}
+function checkedTruth(plan, out) {
+  const truth = /* @__PURE__ */ new Map();
+  for (const [p, arr] of Object.entries(out?.values ?? {})) {
+    if (arr === void 0) {
+      continue;
+    }
+    if (!STYLE_PROPERTIES[plan.target].has(p) && !p.startsWith("graphty:")) {
+      plan.notes.add(STYLE_ISSUE.NOT_CARRIED, plan.target, p, { sample: p });
+      continue;
+    }
+    const vals = checkedValues(plan, p, arr);
+    plan.spend(plan.n);
+    if (vals.some((v) => v !== null)) {
+      truth.set(p, vals);
+    }
+  }
+  return truth;
+}
+function checkedValues(plan, p, arr) {
+  const vals = new Array(plan.n).fill(null);
+  for (let i = 0; i < plan.n && i < arr.length; i++) {
+    const v = arr[i] ?? null;
+    if (v !== null && isStyleValue(plan.target, p, v)) {
+      vals[i] = v;
+    } else if (v !== null) {
+      plan.notes.add(STYLE_ISSUE.BAD_VALUE, plan.target, p, { sample: v, element: i });
+    }
+  }
+  return vals;
+}
+function defined(o) {
+  if (o === void 0) {
+    return void 0;
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(o)) {
+    if (v !== void 0) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function writes(r) {
+  return [...Object.keys(r.set ?? {}), ...Object.keys(r.map ?? {})];
+}
+function prepareDeclared(plan, declared, features) {
+  const src = refSource(plan.target, plan.n, plan.columns, features);
+  const drafts = [];
+  for (const r of declared.filter((x) => x.target === plan.target)) {
+    const d = { ...r, set: defined(r.set), map: defined(r.map) };
+    if (d.set === void 0) {
+      delete d.set;
+    }
+    if (d.map === void 0) {
+      delete d.map;
+    }
+    if (!isShortPredicate(r.where)) {
+      asMembership(plan, d, r, src);
+    }
+    drafts.push(d);
+  }
+  const merged = mergedDefaults(plan.target, drafts);
+  for (const d of merged) {
+    d.id = uniqueId(plan, d.id);
+  }
+  return merged;
+}
+function asMembership(plan, d, r, src) {
+  let member = 1;
+  while (plan.columns.has(`member.${String(member)}`)) {
+    member++;
+  }
+  const key = `member.${String(member)}`;
+  const col = new Array(plan.n).fill(null);
+  let count2 = 0;
+  for (let i = 0; i < plan.n; i++) {
+    if (matches(r.where, src, i)) {
+      col[i] = true;
+      count2++;
+    }
+  }
+  plan.spend(plan.n * 8);
+  plan.columns.set(key, col);
+  d.where = { has: { style: key } };
+  d.facts = { ...r.facts, elements: count2, reason: r.facts?.reason ?? "SELECTOR" };
+  plan.notes.add(STYLE_ISSUE.SELECTOR_AS_COLUMN, plan.target, r.id, { count: count2 });
+}
+function mergedDefaults(target, drafts) {
+  const merged = [];
+  const plain = (x) => "all" in x.where && x.set !== void 0 && x.map === void 0;
+  let i = 0;
+  while (i < drafts.length) {
+    let j = i + 1;
+    while (plain(drafts[i]) && j < drafts.length && plain(drafts[j])) {
+      j++;
+    }
+    if (j - i >= 2) {
+      merged.push({
+        id: drafts[i].id,
+        target,
+        role: "defaults",
+        origin: "declared",
+        where: { all: true },
+        set: Object.assign({}, ...drafts.slice(i, j).map((x) => x.set))
+      });
+    } else {
+      merged.push(drafts[i]);
+    }
+    i = j;
+  }
+  return merged;
+}
+const ORDER = ["passdata", "discrete", "continuous", "opaque"];
+function passCandidate(plan, fam, truth, infos) {
+  const cols = /* @__PURE__ */ new Map();
+  for (const p of fam.props) {
+    const canon = canonicalFor(plan.target, p);
+    const isColor = STYLE_PROPERTIES[plan.target].get(p) === "color";
+    const t = truth.get(p) ?? [];
+    const hit = infos.find((f) => {
+      if (!("data" in f.feature.ref)) {
+        return false;
+      }
+      plan.spend(plan.n);
+      for (let i = 0; i < plan.n; i++) {
+        const raw2 = f.feature.values[i];
+        if (isColor && raw2 !== null && !(typeof raw2 === "string" && /^#[0-9a-fA-F]{6}$/.test(raw2))) {
+          return false;
+        }
+        if ((raw2 === null ? null : canon(raw2)) !== t[i]) {
+          return false;
+        }
+      }
+      return true;
+    });
+    if (hit === void 0) {
+      return null;
+    }
+    cols.set(p, hit);
+  }
+  const raw = Array.from(cols.values()).some((f) => f.raw);
+  return { type: "passdata", cols, raw, cost: raw ? 240 : 50 };
+}
+function planTarget(plan, out, features, rawNames, toolSet, signal) {
+  const { target, n } = plan;
+  for (const [k, v] of out?.columns ?? []) {
+    plan.columns.set(k, v);
+  }
+  const truth = checkedTruth(plan, out);
+  const toolRule = toolSet === null ? [] : [
+    {
+      id: uniqueId(plan, `${target}.tool`),
+      target,
+      role: "defaults",
+      origin: "tool",
+      where: { all: true },
+      set: toolSet
+    }
+  ];
+  const declared = prepareDeclared(plan, out?.rules ?? [], features);
+  const declaredProps = new Set(declared.flatMap(writes));
+  const { defaults, rest } = splitDefaults(n, truth, declaredProps);
+  plan.spend(n * truth.size);
+  const inferred = [];
+  if (Object.keys(defaults).length > 0) {
+    inferred.push({
+      id: uniqueId(plan, `${target}.defaults`),
+      target,
+      role: "defaults",
+      origin: "inferred",
+      where: { all: true },
+      set: defaults
+    });
+  }
+  const families = familiesOf(rest);
+  plan.spend(n * rest.length);
+  const infos = features.map((f) => describeFeature(f, "data" in f.ref && rawNames.has(f.ref.data))).sort((a, b) => a.distinct - b.distinct);
+  plan.spend(n * features.length);
+  const testable = infos.filter((f) => f.categorical || f.numeric).slice(0, MAX_FEATURES);
+  const groups = [];
+  const mappings = /* @__PURE__ */ new Map();
+  const passData = {
+    id: `${target}.passthrough`,
+    target,
+    role: "passthrough",
+    origin: "inferred",
+    where: { all: true },
+    map: {}
+  };
+  const passRaw = {
+    id: `${target}.passthrough.raw`,
+    target,
+    role: "passthrough",
+    origin: "inferred",
+    where: { all: true },
+    map: {},
+    facts: { reason: "NO_EXPLANATION" }
+  };
+  const copy = {
+    id: `${target}.copy`,
+    target,
+    role: "passthrough",
+    origin: "inferred",
+    where: { all: true },
+    map: {},
+    facts: { reason: "NO_EXPLANATION" }
+  };
+  const opaque = [];
+  const tolerated = /* @__PURE__ */ new Map();
+  let budgetHit = 0;
+  const st = { groups, mappings, passData, passRaw, copy, opaque, tolerated };
+  for (const fam of families) {
+    signal?.throwIfAborted();
+    if (plan.budget.exhausted(target)) {
+      budgetHit++;
+      opaque.push({ fam, raw: null });
+      continue;
+    }
+    applyChoice(plan, st, fam, chooseCandidate(plan, fam, testable, infos, truth), truth);
+  }
+  if (budgetHit > 0) {
+    plan.notes.add(STYLE_ISSUE.BUDGET, target, null, { count: budgetHit });
+  }
+  poolOpaque(plan, st, budgetHit, truth);
+  const nonEmpty = (r) => Object.keys(r.map ?? {}).length > 0;
+  const sortedMappings = Array.from(mappings.values()).sort((a, b) => compareText(a.id, b.id));
+  const drafts = [
+    ...toolRule,
+    ...declared,
+    ...inferred,
+    ...groups,
+    ...sortedMappings,
+    ...[passData, passRaw, copy].filter(nonEmpty)
+  ];
+  for (const d of drafts.slice(toolRule.length + declared.length + inferred.length)) {
+    d.id = uniqueId(plan, d.id);
+  }
+  const src = refSource(target, n, plan.columns, features);
+  enforceCap(plan, drafts, truth, src);
+  const exceptions = replay(plan, drafts, truth, toolSet, tolerated, src);
+  if (exceptions !== null) {
+    drafts.push(exceptions);
+  }
+  return drafts.map(finish);
+}
+function splitDefaults(n, truth, declaredProps) {
+  const defaults = {};
+  const rest = [];
+  for (const [p, a] of truth) {
+    const first = a[0];
+    if (declaredProps.has(p)) {
+      continue;
+    }
+    if (n > 0 && first !== null && a.every((v) => v === first)) {
+      defaults[p] = first;
+    } else {
+      rest.push([p, a]);
+    }
+  }
+  return { defaults, rest };
+}
+function chooseCandidate(plan, fam, testable, infos, truth) {
+  const { target, n } = plan;
+  const cands = [];
+  const textual = fam.props.some((p) => STYLE_PROPERTIES[target].get(p) === "text");
+  if (!textual) {
+    for (const f of testable) {
+      const d = discreteCandidate(fam, f, n, plan.spend);
+      if (d !== null) {
+        cands.push(d);
+      }
+      const c = continuousCandidate(fam, f, truth, plan.spend);
+      if (c !== null) {
+        cands.push(c);
+      }
+      if (plan.budget.exhausted(target)) {
+        break;
+      }
+    }
+  }
+  const pass = passCandidate(plan, fam, truth, infos);
+  if (pass !== null) {
+    cands.push(pass);
+  }
+  cands.push({ type: "opaque", cost: 250 });
+  cands.sort((a, b) => a.cost - b.cost || ORDER.indexOf(a.type) - ORDER.indexOf(b.type));
+  return cands[0];
+}
+function applyChoice(plan, st, fam, c, truth) {
+  if (c.type === "discrete") {
+    applyDiscrete(plan, st, fam, c, truth);
+  } else if (c.type === "continuous") {
+    applyContinuous(plan, st, fam, c, truth);
+  } else if (c.type === "passdata" && !c.raw) {
+    for (const p of fam.props) {
+      setMapping(st.passData, p, { kind: "passthrough", by: c.cols.get(p).feature.ref });
+    }
+  } else {
+    st.opaque.push({ fam, raw: c.type === "passdata" ? c.cols : null });
+  }
+}
+function mappingRule(plan, st, key, id) {
+  let r = st.mappings.get(key);
+  if (r === void 0) {
+    r = { id, target: plan.target, role: "mapping", origin: "inferred", where: { all: true }, map: {} };
+    st.mappings.set(key, r);
+  }
+  return r;
+}
+function materialize(plan, info) {
+  if ("style" in info.feature.ref) {
+    plan.columns.set(info.feature.ref.style, info.feature.values);
+  }
+}
+function applyDiscrete(plan, st, fam, c, truth) {
+  const { target } = plan;
+  materialize(plan, c.info);
+  const rule = mappingRule(plan, st, `discrete|${c.info.name}`, `${target}.by.${c.info.name}`);
+  const rep = /* @__PURE__ */ new Map();
+  for (const i of fam.styled) {
+    if (!rep.has(fam.blocks[i])) {
+      rep.set(fam.blocks[i], i);
+    }
+  }
+  for (const p of fam.props) {
+    const t = truth.get(p) ?? [];
+    const table = Array.from(c.table.values(), ({ raw, block }) => [
+      raw,
+      t[rep.get(block) ?? -1]
+    ]);
+    setMapping(rule, p, { kind: "discrete", by: c.info.feature.ref, table });
+  }
+  if (c.bucket === null) {
+    return;
+  }
+  const set = {};
+  for (const p of fam.props) {
+    set[p] = (truth.get(p) ?? [])[rep.get(c.bucket) ?? -1];
+  }
+  st.groups.push({
+    id: `${target}.missing.${c.info.name}`,
+    target,
+    role: "group",
+    origin: "inferred",
+    where: { not: { has: c.info.feature.ref } },
+    set
+  });
+}
+function applyContinuous(plan, st, fam, c, truth) {
+  const { target } = plan;
+  materialize(plan, c.info);
+  const rule = mappingRule(plan, st, `continuous|${c.info.name}`, `${target}.ramp.${c.info.name}`);
+  for (const p of fam.props) {
+    const points = c.points.get(p) ?? [];
+    setMapping(rule, p, { kind: "continuous", by: c.info.feature.ref, points });
+    if (!c.tolerant) {
+      continue;
+    }
+    const t = truth.get(p) ?? [];
+    const set = /* @__PURE__ */ new Set();
+    for (const i of fam.styled) {
+      if (evalContinuous(points, numberOf(c.info.feature.values[i])) !== t[i]) {
+        set.add(i);
+        plan.notes.add(STYLE_ISSUE.RAMP_ROUNDED, target, p, { element: i, sample: t[i] });
+      }
+    }
+    st.tolerated.set(p, set);
+  }
+}
+function poolOpaque(plan, st, budgetHit, truth) {
+  const { target, n } = plan;
+  if (st.opaque.length === 0) {
+    return;
+  }
+  const props = st.opaque.flatMap((o) => o.fam.props);
+  const classes = budgetHit > 0 ? null : styleClasses(target, props, truth, n, plan.spend);
+  const classed = new Set(classes?.classed ?? []);
+  if (classes !== null) {
+    addClassRules(plan, st, classes);
+  }
+  let distinct = 0;
+  for (const { fam, raw } of st.opaque) {
+    for (const p of fam.props.filter((x) => !classed.has(x))) {
+      const viaRaw = raw?.get(p);
+      if (viaRaw === void 0) {
+        distinct = Math.max(distinct, copyProperty(plan, st.copy, p, truth.get(p) ?? []));
+      } else {
+        setMapping(st.passRaw, p, { kind: "passthrough", by: viaRaw.feature.ref });
+      }
+    }
+  }
+  st.copy.facts = { reason: budgetHit > 0 ? "BUDGET" : "NO_EXPLANATION", distinctValues: distinct };
+}
+function addClassRules(plan, st, classes) {
+  plan.columns.set(CLASS_COLUMN, classes.column);
+  for (const r of classes.rules) {
+    if (r.role === "group") {
+      st.groups.push({ ...r, id: r.id, set: { ...r.set } });
+    } else {
+      st.mappings.set(r.id, { ...r, map: { ...r.map } });
+    }
+  }
+}
+function copyProperty(plan, copy, p, t) {
+  plan.columns.set(`copy.${p}`, t.slice());
+  setMapping(copy, p, { kind: "passthrough", by: { style: `copy.${p}` } });
+  plan.spend(plan.n);
+  return new Set(t.filter((v) => v !== null)).size;
+}
+function finish(d) {
+  const r = { id: d.id, target: d.target, role: d.role, origin: d.origin, where: d.where };
+  if (d.set !== void 0 && Object.keys(d.set).length > 0) {
+    r.set = d.set;
+  }
+  if (d.map !== void 0 && Object.keys(d.map).length > 0) {
+    r.map = d.map;
+  }
+  if (d.facts !== void 0) {
+    r.facts = Object.fromEntries(Object.entries(d.facts).filter(([, v]) => v !== void 0));
+  }
+  if (d.ext !== void 0) {
+    r.ext = d.ext;
+  }
+  return r;
+}
+function compareText(a, b) {
+  if (a === b) {
+    return 0;
+  }
+  return a < b ? -1 : 1;
+}
+function ruleSize(r) {
+  let size = Object.keys(r.set ?? {}).length;
+  for (const m of Object.values(r.map ?? {})) {
+    if (m.kind === "discrete") {
+      size += m.table.length;
+    } else if (m.kind === "continuous") {
+      size += m.points.length;
+    } else {
+      size += 1;
+    }
+  }
+  return size;
+}
+const FOLD_ORDER = { inferred: 0, declared: 1, tool: 2 };
+function enforceCap(plan, drafts, truth, src) {
+  const cap = MAX_STYLE_RULES - 1;
+  const copyId = `${plan.target}.copy`;
+  let folded = 0;
+  while (drafts.length > cap) {
+    const cands = drafts.filter((r) => r.id !== copyId);
+    if (cands.length === 0) {
+      break;
+    }
+    cands.sort((a, b) => {
+      const pa = a.role === "passthrough" ? 1 : 0;
+      const pb = b.role === "passthrough" ? 1 : 0;
+      return pa - pb || (FOLD_ORDER[a.origin] ?? 1) - (FOLD_ORDER[b.origin] ?? 1) || ruleSize(b) - ruleSize(a) || drafts.indexOf(b) - drafts.indexOf(a);
+    });
+    const victim = cands[0];
+    const before = drafts.map(finish);
+    drafts.splice(drafts.indexOf(victim), 1);
+    let copy = drafts.find((r) => r.id === copyId);
+    if (copy === void 0) {
+      copy = {
+        id: copyId,
+        target: plan.target,
+        role: "passthrough",
+        origin: "inferred",
+        where: { all: true },
+        map: {}
+      };
+      plan.ids.add(copyId);
+    } else {
+      drafts.splice(drafts.indexOf(copy), 1);
+    }
+    for (const p of new Set(writes(victim))) {
+      const t = truth.get(p);
+      const vals = t === void 0 ? resolveRules(before, plan.target, p, src, plan.budget) : t.slice();
+      plan.columns.set(`copy.${p}`, vals);
+      setMapping(copy, p, { kind: "passthrough", by: { style: `copy.${p}` } });
+    }
+    copy.facts = { ...copy.facts, reason: "LAYER_CAP" };
+    drafts.push(copy);
+    folded++;
+  }
+  if (folded > 0) {
+    plan.notes.add(STYLE_ISSUE.LAYER_CAP, plan.target, null, { count: folded });
+  }
+}
+function differences(n, got, want, tolerated) {
+  let col = null;
+  for (let i = 0; i < n; i++) {
+    const w = want(i);
+    const differs = w !== null && got[i] !== w && !(tolerated?.has(i) === true && within(got[i], w));
+    if (differs) {
+      col ??= new Array(n).fill(null);
+      col[i] = w;
+    }
+  }
+  return col;
+}
+function replay(plan, drafts, truth, toolSet, tolerated, src) {
+  const rules = drafts.map(finish);
+  const toolRules = rules.filter((r) => r.origin === "tool");
+  const ownToolRules = toolRules.length > (toolSet === null ? 0 : 1);
+  const map = {};
+  for (const [p, t] of truth) {
+    const got = resolveRules(rules, plan.target, p, src, plan.budget);
+    const perElement = ownToolRules ? resolveRules(toolRules, plan.target, p, src, plan.budget) : null;
+    const constant = toolSet?.[p] ?? null;
+    const want = (i) => t[i] ?? (perElement === null ? constant : perElement[i]);
+    const col = differences(plan.n, got, want, tolerated.get(p));
+    if (col !== null) {
+      plan.columns.set(`exceptions.${p}`, col);
+      map[p] = { kind: "passthrough", by: { style: `exceptions.${p}` } };
+    }
+  }
+  if (Object.keys(map).length === 0) {
+    return null;
+  }
+  return {
+    id: uniqueId(plan, `${plan.target}.exceptions`),
+    target: plan.target,
+    role: "exceptions",
+    origin: "inferred",
+    where: { all: true },
+    map
+  };
+}
+const TARGETS = ["node", "edge"];
+const ENUM_KINDS = /* @__PURE__ */ new Set(["shape", "borderStyle", "lineStyle", "arrow", "weight", "position"]);
+function extractStyles(importer, snapshot, report, options = {}) {
+  const signal = options.signal ?? void 0;
+  const notes = new StyleNotes();
+  const budget = options.budget ?? new StyleBudget();
+  const canonical = readStyleValues(importer, snapshot, report, { notes, budget, signal });
+  const fingerprint = styleFingerprint(snapshot);
+  const blockText = canonical?.block ?? graphValue(snapshot, STYLE_BLOCK_NAME);
+  if (blockText !== void 0) {
+    const parsed = parseStyleBlock(blockText, fingerprint);
+    if (parsed.ok) {
+      const truth = canonical === null ? {} : { node: canonical.node.values, edge: canonical.edge.values };
+      const fromBlock = blockStyles(
+        parsed.block,
+        snapshot,
+        importer.format,
+        truth,
+        canonical?.notes ?? [],
+        canonical?.tool ?? null,
+        canonical?.opacityInColor === true
+      );
+      if (fromBlock !== null) {
+        return fromBlock;
+      }
+      notes.add(STYLE_ISSUE.BLOCK_IGNORED, null, null, { sample: "INVALID" });
+    } else {
+      notes.add(STYLE_ISSUE.BLOCK_IGNORED, null, null, { sample: parsed.reason });
+    }
+  }
+  if (canonical === null) {
+    const list = notes.list();
+    return list.length === 0 ? null : emptyStyles(importer.format, list, snapshot, fingerprint);
+  }
+  const raw = { node: new Set(canonical.raw.node), edge: new Set(canonical.raw.edge) };
+  const features = {
+    node: featuresOf(snapshot, "node").filter((f) => !("data" in f.ref && raw.node.has(f.ref.data))),
+    edge: featuresOf(snapshot, "edge").filter((f) => !("data" in f.ref && raw.edge.has(f.ref.data)))
+  };
+  const planned = planStyles(
+    {
+      format: importer.format,
+      dialect: canonical.dialect,
+      tool: canonical.tool,
+      units: canonical.units,
+      graph: canonical.graph,
+      node: canonical.node,
+      edge: canonical.edge,
+      fingerprint
+    },
+    features,
+    {
+      toolDefaults: options.toolDefaults,
+      budget,
+      notes,
+      rawColumns: { node: canonical.raw.node, edge: canonical.raw.edge },
+      signal
+    }
+  );
+  if (canonical.notes.length === 0) {
+    return planned;
+  }
+  return { ...planned, styles: { ...planned.styles, notes: [...canonical.notes, ...planned.styles.notes] } };
+}
+function readStyleValues(importer, snapshot, report, context) {
+  const { notes, budget, signal } = context;
+  signal?.throwIfAborted();
+  let canonical;
+  if (importer.styles === void 0) {
+    canonical = roleStyles(snapshot, importer.format, notes, budget);
+  } else {
+    const got = importer.styles(snapshot, { signal, budget, kept: keptForStyles(report) });
+    canonical = got === null ? null : canonicalOf(got, snapshot, notes, budget, signal);
+  }
+  signal?.throwIfAborted();
+  return canonical === null ? null : withPairedHalves(canonical, snapshot);
+}
+function withPairedHalves(truth, snapshot) {
+  const pair = snapshot.edges.byRole("pair");
+  if (pair === null) {
+    return truth;
+  }
+  const values = {};
+  for (const [property, col] of Object.entries(truth.edge.values)) {
+    if (col === void 0) {
+      continue;
+    }
+    const out = [...col];
+    for (let e = 0; e < out.length; e++) {
+      const first = pair.isSet(e) ? pair.value(e) : e;
+      if (first < e) {
+        out[e] = col[first] ?? null;
+      }
+    }
+    values[property] = out;
+  }
+  return { ...truth, edge: { ...truth.edge, values } };
+}
+function graphValue(snapshot, name) {
+  return snapshot.graph.has(name) ? plainCell(snapshot.graph.value(name, 0)) : void 0;
+}
+function emptyStyles(format, notes, snapshot, fingerprint) {
+  return {
+    styles: {
+      version: 1,
+      source: { format, dialect: null, tool: null },
+      units: { length: "px" },
+      graph: {},
+      rules: [],
+      notes
+    },
+    columns: { node: /* @__PURE__ */ new Map(), edge: /* @__PURE__ */ new Map() },
+    features: { node: featuresOf(snapshot, "node"), edge: featuresOf(snapshot, "edge") },
+    fingerprint
+  };
+}
+function canonicalOf(got, snapshot, notes, budget, signal) {
+  if ("canonical" in got) {
+    return {
+      dialect: got.dialect ?? null,
+      tool: got.tool ?? null,
+      units: got.units ?? "px",
+      graph: got.graph ?? {},
+      node: got.node ?? { values: {} },
+      edge: got.edge ?? { values: {} },
+      raw: { node: got.readFrom?.node ?? [], edge: got.readFrom?.edge ?? [] },
+      notes: got.notes ?? [],
+      block: got.block ?? null,
+      opacityInColor: got.opacityInColor === true
+    };
+  }
+  const { dialect } = got;
+  const raw = { node: [], edge: [] };
+  const out = { node: { values: {} }, edge: { values: {} } };
+  for (const target of TARGETS) {
+    const given = got[target];
+    if (given === void 0) {
+      continue;
+    }
+    const columns = /* @__PURE__ */ new Map();
+    for (const [property, source] of Object.entries(given)) {
+      signal?.throwIfAborted();
+      const values = rawValues(snapshot, target, property, source, notes, raw[target]);
+      if (values !== null) {
+        columns.set(property, values);
+      }
+    }
+    out[target] = { values: canonicalize(target, columns, dialect, count(snapshot, target), notes, budget) };
+  }
+  return {
+    dialect,
+    tool: null,
+    units: styleLengthUnit(dialect),
+    graph: {},
+    node: out.node,
+    edge: out.edge,
+    raw,
+    notes: []
+  };
+}
+function count(snapshot, target) {
+  return target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+}
+function rawValues(snapshot, target, property, source, notes, raw) {
+  if (Array.isArray(source)) {
+    return source;
+  }
+  if (source === null || typeof source !== "object" || typeof source.data !== "string") {
+    notes.add(STYLE_ISSUE.BAD_MAPPING, target, property, { sample: source });
+    return null;
+  }
+  const name = source.data;
+  const table = target === "node" ? snapshot.nodes : snapshot.edges;
+  if (!table.has(name)) {
+    notes.add(STYLE_ISSUE.MAPPING_COLUMN_MISSING, target, property, { sample: name });
+    return null;
+  }
+  raw.push(name);
+  const n = count(snapshot, target);
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) {
+    out[i] = plainCell(table.value(name, i));
+  }
+  return out;
+}
+function canonicalize(target, columns, dialect, n, notes, budget) {
+  const cx = { target, dialect, n, notes, budget };
+  const out = /* @__PURE__ */ Object.create(null);
+  const alphas = /* @__PURE__ */ new Map();
+  for (const [property, raws] of columns) {
+    const { col, alpha } = canonicalColumn(cx, property, raws);
+    out[property] = col;
+    if (alpha !== null) {
+      alphas.set(property, alpha);
+    }
+  }
+  for (const [property, alpha] of alphas) {
+    moveAlpha(cx, out, property, alpha);
+  }
+  return out;
+}
+function canonicalColumn(cx, property, raws) {
+  const { target, dialect, n, notes, budget } = cx;
+  const kind = STYLE_PROPERTIES[target].get(property);
+  const col = new Array(n).fill(null);
+  let alpha = null;
+  for (let i = 0; i < n && i < raws.length; i++) {
+    const site = { notes, target, property, element: i, budget };
+    const v = firstItem(raws[i], site);
+    if (v === null || v === void 0) {
+      continue;
+    }
+    if (kind !== "color") {
+      col[i] = canonValue(kind, property, v, dialect, site);
+      continue;
+    }
+    const c = canonColor(v, dialect, site, { use: colorUse(target, property) });
+    col[i] = c?.color ?? null;
+    if (c !== null && c.alpha < 1) {
+      alpha ??= new Array(n).fill(null);
+      alpha[i] = c.alpha;
+    }
+  }
+  return { col, alpha };
+}
+function firstItem(v, site) {
+  if (!Array.isArray(v)) {
+    return v;
+  }
+  if (v.length > 1) {
+    site.notes.add(STYLE_ISSUE.BAD_VALUE, site.target, site.property, { sample: v, element: site.element });
+  }
+  return v.length === 0 ? null : v[0];
+}
+function moveAlpha(cx, out, property, alpha) {
+  const { target, n, notes } = cx;
+  const carrier = OPACITY_OF.get(`${target}.${property}`) ?? null;
+  let opacity = null;
+  if (carrier !== null) {
+    out[carrier] ??= new Array(n).fill(null);
+    opacity = out[carrier];
+  }
+  for (let i = 0; i < n; i++) {
+    const a = alpha[i];
+    if (a === null) {
+      continue;
+    }
+    const site = { notes, target, property, element: i };
+    const stated = opacity === null ? null : opacity[i];
+    const merged = colorOpacity(
+      { color: out[property][i], alpha: a },
+      stated,
+      site,
+      opacity !== null
+    );
+    if (opacity !== null) {
+      opacity[i] = merged;
+    }
+  }
+}
+const OPACITY_OF = /* @__PURE__ */ new Map([
+  ["node.fill", "fillOpacity"],
+  ["edge.color", "opacity"]
+]);
+function colorUse(target, property) {
+  if (property === "fill") {
+    return "fill";
+  }
+  return target === "edge" && property === "color" ? "edge" : "line";
+}
+function canonValue(kind, property, raw, dialect, site) {
+  switch (kind) {
+    case "number":
+      return canonNumber(
+        raw,
+        site,
+        dialect === "graphviz" && (property === "width" || property === "height") ? DOT_POINTS_PER_INCH : 1
+      );
+    case "opacity":
+      return canonOpacity(raw, dialect, site);
+    case "boolean":
+      return canonBoolean(raw, site);
+    case "text":
+      return canonText(raw, site);
+    case void 0:
+      return typeof raw === "string" || typeof raw === "boolean" || typeof raw === "number" && Number.isFinite(raw) ? raw : null;
+    default:
+      return ENUM_KINDS.has(kind) ? canonEnum(kind, raw, dialect, site) : null;
+  }
+}
+const ROLE_PROPERTIES = {
+  node: [
+    ["color", ["fill"]],
+    ["size", ["width", "height"]],
+    ["shape", ["shape"]],
+    ["hidden", ["visible"]]
+  ],
+  edge: [
+    ["color", ["color"]],
+    ["thickness", ["width"]],
+    ["shape", ["lineStyle"]],
+    ["hidden", ["visible"]]
+  ]
+};
+function roleStyles(snapshot, dialect, notes, budget) {
+  const raw = { node: [], edge: [] };
+  const out = { node: { values: {} }, edge: { values: {} } };
+  for (const target of TARGETS) {
+    const table = target === "node" ? snapshot.nodes : snapshot.edges;
+    const n = count(snapshot, target);
+    const columns = /* @__PURE__ */ new Map();
+    for (const [role, properties] of ROLE_PROPERTIES[target]) {
+      const col = table.byRole(role);
+      if (col === null) {
+        continue;
+      }
+      raw[target].push(col.meta.name);
+      const vals = roleValues(table, col.meta, role, n);
+      for (const p of properties) {
+        columns.set(p, vals);
+      }
+    }
+    out[target] = { values: canonicalize(target, columns, dialect, n, notes, budget) };
+  }
+  if (raw.node.length === 0 && raw.edge.length === 0) {
+    return null;
+  }
+  return {
+    dialect,
+    tool: null,
+    units: styleLengthUnit(dialect),
+    graph: {},
+    node: out.node,
+    edge: out.edge,
+    raw,
+    notes: []
+  };
+}
+function roleValues(table, meta, role, n) {
+  return Array.from({ length: n }, (_, i) => {
+    const v = plainCell(table.value(meta.name, i));
+    if (role === "color") {
+      return channelsColor(v, meta.dtype);
+    }
+    if (role === "hidden") {
+      return typeof v === "boolean" ? !v : null;
+    }
+    return v;
+  });
+}
+function channelsColor(v, dtype) {
+  if (!Array.isArray(v) || v.length !== 3 && v.length !== 4 || !v.every((x) => typeof x === "number" && Number.isFinite(x))) {
+    return v;
+  }
+  const scale = dtype === "f32" || dtype === "f64" ? 255 : 1;
+  const [r, g, b] = v.map((x) => Math.round(x * scale));
+  const alphaScale = scale === 255 ? 1 : 255;
+  const a = v.length === 4 ? v[3] / alphaScale : 1;
+  return `rgba(${String(r)}, ${String(g)}, ${String(b)}, ${String(a)})`;
+}
+export {
+  MAX_STYLE_RULES as M,
+  extractStyles as e,
+  planStyles as p
+};
+//# sourceMappingURL=generic-BGO71QBv.js.map