@data-profile/fingerprint 0.0.0-stage → 0.2.0

package/dist/chunk-eygy4k4w.js

@@ -0,0 +1,669 @@
+// temp/src/palette.ts
+var DEFAULT_PALETTE = [
+  "#2f6fde",
+  "#2bb3e6",
+  "#f26b3a",
+  "#f5b82e",
+  "#14a39a",
+  "#7a5af5",
+  "#3fae6b",
+  "#d9488f",
+  "#8c6d46",
+  "#5e8c99"
+];
+var UNKNOWN_COLOR = "#b8bcc4";
+
+// temp/src/hash.ts
+function stableHash(value) {
+  let hash = 2166136261;
+  for (let i = 0;i < value.length; i++)
+    hash = Math.imul(hash ^ value.charCodeAt(i), 16777619);
+  return hash >>> 0;
+}
+var unitHash = (key) => stableHash(key) / 2 ** 32;
+var compareIds = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+
+// temp/src/form.ts
+var clamp = (value, low, high) => Math.min(high, Math.max(low, value));
+var quantise = (value, step = 0.2) => Math.round(value / step) * step;
+function formFromSeed(seed) {
+  const h = (key) => unitHash(`${seed}:${key}`);
+  return {
+    pattern: "loop",
+    hand: h("hand") < 0.5 ? -1 : 1,
+    coreX: quantise(h("x") * 2 - 1) * 0.5,
+    coreY: quantise(h("y") * 2 - 1) * 0.5,
+    spread: quantise(h("spread")),
+    tilt: Math.round((h("tilt") - 0.5) * 12)
+  };
+}
+function resolveForm(seed, shape = {}) {
+  const resolved = { ...formFromSeed(seed), ...shape };
+  return {
+    ...resolved,
+    coreX: clamp(resolved.coreX, -1, 1),
+    coreY: clamp(resolved.coreY, -1, 1),
+    spread: clamp(resolved.spread, 0, 1),
+    tilt: clamp(resolved.tilt, -10, 10)
+  };
+}
+function lean(items, dimension) {
+  if (!dimension || dimension.categories.length < 2)
+    return 0.5;
+  const index = new Map(dimension.categories.map((c, i) => [c.id, i / (dimension.categories.length - 1)]));
+  let sum = 0;
+  let n = 0;
+  for (const item of items) {
+    const at = index.get(item.values[dimension.id] ?? "");
+    if (at !== undefined) {
+      sum += at;
+      n += 1;
+    }
+  }
+  return n ? sum / n : 0.5;
+}
+function formFromItems(items, dimensions, seed = "fingerprint") {
+  const [first, second, third] = dimensions;
+  let top = 0;
+  if (first) {
+    const counts = new Map;
+    for (const item of items) {
+      const value = item.values[first.id];
+      if (value != null)
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    }
+    top = items.length ? Math.max(0, ...counts.values()) / items.length : 0;
+  }
+  const total = dimensions.reduce((sum, d) => sum + d.categories.length, 0);
+  const used = dimensions.reduce((sum, d) => sum + d.categories.filter((c) => items.some((item) => item.values[d.id] === c.id)).length, 0);
+  const across = lean(items, second);
+  return resolveForm(seed, {
+    pattern: items.length < 12 ? "arch" : top >= 0.4 ? "loop" : "whorl",
+    hand: across < 0.5 ? -1 : 1,
+    coreX: quantise((across - 0.5) * 2),
+    coreY: quantise((lean(items, third) - 0.5) * 2),
+    spread: total ? quantise(used / total) : 0.5
+  });
+}
+
+// temp/src/ridges.ts
+var FRAME = { width: 400, height: 520, cx: 200, cy: 260, rx: 180, ry: 240 };
+var DEG = Math.PI / 180;
+var outlineRadius = (x, y) => Math.hypot((x - FRAME.cx) / FRAME.rx, (y - FRAME.cy) / FRAME.ry);
+var smoothstep = (a, b, x) => {
+  const t = Math.min(1, Math.max(0, (x - a) / (b - a)));
+  return t * t * (3 - 2 * t);
+};
+function singularities(shape) {
+  const { rx, ry, cx, cy } = FRAME;
+  const centre = [cx + shape.coreX * 0.12 * rx, cy - 0.1 * ry + shape.coreY * 0.1 * ry];
+  const [x, y] = centre;
+  if (shape.pattern === "arch")
+    return { centre, cores: [], deltas: [] };
+  if (shape.pattern === "loop")
+    return {
+      centre,
+      cores: [centre],
+      deltas: [
+        [x + shape.hand * (0.4 + 0.25 * shape.spread) * rx, y + (0.38 + 0.12 * shape.spread) * ry]
+      ]
+    };
+  const twist = 0.06 * rx;
+  return {
+    centre,
+    cores: [
+      [x - twist, y - shape.hand * 0.025 * ry],
+      [x + twist, y + shape.hand * 0.025 * ry]
+    ],
+    deltas: [
+      [x - (0.5 + 0.2 * shape.spread) * rx, y + 0.42 * ry],
+      [x + (0.5 + 0.2 * shape.spread) * rx, y + 0.42 * ry]
+    ]
+  };
+}
+function orientation(x, y, shape, s) {
+  const tilt = shape.tilt * DEG;
+  let theta;
+  if (shape.pattern === "arch") {
+    const width = (0.35 + 0.25 * shape.spread) * FRAME.rx;
+    const u = (x - s.centre[0]) / width;
+    const height = 0.3 * FRAME.ry * Math.max(0, 1 - Math.abs(y - s.centre[1]) / FRAME.ry);
+    theta = tilt + Math.atan(2 * height * u / width * Math.exp(-u * u));
+  } else {
+    let sum = 0;
+    for (const [px, py] of s.cores)
+      sum += Math.atan2(y - py, x - px);
+    for (const [px, py] of s.deltas)
+      sum -= Math.atan2(y - py, x - px);
+    theta = tilt + sum / 2;
+  }
+  const r = outlineRadius(x, y);
+  const over = smoothstep(FRAME.cy + 0.25 * FRAME.ry, FRAME.cy - 0.25 * FRAME.ry, y);
+  const weight = smoothstep(0.68, 1, r) * (0.4 + 0.6 * over);
+  if (weight === 0)
+    return theta;
+  const tangent = Math.atan2((x - FRAME.cx) / FRAME.rx ** 2, -(y - FRAME.cy) / FRAME.ry ** 2);
+  const vx = (1 - weight) * Math.cos(2 * theta) + weight * Math.cos(2 * tangent);
+  const vy = (1 - weight) * Math.sin(2 * theta) + weight * Math.sin(2 * tangent);
+  return Math.atan2(vy, vx) / 2;
+}
+
+class PointGrid {
+  size;
+  cells = new Map;
+  constructor(size) {
+    this.size = size;
+  }
+  key = (gx, gy) => gx * 4096 + gy;
+  add(x, y, line, index) {
+    const k = this.key(Math.floor(x / this.size), Math.floor(y / this.size));
+    const cell = this.cells.get(k);
+    if (cell)
+      cell.push({ x, y, line, index });
+    else
+      this.cells.set(k, [{ x, y, line, index }]);
+    return k;
+  }
+  removeLine(line, keys) {
+    for (const k of new Set(keys)) {
+      const kept = (this.cells.get(k) ?? []).filter((p) => p.line !== line);
+      if (kept.length)
+        this.cells.set(k, kept);
+      else
+        this.cells.delete(k);
+    }
+  }
+  near(x, y, distance, counts) {
+    const gx = Math.floor(x / this.size);
+    const gy = Math.floor(y / this.size);
+    for (let dx = -1;dx <= 1; dx++)
+      for (let dy = -1;dy <= 1; dy++)
+        for (const p of this.cells.get(this.key(gx + dx, gy + dy)) ?? [])
+          if ((p.x - x) ** 2 + (p.y - y) ** 2 < distance ** 2 && counts(p))
+            return true;
+    return false;
+  }
+}
+var OUTLINE_LIMIT = 0.985;
+function ridges(shape, spacing) {
+  const s = singularities(shape);
+  const step = spacing * 0.3;
+  const selfGap = Math.ceil(3 * spacing / step);
+  const minLength = Math.ceil(2 * spacing / step);
+  const maxSteps = Math.ceil(4 * Math.PI * (FRAME.rx + FRAME.ry) / step);
+  const grid = new PointGrid(spacing);
+  const lines = [];
+  const singular = [...s.cores, ...s.deltas];
+  const free = (x, y, line, index) => outlineRadius(x, y) <= OUTLINE_LIMIT && singular.every(([px, py]) => Math.hypot(x - px, y - py) > spacing * 0.6) && !grid.near(x, y, spacing, (p) => p.line !== line || Math.abs(p.index - index) > selfGap);
+  const direction = (x, y, previous) => {
+    const theta = orientation(x, y, shape, s);
+    const v = [Math.cos(theta), Math.sin(theta)];
+    return v[0] * previous[0] + v[1] * previous[1] < 0 ? [-v[0], -v[1]] : v;
+  };
+  const trace = (seed) => {
+    const line = lines.length;
+    const theta = orientation(seed[0], seed[1], shape, s);
+    const keys = [grid.add(seed[0], seed[1], line, 0)];
+    const halves = [1, -1].map((sign) => {
+      const points2 = [];
+      let p = seed;
+      let previous = [sign * Math.cos(theta), sign * Math.sin(theta)];
+      for (let i = 1;i <= maxSteps; i++) {
+        const v1 = direction(p[0], p[1], previous);
+        const v2 = direction(p[0] + v1[0] * step / 2, p[1] + v1[1] * step / 2, v1);
+        if (v2[0] * previous[0] + v2[1] * previous[1] < 0.8)
+          break;
+        const q = [p[0] + v2[0] * step, p[1] + v2[1] * step];
+        if (!free(q[0], q[1], line, sign * i))
+          break;
+        keys.push(grid.add(q[0], q[1], line, sign * i));
+        points2.push(q);
+        p = q;
+        previous = v2;
+      }
+      return points2;
+    });
+    const points = [...halves[1].reverse(), seed, ...halves[0]];
+    if (points.length < minLength) {
+      grid.removeLine(line, keys);
+      return null;
+    }
+    return points;
+  };
+  const queue = [];
+  const seedFrom = (points) => {
+    const every = Math.max(1, Math.round(spacing / step / 2));
+    for (let i = 1;i < points.length - 1; i += every) {
+      const [ax, ay] = points[i - 1];
+      const [bx, by] = points[i + 1];
+      const length = Math.hypot(bx - ax, by - ay) || 1;
+      const [nx, ny] = [-(by - ay) / length, (bx - ax) / length];
+      const [x, y] = points[i];
+      queue.push([x + nx * spacing, y + ny * spacing], [x - nx * spacing, y - ny * spacing]);
+    }
+  };
+  const attempt = (seed) => {
+    if (!free(seed[0], seed[1], -1, 0))
+      return;
+    const points = trace(seed);
+    if (!points)
+      return;
+    lines.push(points);
+    seedFrom(points);
+  };
+  let next = 0;
+  const drain = () => {
+    while (next < queue.length)
+      attempt(queue[next++]);
+  };
+  queue.push([s.centre[0], s.centre[1] - spacing]);
+  drain();
+  const sweep = [];
+  for (let x = FRAME.cx - FRAME.rx;x <= FRAME.cx + FRAME.rx; x += spacing / 2)
+    for (let y = FRAME.cy - FRAME.ry;y <= FRAME.cy + FRAME.ry; y += spacing / 2)
+      if (outlineRadius(x, y) <= OUTLINE_LIMIT)
+        sweep.push([x, y]);
+  const distance = ([x, y]) => Math.hypot(x - s.centre[0], y - s.centre[1]);
+  sweep.sort((a, b) => distance(a) - distance(b) || a[0] - b[0] || a[1] - b[1]);
+  for (const seed of sweep) {
+    attempt(seed);
+    drain();
+  }
+  return orderFromCore(lines, s.centre);
+}
+function orderFromCore(lines, [cx, cy]) {
+  const reach = (line) => Math.min(...line.map(([x, y]) => Math.hypot(x - cx, y - cy)));
+  const swept = (line) => {
+    let total = 0;
+    for (let i = 1;i < line.length; i++) {
+      let d = Math.atan2(line[i][1] - cy, line[i][0] - cx) - Math.atan2(line[i - 1][1] - cy, line[i - 1][0] - cx);
+      if (d > Math.PI)
+        d -= 2 * Math.PI;
+      if (d < -Math.PI)
+        d += 2 * Math.PI;
+      total += d;
+    }
+    return total;
+  };
+  return lines.map((line) => ({ line: swept(line) < 0 ? [...line].reverse() : line, reach: reach(line) })).sort((a, b) => a.reach - b.reach || a.line[0][0] - b.line[0][0] || a.line[0][1] - b.line[0][1]).map(({ line }) => line);
+}
+
+// temp/src/slots.ts
+function polylineLength(points) {
+  let length = 0;
+  for (let i = 1;i < points.length; i++)
+    length += Math.hypot(points[i][0] - points[i - 1][0], points[i][1] - points[i - 1][1]);
+  return length;
+}
+function allocate(lengths, count) {
+  const total = lengths.reduce((sum, length) => sum + length, 0);
+  if (total === 0 || count === 0)
+    return lengths.map(() => 0);
+  const average = total / count;
+  const counts = lengths.map((length) => Math.floor(length / average));
+  for (let left = count - counts.reduce((sum, n) => sum + n, 0);left > 0; left--) {
+    let best = 0;
+    for (let i = 1;i < lengths.length; i++)
+      if (lengths[i] / (counts[i] + 1) > lengths[best] / (counts[best] + 1))
+        best = i;
+    counts[best] += 1;
+  }
+  return counts;
+}
+function pointAt(line, at) {
+  let walked = 0;
+  for (let i = 1;i < line.length; i++) {
+    const [x0, y0] = line[i - 1];
+    const [x1, y1] = line[i];
+    const segment = Math.hypot(x1 - x0, y1 - y0);
+    if (at <= walked + segment || i === line.length - 1) {
+      const f = segment === 0 ? 0 : Math.min(1, (at - walked) / segment);
+      return {
+        x: x0 + (x1 - x0) * f,
+        y: y0 + (y1 - y0) * f,
+        rotation: Math.atan2(y1 - y0, x1 - x0) * 180 / Math.PI
+      };
+    }
+    walked += segment;
+  }
+  const [x, y] = line[0];
+  return { x, y, rotation: 0 };
+}
+function slotsAlong(lines, count) {
+  const lengths = lines.map(polylineLength);
+  const counts = allocate(lengths, count);
+  const slots = [];
+  let pitch = Infinity;
+  lines.forEach((line, k) => {
+    const n = counts[k];
+    if (n === 0)
+      return;
+    const step = lengths[k] / n;
+    if (n > 1)
+      pitch = Math.min(pitch, step);
+    for (let i = 0;i < n; i++)
+      slots.push(pointAt(line, (i + 0.5) * step));
+  });
+  return { slots, pitch };
+}
+
+// temp/src/layout.ts
+var UNKNOWN_CATEGORY_ID = "~unknown";
+var DEFAULTS = { seed: "fingerprint", maxMarks: 600, minRidges: 6 };
+var MARK_FILL = 0.85;
+
+class FingerprintDataError extends Error {
+  name = "FingerprintDataError";
+}
+var positive = (value) => value !== undefined && Number.isFinite(value) && value >= 1 ? Math.floor(value) : undefined;
+var DISTINCT = { color: 10, shape: 5 };
+var prepared = new WeakMap;
+function prepare(items) {
+  const hit = prepared.get(items);
+  if (hit)
+    return hit;
+  const seen = new Set;
+  for (const item of items) {
+    if (seen.has(item.id))
+      throw new FingerprintDataError(`Duplicate item id "${item.id}"`);
+    seen.add(item.id);
+    const weight = item.weight ?? 1;
+    if (!Number.isFinite(weight) || weight <= 0)
+      throw new FingerprintDataError(`Item "${item.id}" has weight ${weight}; weights must be positive`);
+  }
+  const byId = Uint32Array.from(items.keys()).sort((a, b) => compareIds(items[a].id, items[b].id));
+  const idRank = new Uint32Array(items.length);
+  byId.forEach((index, rank) => idRank[index] = rank);
+  const result = { idRank, ranks: new WeakMap };
+  prepared.set(items, result);
+  return result;
+}
+function ranksIn(items, ready, d) {
+  const hit = ready.ranks.get(d);
+  if (hit)
+    return hit;
+  const index = new Map(d.categories.map((c, i) => [c.id, i]));
+  const unknown = d.categories.length;
+  const ranks = new Int32Array(items.length);
+  items.forEach((item, i) => {
+    const value = item.values[d.id];
+    ranks[i] = (value != null ? index.get(value) : undefined) ?? unknown;
+  });
+  ready.ranks.set(d, ranks);
+  return ranks;
+}
+function validateDimension(dimension) {
+  const categories = new Set;
+  for (const category of dimension.categories) {
+    if (category.id === UNKNOWN_CATEGORY_ID)
+      throw new FingerprintDataError(`Category id "${UNKNOWN_CATEGORY_ID}" is reserved`);
+    if (categories.has(category.id))
+      throw new FingerprintDataError(`Duplicate category id "${category.id}" in "${dimension.id}"`);
+    categories.add(category.id);
+  }
+}
+function resolveEncoding(dimensions, encoding) {
+  const arrange = encoding?.arrange ?? dimensions[0]?.id;
+  if (arrange === undefined)
+    throw new FingerprintDataError("At least one dimension is needed");
+  const resolved = {
+    arrange,
+    color: encoding?.color === undefined ? arrange : encoding.color,
+    shape: encoding?.shape === undefined ? arrange : encoding.shape,
+    lightness: encoding?.lightness ?? null
+  };
+  for (const [channel, id] of Object.entries(resolved)) {
+    if (id === null)
+      continue;
+    const dimension = dimensions.find((d) => d.id === id);
+    if (!dimension)
+      throw new FingerprintDataError(`The ${channel} encoding names "${id}", which is not a dimension`);
+    if (channel === "lightness" && !dimension.ordered)
+      throw new FingerprintDataError(`"${id}" drives lightness but is not ordered; lighter and darker would read as less and more`);
+  }
+  return resolved;
+}
+var ridgeCache = new Map;
+function cachedRidges(form, spacing) {
+  const key = `${JSON.stringify(form)}:${spacing}`;
+  const hit = ridgeCache.get(key);
+  if (hit)
+    return hit;
+  const traced = ridges(form, spacing);
+  ridgeCache.set(key, traced);
+  if (ridgeCache.size > 8)
+    ridgeCache.delete(ridgeCache.keys().next().value);
+  return traced;
+}
+function layoutFingerprint(input) {
+  const { items, dimensions, encoding } = input;
+  const seed = input.seed ?? DEFAULTS.seed;
+  const maxMarks = positive(input.maxMarks) ?? DEFAULTS.maxMarks;
+  const minRidges = positive(input.minRidges) ?? DEFAULTS.minRidges;
+  const form = resolveForm(seed, input.form);
+  const ready = prepare(items);
+  const encoded = resolveEncoding(dimensions, encoding);
+  const byId = new Map(dimensions.map((d) => [d.id, d]));
+  const used = [...new Set([encoded.color, encoded.shape, encoded.lightness, encoded.arrange])].filter((id) => id !== null).map((id) => byId.get(id));
+  used.forEach(validateDimension);
+  const priority = [...new Set([encoded.arrange, encoded.color, encoded.shape, encoded.lightness])].filter((id) => id !== null).map((id) => byId.get(id));
+  const ranks = new Map(used.map((d) => [d.id, ranksIn(items, ready, d)]));
+  const categoryAt = (d, rank) => d.categories[rank]?.id ?? UNKNOWN_CATEGORY_ID;
+  const groups = used.map((d) => {
+    const channels = ["color", "shape", "lightness", "arrange"].filter((c) => encoded[c] === d.id);
+    const drives = (c) => channels.includes(c);
+    const entry = (id, label, i, color, href) => ({
+      id,
+      label,
+      color: drives("color") ? i === null ? UNKNOWN_COLOR : color ?? DEFAULT_PALETTE[i % DEFAULT_PALETTE.length] : "currentColor",
+      shape: drives("shape") ? i : 0,
+      lightness: drives("lightness") && i !== null ? d.categories.length > 1 ? i / (d.categories.length - 1) : 1 : null,
+      href,
+      unknown: i === null,
+      count: 0,
+      weight: 0
+    });
+    return {
+      dimensionId: d.id,
+      label: d.label,
+      channels,
+      entries: [
+        ...d.categories.map((c, i) => entry(c.id, c.label, i, c.color, c.href)),
+        entry(UNKNOWN_CATEGORY_ID, d.unknownLabel ?? "Unknown", null)
+      ]
+    };
+  });
+  const groupOf = new Map(groups.map((g) => [g.dimensionId, g]));
+  const entryOf = (dimensionId, categoryId) => {
+    const d = byId.get(dimensionId);
+    const rank = d.categories.findIndex((c) => c.id === categoryId);
+    return groupOf.get(dimensionId).entries[rank === -1 ? d.categories.length : rank];
+  };
+  for (const d of used) {
+    const entries = groupOf.get(d.id).entries;
+    const r = ranks.get(d.id);
+    for (let i = 0;i < items.length; i++) {
+      const entry = entries[r[i]];
+      entry.count += 1;
+      entry.weight += items[i].weight ?? 1;
+    }
+  }
+  const n = items.length;
+  const comboKeys = new Float64Array(n);
+  const priorityRanks = priority.map((d) => ranks.get(d.id));
+  const radix = priority.map((d) => d.categories.length + 1);
+  for (let i = 0;i < n; i++) {
+    let key = 0;
+    for (let k = 0;k < priority.length; k++)
+      key = key * radix[k] + priorityRanks[k][i];
+    comboKeys[i] = key;
+  }
+  const order = Uint32Array.from(items.keys()).sort((a, b) => comboKeys[a] - comboKeys[b] || ready.idRank[a] - ready.idRank[b]);
+  const itemsPerMark = Math.max(1, Math.ceil(n / maxMarks));
+  const marksOf = [];
+  for (let k = 0;k < n; k++) {
+    const item = items[order[k]];
+    const last = marksOf.at(-1);
+    if (last && comboKeys[order[k]] === comboKeys[order[k - 1]] && last.members.length < itemsPerMark) {
+      last.members.push(item);
+      continue;
+    }
+    const categories = Object.fromEntries(used.map((d) => [d.id, categoryAt(d, ranks.get(d.id)[order[k]])]));
+    marksOf.push({ key: used.map((d) => categories[d.id]).join("|"), categories, members: [item] });
+  }
+  const marks = Math.max(1, marksOf.length);
+  const widest = FRAME.rx / minRidges;
+  let spacing = Math.min(widest, Math.sqrt(Math.PI * FRAME.rx * FRAME.ry * 0.85 / marks));
+  let lines = cachedRidges(form, spacing);
+  if (marksOf.length > 0) {
+    const traced = lines.reduce((sum, line) => sum + polylineLength(line), 0);
+    const corrected = Math.min(widest, Math.sqrt(traced * spacing / marks));
+    if (Math.abs(corrected - spacing) / spacing > 0.03) {
+      spacing = corrected;
+      lines = cachedRidges(form, spacing);
+    }
+  }
+  const { slots, pitch } = slotsAlong(lines, marksOf.length);
+  const footprint = Math.min(pitch, spacing) * MARK_FILL;
+  const weights = marksOf.map((mark) => mark.members.reduce((sum, item) => sum + (item.weight ?? 1), 0));
+  const heaviest = Math.max(0, ...weights);
+  const perKey = new Map;
+  const nodes = marksOf.map((mark, i) => {
+    const n2 = perKey.get(mark.key) ?? 0;
+    perKey.set(mark.key, n2 + 1);
+    const slot = slots[i];
+    const property = (channel) => {
+      const id = encoded[channel];
+      return id === null ? null : entryOf(id, mark.categories[id]);
+    };
+    return {
+      id: itemsPerMark === 1 ? mark.members[0].id : `${mark.key}#${n2}`,
+      itemIds: mark.members.map((item) => item.id),
+      categories: mark.categories,
+      x: slot.x,
+      y: slot.y,
+      rotation: slot.rotation,
+      size: footprint * Math.sqrt(weights[i] / heaviest),
+      weight: weights[i],
+      color: property("color")?.color ?? "currentColor",
+      shape: encoded.shape === null ? 0 : property("shape").shape,
+      lightness: property("lightness")?.lightness ?? null
+    };
+  });
+  for (const group of groups)
+    group.entries = group.entries.filter((e) => !e.unknown || e.count > 0);
+  const warnings = [];
+  for (const channel of ["color", "shape"]) {
+    const id = encoded[channel];
+    if (id === null)
+      continue;
+    const shown = groupOf.get(id).entries.filter((e) => !e.unknown && e.count > 0).length;
+    if (shown > DISTINCT[channel])
+      warnings.push(`${channel === "color" ? "Colour" : "Shape"} shows ${shown} categories of "${byId.get(id).label}"; beyond ${DISTINCT[channel]} they repeat, so only the legend tells them apart.`);
+  }
+  return {
+    width: FRAME.width,
+    height: FRAME.height,
+    encoding: encoded,
+    nodes,
+    ridges: lines,
+    form,
+    ridgeSpacing: spacing,
+    legends: groups,
+    warnings,
+    itemsPerMark,
+    itemCount: items.length
+  };
+}
+function emptyLayout() {
+  return {
+    width: FRAME.width,
+    height: FRAME.height,
+    encoding: { arrange: "", color: null, shape: null, lightness: null },
+    nodes: [],
+    ridges: [],
+    form: resolveForm(DEFAULTS.seed),
+    ridgeSpacing: FRAME.rx / DEFAULTS.minRidges,
+    legends: [],
+    warnings: [],
+    itemsPerMark: 1,
+    itemCount: 0
+  };
+}
+
+// temp/src/opacity.ts
+var markOpacity = (node) => node.lightness === null ? 1 : 0.3 + 0.7 * node.lightness;
+function ridgeOpacity(itemCount, style = {}) {
+  const { show = "auto", fadeFrom = 60, fadeTo = 160, opacity = 0.22 } = style;
+  if (show === "never")
+    return 0;
+  if (show === "always" || itemCount <= fadeFrom)
+    return opacity;
+  if (itemCount >= fadeTo)
+    return 0;
+  return opacity * (1 - (itemCount - fadeFrom) / (fadeTo - fadeFrom));
+}
+
+// temp/src/callouts.ts
+var CALLOUT_GUTTER = 190;
+var ANCHOR_CLEARANCE = 28;
+var CALLOUT_HEIGHT = 96;
+function placeCallouts(layout, annotations) {
+  const taken = [];
+  const anchored = annotations.flatMap((annotation) => {
+    const wanted = new Set(annotation.categoryIds);
+    const dimensionId = annotation.dimensionId ?? layout.encoding.arrange;
+    const marks = layout.nodes.filter((node) => wanted.has(node.categories[dimensionId] ?? ""));
+    if (marks.length === 0)
+      return [];
+    const cx = marks.reduce((sum, node) => sum + node.x, 0) / marks.length;
+    const cy = marks.reduce((sum, node) => sum + node.y, 0) / marks.length;
+    const byCloseness = [...marks].sort((a, b) => Math.hypot(a.x - cx, a.y - cy) - Math.hypot(b.x - cx, b.y - cy));
+    const clear = (node) => taken.every((t) => Math.hypot(node.x - t.x, node.y - t.y) >= ANCHOR_CLEARANCE);
+    const anchor = byCloseness.find(clear) ?? byCloseness[0];
+    taken.push(anchor);
+    const side = anchor.x < layout.width / 2 ? "left" : "right";
+    return [{ annotation, anchor: { x: anchor.x, y: anchor.y }, side }];
+  });
+  const placed = [];
+  for (const side of ["left", "right"]) {
+    const column = anchored.filter((c) => c.side === side).sort((a, b) => a.anchor.y - b.anchor.y);
+    const tops = [];
+    for (const callout of column)
+      tops.push(Math.max(callout.anchor.y - CALLOUT_HEIGHT / 3, (tops.at(-1) ?? -Infinity) + CALLOUT_HEIGHT));
+    const overflow = Math.max(0, (tops.at(-1) ?? 0) + CALLOUT_HEIGHT - layout.height);
+    column.forEach((callout, i) => placed.push({ ...callout, labelY: Math.max(0, tops[i] - overflow), number: 0 }));
+  }
+  return placed.map((callout, i) => ({ ...callout, number: i + 1 }));
+}
+
+// temp/src/describe.ts
+var PROPERTY = {
+  color: "colour",
+  shape: "shape",
+  lightness: "lightness"
+};
+function describeLayout(layout, unit = "items") {
+  if (layout.itemCount === 0)
+    return `No ${unit} yet.`;
+  const arrange = layout.legends.find((group) => group.dimensionId === layout.encoding.arrange);
+  const ranked = arrange.entries.filter((entry) => entry.count > 0).sort((a, b) => b.count - a.count);
+  const named = ranked.slice(0, 3).map((entry) => `${entry.label} ${entry.count.toLocaleString("en-GB")}`);
+  const rest = ranked.length - named.length;
+  const parts = [
+    `${layout.itemCount.toLocaleString("en-GB")} ${unit} by ${arrange.label.toLowerCase()}: ${named.join(", ")}${rest > 0 ? `, and ${rest} more ${rest === 1 ? "category" : "categories"}` : ""}.`
+  ];
+  if (layout.legends.length > 1) {
+    const shown = layout.legends.flatMap((group) => group.channels.filter((channel) => channel !== "arrange").map((channel) => channel === "lightness" ? `lightness shows ${group.label.toLowerCase()} (fainter is earlier)` : `${PROPERTY[channel]} shows ${group.label.toLowerCase()}`));
+    if (shown.length)
+      parts.push(`${shown.join(", ").replace(/^./, (c) => c.toUpperCase())}.`);
+  }
+  if (layout.itemsPerMark > 1)
+    parts.push(`Each mark stands for up to ${layout.itemsPerMark} ${unit}.`);
+  return parts.join(" ");
+}
+
+export { DEFAULT_PALETTE, UNKNOWN_COLOR, formFromItems, UNKNOWN_CATEGORY_ID, FingerprintDataError, layoutFingerprint, emptyLayout, markOpacity, ridgeOpacity, CALLOUT_GUTTER, CALLOUT_HEIGHT, placeCallouts, describeLayout };
+
+//# debugId=C8FF8090BDB0F57164756E2164756E21
+//# sourceMappingURL=chunk-eygy4k4w.js.map