@pixerate/editor 0.24.0 → 0.25.0

package/dist/chunk-4BVP64JJ.cjs

@@ -0,0 +1,1406 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/tokens/types.ts
+var TOKEN_TYPES = ["color", "number", "string", "boolean"];
+var TokenError = class extends Error {
+  
+  constructor(code, message) {
+    super(message);
+    this.name = "TokenError";
+    this.code = code;
+  }
+};
+function isTokenAlias(value) {
+  return typeof value === "object" && value !== null && typeof value.alias === "string";
+}
+var EMPTY_TOKEN_STATE = Object.freeze({ collections: Object.freeze([]), variables: Object.freeze([]) });
+
+// src/tokens/color.ts
+var HEX = /^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var RGB = /^rgba?\(([^()]*)\)$/i;
+var clamp01 = (v) => Math.min(1, Math.max(0, v));
+var byte = (v) => Math.round(clamp01(v) * 255);
+var hex2 = (n) => n.toString(16).padStart(2, "0");
+function rgbaToHex(r, g, b, a = 1) {
+  const head = `#${hex2(byte(r))}${hex2(byte(g))}${hex2(byte(b))}`;
+  const alpha = byte(a);
+  return alpha === 255 ? head : head + hex2(alpha);
+}
+function hexToRgba(hex) {
+  const normal = normalizeTokenColor(hex);
+  if (normal === null) return null;
+  const n = (i) => parseInt(normal.slice(i, i + 2), 16) / 255;
+  return { r: n(1), g: n(3), b: n(5), a: normal.length === 9 ? n(7) : 1 };
+}
+function channel(part, scale) {
+  const pct = part.endsWith("%");
+  const n = Number(pct ? part.slice(0, -1) : part);
+  if (!Number.isFinite(n)) return null;
+  return pct ? n / 100 : n / scale;
+}
+function normalizeTokenColor(input) {
+  if (typeof input === "string") {
+    const text = input.trim();
+    if (text.length > 200) return null;
+    const lower = text.toLowerCase();
+    if (lower === "transparent") return "#00000000";
+    if (lower === "black") return "#000000";
+    if (lower === "white") return "#ffffff";
+    const hex = HEX.exec(text);
+    if (hex) {
+      let digits = hex[1].toLowerCase();
+      if (digits.length <= 4) digits = [...digits].map((c) => c + c).join("");
+      if (digits.length === 8 && digits.endsWith("ff")) digits = digits.slice(0, 6);
+      return `#${digits}`;
+    }
+    const rgb = RGB.exec(text);
+    if (rgb) {
+      const [colour, alphaPart] = rgb[1].split("/");
+      const parts = colour.split(/[\s,]+/).filter(Boolean);
+      let alpha = _optionalChain([alphaPart, 'optionalAccess', _ => _.trim, 'call', _2 => _2()]);
+      if (parts.length === 4 && alpha === void 0) alpha = parts.pop();
+      if (parts.length !== 3) return null;
+      const channels = parts.map((p) => channel(p, 255));
+      const a = alpha === void 0 || alpha === "" ? 1 : channel(alpha, 1);
+      if (channels.some((c) => c === null) || a === null) return null;
+      return rgbaToHex(channels[0], channels[1], channels[2], a);
+    }
+    return null;
+  }
+  if (typeof input === "object" && input !== null) {
+    const obj = input;
+    if (Array.isArray(obj.components)) {
+      const space = obj.colorSpace;
+      if (space === void 0 || space === "srgb") {
+        const [r2, g2, b2] = obj.components;
+        const a2 = obj.alpha === void 0 ? 1 : obj.alpha;
+        if ([r2, g2, b2, a2].every((v) => typeof v === "number" && Number.isFinite(v))) {
+          return rgbaToHex(r2, g2, b2, a2);
+        }
+      }
+      if (typeof obj.hex === "string") {
+        const base = normalizeTokenColor(obj.hex);
+        if (base === null) return null;
+        const a2 = typeof obj.alpha === "number" ? obj.alpha : 1;
+        const c = hexToRgba(base);
+        return rgbaToHex(c.r, c.g, c.b, a2);
+      }
+      return null;
+    }
+    const { r, g, b } = obj;
+    const a = obj.a === void 0 ? 1 : obj.a;
+    if ([r, g, b, a].every((v) => typeof v === "number" && Number.isFinite(v))) {
+      return rgbaToHex(r, g, b, a);
+    }
+  }
+  return null;
+}
+
+// src/tokens/model.ts
+var indexes = /* @__PURE__ */ new WeakMap();
+function indexOf(state) {
+  let index = indexes.get(state);
+  if (!index) {
+    index = {
+      collections: new Map(state.collections.map((c) => [c.id, c])),
+      variables: new Map(state.variables.map((v) => [v.id, v]))
+    };
+    indexes.set(state, index);
+  }
+  return index;
+}
+function getTokenCollection(state, id) {
+  return indexOf(state).collections.get(id);
+}
+function getTokenVariable(state, id) {
+  return indexOf(state).variables.get(id);
+}
+function findTokenCollection(state, name) {
+  return state.collections.find((c) => c.name === name);
+}
+function findTokenVariable(state, name, collectionId) {
+  return state.variables.find((v) => v.name === name && (collectionId === void 0 || v.collectionId === collectionId));
+}
+function getCollectionVariables(state, collectionId) {
+  return state.variables.filter((v) => v.collectionId === collectionId);
+}
+function getDefaultMode(collection) {
+  return collection.modes[0];
+}
+function findTokenMode(collection, key) {
+  return _nullishCoalesce(collection.modes.find((m) => m.id === key), () => ( collection.modes.find((m) => m.name === key)));
+}
+function getCurrentMode(collection, modes) {
+  const chosen = _optionalChain([modes, 'optionalAccess', _3 => _3[collection.id]]);
+  return chosen !== void 0 && collection.modes.find((m) => m.id === chosen) || collection.modes[0];
+}
+function defaultTokenValue(type) {
+  switch (type) {
+    case "color":
+      return "#000000";
+    case "number":
+      return 0;
+    case "string":
+      return "";
+    case "boolean":
+      return true;
+  }
+}
+function coerceTokenLiteral(type, value) {
+  switch (type) {
+    case "color":
+      return normalizeTokenColor(value);
+    case "number": {
+      if (typeof value === "number") return Number.isFinite(value) ? value : null;
+      if (typeof value === "string" && value.trim() !== "") {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : null;
+      }
+      return null;
+    }
+    case "string":
+      return typeof value === "string" ? value : null;
+    case "boolean":
+      if (typeof value === "boolean") return value;
+      if (value === "true") return true;
+      if (value === "false") return false;
+      return null;
+  }
+}
+function literalTokenType(value) {
+  return typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string";
+}
+function formatTokenValue(state, value) {
+  if (value === void 0) return "";
+  if (isTokenAlias(value)) return `\u2192 ${_nullishCoalesce(_optionalChain([getTokenVariable, 'call', _4 => _4(state, value.alias), 'optionalAccess', _5 => _5.name]), () => ( value.alias))}`;
+  return String(value);
+}
+function label(state, id) {
+  const v = getTokenVariable(state, id);
+  return v ? `\`${v.name}\`` : `\`${id}\``;
+}
+function resolveToken(state, id, modes) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = id;
+  let type;
+  for (; ; ) {
+    if (seen.has(current)) {
+      chain.push(current);
+      return {
+        ok: false,
+        code: "cycle",
+        message: `Alias cycle: ${chain.map((c) => label(state, c)).join(" \u2192 ")}`,
+        chain
+      };
+    }
+    seen.add(current);
+    chain.push(current);
+    const variable = getTokenVariable(state, current);
+    if (!variable) {
+      return {
+        ok: false,
+        code: "missing",
+        message: chain.length === 1 ? `No variable ${label(state, current)}` : `${label(state, chain[chain.length - 2])} aliases a missing variable ${label(state, current)}`,
+        chain
+      };
+    }
+    if (type !== void 0 && variable.type !== type) {
+      return {
+        ok: false,
+        code: "type-mismatch",
+        message: `${label(state, chain[chain.length - 2])} (${type}) aliases ${label(state, current)} (${variable.type})`,
+        chain
+      };
+    }
+    type = variable.type;
+    const collection = getTokenCollection(state, variable.collectionId);
+    const mode = collection ? getCurrentMode(collection, modes) : void 0;
+    let modeId = _optionalChain([mode, 'optionalAccess', _6 => _6.id]);
+    let value = modeId !== void 0 ? variable.valuesByMode[modeId] : void 0;
+    if (value === void 0) {
+      const fallback = _optionalChain([collection, 'optionalAccess', _7 => _7.modes, 'access', _8 => _8[0], 'optionalAccess', _9 => _9.id]);
+      if (fallback !== void 0 && variable.valuesByMode[fallback] !== void 0) {
+        modeId = fallback;
+        value = variable.valuesByMode[fallback];
+      } else {
+        const first = Object.keys(variable.valuesByMode)[0];
+        if (first !== void 0) {
+          modeId = first;
+          value = variable.valuesByMode[first];
+        }
+      }
+    }
+    if (value === void 0 || modeId === void 0) {
+      return { ok: false, code: "no-value", message: `${label(state, current)} has no value`, chain };
+    }
+    if (isTokenAlias(value)) {
+      current = value.alias;
+      continue;
+    }
+    return { ok: true, value, type: variable.type, variable, modeId, chain };
+  }
+}
+function resolveTokenValue(state, id, modes) {
+  const result = resolveToken(state, id, modes);
+  return result.ok ? result.value : void 0;
+}
+function resolveTokenInMode(state, variableId, modeId) {
+  const variable = getTokenVariable(state, variableId);
+  if (!variable) return void 0;
+  return resolveTokenValue(state, variableId, { [variable.collectionId]: modeId });
+}
+function checkTokenAlias(state, variable, targetId) {
+  const target = getTokenVariable(state, targetId);
+  if (!target) return new TokenError("alias-missing", `No variable \`${targetId}\` to alias`);
+  if (target.type !== variable.type) {
+    return new TokenError("type-mismatch", `Can't alias a ${variable.type} variable to a ${target.type} one (\`${target.name}\`)`);
+  }
+  const parent = /* @__PURE__ */ new Map([[target.id, null]]);
+  const stack = [target.id];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === variable.id) {
+      const path2 = [];
+      for (let at = current; at != null; at = parent.get(at)) path2.push(at);
+      const names = [variable.id, ...path2.reverse()].map((id) => id === variable.id ? `\`${variable.name}\`` : label(state, id));
+      return new TokenError("alias-cycle", `The alias would create a cycle: ${names.join(" \u2192 ")}`);
+    }
+    const v = getTokenVariable(state, current);
+    if (!v) continue;
+    for (const value of Object.values(v.valuesByMode)) {
+      if (isTokenAlias(value) && !parent.has(value.alias)) {
+        parent.set(value.alias, current);
+        stack.push(value.alias);
+      }
+    }
+  }
+  return null;
+}
+var TOKEN_SCOPES_BY_TYPE = {
+  number: [
+    "CORNER_RADIUS",
+    "WIDTH_HEIGHT",
+    "GAP",
+    "OPACITY",
+    "STROKE_FLOAT",
+    "EFFECT_FLOAT",
+    "FONT_WEIGHT",
+    "FONT_SIZE",
+    "LINE_HEIGHT",
+    "LETTER_SPACING",
+    "PARAGRAPH_SPACING",
+    "PARAGRAPH_INDENT",
+    "TEXT_CONTENT"
+  ],
+  color: ["FRAME_FILL", "SHAPE_FILL", "TEXT_FILL", "STROKE_COLOR", "EFFECT_COLOR"],
+  string: ["TEXT_CONTENT", "FONT_FAMILY", "FONT_STYLE"],
+  boolean: []
+};
+function isTokenScopeKnown(type, scope) {
+  return scope === "ALL_SCOPES" || scope === "ALL_FILLS" && type === "color" || TOKEN_SCOPES_BY_TYPE[type].includes(scope);
+}
+function normalizeTokenScopes(type, scopes) {
+  if (scopes == null) return void 0;
+  const list = [];
+  for (const scope of scopes) {
+    if (!isTokenScopeKnown(type, scope)) throw new TokenError("unknown-scope", `Unknown ${type} scope \`${scope}\``);
+    if (!list.includes(scope)) list.push(scope);
+  }
+  const allowed = TOKEN_SCOPES_BY_TYPE[type];
+  const all = list.includes("ALL_SCOPES") || allowed.length > 0 && allowed.every((s) => list.includes(s));
+  return all ? void 0 : list;
+}
+function isTokenInScope(variable, scope) {
+  if (!variable.scopes || scope === void 0) return true;
+  return variable.scopes.some((s) => s === scope || s === "ALL_SCOPES" || s === "ALL_FILLS" && scope.endsWith("_FILL"));
+}
+var BAD_NAME_CHARS = /[{}.]/;
+function normalizeTokenName(name, what = "Variable") {
+  if (typeof name !== "string") throw new TokenError("invalid-name", `${what} name must be a string`);
+  const segments = name.split("/").map((s) => s.trim());
+  if (name.length > 500 || segments.some((s) => s === "")) {
+    throw new TokenError("invalid-name", `${what} name \`${name}\` has an empty group`);
+  }
+  for (const segment of segments) {
+    if (BAD_NAME_CHARS.test(segment) || segment.startsWith("$")) {
+      throw new TokenError("invalid-name", `${what} name \`${name}\` can't contain \`{\`, \`}\` or \`.\`, or start a group with \`$\``);
+    }
+  }
+  return segments.join("/");
+}
+function normalizeModeName(name) {
+  if (typeof name !== "string" || name.trim() === "") throw new TokenError("invalid-name", "Mode name can't be empty");
+  return name.trim().slice(0, 200);
+}
+function checkVariableName(state, collectionId, name, exceptId) {
+  for (const other of state.variables) {
+    if (other.collectionId !== collectionId || other.id === exceptId) continue;
+    if (other.name === name) throw new TokenError("duplicate-name", `A variable named \`${name}\` already exists in this collection`);
+    if (other.name.startsWith(name + "/") || name.startsWith(other.name + "/")) {
+      throw new TokenError("name-conflict", `\`${name}\` clashes with \`${other.name}\`: a name can't be both a variable and a group`);
+    }
+  }
+}
+var fallbackCounter = 0;
+var defaultTokenId = (kind) => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return `${kind}-${crypto.randomUUID()}`;
+  fallbackCounter += 1;
+  return `${kind}-${Date.now().toString(36)}-${fallbackCounter}`;
+};
+function requireCollection(state, id) {
+  const c = getTokenCollection(state, id);
+  if (!c) throw new TokenError("not-found", `No collection \`${id}\``);
+  return c;
+}
+function requireVariable(state, id) {
+  const v = getTokenVariable(state, id);
+  if (!v) throw new TokenError("not-found", `No variable \`${id}\``);
+  return v;
+}
+function requireMode(collection, key) {
+  const m = findTokenMode(collection, key);
+  if (!m) throw new TokenError("not-found", `No mode \`${key}\` in \`${collection.name}\``);
+  return m;
+}
+function replaceCollection(state, next) {
+  return { ...state, collections: state.collections.map((c) => c.id === next.id ? next : c) };
+}
+function replaceVariable(state, next) {
+  return { ...state, variables: state.variables.map((v) => v.id === next.id ? next : v) };
+}
+function createTokenCollection(state, input, createId = defaultTokenId) {
+  const name = normalizeTokenName(input.name, "Collection");
+  if (state.collections.some((c) => c.name === name)) {
+    throw new TokenError("duplicate-name", `A collection named \`${name}\` already exists`);
+  }
+  const modeNames = input.modes && input.modes.length > 0 ? input.modes.map(normalizeModeName) : ["Default"];
+  const collection = {
+    id: createId("collection"),
+    name,
+    modes: modeNames.map((n) => ({ id: createId("mode"), name: n }))
+  };
+  return { state: { ...state, collections: [...state.collections, collection] }, collection };
+}
+function renameTokenCollection(state, id, name) {
+  const collection = requireCollection(state, id);
+  const next = normalizeTokenName(name, "Collection");
+  if (state.collections.some((c) => c.id !== id && c.name === next)) {
+    throw new TokenError("duplicate-name", `A collection named \`${next}\` already exists`);
+  }
+  return replaceCollection(state, { ...collection, name: next });
+}
+function deleteTokenVariables(state, ids) {
+  const gone = /* @__PURE__ */ new Set();
+  for (const id of ids) if (getTokenVariable(state, id)) gone.add(id);
+  if (gone.size === 0) return { state, deleted: [] };
+  const variables = [];
+  for (const v of state.variables) {
+    if (gone.has(v.id)) continue;
+    let values = null;
+    for (const [modeId, value] of Object.entries(v.valuesByMode)) {
+      if (!isTokenAlias(value) || !gone.has(value.alias)) continue;
+      const target = getTokenVariable(state, value.alias);
+      const resolved = resolveTokenValue(state, target.id, { [target.collectionId]: modeId, [v.collectionId]: modeId });
+      values ??= { ...v.valuesByMode };
+      values[modeId] = _nullishCoalesce(resolved, () => ( defaultTokenValue(v.type)));
+    }
+    variables.push(values ? { ...v, valuesByMode: values } : v);
+  }
+  return { state: { ...state, variables }, deleted: [...gone] };
+}
+function deleteTokenCollection(state, id) {
+  requireCollection(state, id);
+  const result = deleteTokenVariables(
+    state,
+    state.variables.filter((v) => v.collectionId === id).map((v) => v.id)
+  );
+  return { state: { ...result.state, collections: result.state.collections.filter((c) => c.id !== id) }, deleted: result.deleted };
+}
+function addTokenMode(state, collectionId, name, options = {}, createId = defaultTokenId) {
+  const collection = requireCollection(state, collectionId);
+  const modeName = normalizeModeName(name);
+  if (collection.modes.some((m) => m.name === modeName)) {
+    throw new TokenError("duplicate-name", `\`${collection.name}\` already has a mode named \`${modeName}\``);
+  }
+  const source = options.from !== void 0 ? requireMode(collection, options.from) : collection.modes[0];
+  const mode = { id: createId("mode"), name: modeName };
+  let next = replaceCollection(state, { ...collection, modes: [...collection.modes, mode] });
+  next = {
+    ...next,
+    variables: next.variables.map((v) => {
+      if (v.collectionId !== collectionId) return v;
+      const value = _nullishCoalesce(v.valuesByMode[source.id], () => ( defaultTokenValue(v.type)));
+      return { ...v, valuesByMode: { ...v.valuesByMode, [mode.id]: value } };
+    })
+  };
+  return { state: next, mode };
+}
+function renameTokenMode(state, collectionId, modeId, name) {
+  const collection = requireCollection(state, collectionId);
+  const mode = requireMode(collection, modeId);
+  const modeName = normalizeModeName(name);
+  if (collection.modes.some((m) => m.id !== mode.id && m.name === modeName)) {
+    throw new TokenError("duplicate-name", `\`${collection.name}\` already has a mode named \`${modeName}\``);
+  }
+  return replaceCollection(state, { ...collection, modes: collection.modes.map((m) => m.id === mode.id ? { ...m, name: modeName } : m) });
+}
+function removeTokenMode(state, collectionId, modeId) {
+  const collection = requireCollection(state, collectionId);
+  const mode = requireMode(collection, modeId);
+  if (collection.modes.length < 2) throw new TokenError("last-mode", "A collection keeps at least one mode");
+  const next = replaceCollection(state, { ...collection, modes: collection.modes.filter((m) => m.id !== mode.id) });
+  return {
+    ...next,
+    variables: next.variables.map((v) => {
+      if (v.collectionId !== collectionId || !(mode.id in v.valuesByMode)) return v;
+      const values = { ...v.valuesByMode };
+      delete values[mode.id];
+      return { ...v, valuesByMode: values };
+    })
+  };
+}
+function moveTokenMode(state, collectionId, modeId, to) {
+  const collection = requireCollection(state, collectionId);
+  const mode = requireMode(collection, modeId);
+  const modes = collection.modes.filter((m) => m.id !== mode.id);
+  const at = Math.min(Math.max(Number.isFinite(to) ? Math.trunc(to) : 0, 0), modes.length);
+  modes.splice(at, 0, mode);
+  return replaceCollection(state, { ...collection, modes });
+}
+function prepareTokenValue(state, variable, value) {
+  if (isTokenAlias(value)) {
+    const error = checkTokenAlias(state, variable, value.alias);
+    if (error) throw error;
+    return { alias: value.alias };
+  }
+  const literal = coerceTokenLiteral(variable.type, value);
+  if (literal === null) {
+    throw new TokenError("invalid-value", `\`${String(value)}\` is not a ${variable.type} value for \`${variable.name}\``);
+  }
+  return literal;
+}
+function normalizeUnit(unit) {
+  if (unit === void 0 || unit === null || unit === "") return void 0;
+  if (typeof unit !== "string" || !/^[a-z%]{1,8}$/i.test(unit)) throw new TokenError("invalid-value", `Unknown unit \`${String(unit)}\``);
+  return unit.toLowerCase();
+}
+function createTokenVariable(state, input, createId = defaultTokenId) {
+  const collection = requireCollection(state, input.collectionId);
+  if (!["color", "number", "string", "boolean"].includes(input.type)) {
+    throw new TokenError("invalid-type", `Unknown variable type \`${String(input.type)}\``);
+  }
+  const name = normalizeTokenName(input.name);
+  checkVariableName(state, collection.id, name);
+  const id = createId("variable");
+  const stub = { id, type: input.type, name };
+  const base = input.value === void 0 ? defaultTokenValue(input.type) : prepareTokenValue(state, stub, input.value);
+  const valuesByMode = {};
+  for (const mode of collection.modes) valuesByMode[mode.id] = base;
+  if (input.values) {
+    for (const [key, raw] of Object.entries(input.values)) {
+      const mode = requireMode(collection, key);
+      valuesByMode[mode.id] = prepareTokenValue(state, stub, raw);
+    }
+  }
+  const variable = {
+    id,
+    name,
+    collectionId: collection.id,
+    type: input.type,
+    valuesByMode,
+    ...input.description ? { description: String(input.description) } : {},
+    ...input.scopes !== void 0 ? { scopes: normalizeTokenScopes(input.type, input.scopes) } : {}
+  };
+  if (variable.scopes === void 0) delete variable.scopes;
+  const unit = normalizeUnit(input.unit);
+  if (unit) variable.unit = unit;
+  return { state: { ...state, variables: [...state.variables, variable] }, variable };
+}
+function setTokenValue(state, variableId, value, modeId) {
+  const variable = requireVariable(state, variableId);
+  const collection = requireCollection(state, variable.collectionId);
+  const mode = modeId === void 0 ? collection.modes[0] : requireMode(collection, modeId);
+  const prepared = prepareTokenValue(state, variable, value);
+  const current = variable.valuesByMode[mode.id];
+  if (current === prepared || isTokenAlias(current) && isTokenAlias(prepared) && current.alias === prepared.alias) return state;
+  return replaceVariable(state, { ...variable, valuesByMode: { ...variable.valuesByMode, [mode.id]: prepared } });
+}
+function renameTokenVariable(state, variableId, name) {
+  const variable = requireVariable(state, variableId);
+  const next = normalizeTokenName(name);
+  if (next === variable.name) return state;
+  checkVariableName(state, variable.collectionId, next, variable.id);
+  return replaceVariable(state, { ...variable, name: next });
+}
+function updateTokenVariable(state, variableId, input) {
+  const variable = requireVariable(state, variableId);
+  const next = { ...variable };
+  if (input.description !== void 0) {
+    if (input.description) next.description = String(input.description);
+    else delete next.description;
+  }
+  if (input.scopes !== void 0) {
+    const scopes = normalizeTokenScopes(variable.type, input.scopes);
+    if (scopes) next.scopes = scopes;
+    else delete next.scopes;
+  }
+  if (input.unit !== void 0) {
+    const unit = normalizeUnit(input.unit);
+    if (unit) next.unit = unit;
+    else delete next.unit;
+  }
+  return replaceVariable(state, next);
+}
+function parseTokenState(input) {
+  const issues = [];
+  let raw = input;
+  if (typeof raw === "string") {
+    try {
+      raw = JSON.parse(raw);
+    } catch (e) {
+      return { state: { collections: [], variables: [] }, issues: [{ message: "Not JSON" }] };
+    }
+  }
+  const obj = typeof raw === "object" && raw !== null ? raw : {};
+  const collections = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const c of Array.isArray(obj.collections) ? obj.collections : []) {
+    const item = c;
+    const modes = Array.isArray(_optionalChain([item, 'optionalAccess', _10 => _10.modes])) ? item.modes.filter(
+      (m) => typeof m === "object" && m !== null && typeof m.id === "string" && typeof m.name === "string"
+    ) : [];
+    if (!item || typeof item.id !== "string" || typeof item.name !== "string" || modes.length === 0 || ids.has(item.id)) {
+      issues.push({ message: "Dropped an invalid collection" });
+      continue;
+    }
+    ids.add(item.id);
+    collections.push({ id: item.id, name: item.name, modes: modes.map((m) => ({ id: m.id, name: m.name })) });
+  }
+  const byId = new Map(collections.map((c) => [c.id, c]));
+  const variables = [];
+  const varIds = /* @__PURE__ */ new Set();
+  for (const v of Array.isArray(obj.variables) ? obj.variables : []) {
+    const item = v;
+    const collection = item && typeof item.collectionId === "string" ? byId.get(item.collectionId) : void 0;
+    if (!item || typeof item.id !== "string" || typeof item.name !== "string" || !collection || !["color", "number", "string", "boolean"].includes(item.type) || varIds.has(item.id)) {
+      issues.push({ message: "Dropped an invalid variable", variableId: typeof _optionalChain([item, 'optionalAccess', _11 => _11.id]) === "string" ? item.id : void 0 });
+      continue;
+    }
+    varIds.add(item.id);
+    const type = item.type;
+    const values = {};
+    const rawValues = typeof item.valuesByMode === "object" && item.valuesByMode !== null ? item.valuesByMode : {};
+    for (const mode of collection.modes) {
+      const value = rawValues[mode.id];
+      if (isTokenAlias(value)) values[mode.id] = { alias: value.alias };
+      else {
+        const literal = coerceTokenLiteral(type, value);
+        if (literal === null) issues.push({ message: `\`${item.name}\` had no valid value in \`${mode.name}\``, variableId: item.id });
+        values[mode.id] = _nullishCoalesce(literal, () => ( defaultTokenValue(type)));
+      }
+    }
+    const variable = { id: item.id, name: item.name, collectionId: collection.id, type, valuesByMode: values };
+    if (typeof item.description === "string" && item.description) variable.description = item.description;
+    if (Array.isArray(item.scopes)) {
+      try {
+        const scopes = normalizeTokenScopes(type, item.scopes);
+        if (scopes) variable.scopes = scopes;
+      } catch (e2) {
+        issues.push({ message: `Dropped unknown scopes of \`${item.name}\``, variableId: item.id });
+      }
+    }
+    if (typeof item.unit === "string" && /^[a-z%]{1,8}$/i.test(item.unit)) variable.unit = item.unit.toLowerCase();
+    variables.push(variable);
+  }
+  let state = { collections, variables };
+  const fixed = state.variables.map((variable) => {
+    let values = null;
+    for (const [modeId, value] of Object.entries(variable.valuesByMode)) {
+      if (!isTokenAlias(value)) continue;
+      const target = state.variables.find((t) => t.id === value.alias);
+      if (!target || target.type !== variable.type) {
+        values ??= { ...variable.valuesByMode };
+        values[modeId] = defaultTokenValue(variable.type);
+        issues.push({ message: `\`${variable.name}\` aliased a missing or mistyped variable`, variableId: variable.id });
+      }
+    }
+    return values ? { ...variable, valuesByMode: values } : variable;
+  });
+  state = { collections, variables: fixed };
+  const literalOnly = fixed.map((variable) => {
+    const values = {};
+    for (const [modeId, value] of Object.entries(variable.valuesByMode)) values[modeId] = isTokenAlias(value) ? defaultTokenValue(variable.type) : value;
+    return { ...variable, valuesByMode: values };
+  });
+  let rebuilt = { collections, variables: literalOnly };
+  for (const variable of fixed) {
+    for (const [modeId, value] of Object.entries(variable.valuesByMode)) {
+      if (!isTokenAlias(value)) continue;
+      const error = checkTokenAlias(rebuilt, variable, value.alias);
+      if (error) {
+        issues.push({ message: `\`${variable.name}\`: ${error.message}`, variableId: variable.id });
+        continue;
+      }
+      const current = getTokenVariable(rebuilt, variable.id);
+      rebuilt = replaceVariable(rebuilt, { ...current, valuesByMode: { ...current.valuesByMode, [modeId]: { alias: value.alias } } });
+    }
+  }
+  return { state: rebuilt, issues };
+}
+
+// src/tokens/store.ts
+var TokenStore = (_class = class {
+  
+  __init() {this.undoStack = []}
+  __init2() {this.redoStack = []}
+  __init3() {this.listeners = /* @__PURE__ */ new Set()}
+  __init4() {this.pending = null}
+  __init5() {this.depth = 0}
+  
+  
+  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);
+    this.state = _nullishCoalesce(options.initialState, () => ( EMPTY_TOKEN_STATE));
+    this.createId = _nullishCoalesce(options.createId, () => ( defaultTokenId));
+    this.historyLimit = Math.max(0, _nullishCoalesce(options.historyLimit, () => ( 100)));
+  }
+  __init6() {this.getState = () => this.state}
+  __init7() {this.subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }}
+  get collections() {
+    return this.state.collections;
+  }
+  get variables() {
+    return this.state.variables;
+  }
+  canUndo() {
+    return this.undoStack.length > 0;
+  }
+  canRedo() {
+    return this.redoStack.length > 0;
+  }
+  /** Resolves a variable under `modes` (see `resolveToken`). */
+  resolve(id, modes) {
+    return resolveToken(this.state, id, modes);
+  }
+  resolveValue(id, modes) {
+    return resolveTokenValue(this.state, id, modes);
+  }
+  /**
+   * Runs `fn` as one undo step with one change event. If `fn` throws, every change it made is
+   * rolled back and the error rethrown.
+   */
+  transact(reason, fn) {
+    const outer = this.depth === 0;
+    if (outer) this.pending = { reason, previous: this.state, deleted: [] };
+    this.depth += 1;
+    try {
+      const result = fn(this);
+      this.depth -= 1;
+      if (outer) this.flush();
+      return result;
+    } catch (error) {
+      this.depth -= 1;
+      if (outer) {
+        this.state = this.pending.previous;
+        this.pending = null;
+      }
+      throw error;
+    }
+  }
+  apply(reason, next, deleted = []) {
+    if (next === this.state) return;
+    if (this.depth > 0) {
+      this.state = next;
+      this.pending.deleted.push(...deleted);
+      return;
+    }
+    this.pending = { reason, previous: this.state, deleted: [...deleted] };
+    this.state = next;
+    this.flush();
+  }
+  flush() {
+    const pending = this.pending;
+    this.pending = null;
+    if (pending.previous === this.state) return;
+    this.undoStack.push({ state: pending.previous, reason: pending.reason });
+    if (this.undoStack.length > this.historyLimit) this.undoStack.splice(0, this.undoStack.length - this.historyLimit);
+    this.redoStack = [];
+    this.emit({ source: "edit", reason: pending.reason, state: this.state, previous: pending.previous, deletedVariableIds: pending.deleted });
+  }
+  emit(event) {
+    for (const listener of [...this.listeners]) listener(event);
+  }
+  undo() {
+    const entry = this.undoStack.pop();
+    if (!entry) return false;
+    const previous = this.state;
+    this.redoStack.push({ state: previous, reason: entry.reason });
+    this.state = entry.state;
+    this.emit({ source: "undo", reason: entry.reason, state: this.state, previous, deletedVariableIds: [] });
+    return true;
+  }
+  redo() {
+    const entry = this.redoStack.pop();
+    if (!entry) return false;
+    const previous = this.state;
+    this.undoStack.push({ state: previous, reason: entry.reason });
+    this.state = entry.state;
+    this.emit({ source: "redo", reason: entry.reason, state: this.state, previous, deletedVariableIds: [] });
+    return true;
+  }
+  /**
+   * Replaces the whole state (e.g. after loading a file). Untrusted data should go through
+   * `parseTokenState` first. With `record: true` it is an undo step; otherwise history is cleared.
+   */
+  replaceState(state, options = {}) {
+    if (options.record) {
+      this.apply(_nullishCoalesce(options.reason, () => ( "replace")), state);
+      return;
+    }
+    const previous = this.state;
+    this.state = state;
+    this.undoStack = [];
+    this.redoStack = [];
+    this.emit({ source: "replace", reason: _nullishCoalesce(options.reason, () => ( "replace")), state, previous, deletedVariableIds: [] });
+  }
+  /** Loads untrusted JSON (or an object) as the new state; returns the issues found. */
+  load(input) {
+    const { state, issues } = parseTokenState(input);
+    this.replaceState(state, { reason: "load" });
+    return issues;
+  }
+  /** The state as JSON. */
+  toJSON() {
+    return this.state;
+  }
+  // --- Collections and modes -----------------------------------------------------------------
+  createCollection(name, modes) {
+    const input = { name, modes };
+    const result = createTokenCollection(this.state, input, this.createId);
+    this.apply("createCollection", result.state);
+    return result.collection;
+  }
+  renameCollection(id, name) {
+    this.apply("renameCollection", renameTokenCollection(this.state, id, name));
+  }
+  deleteCollection(id) {
+    const result = deleteTokenCollection(this.state, id);
+    this.apply("deleteCollection", result.state, result.deleted);
+    return result.deleted;
+  }
+  addMode(collectionId, name, options = {}) {
+    const result = addTokenMode(this.state, collectionId, name, options, this.createId);
+    this.apply("addMode", result.state);
+    return result.mode;
+  }
+  renameMode(collectionId, modeId, name) {
+    this.apply("renameMode", renameTokenMode(this.state, collectionId, modeId, name));
+  }
+  removeMode(collectionId, modeId) {
+    this.apply("removeMode", removeTokenMode(this.state, collectionId, modeId));
+  }
+  moveMode(collectionId, modeId, to) {
+    this.apply("moveMode", moveTokenMode(this.state, collectionId, modeId, to));
+  }
+  /** Makes a mode the default by moving it first. */
+  setDefaultMode(collectionId, modeId) {
+    this.apply("setDefaultMode", moveTokenMode(this.state, collectionId, modeId, 0));
+  }
+  // --- Variables -----------------------------------------------------------------------------
+  createVariable(input) {
+    const result = createTokenVariable(this.state, input, this.createId);
+    this.apply("createVariable", result.state);
+    return result.variable;
+  }
+  /** Sets a literal or `{ alias }` in one mode (id or name; default: the default mode). */
+  setValue(variableId, value, modeId) {
+    this.apply("setValue", setTokenValue(this.state, variableId, value, modeId));
+  }
+  renameVariable(variableId, name) {
+    this.apply("renameVariable", renameTokenVariable(this.state, variableId, name));
+  }
+  updateVariable(variableId, input) {
+    this.apply("updateVariable", updateTokenVariable(this.state, variableId, input));
+  }
+  /** Deletes variables; aliases to them take their values. Returns the ids deleted. */
+  deleteVariables(ids) {
+    const result = deleteTokenVariables(this.state, typeof ids === "string" ? [ids] : ids);
+    this.apply("deleteVariables", result.state, result.deleted);
+    return result.deleted;
+  }
+  /** Applies a pure state transform (e.g. `importW3CTokens`) as one undo step. */
+  update(reason, fn) {
+    this.apply(reason, fn(this.state));
+  }
+}, _class);
+function createTokenStore(options = {}) {
+  return new TokenStore(options);
+}
+
+// src/tokens/css.ts
+function tokenSlug(name) {
+  let out = "";
+  let dash = false;
+  for (const ch of name.toLowerCase()) {
+    if (ch >= "a" && ch <= "z" || ch >= "0" && ch <= "9" || ch === "_") {
+      if (dash && out) out += "-";
+      out += ch;
+      dash = false;
+    } else dash = true;
+  }
+  return out || "token";
+}
+function getTokenCssName(state, variable, options = {}) {
+  const collection = getTokenCollection(state, variable.collectionId);
+  const head = options.collectionPrefix && collection ? `${tokenSlug(collection.name)}-` : "";
+  const prefix = options.prefix ? `${tokenSlug(options.prefix)}-` : "";
+  return `--${prefix}${head}${tokenSlug(variable.name)}`;
+}
+function cssString(value) {
+  let out = '"';
+  for (const ch of value) {
+    if (ch === '"' || ch === "\\") out += "\\" + ch;
+    else if (ch === "\n") out += "\\a ";
+    else if (ch === "\r") out += "\\d ";
+    else if (ch === "<") out += "\\3c ";
+    else out += ch;
+  }
+  return out + '"';
+}
+function formatTokenCssValue(value, variable, options = {}) {
+  switch (variable.type) {
+    case "color":
+      return String(value);
+    case "number":
+      return options.formatNumber ? options.formatNumber(value, variable) : `${value}${_nullishCoalesce(variable.unit, () => ( ""))}`;
+    case "string":
+      return cssString(String(value));
+    case "boolean":
+      return value ? "true" : "false";
+  }
+}
+var defaultModeValue = (mode) => tokenSlug(mode.name);
+function attributeFor(options, collection) {
+  const attr = typeof options.attribute === "function" ? options.attribute(collection) : _nullishCoalesce(options.attribute, () => ( "data-mode"));
+  return tokenSlug(attr);
+}
+function exportTokensCss(state, options = {}) {
+  const selector = _nullishCoalesce(options.selector, () => ( ":root"));
+  const wanted = options.collections ? new Set(options.collections) : null;
+  const collections = state.collections.filter((c) => !wanted || wanted.has(c.id));
+  const exported = new Set(state.variables.filter((v) => collections.some((c) => c.id === v.collectionId)).map((v) => v.id));
+  const modeValue = _nullishCoalesce(options.modeValue, () => ( defaultModeValue));
+  const declaration = (variable, collection, mode) => {
+    const value = variable.valuesByMode[mode.id];
+    if (isTokenAlias(value) && exported.has(value.alias)) {
+      const target = getTokenVariable(state, value.alias);
+      return `  ${getTokenCssName(state, variable, options)}: var(${getTokenCssName(state, target, options)});`;
+    }
+    const resolved = resolveToken(state, variable.id, { [collection.id]: mode.id });
+    if (!resolved.ok) return null;
+    return `  ${getTokenCssName(state, variable, options)}: ${formatTokenCssValue(resolved.value, variable, options)};`;
+  };
+  const blocks = [];
+  const rootLines = [];
+  for (const collection of collections) {
+    const vars = state.variables.filter((v) => v.collectionId === collection.id);
+    for (const v of vars) {
+      const line = declaration(v, collection, collection.modes[0]);
+      if (line) rootLines.push(line);
+    }
+  }
+  const rootSelectors = [selector];
+  if (options.nested) {
+    for (const collection of collections) {
+      rootSelectors.push(`[${attributeFor(options, collection)}="${tokenSlug(modeValue(collection.modes[0], collection))}"]`);
+    }
+  }
+  blocks.push(`${[...new Set(rootSelectors)].join(", ")} {
+${rootLines.join("\n")}${rootLines.length ? "\n" : ""}}`);
+  for (const collection of collections) {
+    const vars = state.variables.filter((v) => v.collectionId === collection.id);
+    const attr = attributeFor(options, collection);
+    for (const mode of collection.modes.slice(1)) {
+      const lines = vars.map((v) => declaration(v, collection, mode)).filter((l) => l !== null);
+      const value = tokenSlug(modeValue(mode, collection));
+      const selectors = [`${selector}[${attr}="${value}"]`];
+      if (options.nested) selectors.push(`[${attr}="${value}"]`);
+      blocks.push(`${selectors.join(", ")} {
+${lines.join("\n")}${lines.length ? "\n" : ""}}`);
+    }
+  }
+  return blocks.join("\n\n") + "\n";
+}
+function getTokenCssVariables(state, modes, options = {}) {
+  const wanted = options.collections ? new Set(options.collections) : null;
+  const out = {};
+  for (const variable of state.variables) {
+    if (wanted && !wanted.has(variable.collectionId)) continue;
+    const collection = getTokenCollection(state, variable.collectionId);
+    if (!collection) continue;
+    const resolved = resolveToken(state, variable.id, { ...modes, [collection.id]: getCurrentMode(collection, modes).id });
+    if (resolved.ok) out[getTokenCssName(state, variable, options)] = formatTokenCssValue(resolved.value, variable, options);
+  }
+  return out;
+}
+
+// src/tokens/w3c.ts
+var W3C_TOKENS_EXTENSION = "com.pixerate.tokens";
+function path(name) {
+  return name.split("/");
+}
+function reference(state, variable) {
+  const collection = getTokenCollection(state, variable.collectionId);
+  return `{${[_nullishCoalesce(_optionalChain([collection, 'optionalAccess', _12 => _12.name]), () => ( variable.collectionId)), ...path(variable.name)].join(".")}}`;
+}
+function w3cType(variable) {
+  if (variable.type === "number") {
+    if (variable.unit === "ms" || variable.unit === "s") return "duration";
+    if (variable.unit) return "dimension";
+  }
+  return variable.type;
+}
+function w3cLiteral(variable, value, colorFormat) {
+  if (variable.type === "color" && colorFormat === "object") {
+    const c = hexToRgba(String(value));
+    if (c) {
+      const round = (n) => Math.round(n * 1e4) / 1e4;
+      return { colorSpace: "srgb", components: [round(c.r), round(c.g), round(c.b)], alpha: round(c.a), hex: String(value).slice(0, 7) };
+    }
+  }
+  if (variable.type === "number" && variable.unit) return { value, unit: variable.unit };
+  return value;
+}
+function w3cValue(state, variable, value, colorFormat) {
+  if (value === void 0) return null;
+  if (isTokenAlias(value)) {
+    const target = getTokenVariable(state, value.alias);
+    return target ? reference(state, target) : null;
+  }
+  return w3cLiteral(variable, value, colorFormat);
+}
+function exportW3CTokens(state, options = {}) {
+  const withExtensions = options.extensions !== false;
+  const colorFormat = _nullishCoalesce(options.colorFormat, () => ( "hex"));
+  const wanted = options.collections ? new Set(options.collections) : null;
+  const root = {};
+  for (const collection of state.collections) {
+    if (wanted && !wanted.has(collection.id)) continue;
+    const group = {};
+    if (withExtensions) {
+      group.$extensions = {
+        [W3C_TOKENS_EXTENSION]: { id: collection.id, modes: collection.modes.map((m) => ({ id: m.id, name: m.name })) }
+      };
+    }
+    const chosen = _optionalChain([options, 'access', _13 => _13.modes, 'optionalAccess', _14 => _14[collection.id]]);
+    const mode = chosen !== void 0 && collection.modes.find((m) => m.id === chosen) || collection.modes[0];
+    for (const variable of state.variables) {
+      if (variable.collectionId !== collection.id) continue;
+      const token = {
+        $type: w3cType(variable),
+        $value: w3cValue(state, variable, variable.valuesByMode[mode.id], colorFormat)
+      };
+      if (variable.description) token.$description = variable.description;
+      if (withExtensions) {
+        const modes = {};
+        for (const m of collection.modes) modes[m.name] = w3cValue(state, variable, variable.valuesByMode[m.id], colorFormat);
+        const ext = { id: variable.id, modes };
+        if (variable.scopes) ext.scopes = [...variable.scopes];
+        if (variable.unit) ext.unit = variable.unit;
+        token.$extensions = { [W3C_TOKENS_EXTENSION]: ext };
+      }
+      let at = group;
+      const segments = path(variable.name);
+      for (const segment of segments.slice(0, -1)) {
+        const next = at[segment];
+        if (typeof next !== "object" || next === null || Array.isArray(next) || "$value" in next) at[segment] = {};
+        at = at[segment];
+      }
+      at[segments[segments.length - 1]] = token;
+    }
+    root[collection.name] = group;
+  }
+  return root;
+}
+function exportW3CTokensJson(state, options = {}) {
+  return JSON.stringify(exportW3CTokens(state, options), null, 2);
+}
+var MAX_DEPTH = 32;
+var REF = /^\{([^{}]+)\}$/;
+var MEASURE = /^(-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)\s*([a-z%]*)$/i;
+var FONT_WEIGHTS = {
+  thin: 100,
+  hairline: 100,
+  "extra-light": 200,
+  "ultra-light": 200,
+  light: 300,
+  normal: 400,
+  regular: 400,
+  book: 400,
+  medium: 500,
+  "semi-bold": 600,
+  "demi-bold": 600,
+  bold: 700,
+  "extra-bold": 800,
+  "ultra-bold": 800,
+  black: 900,
+  heavy: 900,
+  "extra-black": 950,
+  "ultra-black": 950
+};
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function extensionOf(node) {
+  const ext = node.$extensions;
+  if (!isObject(ext)) return void 0;
+  const ours = ext[W3C_TOKENS_EXTENSION];
+  return isObject(ours) ? ours : void 0;
+}
+function aliasRef(value) {
+  if (typeof value !== "string" || value.length > 1e3) return null;
+  const match = REF.exec(value.trim());
+  return match ? match[1].trim() : null;
+}
+function mapType(type) {
+  switch (type) {
+    case "color":
+      return "color";
+    case "number":
+    case "dimension":
+    case "duration":
+    case "fontWeight":
+      return "number";
+    case "string":
+    case "text":
+    case "fontFamily":
+    case "fontStyle":
+      return "string";
+    case "boolean":
+      return "boolean";
+    default:
+      return null;
+  }
+}
+function inferType(value) {
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "number") return "number";
+  if (typeof value === "string") {
+    const text = value.trim();
+    if ((text.startsWith("#") || /^rgba?\(/i.test(text)) && normalizeTokenColor(text)) return "color";
+    if (MEASURE.test(text) && /[a-z%]$/i.test(text)) return "dimension";
+    return "string";
+  }
+  if (isObject(value) && Array.isArray(value.components)) return "color";
+  if (isObject(value) && typeof value.value === "number" && typeof value.unit === "string") return "dimension";
+  return void 0;
+}
+function readLiteral(w3cType2, type, value) {
+  if (type === "number") {
+    if (w3cType2 === "fontWeight" && typeof value === "string") {
+      const weight = FONT_WEIGHTS[value.trim().toLowerCase()];
+      return weight === void 0 ? null : { value: weight };
+    }
+    if (isObject(value) && typeof value.value === "number" && Number.isFinite(value.value)) {
+      const unit = typeof value.unit === "string" && /^[a-z%]{1,8}$/i.test(value.unit) ? value.unit.toLowerCase() : void 0;
+      return { value: value.value, unit };
+    }
+    if (typeof value === "string" && value.length <= 100) {
+      const match = MEASURE.exec(value.trim());
+      if (!match) return null;
+      const n2 = Number(match[1]);
+      if (!Number.isFinite(n2)) return null;
+      const unit = match[2] ? match[2].toLowerCase() : void 0;
+      return { value: n2, unit: unit && unit.length <= 8 ? unit : void 0 };
+    }
+    const n = coerceTokenLiteral("number", value);
+    return n === null ? null : { value: n };
+  }
+  if (type === "string" && w3cType2 === "fontFamily" && Array.isArray(value)) {
+    return value.every((v) => typeof v === "string") ? { value: value.join(", ") } : null;
+  }
+  const literal = coerceTokenLiteral(type, value);
+  return literal === null ? null : { value: literal };
+}
+function collectTokens(group, collection, prefix, inheritedType, out, warnings, depth) {
+  if (depth > MAX_DEPTH) {
+    warnings.push(`\`${prefix.join(".")}\` is nested too deeply; skipped`);
+    return;
+  }
+  const groupType = typeof group.$type === "string" ? group.$type : inheritedType;
+  for (const [key, child] of Object.entries(group)) {
+    if (key.startsWith("$")) continue;
+    const at = [...prefix, key];
+    if (!isObject(child)) {
+      warnings.push(`\`${at.join(".")}\` is not a token or group; skipped`);
+      continue;
+    }
+    if ("$value" in child) {
+      out.push({
+        collection,
+        path: at,
+        type: typeof child.$type === "string" ? child.$type : groupType,
+        value: child.$value,
+        description: child.$description,
+        ext: extensionOf(child)
+      });
+    } else collectTokens(child, collection, at, groupType, out, warnings, depth + 1);
+  }
+}
+function importW3CTokens(state, input, options = {}) {
+  let doc = input;
+  if (typeof doc === "string") {
+    try {
+      doc = JSON.parse(doc);
+    } catch (e3) {
+      throw new TokenError("invalid-input", "Not JSON");
+    }
+  }
+  if (!isObject(doc)) throw new TokenError("invalid-input", "Expected a design tokens object");
+  const createId = _nullishCoalesce(options.createId, () => ( defaultTokenId));
+  const report = { collectionsAdded: 0, modesAdded: 0, variablesAdded: 0, variablesUpdated: 0, warnings: [] };
+  const warn = (message) => {
+    if (report.warnings.length < 500) report.warnings.push(message);
+  };
+  const marked = Object.entries(doc).filter(([key, value]) => !key.startsWith("$") && isObject(value) && !("$value" in value) && Array.isArray(_optionalChain([extensionOf, 'call', _15 => _15(value), 'optionalAccess', _16 => _16.modes])));
+  const plainName = _nullishCoalesce(options.collection, () => ( "Tokens"));
+  const sources = [];
+  if (marked.length > 0) {
+    for (const [key, value] of marked) {
+      const ext = extensionOf(value);
+      sources.push({ name: key, group: value, modes: ext.modes, id: ext.id, plain: false });
+    }
+    const rest = {};
+    for (const [key, value] of Object.entries(doc)) if (!marked.some(([k]) => k === key)) rest[key] = value;
+    if (Object.keys(rest).some((k) => !k.startsWith("$"))) sources.push({ name: plainName, group: rest, plain: true });
+  } else sources.push({ name: plainName, group: doc, plain: true });
+  const usedIds = /* @__PURE__ */ new Set([...state.collections.map((c) => c.id), ...state.variables.map((v) => v.id)]);
+  for (const c of state.collections) for (const m of c.modes) usedIds.add(m.id);
+  const idFrom = (candidate, kind) => (k) => {
+    if (k === kind && typeof candidate === "string" && candidate.length > 0 && candidate.length <= 200 && !usedIds.has(candidate)) {
+      usedIds.add(candidate);
+      return candidate;
+    }
+    const id = createId(k);
+    usedIds.add(id);
+    return id;
+  };
+  let next = state;
+  const tokens = [];
+  const collectionIds = /* @__PURE__ */ new Map();
+  const plainMode = /* @__PURE__ */ new Map();
+  const ensureMode = (collectionId, name, id) => {
+    const collection = getTokenCollection(next, collectionId);
+    const existing = findTokenMode(collection, name);
+    if (existing) return existing.id;
+    try {
+      const result = addTokenMode(next, collectionId, name, {}, idFrom(id, "mode"));
+      next = result.state;
+      report.modesAdded += 1;
+      return result.mode.id;
+    } catch (error) {
+      warn(`Mode \`${name}\`: ${error.message}`);
+      return null;
+    }
+  };
+  for (const source of sources) {
+    let collection = findTokenCollection(next, source.name);
+    if (!collection) {
+      const declared = (_nullishCoalesce(source.modes, () => ( []))).filter(isObject);
+      const names = declared.map((m) => m.name).filter((n) => typeof n === "string" && n.trim() !== "");
+      if (source.plain && options.mode) names.splice(0, names.length, options.mode);
+      try {
+        const ids = [source.id, ...declared.map((m) => m.id)];
+        let i = 0;
+        const factory = (kind) => idFrom(kind === "collection" ? ids[0] : ids[++i], kind)(kind);
+        const result = createTokenCollection(next, { name: source.name, modes: names.length ? names : void 0 }, factory);
+        next = result.state;
+        collection = result.collection;
+        report.collectionsAdded += 1;
+      } catch (error) {
+        warn(`Collection \`${source.name}\`: ${error.message}`);
+        continue;
+      }
+    } else {
+      for (const m of (_nullishCoalesce(source.modes, () => ( []))).filter(isObject)) {
+        if (typeof m.name === "string" && m.name.trim()) ensureMode(collection.id, m.name, m.id);
+      }
+    }
+    collectionIds.set(source.name, collection.id);
+    const modeId = options.mode && source.plain ? ensureMode(collection.id, options.mode) : getTokenCollection(next, collection.id).modes[0].id;
+    if (modeId) plainMode.set(source.name, modeId);
+    collectTokens(source.group, source.name, [], void 0, tokens, report.warnings, 0);
+  }
+  const byFullPath = /* @__PURE__ */ new Map();
+  for (const token of tokens) byFullPath.set([token.collection, ...token.path].join("."), token);
+  const findRaw = (ref, from) => _nullishCoalesce(byFullPath.get(ref), () => ( byFullPath.get(`${from.collection}.${ref}`)));
+  const typeOf = (token) => {
+    let current = token;
+    for (let i = 0; i < MAX_DEPTH && current; i++) {
+      if (current.type) return current.type;
+      const ref = aliasRef(current.value);
+      if (ref === null) return inferType(current.value);
+      current = findRaw(ref, current);
+    }
+    return void 0;
+  };
+  const pending = [];
+  const variableFor = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const label2 = [token.collection, ...token.path].join(".");
+    const collectionId = collectionIds.get(token.collection);
+    if (!collectionId) continue;
+    const w3cType2 = typeOf(token);
+    const type = w3cType2 ? mapType(w3cType2) : null;
+    if (!w3cType2 || !type) {
+      warn(`\`${label2}\` has an unsupported type \`${_nullishCoalesce(w3cType2, () => ( "unknown"))}\`; skipped`);
+      continue;
+    }
+    let name;
+    try {
+      name = normalizeTokenName(token.path.join("/"));
+    } catch (error) {
+      warn(`\`${label2}\`: ${error.message}`);
+      continue;
+    }
+    let variable = findTokenVariable(next, name, collectionId);
+    if (variable && variable.type !== type) {
+      warn(`\`${name}\` is a ${variable.type} variable; the ${type} token \`${label2}\` was skipped`);
+      continue;
+    }
+    if (!variable) {
+      try {
+        const result = createTokenVariable(next, { collectionId, name, type }, idFrom(_optionalChain([token, 'access', _17 => _17.ext, 'optionalAccess', _18 => _18.id]), "variable"));
+        next = result.state;
+        variable = result.variable;
+        report.variablesAdded += 1;
+      } catch (error) {
+        warn(`\`${label2}\`: ${error.message}`);
+        continue;
+      }
+    } else report.variablesUpdated += 1;
+    variableFor.set(token, variable.id);
+    const values = [];
+    const extModes = _optionalChain([token, 'access', _19 => _19.ext, 'optionalAccess', _20 => _20.modes]);
+    if (isObject(extModes)) {
+      for (const [modeName, value] of Object.entries(extModes)) {
+        const modeId = ensureMode(collectionId, modeName);
+        if (modeId) values.push([modeId, value]);
+      }
+    } else {
+      const modeId = plainMode.get(token.collection);
+      if (modeId) values.push([modeId, token.value]);
+    }
+    let unit;
+    for (const [modeId, raw] of values) {
+      const ref = aliasRef(raw);
+      if (ref !== null) {
+        pending.push({ variable, modeId, ref, token });
+        continue;
+      }
+      const literal = readLiteral(w3cType2, type, raw);
+      if (!literal) {
+        warn(`\`${label2}\` has an invalid ${w3cType2} value; kept the previous value`);
+        continue;
+      }
+      if (literal.unit) unit = literal.unit;
+      next = setTokenValue(next, variable.id, literal.value, modeId);
+    }
+    const update = {};
+    if (typeof token.description === "string") update.description = token.description;
+    const extUnit = _optionalChain([token, 'access', _21 => _21.ext, 'optionalAccess', _22 => _22.unit]);
+    if (typeof extUnit === "string") unit = extUnit;
+    if (unit && unit !== variable.unit) update.unit = unit;
+    if (Array.isArray(_optionalChain([token, 'access', _23 => _23.ext, 'optionalAccess', _24 => _24.scopes]))) update.scopes = token.ext.scopes.filter((s) => typeof s === "string");
+    if (Object.keys(update).length > 0) {
+      try {
+        next = updateTokenVariable(next, variable.id, update);
+      } catch (error) {
+        warn(`\`${label2}\`: ${error.message}`);
+      }
+    }
+  }
+  for (const { variable, modeId, ref, token } of pending) {
+    const label2 = [token.collection, ...token.path].join(".");
+    const raw = findRaw(ref, token);
+    let targetId = raw ? variableFor.get(raw) : void 0;
+    if (!targetId) {
+      const dot = ref.indexOf(".");
+      const inCollection = dot > 0 ? findTokenCollection(next, ref.slice(0, dot)) : void 0;
+      const found = inCollection && findTokenVariable(next, ref.slice(dot + 1).split(".").join("/"), inCollection.id) || findTokenVariable(next, ref.split(".").join("/"), variable.collectionId);
+      targetId = found ? found.id : void 0;
+    }
+    if (!targetId) {
+      warn(`\`${label2}\` refers to \`{${ref}}\`, which doesn't exist; kept the previous value`);
+      continue;
+    }
+    const current = getTokenVariable(next, variable.id);
+    const error = checkTokenAlias(next, current, targetId);
+    if (error) {
+      warn(`\`${label2}\`: ${error.message}`);
+      continue;
+    }
+    next = setTokenValue(next, variable.id, { alias: targetId }, modeId);
+  }
+  return { state: next, report };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.TOKEN_TYPES = TOKEN_TYPES; exports.TokenError = TokenError; exports.isTokenAlias = isTokenAlias; exports.EMPTY_TOKEN_STATE = EMPTY_TOKEN_STATE; exports.rgbaToHex = rgbaToHex; exports.hexToRgba = hexToRgba; exports.normalizeTokenColor = normalizeTokenColor; exports.getTokenCollection = getTokenCollection; exports.getTokenVariable = getTokenVariable; exports.findTokenCollection = findTokenCollection; exports.findTokenVariable = findTokenVariable; exports.getCollectionVariables = getCollectionVariables; exports.getDefaultMode = getDefaultMode; exports.findTokenMode = findTokenMode; exports.getCurrentMode = getCurrentMode; exports.defaultTokenValue = defaultTokenValue; exports.coerceTokenLiteral = coerceTokenLiteral; exports.literalTokenType = literalTokenType; exports.formatTokenValue = formatTokenValue; exports.resolveToken = resolveToken; exports.resolveTokenValue = resolveTokenValue; exports.resolveTokenInMode = resolveTokenInMode; exports.checkTokenAlias = checkTokenAlias; exports.TOKEN_SCOPES_BY_TYPE = TOKEN_SCOPES_BY_TYPE; exports.isTokenScopeKnown = isTokenScopeKnown; exports.normalizeTokenScopes = normalizeTokenScopes; exports.isTokenInScope = isTokenInScope; exports.normalizeTokenName = normalizeTokenName; exports.defaultTokenId = defaultTokenId; exports.createTokenCollection = createTokenCollection; exports.renameTokenCollection = renameTokenCollection; exports.deleteTokenVariables = deleteTokenVariables; exports.deleteTokenCollection = deleteTokenCollection; exports.addTokenMode = addTokenMode; exports.renameTokenMode = renameTokenMode; exports.removeTokenMode = removeTokenMode; exports.moveTokenMode = moveTokenMode; exports.prepareTokenValue = prepareTokenValue; exports.createTokenVariable = createTokenVariable; exports.setTokenValue = setTokenValue; exports.renameTokenVariable = renameTokenVariable; exports.updateTokenVariable = updateTokenVariable; exports.parseTokenState = parseTokenState; exports.TokenStore = TokenStore; exports.createTokenStore = createTokenStore; exports.tokenSlug = tokenSlug; exports.getTokenCssName = getTokenCssName; exports.cssString = cssString; exports.formatTokenCssValue = formatTokenCssValue; exports.exportTokensCss = exportTokensCss; exports.getTokenCssVariables = getTokenCssVariables; exports.W3C_TOKENS_EXTENSION = W3C_TOKENS_EXTENSION; exports.exportW3CTokens = exportW3CTokens; exports.exportW3CTokensJson = exportW3CTokensJson; exports.importW3CTokens = importW3CTokens;
+//# sourceMappingURL=chunk-4BVP64JJ.cjs.map