@weasel-js/prefs 1.10.1 → 1.11.0

package/dist/chunk-OZFER7VN.js

@@ -0,0 +1,706 @@
+import { formatUnit, unitScale, endlessAllows } from '@weasel-js/quantity';
+import { matchQuery, isPlainObject } from '@weasel-js/registry';
+import { hexToRgba, interpolateSrgb, rgbaToHex } from '@weasel-js/paint';
+
+// src/alias.ts
+function prefAliasTarget(alias, leafAt) {
+  const passed = /* @__PURE__ */ new Set();
+  let path = alias.of;
+  for (; ; ) {
+    if (passed.has(path)) return void 0;
+    passed.add(path);
+    const leaf = leafAt(path);
+    if (leaf === void 0) return void 0;
+    if (leaf.kind !== "alias") return { path, leaf };
+    path = leaf.of;
+  }
+}
+function prefAliasName(alias, target) {
+  if (alias.name !== "") return alias.name;
+  return target === void 0 ? "Alias" : target.name;
+}
+function prefAliasedLeaf(alias, target) {
+  return {
+    ...target,
+    name: prefAliasName(alias, target),
+    description: alias.description === "" ? target.description : alias.description,
+    ...alias.access ? { access: alias.access } : {},
+    ...alias.tags ? { tags: [...target.tags ?? [], ...alias.tags] } : {}
+  };
+}
+function prefUnitAccepts(unit) {
+  return unit.suffix === void 0 ? { ...unit.accepts } : { [unit.suffix]: 1, ...unit.accepts };
+}
+function isPrefLinearUnit(unit) {
+  return typeof unit.toDisplay !== "function";
+}
+var SHOWN = "shown";
+function decimalPlaces(n) {
+  const text = String(n);
+  if (text.includes("e")) return void 0;
+  const dot = text.indexOf(".");
+  return dot === -1 ? 0 : text.length - dot - 1;
+}
+var DECIMAL_PLACES = 12;
+function storedOf(shown, scale, offset) {
+  const raw = shown * scale + offset;
+  const [a, b, c] = [decimalPlaces(shown), decimalPlaces(scale), decimalPlaces(offset)];
+  if (a === void 0 || b === void 0 || c === void 0 || !Number.isFinite(raw)) return raw;
+  const places = Math.max(a + b, c);
+  return places > DECIMAL_PLACES ? raw : Number(raw.toFixed(places));
+}
+function resolvePrefUnit(unit) {
+  if (!isPrefLinearUnit(unit)) {
+    return { ...unit, format: unit.format ?? ((stored) => `${unit.toDisplay(stored)}${unit.suffix ?? ""}`) };
+  }
+  const { scale, offset = 0, precision, suffix, accepts } = unit;
+  const round = precision === void 0 ? void 0 : 10 ** precision;
+  const system = { base: "stored", units: { [SHOWN]: { factor: scale, offset } } };
+  return {
+    toDisplay: (stored) => {
+      const shown = (stored - offset) / scale;
+      return round === void 0 ? shown : Math.round(shown * round) / round;
+    },
+    fromDisplay: (shown) => storedOf(shown, scale, offset),
+    format: (stored) => `${formatUnit(stored, SHOWN, system, { precision: precision ?? 2, suffix: false })}${suffix ?? ""}`,
+    ...suffix === void 0 ? {} : { suffix },
+    ...accepts === void 0 ? {} : { accepts }
+  };
+}
+function prefUnit(system, display, opts) {
+  let self;
+  try {
+    self = unitScale(system, display);
+  } catch (e) {
+    throw new Error(`prefUnit: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const suffix = opts?.suffix ?? display;
+  const accepts = { [suffix]: 1 };
+  for (const name of Object.keys(system.units)) {
+    const other = unitScale(system, name);
+    const factor = other.factor / self.factor;
+    const offset = (other.offset - self.offset) / self.factor;
+    accepts[name] = offset === 0 ? factor : { factor, offset };
+  }
+  return {
+    suffix,
+    scale: self.factor,
+    ...self.offset === 0 ? {} : { offset: self.offset },
+    accepts,
+    ...opts?.precision === void 0 ? {} : { precision: opts.precision }
+  };
+}
+function prefDisplayBounds(p) {
+  const ends = p.endless === void 0 ? {} : { endless: p.endless };
+  if (!p.unit) return { min: p.min, max: p.max, step: p.step ?? 1, ...ends };
+  const { toDisplay } = resolvePrefUnit(p.unit);
+  const backward = toDisplay(1) < toDisplay(0);
+  const lo = p.min === void 0 ? void 0 : toDisplay(p.min);
+  const hi = p.max === void 0 ? void 0 : toDisplay(p.max);
+  const flipped = lo !== void 0 && hi !== void 0 && lo > hi;
+  const step = p.step === void 0 ? 1 : Math.abs(toDisplay(p.step) - toDisplay(0)) || p.step;
+  const flip = { min: "max", max: "min", both: "both" };
+  const endless = backward && p.endless !== void 0 ? flip[p.endless] : p.endless;
+  return { min: flipped ? hi : lo, max: flipped ? lo : hi, step, ...endless === void 0 ? {} : { endless } };
+}
+function isPrefLeaf(node) {
+  return "kind" in node;
+}
+var VALUELESS = /* @__PURE__ */ new Set(["action", "actions", "alias", "label", "separator"]);
+function prefHoldsValue(leaf) {
+  return !VALUELESS.has(leaf.kind);
+}
+function isPrefSection(node) {
+  return !isPrefLeaf(node) && "members" in node;
+}
+function prefSectionLeaves(members) {
+  return Object.entries(members).flatMap(
+    ([key, child]) => isPrefLeaf(child) ? [[key, child]] : prefSectionLeaves(child.members)
+  );
+}
+function prefLeafAt(schema, path) {
+  if (isPrefSection(schema)) return prefSectionLeaves(schema.members).find(([key]) => key === path)?.[1];
+  let node = schema;
+  for (const seg of path.split(".")) {
+    if (isPrefLeaf(node) || !Object.hasOwn(node.children, seg)) return void 0;
+    node = node.children[seg];
+  }
+  return isPrefLeaf(node) ? node : void 0;
+}
+function prefValueAtPath(values, path) {
+  let cur = values;
+  for (const seg of path.split(".")) {
+    if (cur == null || typeof cur !== "object" || !Object.hasOwn(cur, seg)) return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+function visibleFields(fields, keepEmpty) {
+  const out = {};
+  for (const [key, child] of Object.entries(fields)) {
+    if (isPrefLeaf(child)) {
+      const kept = visiblePrefSubtree(child, false, keepEmpty);
+      if (kept) out[key] = kept;
+      continue;
+    }
+    const members = visibleFields(child.members, keepEmpty);
+    if (Object.keys(members).length > 0 || keepEmpty) out[key] = { ...child, members };
+  }
+  return out;
+}
+function visiblePrefSubtree(node, showHidden, keepEmpty = false) {
+  if (isPrefLeaf(node)) {
+    if (node.hidden && !showHidden) return null;
+    if (showHidden || node.kind !== "object") return node;
+    return { ...node, children: visibleFields(node.children, keepEmpty) };
+  }
+  const group = node;
+  const children = {};
+  for (const [key, child] of Object.entries(group.children)) {
+    const kept = visiblePrefSubtree(child, showHidden, keepEmpty);
+    if (kept) children[key] = kept;
+  }
+  if (Object.keys(children).length === 0 && !keepEmpty) return null;
+  return { ...node, children };
+}
+var VERSION_RECORD = "$version";
+function prefLeaves(schema) {
+  const out = /* @__PURE__ */ new Map();
+  const walk = (group, prefix) => {
+    for (const [key, child] of Object.entries(group.children)) {
+      if (key.includes(".")) {
+        throw new Error(`[prefs] schema key "${key}" contains "."; group keys are path segments`);
+      }
+      if (prefix === "" && key === VERSION_RECORD) {
+        throw new Error(`[prefs] schema key "${VERSION_RECORD}" is reserved`);
+      }
+      const path = prefix === "" ? key : `${prefix}.${key}`;
+      if (isPrefLeaf(child)) out.set(path, child);
+      else walk(child, path);
+    }
+  };
+  walk(schema, "");
+  return out;
+}
+function setOwnPrefValue(tree, key, value) {
+  Object.defineProperty(tree, key, { value, writable: true, enumerable: true, configurable: true });
+}
+function assignPrefValueAtPath(root, path, value) {
+  const parts = path.split(".");
+  let cursor = root;
+  for (const part of parts.slice(0, -1)) {
+    if (!Object.hasOwn(cursor, part) || cursor[part] == null) setOwnPrefValue(cursor, part, {});
+    cursor = cursor[part];
+  }
+  setOwnPrefValue(cursor, parts[parts.length - 1], value);
+}
+function flattenPrefValues(schema, tree) {
+  const out = [];
+  for (const path of prefLeaves(schema).keys()) {
+    const value = prefValueAtPath(tree, path);
+    if (value !== void 0) out.push([path, value]);
+  }
+  return out;
+}
+function prefLeafMatches(pref, path, query) {
+  return matchQuery(query, { text: [pref.name, pref.description, path], tags: pref.tags }) !== null;
+}
+function filterPrefSubtree(node, query, path = "", over) {
+  const q = query.trim().toLowerCase();
+  if (q === "") return node;
+  const within = over ?? (isPrefLeaf(node) ? void 0 : node);
+  const find = (p) => within && prefLeafAt(within, p);
+  if (isPrefLeaf(node)) {
+    const target = node.kind === "alias" ? prefAliasTarget(node, find) : void 0;
+    const drawn = target ? prefAliasedLeaf(node, target.leaf) : node;
+    return prefLeafMatches(drawn, path, q) ? node : null;
+  }
+  const group = node;
+  if (matchQuery(q, { text: [group.name], tags: group.tags }) !== null) return node;
+  const children = {};
+  for (const [key, child] of Object.entries(group.children)) {
+    const kept = filterPrefSubtree(child, q, path === "" ? key : `${path}.${key}`, within);
+    if (kept) children[key] = kept;
+  }
+  if (Object.keys(children).length === 0) return null;
+  return { ...node, children };
+}
+function prefNumberAt(leaf, read) {
+  const { minAt, maxAt, ...rest } = leaf;
+  if (minAt === void 0 && maxAt === void 0) return leaf;
+  const lo = minAt?.(read);
+  const hi = maxAt?.(read);
+  return {
+    ...rest,
+    ...lo === void 0 ? {} : { min: leaf.min === void 0 ? lo : Math.max(leaf.min, lo) },
+    ...hi === void 0 ? {} : { max: leaf.max === void 0 ? hi : Math.min(leaf.max, hi) }
+  };
+}
+function prefClampNumber(leaf, n) {
+  if (endlessAllows(leaf.endless, n)) return n;
+  let v = n;
+  if (leaf.min !== void 0 && v < leaf.min) v = leaf.min;
+  if (leaf.max !== void 0 && v > leaf.max) v = leaf.max;
+  return v;
+}
+function isPrefLocus(value) {
+  if (!isPlainObject(value)) return false;
+  const keys = Object.keys(value);
+  return keys.length === 2 && typeof value.$by === "string" && isPlainObject(value.$of);
+}
+function selectionWeights(selection) {
+  return Object.fromEntries(Object.entries(selection).map(([path, option]) => [path, { [option]: 1 }]));
+}
+var member = (locus, option, absent) => Object.hasOwn(locus.$of, option) ? locus.$of[option] : absent;
+function weighLocus(stored, weights, absent) {
+  const out = [];
+  const walk = (value, weight) => {
+    if (!isPrefLocus(value)) {
+      out.push({ value, weight });
+      return;
+    }
+    for (const [option, share] of Object.entries(weights[value.$by] ?? {})) {
+      if (share > 0) walk(member(value, option, absent), weight * share);
+    }
+  };
+  walk(stored, 1);
+  return out;
+}
+function memberAt(stored, selection, absent) {
+  let value = stored;
+  while (isPrefLocus(value)) {
+    const option = selection[value.$by];
+    if (option === void 0) return absent;
+    value = member(value, option, absent);
+  }
+  return value;
+}
+function writeMember(stored, selection, next) {
+  if (!isPrefLocus(stored)) return next;
+  const option = selection[stored.$by];
+  if (option === void 0) return stored;
+  return { $by: stored.$by, $of: { ...stored.$of, [option]: writeMember(stored.$of[option], selection, next) } };
+}
+function splitLocus(stored, by, options, order) {
+  const across = (value) => ({ $by: by, $of: Object.fromEntries(options.map((option) => [option, value])) });
+  if (!isPrefLocus(stored)) return across(stored);
+  if (stored.$by === by) return stored;
+  if (order.indexOf(stored.$by) > order.indexOf(by)) return across(stored);
+  return mapMembers(stored, (inner) => splitLocus(inner, by, options, order));
+}
+function joinLocus(stored, by, selection, absent) {
+  if (!isPrefLocus(stored)) return stored;
+  if (stored.$by !== by) return mapMembers(stored, (inner) => joinLocus(inner, by, selection, absent));
+  const option = selection[by];
+  return option === void 0 ? absent : member(stored, option, absent);
+}
+function mapMembers(locus, fn) {
+  let out;
+  for (const [option, value] of Object.entries(locus.$of)) {
+    const next = fn(value);
+    if (next !== value) (out ??= { ...locus.$of })[option] = next;
+  }
+  return out ? { $by: locus.$by, $of: out } : locus;
+}
+function mapLocusMembers(stored, fn) {
+  return isPrefLocus(stored) ? mapMembers(stored, (inner) => mapLocusMembers(inner, fn)) : fn(stored);
+}
+function locusSelectors(stored) {
+  const out = /* @__PURE__ */ new Set();
+  const walk = (value) => {
+    if (!isPrefLocus(value)) return;
+    out.add(value.$by);
+    for (const inner of Object.values(value.$of)) walk(inner);
+  };
+  walk(stored);
+  return out;
+}
+function repairLocus(stored, allowed, optionsOf, repairMember) {
+  const BAD = /* @__PURE__ */ Symbol("bad");
+  const walk = (value, met) => {
+    if (!isPrefLocus(value)) return repairMember(value);
+    const options = allowed.includes(value.$by) && !met.includes(value.$by) ? optionsOf(value.$by) : void 0;
+    if (!options) return BAD;
+    const of = {};
+    for (const option of options) {
+      if (!Object.hasOwn(value.$of, option)) continue;
+      const read2 = walk(value.$of[option], [...met, value.$by]);
+      if (read2 === BAD) return BAD;
+      of[option] = read2;
+    }
+    return { $by: value.$by, $of: of };
+  };
+  const read = walk(stored, []);
+  return read === BAD ? void 0 : read;
+}
+var heaviest = (members) => members.reduce((most, m) => m.weight > most.weight ? m : most).value;
+var blendNumber = (members, leaf) => {
+  let sum = 0;
+  let total = 0;
+  for (const { value, weight } of members) {
+    if (typeof value !== "number" || !Number.isFinite(value)) return heaviest(members);
+    sum += value * weight;
+    total += weight;
+  }
+  return sum / total;
+};
+var blendColor = (members, leaf) => {
+  let mixed;
+  let total = 0;
+  for (const { value, weight } of members) {
+    let next;
+    try {
+      next = hexToRgba(value);
+    } catch {
+      return heaviest(members);
+    }
+    total += weight;
+    if (!mixed) {
+      mixed = next;
+      continue;
+    }
+    const t = weight / total;
+    const [r, g, b] = interpolateSrgb([mixed[0], mixed[1], mixed[2]], [next[0], next[1], next[2]], t, "oklch");
+    mixed = [r, g, b, mixed[3] + (next[3] - mixed[3]) * t];
+  }
+  return rgbaToHex(mixed);
+};
+var PREF_BLENDS = { number: blendNumber, color: blendColor };
+function blendPref(leaf, members, blends) {
+  if (members.length === 0) return leaf.default;
+  if (members.length === 1) return members[0].value;
+  const blend = (blends && Object.hasOwn(blends, leaf.kind) ? blends[leaf.kind] : void 0) ?? (Object.hasOwn(PREF_BLENDS, leaf.kind) ? PREF_BLENDS[leaf.kind] : void 0) ?? heaviest;
+  return blend(members, leaf);
+}
+
+// src/splitCheck.ts
+var refusal = (leaf) => {
+  if (!leaf) return ["no-leaf", "names no leaf"];
+  if (leaf.kind !== "enum") return ["not-enum", `names a ${leaf.kind} leaf, and only an enum has options to split by`];
+  const selector = leaf;
+  if (selector.encoding) return ["encoded", "names an enum with an encoding, whose stored value is not its option"];
+  if (selector.clearable) return ["clearable", "names a clearable enum, which may hold none of its options"];
+  if (selector.splitBy?.length) return ["split", "names a leaf that may itself be split"];
+  return void 0;
+};
+function prefSelectors(leaves) {
+  const out = /* @__PURE__ */ new Map();
+  for (const leaf of leaves.values()) {
+    for (const path of leaf.splitBy ?? []) {
+      const selector = leaves.get(path);
+      if (out.has(path) || refusal(selector)) continue;
+      out.set(path, selector.options.map((option) => option.value));
+    }
+  }
+  return out;
+}
+function checkPrefSplits(schema) {
+  const leaves = prefLeaves(schema);
+  const out = [];
+  for (const [at, leaf] of leaves) {
+    for (const path of locusSelectors(leaf.defaultLocus)) {
+      if (leaf.splitBy?.includes(path)) continue;
+      out.push({ code: "default", at, path, problem: `its defaultLocus is split by "${path}", which its splitBy does not list` });
+    }
+    if (!leaf.splitBy?.length) continue;
+    if (!prefHoldsValue(leaf)) {
+      out.push({ code: "valueless", at, problem: `a ${leaf.kind} leaf holds no value to split` });
+      continue;
+    }
+    leaf.splitBy.forEach((path, i) => {
+      if (leaf.splitBy.indexOf(path) !== i) {
+        out.push({ code: "twice", at, path, problem: `"${path}" is listed twice` });
+        return;
+      }
+      const why = refusal(leaves.get(path));
+      if (why) out.push({ code: why[0], at, path, problem: `"${path}" ${why[1]}` });
+    });
+  }
+  return out;
+}
+
+// src/css.ts
+var kebab = (path) => path.replace(/\./g, "-").replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+var CSS_UNITS = {
+  px: "px",
+  "%": "%",
+  em: "em",
+  rem: "rem",
+  ch: "ch",
+  pt: "pt",
+  vw: "vw",
+  vh: "vh",
+  ms: "ms",
+  s: "s",
+  "\xB0": "deg",
+  deg: "deg",
+  rad: "rad",
+  turn: "turn"
+};
+var IDENT = /^-?[A-Za-z_][\w-]*$/;
+var quoted = (text) => `'${text.replace(/[\\']/g, "\\$&")}'`;
+function cssValue(leaf, value) {
+  switch (leaf.kind) {
+    case "number": {
+      if (typeof value !== "number" || !Number.isFinite(value)) return null;
+      const { unit } = leaf;
+      const resolved = unit ? resolvePrefUnit(unit) : void 0;
+      const shown = resolved ? resolved.toDisplay(value) : value;
+      const suffix = resolved?.suffix !== void 0 && Object.hasOwn(CSS_UNITS, resolved.suffix) ? CSS_UNITS[resolved.suffix] : "";
+      return `${Number(shown.toFixed(6))}${suffix}`;
+    }
+    case "boolean":
+      return typeof value === "boolean" ? value ? "1" : "0" : null;
+    case "color":
+      return typeof value === "string" && value !== "" ? value : null;
+    case "enum":
+      if (typeof value !== "string" || leaf.encoding) return null;
+      return IDENT.test(value) ? value : quoted(value);
+    case "string":
+      return typeof value === "string" ? quoted(value) : null;
+    default:
+      return null;
+  }
+}
+function toldApart(held, optionsOf, absent) {
+  const out = [];
+  const walk = (value, under) => {
+    if (!isPrefLocus(value)) {
+      out.push({ under, value });
+      return;
+    }
+    for (const option of optionsOf(value.$by)) {
+      walk(Object.hasOwn(value.$of, option) ? value.$of[option] : absent, [...under, [value.$by, option]]);
+    }
+  };
+  walk(held, []);
+  return out;
+}
+function prefsCss(store, options = {}) {
+  const root = options.root ?? ":root";
+  const property = options.property ?? ((path) => `--${kebab(path)}`);
+  const attribute = options.attribute ?? ((selector) => `data-${kebab(selector)}`);
+  const leaves = new Map([...prefLeaves(store.schema)].filter(([, leaf]) => prefHoldsValue(leaf)));
+  const selectors = prefSelectors(leaves);
+  const defaults = Object.fromEntries([...selectors.keys()].map((path) => [path, leaves.get(path).default]));
+  const base = store.values({ at: defaults });
+  const blocks = /* @__PURE__ */ new Map();
+  const declare = (under, path, leaf, value) => {
+    const name = property(path, leaf);
+    if (name === null) return;
+    const given = options.value?.(value, leaf, path);
+    const text = given === void 0 ? cssValue(leaf, value) : given;
+    if (text === null) return;
+    const key = under.map(([selector, option]) => `${selector}=${option}`).join("&");
+    if (!blocks.has(key)) blocks.set(key, { under, lines: [] });
+    blocks.get(key).lines.push(`  ${name}: ${text};`);
+  };
+  for (const [path, leaf] of leaves) {
+    declare([], path, leaf, prefValueAtPath(base, path));
+    const own = selectors.get(path);
+    if (own) for (const option of own) declare([[path, option]], path, leaf, option);
+    const held = store.locus(path);
+    if (!held) continue;
+    for (const { under, value } of toldApart(held, (selector) => selectors.get(selector) ?? [], leaf.default)) {
+      declare(under, path, leaf, value);
+    }
+  }
+  return [...blocks.values()].map((block, i) => ({ ...block, i })).sort((a, b) => a.under.length - b.under.length || a.i - b.i).map(({ under, lines }) => {
+    const matched = under.map(([selector, option]) => `[${attribute(selector)}=${quoted(option)}]`).join("");
+    const at = root === ":host" && matched !== "" ? `:host(${matched})` : `${root}${matched}`;
+    return `:where(${at}) {
+${lines.join("\n")}
+}`;
+  }).join("\n\n");
+}
+function prefsCssAttributes(store, options = {}) {
+  const attribute = options.attribute ?? ((selector) => `data-${kebab(selector)}`);
+  const leaves = prefLeaves(store.schema);
+  return Object.fromEntries([...prefSelectors(leaves).keys()].map((path) => [attribute(path), store.get(path)]));
+}
+
+// src/union.ts
+function prefVariantOf(leaf, value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const key = value[leaf.tag];
+  if (typeof key !== "string" || !Object.hasOwn(leaf.variants, key)) return void 0;
+  return [key, leaf.variants[key]];
+}
+function prefVariantDefault(leaf, key) {
+  const held = leaf.variants[key]?.default;
+  const fields = held !== null && typeof held === "object" ? held : {};
+  return { ...fields, [leaf.tag]: key };
+}
+function repairPrefValue(leaf, stored, validators) {
+  if (leaf.kind === "number") {
+    if (stored === "Infinity") stored = Infinity;
+    else if (stored === "-Infinity") stored = -Infinity;
+  }
+  const validate = validators?.[leaf.kind];
+  if (validate) {
+    try {
+      const out = validate(stored, leaf);
+      return out === void 0 ? leaf.default : out;
+    } catch {
+      return leaf.default;
+    }
+  }
+  switch (leaf.kind) {
+    case "number":
+      return repairNumber(leaf, stored);
+    case "boolean":
+      return leaf.encoding || typeof stored === "boolean" ? stored : leaf.default;
+    case "string":
+    case "color":
+    case "field":
+      return typeof stored === "string" ? stored : leaf.default;
+    case "enum": {
+      const e = leaf;
+      if (e.encoding) return stored;
+      return e.options.some((o) => o.value === stored) ? stored : leaf.default;
+    }
+    case "object":
+      if (isPlainObject(stored)) return repairFields(leaf, stored, validators);
+      return leaf.fromScalar ? stored : leaf.default;
+    case "map":
+      return repairMap(leaf, stored, validators);
+    case "union": {
+      const variant = prefVariantOf(leaf, stored);
+      return variant ? repairFields(variant[1], stored, validators) : leaf.default;
+    }
+    case "list":
+      return repairList(leaf, stored, validators);
+    default:
+      return stored;
+  }
+}
+function repairFields(leaf, stored, validators) {
+  let out;
+  for (const [key, field] of prefSectionLeaves(leaf.children)) {
+    if (!Object.hasOwn(stored, key) || stored[key] === void 0) continue;
+    const read = repairPrefValue(field, stored[key], validators);
+    if (read !== stored[key]) (out ??= { ...stored })[key] = read;
+  }
+  return out ?? stored;
+}
+function repairMap(leaf, stored, validators) {
+  if (!isPlainObject(stored)) return leaf.default;
+  const held = stored;
+  let out;
+  for (const [key, value] of Object.entries(held)) {
+    const read = repairPrefValue(leaf.item, value, validators);
+    if (read !== value) (out ??= { ...held })[key] = read;
+  }
+  return out ?? stored;
+}
+function repairList(leaf, stored, validators) {
+  if (!Array.isArray(stored)) return leaf.default;
+  if (leaf.minItems !== void 0 && stored.length < leaf.minItems) return leaf.default;
+  const kept = leaf.maxItems !== void 0 && stored.length > leaf.maxItems ? stored.slice(0, leaf.maxItems) : stored;
+  const read = kept.map((entry) => repairPrefValue(leaf.item, entry, validators));
+  return kept === stored && read.every((entry, i) => entry === stored[i]) ? stored : read;
+}
+function repairNumber(leaf, stored) {
+  if (typeof stored !== "number" || Number.isNaN(stored)) return leaf.default;
+  if (endlessAllows(leaf.endless, stored)) return stored;
+  const v = prefClampNumber(leaf, stored);
+  return Number.isFinite(v) ? v : leaf.default;
+}
+
+// src/stamp.ts
+var isVersion = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
+function stampRecord(value, at) {
+  return { $at: at, value };
+}
+function isStampedRecord(record) {
+  if (record === null || typeof record !== "object") return false;
+  const keys = Object.keys(record);
+  return keys.length === 2 && Object.hasOwn(record, "value") && isVersion(record.$at);
+}
+function readRecord(record, unstamped) {
+  return isStampedRecord(record) ? { at: record.$at, value: record.value, stamped: true } : { at: unstamped, value: record, stamped: false };
+}
+function recordValue(record) {
+  return isStampedRecord(record) ? record.value : record;
+}
+
+// src/snapshot.ts
+function readStored(source, leaf, stored) {
+  const repair = (value) => repairPrefValue(leaf, value, source.validators);
+  if (!leaf.splitBy?.length || !isPrefLocus(stored)) return repair(stored);
+  const read = repairLocus(stored, leaf.splitBy, (path) => source.selectors.get(path), repair);
+  return read === void 0 ? leaf.default : read;
+}
+function resolveHeld(source, leaf, held, weights) {
+  return isPrefLocus(held) ? blendPref(leaf, weighLocus(held, weights, leaf.default), source.blends) : held;
+}
+function createSnapshots(source) {
+  const { leaves, cache, selectors } = source;
+  let snapshot = null;
+  let previous = null;
+  const unsetLoci = /* @__PURE__ */ new Map();
+  const unsetHeld = (path, leaf) => {
+    if (leaf.defaultLocus === void 0) return leaf.default;
+    if (!unsetLoci.has(path)) unsetLoci.set(path, readStored(source, leaf, leaf.defaultLocus));
+    return unsetLoci.get(path);
+  };
+  const build = () => {
+    const held = /* @__PURE__ */ new Map();
+    const raw = /* @__PURE__ */ new Map();
+    const unset = /* @__PURE__ */ new Set();
+    for (const [path, leaf] of leaves) {
+      if (!cache.has(path)) {
+        held.set(path, unsetHeld(path, leaf));
+        unset.add(path);
+        continue;
+      }
+      const record = cache.get(path);
+      raw.set(path, record);
+      const same = previous?.raw.has(path) && previous.raw.get(path) === record;
+      held.set(path, same ? previous.held.get(path) : readStored(source, leaf, recordValue(record)));
+    }
+    previous = { raw, held };
+    const selection = {};
+    for (const path of selectors.keys()) selection[path] = held.get(path);
+    const weights = selectionWeights(selection);
+    const byPath = /* @__PURE__ */ new Map();
+    const splitBy = /* @__PURE__ */ new Map();
+    const loci = /* @__PURE__ */ new Map();
+    const tree = {};
+    for (const [path, leaf] of leaves) {
+      const value = held.get(path);
+      if (isPrefLocus(value)) loci.set(path, value);
+      for (const selector of locusSelectors(value)) splitBy.set(selector, [...splitBy.get(selector) ?? [], path]);
+      const read = resolveHeld(source, leaf, value, weights);
+      byPath.set(path, read);
+      assignPrefValueAtPath(tree, path, read);
+    }
+    return { byPath, held, loci, selection, splitBy, tree, unset };
+  };
+  return {
+    current: () => snapshot ??= build(),
+    peek: () => snapshot,
+    drop: () => {
+      snapshot = null;
+    }
+  };
+}
+function weightsUnder(selectors, selection, given) {
+  const out = {};
+  for (const [path, options] of selectors) {
+    const own = Object.hasOwn(given, path) ? given[path] : void 0;
+    out[path] = own ? Object.fromEntries(options.filter((option) => (own[option] ?? 0) > 0).map((option) => [option, own[option]])) : { [selection[path]]: 1 };
+  }
+  return out;
+}
+function selectionAt(selectors, selection, at) {
+  const out = { ...selection };
+  for (const [path, option] of Object.entries(at)) {
+    if (selectors.get(path)?.includes(option)) out[path] = option;
+  }
+  return out;
+}
+
+export { PREF_BLENDS, VERSION_RECORD, assignPrefValueAtPath, checkPrefSplits, createSnapshots, filterPrefSubtree, flattenPrefValues, isPrefLeaf, isPrefLinearUnit, isPrefLocus, isPrefSection, joinLocus, kebab, locusSelectors, mapLocusMembers, memberAt, prefAliasName, prefAliasTarget, prefAliasedLeaf, prefClampNumber, prefDisplayBounds, prefHoldsValue, prefLeafAt, prefLeaves, prefNumberAt, prefSectionLeaves, prefSelectors, prefUnit, prefUnitAccepts, prefValueAtPath, prefVariantDefault, prefVariantOf, prefsCss, prefsCssAttributes, readRecord, readStored, recordValue, repairLocus, repairPrefValue, resolveHeld, resolvePrefUnit, selectionAt, selectionWeights, setOwnPrefValue, splitLocus, stampRecord, visiblePrefSubtree, weightsUnder, writeMember };
+//# sourceMappingURL=chunk-OZFER7VN.js.map
+//# sourceMappingURL=chunk-OZFER7VN.js.map