@homebound/truss 1.137.4 → 2.0.0-next.1

package/build/plugin/index.js

@@ -0,0 +1,1577 @@
+// src/plugin/index.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname, isAbsolute } from "path";
+
+// src/plugin/transform.ts
+import { parse } from "@babel/parser";
+import _traverse2 from "@babel/traverse";
+import _generate from "@babel/generator";
+import * as t4 from "@babel/types";
+
+// src/plugin/resolve-chain.ts
+function resolveFullChain(chain, mapping) {
+  const parts = [];
+  const markers = [];
+  const filteredChain = [];
+  const scanErrors = [];
+  for (let j = 0; j < chain.length; j++) {
+    const node = chain[j];
+    if (node.type === "getter" && node.name === "marker") {
+      markers.push({ type: "marker" });
+    } else if (node.type === "call" && node.name === "markerOf") {
+      if (node.args.length !== 1) {
+        scanErrors.push("[truss] Unsupported pattern: markerOf() requires exactly one argument (a marker variable)");
+      } else {
+        markers.push({ type: "marker", markerNode: node.args[0] });
+      }
+    } else {
+      filteredChain.push(node);
+    }
+  }
+  let i = 0;
+  let currentNodes = [];
+  while (i < filteredChain.length) {
+    const node = filteredChain[i];
+    if (node.type === "if") {
+      if (node.conditionNode.type === "StringLiteral") {
+        const mediaQuery = node.conditionNode.value;
+        currentNodes.push({ type: "__mediaQuery", mediaQuery });
+        i++;
+        continue;
+      }
+      if (currentNodes.length > 0) {
+        parts.push({
+          type: "unconditional",
+          segments: mergeOverlappingConditions(resolveChain(currentNodes, mapping))
+        });
+        currentNodes = [];
+      }
+      const thenNodes = [];
+      const elseNodes = [];
+      i++;
+      let inElse = false;
+      while (i < filteredChain.length) {
+        if (filteredChain[i].type === "else") {
+          inElse = true;
+          i++;
+          continue;
+        }
+        if (filteredChain[i].type === "if") {
+          break;
+        }
+        if (inElse) {
+          elseNodes.push(filteredChain[i]);
+        } else {
+          thenNodes.push(filteredChain[i]);
+        }
+        i++;
+      }
+      parts.push({
+        type: "conditional",
+        conditionNode: node.conditionNode,
+        thenSegments: mergeOverlappingConditions(resolveChain(thenNodes, mapping)),
+        elseSegments: mergeOverlappingConditions(resolveChain(elseNodes, mapping))
+      });
+    } else {
+      currentNodes.push(node);
+      i++;
+    }
+  }
+  if (currentNodes.length > 0) {
+    parts.push({ type: "unconditional", segments: mergeOverlappingConditions(resolveChain(currentNodes, mapping)) });
+  }
+  const segmentErrors = [];
+  for (const part of parts) {
+    const segs = part.type === "unconditional" ? part.segments : [...part.thenSegments, ...part.elseSegments];
+    for (const seg of segs) {
+      if (seg.error) {
+        segmentErrors.push(seg.error);
+      }
+    }
+  }
+  return { parts, markers, errors: [...scanErrors, ...segmentErrors] };
+}
+function resolveChain(chain, mapping) {
+  const segments = [];
+  let currentMediaQuery = null;
+  let currentPseudoClass = null;
+  let currentPseudoElement = null;
+  let currentWhenPseudo = null;
+  for (const node of chain) {
+    try {
+      if (node.type === "__mediaQuery") {
+        currentMediaQuery = node.mediaQuery;
+        currentWhenPseudo = null;
+        continue;
+      }
+      if (node.type === "getter") {
+        const abbr = node.name;
+        if (isPseudoMethod(abbr)) {
+          currentPseudoClass = pseudoSelector(abbr);
+          currentWhenPseudo = null;
+          continue;
+        }
+        if (mapping.breakpoints && abbr in mapping.breakpoints) {
+          currentMediaQuery = mapping.breakpoints[abbr];
+          currentWhenPseudo = null;
+          continue;
+        }
+        const entry = mapping.abbreviations[abbr];
+        if (!entry) {
+          throw new UnsupportedPatternError(`Unknown abbreviation "${abbr}"`);
+        }
+        const resolved = resolveEntry(
+          abbr,
+          entry,
+          mapping,
+          currentMediaQuery,
+          currentPseudoClass,
+          currentPseudoElement,
+          currentWhenPseudo
+        );
+        segments.push(...resolved);
+      } else if (node.type === "call") {
+        const abbr = node.name;
+        if (abbr === "ifContainer") {
+          currentMediaQuery = containerSelectorFromCall(node);
+          currentWhenPseudo = null;
+          continue;
+        }
+        if (abbr === "add") {
+          const seg = resolveAddCall(node, mapping, currentMediaQuery, currentPseudoClass, currentPseudoElement);
+          segments.push(seg);
+          continue;
+        }
+        if (abbr === "element") {
+          if (node.args.length !== 1 || node.args[0].type !== "StringLiteral") {
+            throw new UnsupportedPatternError(
+              `element() requires exactly one string literal argument (e.g. "::placeholder")`
+            );
+          }
+          currentPseudoElement = node.args[0].value;
+          continue;
+        }
+        if (abbr === "when") {
+          const resolved = resolveWhenCall(node);
+          currentPseudoClass = null;
+          currentMediaQuery = null;
+          currentWhenPseudo = resolved;
+          continue;
+        }
+        if (isPseudoMethod(abbr)) {
+          currentPseudoClass = pseudoSelector(abbr);
+          currentWhenPseudo = null;
+          if (node.args.length > 0) {
+            throw new UnsupportedPatternError(
+              `${abbr}() does not take arguments -- use when("ancestor", ":hover") for relationship pseudos`
+            );
+          }
+          continue;
+        }
+        const entry = mapping.abbreviations[abbr];
+        if (!entry) {
+          throw new UnsupportedPatternError(`Unknown abbreviation "${abbr}"`);
+        }
+        if (entry.kind === "dynamic") {
+          const seg = resolveDynamicCall(
+            abbr,
+            entry,
+            node,
+            mapping,
+            currentMediaQuery,
+            currentPseudoClass,
+            currentPseudoElement
+          );
+          segments.push(seg);
+        } else if (entry.kind === "delegate") {
+          const seg = resolveDelegateCall(
+            abbr,
+            entry,
+            node,
+            mapping,
+            currentMediaQuery,
+            currentPseudoClass,
+            currentPseudoElement
+          );
+          segments.push(seg);
+        } else {
+          throw new UnsupportedPatternError(`Abbreviation "${abbr}" is ${entry.kind}, cannot be called as a function`);
+        }
+      }
+    } catch (err) {
+      if (err instanceof UnsupportedPatternError) {
+        segments.push({ key: "__error", defs: {}, error: err.message });
+      } else {
+        throw err;
+      }
+    }
+  }
+  return segments;
+}
+function conditionKeySuffix(mediaQuery, pseudoClass, pseudoElement, breakpoints) {
+  const parts = [];
+  if (pseudoElement) parts.push(pseudoName(pseudoElement));
+  if (mediaQuery) parts.push(pseudoName(mediaQuery, breakpoints));
+  if (pseudoClass) parts.push(pseudoName(pseudoClass));
+  return parts.join("_");
+}
+function wrapDefsWithConditions(defs, mediaQuery, pseudoClass) {
+  if (!mediaQuery && !pseudoClass) return defs;
+  const result = {};
+  for (const [prop, value] of Object.entries(defs)) {
+    if (pseudoClass && mediaQuery) {
+      result[prop] = { default: null, [pseudoClass]: { default: null, [mediaQuery]: value } };
+    } else if (pseudoClass) {
+      result[prop] = { default: null, [pseudoClass]: value };
+    } else {
+      result[prop] = { default: null, [mediaQuery]: value };
+    }
+  }
+  return result;
+}
+function resolveEntry(abbr, entry, mapping, mediaQuery, pseudoClass, pseudoElement, whenPseudo) {
+  switch (entry.kind) {
+    case "static": {
+      if (whenPseudo) {
+        const suffix2 = whenPseudoKeyName(whenPseudo);
+        const key2 = `${abbr}__${suffix2}`;
+        return [{ key: key2, defs: entry.defs, whenPseudo }];
+      }
+      const suffix = conditionKeySuffix(mediaQuery, pseudoClass, pseudoElement, mapping.breakpoints);
+      const key = suffix ? `${abbr}__${suffix}` : abbr;
+      const defs = pseudoElement ? { [pseudoElement]: wrapDefsWithConditions(entry.defs, mediaQuery, pseudoClass) } : wrapDefsWithConditions(entry.defs, mediaQuery, pseudoClass);
+      return [{ key, defs, mediaQuery, pseudoClass, pseudoElement }];
+    }
+    case "alias": {
+      const result = [];
+      for (const chainAbbr of entry.chain) {
+        const subEntry = mapping.abbreviations[chainAbbr];
+        if (!subEntry) {
+          throw new UnsupportedPatternError(`Alias "${abbr}" references unknown abbreviation "${chainAbbr}"`);
+        }
+        result.push(...resolveEntry(chainAbbr, subEntry, mapping, mediaQuery, pseudoClass, pseudoElement, whenPseudo));
+      }
+      return result;
+    }
+    case "dynamic":
+    case "delegate":
+      throw new UnsupportedPatternError(`Abbreviation "${abbr}" requires arguments \u2014 use ${abbr}() not .${abbr}`);
+    default:
+      throw new UnsupportedPatternError(`Unhandled entry kind for "${abbr}"`);
+  }
+}
+function resolveDynamicCall(abbr, entry, node, mapping, mediaQuery, pseudoClass, pseudoElement) {
+  if (node.args.length !== 1) {
+    throw new UnsupportedPatternError(`${abbr}() expects exactly 1 argument, got ${node.args.length}`);
+  }
+  const argAst = node.args[0];
+  const literalValue = tryEvaluateLiteral(argAst, entry.incremented, mapping.increment);
+  const suffix = conditionKeySuffix(mediaQuery, pseudoClass, pseudoElement, mapping.breakpoints);
+  if (literalValue !== null) {
+    const keySuffix = literalValue.replace(/[^a-zA-Z0-9]/g, "_");
+    const key = suffix ? `${abbr}__${keySuffix}__${suffix}` : `${abbr}__${keySuffix}`;
+    const defs = {};
+    for (const prop of entry.props) {
+      defs[prop] = literalValue;
+    }
+    if (entry.extraDefs) {
+      Object.assign(defs, entry.extraDefs);
+    }
+    const wrappedDefs = wrapDefsWithConditions(defs, mediaQuery, pseudoClass);
+    return {
+      key,
+      defs: pseudoElement ? { [pseudoElement]: wrappedDefs } : wrappedDefs,
+      mediaQuery,
+      pseudoClass,
+      pseudoElement,
+      argResolved: literalValue
+    };
+  } else {
+    const key = suffix ? `${abbr}__${suffix}` : abbr;
+    return {
+      key,
+      defs: {},
+      mediaQuery,
+      pseudoClass,
+      dynamicProps: entry.props,
+      incremented: entry.incremented,
+      dynamicExtraDefs: entry.extraDefs,
+      argNode: argAst
+    };
+  }
+}
+function resolveDelegateCall(abbr, entry, node, mapping, mediaQuery, pseudoClass, pseudoElement) {
+  const targetEntry = mapping.abbreviations[entry.target];
+  if (!targetEntry || targetEntry.kind !== "dynamic") {
+    throw new UnsupportedPatternError(`Delegate "${abbr}" targets "${entry.target}" which is not a dynamic entry`);
+  }
+  if (node.args.length !== 1) {
+    throw new UnsupportedPatternError(`${abbr}() expects exactly 1 argument, got ${node.args.length}`);
+  }
+  const argAst = node.args[0];
+  const literalValue = tryEvaluatePxLiteral(argAst);
+  const suffix = conditionKeySuffix(mediaQuery, pseudoClass, pseudoElement, mapping.breakpoints);
+  if (literalValue !== null) {
+    const keySuffix = literalValue.replace(/[^a-zA-Z0-9]/g, "_");
+    const key = suffix ? `${entry.target}__${keySuffix}__${suffix}` : `${entry.target}__${keySuffix}`;
+    const defs = {};
+    for (const prop of targetEntry.props) {
+      defs[prop] = literalValue;
+    }
+    if (targetEntry.extraDefs) {
+      Object.assign(defs, targetEntry.extraDefs);
+    }
+    const wrappedDefs = wrapDefsWithConditions(defs, mediaQuery, pseudoClass);
+    return {
+      key,
+      defs: pseudoElement ? { [pseudoElement]: wrappedDefs } : wrappedDefs,
+      mediaQuery,
+      pseudoClass,
+      pseudoElement,
+      argResolved: literalValue
+    };
+  } else {
+    const key = suffix ? `${entry.target}__${suffix}` : entry.target;
+    return {
+      key,
+      defs: {},
+      mediaQuery,
+      pseudoClass,
+      pseudoElement,
+      dynamicProps: targetEntry.props,
+      incremented: false,
+      dynamicExtraDefs: targetEntry.extraDefs,
+      argNode: argAst
+    };
+  }
+}
+function resolveAddCall(node, mapping, mediaQuery, pseudoClass, pseudoElement) {
+  if (node.args.length !== 2) {
+    throw new UnsupportedPatternError(
+      `add() requires exactly 2 arguments (property name and value), got ${node.args.length}. The add({...}) object overload is not supported -- use add("propName", value) instead`
+    );
+  }
+  const propArg = node.args[0];
+  if (propArg.type !== "StringLiteral") {
+    throw new UnsupportedPatternError(`add() first argument must be a string literal property name`);
+  }
+  const propName = propArg.value;
+  const valueArg = node.args[1];
+  const literalValue = tryEvaluateAddLiteral(valueArg);
+  const suffix = conditionKeySuffix(mediaQuery, pseudoClass, pseudoElement, mapping.breakpoints);
+  if (literalValue !== null) {
+    const keySuffix = literalValue.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+    const key = suffix ? `add_${propName}__${keySuffix}__${suffix}` : `add_${propName}__${keySuffix}`;
+    const defs = { [propName]: literalValue };
+    const wrappedDefs = wrapDefsWithConditions(defs, mediaQuery, pseudoClass);
+    return {
+      key,
+      defs: pseudoElement ? { [pseudoElement]: wrappedDefs } : wrappedDefs,
+      mediaQuery,
+      pseudoClass,
+      pseudoElement,
+      argResolved: literalValue
+    };
+  } else {
+    const key = suffix ? `add_${propName}__${suffix}` : `add_${propName}`;
+    return {
+      key,
+      defs: {},
+      mediaQuery,
+      pseudoClass,
+      pseudoElement,
+      dynamicProps: [propName],
+      incremented: false,
+      argNode: valueArg
+    };
+  }
+}
+function tryEvaluateAddLiteral(node) {
+  if (node.type === "StringLiteral") {
+    return node.value;
+  }
+  if (node.type === "NumericLiteral") {
+    return String(node.value);
+  }
+  if (node.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "NumericLiteral") {
+    return String(-node.argument.value);
+  }
+  return null;
+}
+var WHEN_RELATIONSHIPS = /* @__PURE__ */ new Set(["ancestor", "descendant", "anySibling", "siblingBefore", "siblingAfter"]);
+function resolveWhenCall(node) {
+  if (node.args.length < 2 || node.args.length > 3) {
+    throw new UnsupportedPatternError(
+      `when() expects 2 or 3 arguments (relationship, [marker], pseudo), got ${node.args.length}`
+    );
+  }
+  const relationshipArg = node.args[0];
+  if (relationshipArg.type !== "StringLiteral") {
+    throw new UnsupportedPatternError(`when() first argument must be a string literal relationship`);
+  }
+  const relationship = relationshipArg.value;
+  if (!WHEN_RELATIONSHIPS.has(relationship)) {
+    throw new UnsupportedPatternError(
+      `when() relationship must be one of: ${[...WHEN_RELATIONSHIPS].join(", ")} -- got "${relationship}"`
+    );
+  }
+  if (node.args.length === 2) {
+    const pseudoArg = node.args[1];
+    if (pseudoArg.type !== "StringLiteral") {
+      throw new UnsupportedPatternError(`when() pseudo selector must be a string literal`);
+    }
+    return { pseudo: pseudoArg.value, relationship };
+  } else {
+    const markerNode = node.args[1];
+    const pseudoArg = node.args[2];
+    if (pseudoArg.type !== "StringLiteral") {
+      throw new UnsupportedPatternError(`when() pseudo selector (3rd argument) must be a string literal`);
+    }
+    return { pseudo: pseudoArg.value, markerNode, relationship };
+  }
+}
+var PSEUDO_METHODS = {
+  onHover: ":hover",
+  onFocus: ":focus",
+  onFocusVisible: ":focus-visible",
+  onActive: ":active",
+  onDisabled: ":disabled"
+};
+function isPseudoMethod(name) {
+  return name in PSEUDO_METHODS;
+}
+function pseudoSelector(name) {
+  return PSEUDO_METHODS[name];
+}
+function whenPseudoKeyName(ap) {
+  const rel = ap.relationship ?? "ancestor";
+  const pn = pseudoName(ap.pseudo);
+  const base = `${rel}${pn.charAt(0).toUpperCase()}${pn.slice(1)}`;
+  if (!ap.markerNode) return base;
+  const suffix = ap.markerNode.type === "Identifier" ? ap.markerNode.name : "marker";
+  return `${base}_${suffix}`;
+}
+function mergeOverlappingConditions(segments) {
+  const propToIndices = /* @__PURE__ */ new Map();
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg.dynamicProps || seg.whenPseudo || seg.error) continue;
+    for (const prop of Object.keys(seg.defs)) {
+      if (!propToIndices.has(prop)) propToIndices.set(prop, []);
+      propToIndices.get(prop).push(i);
+    }
+  }
+  const mergeableProps = /* @__PURE__ */ new Set();
+  for (const [prop, indices] of propToIndices) {
+    if (indices.length < 2) continue;
+    const hasBase = indices.some((i) => !segments[i].mediaQuery && !segments[i].pseudoClass);
+    const hasConditional = indices.some((i) => !!(segments[i].mediaQuery || segments[i].pseudoClass));
+    if (hasBase && hasConditional) {
+      mergeableProps.add(prop);
+    }
+  }
+  if (mergeableProps.size === 0) return segments;
+  const consumedProps = /* @__PURE__ */ new Map();
+  const mergedPropDefs = /* @__PURE__ */ new Map();
+  for (const prop of mergeableProps) {
+    const indices = propToIndices.get(prop);
+    let merged = {};
+    const keyParts = [];
+    for (const idx of indices) {
+      const seg = segments[idx];
+      const value = seg.defs[prop];
+      keyParts.push(seg.key);
+      if (typeof value === "string" || typeof value === "number") {
+        merged.default = value;
+      } else if (typeof value === "object" && value !== null) {
+        for (const [k, v] of Object.entries(value)) {
+          if (k === "default" && v === null && merged.default !== void 0) {
+            continue;
+          }
+          merged[k] = v;
+        }
+      }
+      if (!consumedProps.has(idx)) consumedProps.set(idx, /* @__PURE__ */ new Set());
+      consumedProps.get(idx).add(prop);
+    }
+    const finalValue = Object.keys(merged).length === 1 && "default" in merged ? merged.default : merged;
+    const mergedKey = [...new Set(keyParts)].join("_");
+    mergedPropDefs.set(prop, { defs: { [prop]: finalValue }, key: mergedKey });
+  }
+  const groupByIndices = /* @__PURE__ */ new Map();
+  for (const prop of mergeableProps) {
+    const indices = propToIndices.get(prop);
+    const groupKey = indices.join(",");
+    if (!groupByIndices.has(groupKey)) {
+      groupByIndices.set(groupKey, { props: [], key: mergedPropDefs.get(prop).key });
+    }
+    groupByIndices.get(groupKey).props.push(prop);
+  }
+  const mergedSegments = [];
+  for (const [, group] of groupByIndices) {
+    const defs = {};
+    for (const prop of group.props) {
+      Object.assign(defs, mergedPropDefs.get(prop).defs);
+    }
+    mergedSegments.push({ key: group.key, defs });
+  }
+  const result = [];
+  const mergedEmitted = /* @__PURE__ */ new Set();
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const consumed = consumedProps.get(i);
+    if (!consumed) {
+      result.push(seg);
+      continue;
+    }
+    const remainingDefs = {};
+    for (const [prop, value] of Object.entries(seg.defs)) {
+      if (!consumed.has(prop)) {
+        remainingDefs[prop] = value;
+      }
+    }
+    if (Object.keys(remainingDefs).length > 0) {
+      result.push({ ...seg, defs: remainingDefs });
+    }
+    const indices = [...propToIndices.entries()].filter(([prop]) => consumed.has(prop) && mergeableProps.has(prop)).map(([, idxs]) => idxs.join(","));
+    for (const groupKey of new Set(indices)) {
+      if (!mergedEmitted.has(groupKey)) {
+        const group = groupByIndices.get(groupKey);
+        if (group) {
+          const defs = {};
+          for (const prop of group.props) {
+            Object.assign(defs, mergedPropDefs.get(prop).defs);
+          }
+          result.push({ key: group.key, defs });
+          mergedEmitted.add(groupKey);
+        }
+      }
+    }
+  }
+  return result;
+}
+function pseudoName(pseudo, breakpoints) {
+  if (pseudo.startsWith("@media") && breakpoints) {
+    for (const [getterName, mediaQuery] of Object.entries(breakpoints)) {
+      if (mediaQuery === pseudo) {
+        return getterName.replace(/^if/, "").replace(/^./, (c) => c.toLowerCase());
+      }
+    }
+    return pseudo.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  }
+  if (pseudo.startsWith("@container")) {
+    return pseudo.replace(/^@container\s*/, "container ").replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  }
+  return pseudo.replace(/^:+/, "").replace(/-/g, "_");
+}
+function tryEvaluateLiteral(node, incremented, increment) {
+  if (node.type === "NumericLiteral") {
+    if (incremented) {
+      return `${node.value * increment}px`;
+    }
+    return String(node.value);
+  }
+  if (node.type === "StringLiteral") {
+    return node.value;
+  }
+  if (node.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "NumericLiteral") {
+    const val = -node.argument.value;
+    if (incremented) {
+      return `${val * increment}px`;
+    }
+    return String(val);
+  }
+  return null;
+}
+function tryEvaluatePxLiteral(node) {
+  if (node.type === "NumericLiteral") {
+    return `${node.value}px`;
+  }
+  return null;
+}
+function containerSelectorFromCall(node) {
+  if (node.args.length !== 1) {
+    throw new UnsupportedPatternError(`ifContainer() expects exactly 1 argument, got ${node.args.length}`);
+  }
+  const arg = node.args[0];
+  if (!arg || arg.type !== "ObjectExpression") {
+    throw new UnsupportedPatternError("ifContainer() expects an object literal argument");
+  }
+  let lt;
+  let gt;
+  let name;
+  for (const prop of arg.properties) {
+    if (prop.type === "SpreadElement") {
+      throw new UnsupportedPatternError("ifContainer() does not support spread properties");
+    }
+    if (prop.type !== "ObjectProperty" || prop.computed) {
+      throw new UnsupportedPatternError("ifContainer() expects plain object properties");
+    }
+    const key = objectPropertyName(prop.key);
+    if (!key) {
+      throw new UnsupportedPatternError("ifContainer() only supports identifier/string keys");
+    }
+    const valueNode = prop.value;
+    if (key === "lt") {
+      lt = numericLiteralValue(valueNode, "ifContainer().lt must be a numeric literal");
+      continue;
+    }
+    if (key === "gt") {
+      gt = numericLiteralValue(valueNode, "ifContainer().gt must be a numeric literal");
+      continue;
+    }
+    if (key === "name") {
+      name = stringLiteralValue(valueNode, "ifContainer().name must be a string literal");
+      continue;
+    }
+    throw new UnsupportedPatternError(`ifContainer() does not support property "${key}"`);
+  }
+  if (lt === void 0 && gt === void 0) {
+    throw new UnsupportedPatternError('ifContainer() requires at least one of "lt" or "gt"');
+  }
+  const parts = [];
+  if (gt !== void 0) {
+    parts.push(`(min-width: ${gt + 1}px)`);
+  }
+  if (lt !== void 0) {
+    parts.push(`(max-width: ${lt}px)`);
+  }
+  const query = parts.join(" and ");
+  const namePrefix = name ? `${name} ` : "";
+  return `@container ${namePrefix}${query}`;
+}
+function objectPropertyName(node) {
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "StringLiteral") return node.value;
+  return null;
+}
+function numericLiteralValue(node, errorMessage) {
+  if (node.type === "NumericLiteral") {
+    return node.value;
+  }
+  if (node.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "NumericLiteral") {
+    return -node.argument.value;
+  }
+  throw new UnsupportedPatternError(errorMessage);
+}
+function stringLiteralValue(node, errorMessage) {
+  if (node.type === "StringLiteral") {
+    return node.value;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis.length === 1) {
+    return node.quasis[0].value.cooked ?? "";
+  }
+  throw new UnsupportedPatternError(errorMessage);
+}
+var UnsupportedPatternError = class extends Error {
+  constructor(message) {
+    super(`[truss] Unsupported pattern: ${message}`);
+    this.name = "UnsupportedPatternError";
+  }
+};
+
+// src/plugin/ast-utils.ts
+import * as t from "@babel/types";
+function collectTopLevelBindings(ast) {
+  const used = /* @__PURE__ */ new Set();
+  for (const node of ast.program.body) {
+    if (t.isImportDeclaration(node)) {
+      for (const spec of node.specifiers) {
+        used.add(spec.local.name);
+      }
+      continue;
+    }
+    if (t.isVariableDeclaration(node)) {
+      for (const decl of node.declarations) {
+        collectPatternBindings(decl.id, used);
+      }
+      continue;
+    }
+    if (t.isFunctionDeclaration(node) && node.id) {
+      used.add(node.id.name);
+      continue;
+    }
+    if (t.isClassDeclaration(node) && node.id) {
+      used.add(node.id.name);
+      continue;
+    }
+    if (t.isExportNamedDeclaration(node) && node.declaration) {
+      const decl = node.declaration;
+      if (t.isVariableDeclaration(decl)) {
+        for (const varDecl of decl.declarations) {
+          collectPatternBindings(varDecl.id, used);
+        }
+      } else if ((t.isFunctionDeclaration(decl) || t.isClassDeclaration(decl)) && decl.id) {
+        used.add(decl.id.name);
+      }
+      continue;
+    }
+    if (t.isExportDefaultDeclaration(node)) {
+      const decl = node.declaration;
+      if ((t.isFunctionDeclaration(decl) || t.isClassDeclaration(decl)) && decl.id) {
+        used.add(decl.id.name);
+      }
+    }
+  }
+  return used;
+}
+function collectPatternBindings(pattern, used) {
+  if (t.isVoidPattern(pattern)) {
+    return;
+  }
+  if (t.isIdentifier(pattern)) {
+    used.add(pattern.name);
+    return;
+  }
+  if (t.isAssignmentPattern(pattern)) {
+    collectPatternBindings(pattern.left, used);
+    return;
+  }
+  if (t.isRestElement(pattern)) {
+    collectPatternBindings(pattern.argument, used);
+    return;
+  }
+  if (t.isObjectPattern(pattern)) {
+    for (const prop of pattern.properties) {
+      if (t.isObjectProperty(prop)) {
+        collectPatternBindings(prop.value, used);
+      } else if (t.isRestElement(prop)) {
+        collectPatternBindings(prop.argument, used);
+      }
+    }
+    return;
+  }
+  if (t.isArrayPattern(pattern)) {
+    for (const el of pattern.elements) {
+      if (!el) continue;
+      if (t.isIdentifier(el) || t.isAssignmentPattern(el) || t.isObjectPattern(el) || t.isArrayPattern(el)) {
+        collectPatternBindings(el, used);
+      } else if (t.isRestElement(el)) {
+        collectPatternBindings(el.argument, used);
+      }
+    }
+  }
+}
+function reservePreferredName(used, preferred, secondary) {
+  if (!used.has(preferred)) {
+    used.add(preferred);
+    return preferred;
+  }
+  if (secondary && !used.has(secondary)) {
+    used.add(secondary);
+    return secondary;
+  }
+  const base = secondary ?? preferred;
+  let i = 1;
+  let candidate = `${base}_${i}`;
+  while (used.has(candidate)) {
+    i++;
+    candidate = `${base}_${i}`;
+  }
+  used.add(candidate);
+  return candidate;
+}
+function findCssImportBinding(ast) {
+  for (const node of ast.program.body) {
+    if (!t.isImportDeclaration(node)) continue;
+    for (const spec of node.specifiers) {
+      if (t.isImportSpecifier(spec) && t.isIdentifier(spec.imported, { name: "Css" })) {
+        return spec.local.name;
+      }
+    }
+  }
+  return null;
+}
+function removeCssImport(ast, cssBinding) {
+  for (let i = 0; i < ast.program.body.length; i++) {
+    const node = ast.program.body[i];
+    if (!t.isImportDeclaration(node)) continue;
+    const cssSpecIndex = node.specifiers.findIndex((s) => t.isImportSpecifier(s) && s.local.name === cssBinding);
+    if (cssSpecIndex === -1) continue;
+    if (node.specifiers.length === 1) {
+      ast.program.body.splice(i, 1);
+    } else {
+      node.specifiers.splice(cssSpecIndex, 1);
+    }
+    return;
+  }
+}
+function findStylexNamespaceImport(ast) {
+  for (const node of ast.program.body) {
+    if (!t.isImportDeclaration(node)) continue;
+    if (node.source.value !== "@stylexjs/stylex") continue;
+    for (const spec of node.specifiers) {
+      if (t.isImportNamespaceSpecifier(spec)) {
+        return spec.local.name;
+      }
+    }
+  }
+  return null;
+}
+function findLastImportIndex(ast) {
+  let lastImportIndex = -1;
+  for (let i = 0; i < ast.program.body.length; i++) {
+    if (t.isImportDeclaration(ast.program.body[i])) {
+      lastImportIndex = i;
+    }
+  }
+  return lastImportIndex;
+}
+function insertStylexNamespaceImport(ast, localName) {
+  const stylexImport = t.importDeclaration(
+    [t.importNamespaceSpecifier(t.identifier(localName))],
+    t.stringLiteral("@stylexjs/stylex")
+  );
+  const idx = findLastImportIndex(ast);
+  ast.program.body.splice(idx + 1, 0, stylexImport);
+}
+function extractChain(node, cssBinding) {
+  const chain = [];
+  let current = node;
+  while (true) {
+    if (t.isIdentifier(current, { name: cssBinding })) {
+      chain.reverse();
+      return chain;
+    }
+    if (t.isMemberExpression(current) && !current.computed && t.isIdentifier(current.property)) {
+      const name = current.property.name;
+      if (name === "else") {
+        chain.push({ type: "else" });
+      } else {
+        chain.push({ type: "getter", name });
+      }
+      current = current.object;
+      continue;
+    }
+    if (t.isCallExpression(current) && t.isMemberExpression(current.callee) && !current.callee.computed && t.isIdentifier(current.callee.property)) {
+      const name = current.callee.property.name;
+      if (name === "if") {
+        chain.push({
+          type: "if",
+          conditionNode: current.arguments[0]
+        });
+        current = current.callee.object;
+        continue;
+      }
+      chain.push({
+        type: "call",
+        name,
+        args: current.arguments
+      });
+      current = current.callee.object;
+      continue;
+    }
+    return null;
+  }
+}
+
+// src/plugin/emit-stylex.ts
+import * as t2 from "@babel/types";
+function collectCreateData(chains) {
+  const createEntries = /* @__PURE__ */ new Map();
+  let needsMaybeInc = false;
+  for (const chain of chains) {
+    for (const part of chain.parts) {
+      const segs = part.type === "unconditional" ? part.segments : [...part.thenSegments, ...part.elseSegments];
+      for (const seg of segs) {
+        if (seg.error) continue;
+        if (seg.dynamicProps) {
+          if (!createEntries.has(seg.key)) {
+            createEntries.set(seg.key, {
+              key: seg.key,
+              dynamic: {
+                props: seg.dynamicProps,
+                extraDefs: seg.dynamicExtraDefs,
+                mediaQuery: seg.mediaQuery,
+                pseudoClass: seg.pseudoClass,
+                pseudoElement: seg.pseudoElement
+              }
+            });
+          }
+        } else {
+          if (!createEntries.has(seg.key)) {
+            createEntries.set(seg.key, {
+              key: seg.key,
+              defs: seg.defs,
+              whenPseudo: seg.whenPseudo
+            });
+          }
+        }
+        if (seg.incremented && seg.dynamicProps) {
+          needsMaybeInc = true;
+        }
+      }
+    }
+  }
+  return { createEntries, needsMaybeInc };
+}
+function buildCreateProperties(createEntries, stylexNamespaceName) {
+  const createProperties = [];
+  for (const [, entry] of createEntries) {
+    if (entry.dynamic) {
+      const paramId = t2.identifier("v");
+      const bodyProps = [];
+      const { mediaQuery, pseudoClass } = entry.dynamic;
+      for (const prop of entry.dynamic.props) {
+        if (pseudoClass && mediaQuery) {
+          bodyProps.push(
+            t2.objectProperty(
+              toPropertyKey(prop),
+              t2.objectExpression([
+                t2.objectProperty(t2.identifier("default"), t2.nullLiteral()),
+                t2.objectProperty(
+                  t2.stringLiteral(pseudoClass),
+                  t2.objectExpression([
+                    t2.objectProperty(t2.identifier("default"), t2.nullLiteral()),
+                    t2.objectProperty(t2.stringLiteral(mediaQuery), paramId)
+                  ])
+                )
+              ])
+            )
+          );
+        } else if (pseudoClass || mediaQuery) {
+          const condition = pseudoClass || mediaQuery;
+          bodyProps.push(
+            t2.objectProperty(
+              toPropertyKey(prop),
+              t2.objectExpression([
+                t2.objectProperty(t2.identifier("default"), t2.nullLiteral()),
+                t2.objectProperty(t2.stringLiteral(condition), paramId)
+              ])
+            )
+          );
+        } else {
+          bodyProps.push(t2.objectProperty(toPropertyKey(prop), paramId));
+        }
+      }
+      if (entry.dynamic.extraDefs) {
+        for (const [prop, value] of Object.entries(entry.dynamic.extraDefs)) {
+          if (pseudoClass && mediaQuery) {
+            bodyProps.push(
+              t2.objectProperty(
+                toPropertyKey(prop),
+                t2.objectExpression([
+                  t2.objectProperty(t2.identifier("default"), t2.nullLiteral()),
+                  t2.objectProperty(
+                    t2.stringLiteral(pseudoClass),
+                    t2.objectExpression([
+                      t2.objectProperty(t2.identifier("default"), t2.nullLiteral()),
+                      t2.objectProperty(t2.stringLiteral(mediaQuery), valueToAst(value))
+                    ])
+                  )
+                ])
+              )
+            );
+          } else if (pseudoClass || mediaQuery) {
+            const condition = pseudoClass || mediaQuery;
+            bodyProps.push(
+              t2.objectProperty(
+                toPropertyKey(prop),
+                t2.objectExpression([
+                  t2.objectProperty(t2.identifier("default"), t2.nullLiteral()),
+                  t2.objectProperty(t2.stringLiteral(condition), valueToAst(value))
+                ])
+              )
+            );
+          } else {
+            bodyProps.push(t2.objectProperty(toPropertyKey(prop), valueToAst(value)));
+          }
+        }
+      }
+      let bodyExpr = t2.objectExpression(bodyProps);
+      if (entry.dynamic.pseudoElement) {
+        bodyExpr = t2.objectExpression([t2.objectProperty(t2.stringLiteral(entry.dynamic.pseudoElement), bodyExpr)]);
+      }
+      const arrowFn = t2.arrowFunctionExpression([paramId], bodyExpr);
+      createProperties.push(t2.objectProperty(toPropertyKey(entry.key), arrowFn));
+      continue;
+    }
+    if (entry.whenPseudo && entry.defs) {
+      const ap = entry.whenPseudo;
+      const props = [];
+      for (const [prop, value] of Object.entries(entry.defs)) {
+        const whenCallArgs = [t2.stringLiteral(ap.pseudo)];
+        if (ap.markerNode) {
+          whenCallArgs.push(ap.markerNode);
+        }
+        const relationship = ap.relationship ?? "ancestor";
+        const whenCall = t2.callExpression(
+          t2.memberExpression(
+            t2.memberExpression(t2.identifier(stylexNamespaceName), t2.identifier("when")),
+            t2.identifier(relationship)
+          ),
+          whenCallArgs
+        );
+        props.push(
+          t2.objectProperty(
+            toPropertyKey(prop),
+            t2.objectExpression([
+              t2.objectProperty(t2.identifier("default"), t2.nullLiteral()),
+              t2.objectProperty(whenCall, valueToAst(value), true)
+            ])
+          )
+        );
+      }
+      createProperties.push(t2.objectProperty(toPropertyKey(entry.key), t2.objectExpression(props)));
+      continue;
+    }
+    if (entry.defs) {
+      createProperties.push(t2.objectProperty(toPropertyKey(entry.key), defsToAst(entry.defs)));
+    }
+  }
+  return createProperties;
+}
+function buildMaybeIncDeclaration(helperName, increment) {
+  const incParam = t2.identifier("inc");
+  const body = t2.blockStatement([
+    t2.returnStatement(
+      t2.conditionalExpression(
+        t2.binaryExpression("===", t2.unaryExpression("typeof", incParam), t2.stringLiteral("string")),
+        incParam,
+        t2.templateLiteral(
+          [t2.templateElement({ raw: "", cooked: "" }, false), t2.templateElement({ raw: "px", cooked: "px" }, true)],
+          [t2.binaryExpression("*", incParam, t2.numericLiteral(increment))]
+        )
+      )
+    )
+  ]);
+  return t2.variableDeclaration("const", [
+    t2.variableDeclarator(t2.identifier(helperName), t2.arrowFunctionExpression([incParam], body))
+  ]);
+}
+function buildCreateDeclaration(createVarName, stylexNamespaceName, createProperties) {
+  const createCall = t2.callExpression(t2.memberExpression(t2.identifier(stylexNamespaceName), t2.identifier("create")), [
+    t2.objectExpression(createProperties)
+  ]);
+  return t2.variableDeclaration("const", [t2.variableDeclarator(t2.identifier(createVarName), createCall)]);
+}
+function defsToAst(defs) {
+  const properties = [];
+  for (const [key, value] of Object.entries(defs)) {
+    const keyNode = toPropertyKey(key);
+    if (value === null) {
+      properties.push(t2.objectProperty(keyNode, t2.nullLiteral()));
+    } else if (typeof value === "string") {
+      properties.push(t2.objectProperty(keyNode, t2.stringLiteral(value)));
+    } else if (typeof value === "number") {
+      properties.push(t2.objectProperty(keyNode, t2.numericLiteral(value)));
+    } else if (typeof value === "object") {
+      properties.push(t2.objectProperty(keyNode, defsToAst(value)));
+    }
+  }
+  return t2.objectExpression(properties);
+}
+function valueToAst(value) {
+  if (value === null) return t2.nullLiteral();
+  if (typeof value === "string") return t2.stringLiteral(value);
+  if (typeof value === "number") return t2.numericLiteral(value);
+  if (typeof value === "object") return defsToAst(value);
+  return t2.stringLiteral(String(value));
+}
+function toPropertyKey(key) {
+  return isValidIdentifier(key) ? t2.identifier(key) : t2.stringLiteral(key);
+}
+function isValidIdentifier(s) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(s);
+}
+
+// src/plugin/rewrite-sites.ts
+import _traverse from "@babel/traverse";
+import * as t3 from "@babel/types";
+var traverse = _traverse.default ?? _traverse;
+function rewriteExpressionSites(options) {
+  for (const site of options.sites) {
+    const propsArgs = buildPropsArgsFromChain(site.resolvedChain, options);
+    const cssAttrPath = getCssAttributePath(site.path);
+    if (cssAttrPath) {
+      const propsCall = t3.callExpression(
+        t3.memberExpression(t3.identifier(options.stylexNamespaceName), t3.identifier("props")),
+        propsArgs
+      );
+      const openingElement = cssAttrPath.parentPath;
+      let existingClassNameExpr = null;
+      if (openingElement && openingElement.isJSXOpeningElement()) {
+        const attrs = openingElement.node.attributes;
+        for (let i = 0; i < attrs.length; i++) {
+          const attr = attrs[i];
+          if (t3.isJSXAttribute(attr) && t3.isJSXIdentifier(attr.name, { name: "className" })) {
+            if (t3.isStringLiteral(attr.value)) {
+              existingClassNameExpr = attr.value;
+            } else if (t3.isJSXExpressionContainer(attr.value) && t3.isExpression(attr.value.expression)) {
+              existingClassNameExpr = attr.value.expression;
+            }
+            attrs.splice(i, 1);
+            break;
+          }
+        }
+      }
+      let spreadExpr;
+      if (existingClassNameExpr) {
+        const rId = t3.identifier("__r");
+        const mergedClassName = t3.callExpression(
+          t3.memberExpression(
+            t3.binaryExpression(
+              "+",
+              t3.binaryExpression("+", existingClassNameExpr, t3.stringLiteral(" ")),
+              t3.logicalExpression("||", t3.memberExpression(rId, t3.identifier("className")), t3.stringLiteral(""))
+            ),
+            t3.identifier("trim")
+          ),
+          []
+        );
+        spreadExpr = t3.callExpression(
+          t3.arrowFunctionExpression(
+            [rId],
+            t3.objectExpression([t3.spreadElement(rId), t3.objectProperty(t3.identifier("className"), mergedClassName)])
+          ),
+          [propsCall]
+        );
+      } else {
+        spreadExpr = propsCall;
+      }
+      cssAttrPath.replaceWith(t3.jsxSpreadAttribute(spreadExpr));
+      continue;
+    }
+    site.path.replaceWith(t3.arrayExpression(propsArgs));
+  }
+  rewriteCssArrayExpressions(options.ast, options.stylexNamespaceName);
+}
+function getCssAttributePath(path) {
+  const parentPath = path.parentPath;
+  if (!parentPath || !parentPath.isJSXExpressionContainer()) return null;
+  const attrPath = parentPath.parentPath;
+  if (!attrPath || !attrPath.isJSXAttribute()) return null;
+  if (!t3.isJSXIdentifier(attrPath.node.name, { name: "css" })) return null;
+  return attrPath;
+}
+function buildPropsArgsFromChain(chain, options) {
+  const args = [];
+  for (const marker of chain.markers) {
+    if (marker.markerNode) {
+      args.push(marker.markerNode);
+    } else {
+      args.push(
+        t3.callExpression(
+          t3.memberExpression(t3.identifier(options.stylexNamespaceName), t3.identifier("defaultMarker")),
+          []
+        )
+      );
+    }
+  }
+  for (const part of chain.parts) {
+    if (part.type === "unconditional") {
+      args.push(...buildPropsArgs(part.segments, options));
+      continue;
+    }
+    const thenArgs = buildPropsArgs(part.thenSegments, options);
+    const elseArgs = buildPropsArgs(part.elseSegments, options);
+    if (thenArgs.length === 1 && elseArgs.length === 1) {
+      args.push(t3.conditionalExpression(part.conditionNode, thenArgs[0], elseArgs[0]));
+    } else if (thenArgs.length > 0 || elseArgs.length > 0) {
+      args.push(
+        t3.spreadElement(
+          t3.conditionalExpression(part.conditionNode, t3.arrayExpression(thenArgs), t3.arrayExpression(elseArgs))
+        )
+      );
+    }
+  }
+  return args;
+}
+function buildPropsArgs(segments, options) {
+  const args = [];
+  for (const seg of segments) {
+    if (seg.error) continue;
+    const ref = t3.memberExpression(t3.identifier(options.createVarName), t3.identifier(seg.key));
+    if (seg.dynamicProps && seg.argNode) {
+      let argExpr;
+      if (seg.incremented && options.maybeIncHelperName) {
+        argExpr = t3.callExpression(t3.identifier(options.maybeIncHelperName), [seg.argNode]);
+      } else if (seg.incremented) {
+        argExpr = seg.argNode;
+      } else {
+        argExpr = t3.callExpression(t3.identifier("String"), [seg.argNode]);
+      }
+      args.push(t3.callExpression(ref, [argExpr]));
+    } else {
+      args.push(ref);
+    }
+  }
+  return args;
+}
+function rewriteCssArrayExpressions(ast, stylexNamespaceName) {
+  traverse(ast, {
+    JSXAttribute(path) {
+      if (!t3.isJSXIdentifier(path.node.name, { name: "css" })) return;
+      const value = path.node.value;
+      if (!t3.isJSXExpressionContainer(value)) return;
+      const expr = value.expression;
+      if (!t3.isArrayExpression(expr)) return;
+      const propsArgs = [];
+      for (const el of expr.elements) {
+        if (t3.isSpreadElement(el)) {
+          const arg = el.argument;
+          if (t3.isArrayExpression(arg)) {
+            for (const inner of arg.elements) {
+              if (!inner) continue;
+              if (t3.isSpreadElement(inner)) {
+                propsArgs.push(t3.spreadElement(inner.argument));
+              } else {
+                propsArgs.push(inner);
+              }
+            }
+          } else {
+            propsArgs.push(t3.spreadElement(arg));
+          }
+        } else if (el) {
+          propsArgs.push(el);
+        }
+      }
+      const propsCall = t3.callExpression(
+        t3.memberExpression(t3.identifier(stylexNamespaceName), t3.identifier("props")),
+        propsArgs
+      );
+      path.replaceWith(t3.jsxSpreadAttribute(propsCall));
+    }
+  });
+}
+
+// src/plugin/transform.ts
+var traverse2 = _traverse2.default ?? _traverse2;
+var generate = _generate.default ?? _generate;
+function transformTruss(code, filename, mapping) {
+  if (!code.includes("Css")) return null;
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"],
+    sourceFilename: filename
+  });
+  const cssBindingName = findCssImportBinding(ast);
+  if (!cssBindingName) return null;
+  const sites = [];
+  const errorMessages = [];
+  traverse2(ast, {
+    MemberExpression(path) {
+      if (!t4.isIdentifier(path.node.property, { name: "$" })) return;
+      if (path.node.computed) return;
+      const chain = extractChain(path.node.object, cssBindingName);
+      if (!chain) return;
+      const parentPath = path.parentPath;
+      if (parentPath && parentPath.isMemberExpression() && t4.isIdentifier(parentPath.node.property, { name: "$" })) {
+        return;
+      }
+      const resolvedChain = resolveFullChain(chain, mapping);
+      sites.push({ path, resolvedChain });
+      const line = path.node.loc?.start.line ?? null;
+      for (const err of resolvedChain.errors) {
+        errorMessages.push({ message: err, line });
+      }
+    }
+  });
+  if (sites.length === 0) return null;
+  const { createEntries, needsMaybeInc } = collectCreateData(sites.map((s) => s.resolvedChain));
+  const usedTopLevelNames = collectTopLevelBindings(ast);
+  const existingStylexNamespace = findStylexNamespaceImport(ast);
+  const stylexNamespaceName = existingStylexNamespace ?? reservePreferredName(usedTopLevelNames, "stylex");
+  const createVarName = reservePreferredName(usedTopLevelNames, "css", "css_");
+  const maybeIncHelperName = needsMaybeInc ? reservePreferredName(usedTopLevelNames, "__maybeInc") : null;
+  const createProperties = buildCreateProperties(createEntries, stylexNamespaceName);
+  rewriteExpressionSites({
+    ast,
+    sites,
+    createVarName,
+    stylexNamespaceName,
+    maybeIncHelperName
+  });
+  removeCssImport(ast, cssBindingName);
+  if (!findStylexNamespaceImport(ast)) {
+    insertStylexNamespaceImport(ast, stylexNamespaceName);
+  }
+  const markerVarNames = collectReferencedMarkerNames(createEntries);
+  const hoistedMarkerDecls = hoistMarkerDeclarations(ast, markerVarNames);
+  const declarationsToInsert = [];
+  if (maybeIncHelperName) {
+    declarationsToInsert.push(buildMaybeIncDeclaration(maybeIncHelperName, mapping.increment));
+  }
+  declarationsToInsert.push(...hoistedMarkerDecls);
+  if (createProperties.length > 0) {
+    declarationsToInsert.push(buildCreateDeclaration(createVarName, stylexNamespaceName, createProperties));
+  }
+  for (const { message, line } of errorMessages) {
+    const location = line !== null ? `${filename}:${line}` : filename;
+    const logMessage = `${message} (${location})`;
+    const consoleError = t4.expressionStatement(
+      t4.callExpression(t4.memberExpression(t4.identifier("console"), t4.identifier("error")), [
+        t4.stringLiteral(logMessage)
+      ])
+    );
+    declarationsToInsert.push(consoleError);
+  }
+  if (declarationsToInsert.length > 0) {
+    const insertIndex = findLastImportIndex(ast) + 1;
+    ast.program.body.splice(insertIndex, 0, ...declarationsToInsert);
+  }
+  const output = generate(ast, {
+    sourceFileName: filename,
+    retainLines: false
+  });
+  return { code: output.code, map: output.map };
+}
+function collectReferencedMarkerNames(createEntries) {
+  const names = /* @__PURE__ */ new Set();
+  for (const [, entry] of createEntries) {
+    if (entry.whenPseudo?.markerNode && entry.whenPseudo.markerNode.type === "Identifier") {
+      names.add(entry.whenPseudo.markerNode.name);
+    }
+  }
+  return names;
+}
+function hoistMarkerDeclarations(ast, names) {
+  if (names.size === 0) return [];
+  const hoisted = [];
+  const remaining = new Set(names);
+  for (let i = ast.program.body.length - 1; i >= 0; i--) {
+    if (remaining.size === 0) break;
+    const node = ast.program.body[i];
+    if (!t4.isVariableDeclaration(node)) continue;
+    const matchingDeclarators = [];
+    const otherDeclarators = [];
+    for (const decl of node.declarations) {
+      if (t4.isIdentifier(decl.id) && remaining.has(decl.id.name)) {
+        matchingDeclarators.push(decl);
+        remaining.delete(decl.id.name);
+      } else {
+        otherDeclarators.push(decl);
+      }
+    }
+    if (matchingDeclarators.length === 0) continue;
+    if (otherDeclarators.length === 0) {
+      ast.program.body.splice(i, 1);
+      hoisted.push(node);
+    } else {
+      node.declarations = otherDeclarators;
+      hoisted.push(t4.variableDeclaration(node.kind, matchingDeclarators));
+    }
+  }
+  hoisted.reverse();
+  return hoisted;
+}
+
+// src/plugin/transform-css.ts
+import { parse as parse2 } from "@babel/parser";
+import * as t5 from "@babel/types";
+function transformCssTs(code, filename, mapping) {
+  const ast = parse2(code, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"],
+    sourceFilename: filename
+  });
+  const cssBindingName = findCssImportBinding(ast);
+  if (!cssBindingName) {
+    return `/* [truss] ${filename}: no Css import found */
+`;
+  }
+  const defaultExport = findDefaultExportObject(ast);
+  if (!defaultExport) {
+    return `/* [truss] ${filename}: expected \`export default { ... }\` with an object literal */
+`;
+  }
+  const rules = [];
+  for (const prop of defaultExport.properties) {
+    if (t5.isSpreadElement(prop)) {
+      rules.push(`/* [truss] unsupported: spread elements in css.ts export */`);
+      continue;
+    }
+    if (!t5.isObjectProperty(prop)) {
+      rules.push(`/* [truss] unsupported: non-property in css.ts export */`);
+      continue;
+    }
+    const selector = objectPropertyStringKey(prop);
+    if (selector === null) {
+      rules.push(`/* [truss] unsupported: non-string-literal key in css.ts export */`);
+      continue;
+    }
+    const valueNode = prop.value;
+    if (!t5.isExpression(valueNode)) {
+      rules.push(`/* [truss] unsupported: "${selector}" value is not an expression */`);
+      continue;
+    }
+    const cssResult = resolveCssExpression(valueNode, cssBindingName, mapping, filename);
+    if ("error" in cssResult) {
+      rules.push(`/* [truss] unsupported: "${selector}" \u2014 ${cssResult.error} */`);
+      continue;
+    }
+    rules.push(formatCssRule(selector, cssResult.declarations));
+  }
+  return rules.join("\n\n") + "\n";
+}
+function findDefaultExportObject(ast) {
+  for (const node of ast.program.body) {
+    if (!t5.isExportDefaultDeclaration(node)) continue;
+    const decl = node.declaration;
+    if (t5.isObjectExpression(decl)) return decl;
+    if (t5.isTSAsExpression(decl) && t5.isObjectExpression(decl.expression)) return decl.expression;
+    if (t5.isTSSatisfiesExpression(decl) && t5.isObjectExpression(decl.expression)) return decl.expression;
+  }
+  return null;
+}
+function objectPropertyStringKey(prop) {
+  if (t5.isStringLiteral(prop.key)) return prop.key.value;
+  if (t5.isIdentifier(prop.key) && !prop.computed) return prop.key.name;
+  return null;
+}
+function resolveCssExpression(node, cssBindingName, mapping, filename) {
+  if (!t5.isMemberExpression(node) || node.computed || !t5.isIdentifier(node.property, { name: "$" })) {
+    return { error: "value must be a Css.*.$  expression" };
+  }
+  const chain = extractChain(node.object, cssBindingName);
+  if (!chain) {
+    return { error: "could not extract Css chain from expression" };
+  }
+  for (const n of chain) {
+    if (n.type === "if") return { error: "if() conditionals are not supported in .css.ts files" };
+    if (n.type === "else") return { error: "else is not supported in .css.ts files" };
+  }
+  const resolved = resolveFullChain(chain, mapping);
+  if (resolved.errors.length > 0) {
+    return { error: resolved.errors[0] };
+  }
+  for (const part of resolved.parts) {
+    if (part.type === "conditional") {
+      return { error: "conditional chains are not supported in .css.ts files" };
+    }
+  }
+  const declarations = [];
+  for (const part of resolved.parts) {
+    if (part.type !== "unconditional") continue;
+    for (const seg of part.segments) {
+      if (seg.error) {
+        return { error: seg.error };
+      }
+      if (seg.dynamicProps && !seg.argResolved) {
+        return { error: `dynamic value with variable argument is not supported in .css.ts files` };
+      }
+      if (seg.mediaQuery) {
+        return { error: `media query modifiers (ifSm, ifMd, etc.) are not supported in .css.ts files` };
+      }
+      if (seg.pseudoClass) {
+        return { error: `pseudo-class modifiers (onHover, onFocus, etc.) are not supported in .css.ts files` };
+      }
+      if (seg.pseudoElement) {
+        return { error: `pseudo-element modifiers are not supported in .css.ts files` };
+      }
+      if (seg.whenPseudo) {
+        return { error: `when() modifiers are not supported in .css.ts files` };
+      }
+      for (const [prop, value] of Object.entries(seg.defs)) {
+        if (typeof value === "string" || typeof value === "number") {
+          declarations.push({ property: camelToKebab(prop), value: String(value) });
+        } else {
+          return { error: `unexpected nested value for property "${prop}"` };
+        }
+      }
+    }
+  }
+  return { declarations };
+}
+function camelToKebab(s) {
+  return s.replace(/^(Webkit|Moz|Ms|O)/, (m) => `-${m.toLowerCase()}`).replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+function formatCssRule(selector, declarations) {
+  if (declarations.length === 0) {
+    return `${selector} {}`;
+  }
+  const body = declarations.map((d) => `  ${d.property}: ${d.value};`).join("\n");
+  return `${selector} {
+${body}
+}`;
+}
+
+// src/plugin/index.ts
+var VIRTUAL_CSS_PREFIX = "\0truss-css:";
+function trussPlugin(opts) {
+  let mapping = null;
+  let projectRoot;
+  const externalPackages = opts.externalPackages ?? [];
+  function mappingPath() {
+    return resolve(projectRoot || process.cwd(), opts.mapping);
+  }
+  function ensureMapping() {
+    if (!mapping) {
+      mapping = loadMapping(mappingPath());
+    }
+    return mapping;
+  }
+  return {
+    name: "truss-stylex",
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = config.root;
+    },
+    buildStart() {
+      ensureMapping();
+    },
+    resolveId(source, importer) {
+      if (!source.endsWith(".css.ts")) return null;
+      let absolutePath;
+      if (isAbsolute(source)) {
+        absolutePath = source;
+      } else if (importer) {
+        absolutePath = resolve(dirname(importer), source);
+      } else {
+        absolutePath = resolve(projectRoot || process.cwd(), source);
+      }
+      if (!existsSync(absolutePath)) return null;
+      return VIRTUAL_CSS_PREFIX + absolutePath.slice(0, -3);
+    },
+    load(id) {
+      if (!id.startsWith(VIRTUAL_CSS_PREFIX)) return null;
+      const sourcePath = id.slice(VIRTUAL_CSS_PREFIX.length) + ".ts";
+      const sourceCode = readFileSync(sourcePath, "utf8");
+      return transformCssTs(sourceCode, sourcePath, ensureMapping());
+    },
+    transform(code, id) {
+      if (!/\.[cm]?[jt]sx?(\?|$)/.test(id)) return null;
+      if (!code.includes("Css")) return null;
+      const fileId = stripQueryAndHash(id);
+      if (isNodeModulesFile(fileId) && !isWhitelistedExternalPackageFile(fileId, externalPackages)) {
+        return null;
+      }
+      const result = transformTruss(code, id, ensureMapping());
+      if (!result) return null;
+      return { code: result.code, map: result.map };
+    }
+  };
+}
+function stripQueryAndHash(id) {
+  const queryIndex = id.indexOf("?");
+  const hashIndex = id.indexOf("#");
+  let end = id.length;
+  if (queryIndex >= 0) end = Math.min(end, queryIndex);
+  if (hashIndex >= 0) end = Math.min(end, hashIndex);
+  const cleanId = id.slice(0, end);
+  if (cleanId.startsWith("/@fs/")) {
+    return cleanId.slice(4);
+  }
+  return cleanId;
+}
+function isNodeModulesFile(filePath) {
+  return normalizePath(filePath).includes("/node_modules/");
+}
+function isWhitelistedExternalPackageFile(filePath, externalPackages) {
+  const normalizedPath = normalizePath(filePath);
+  return externalPackages.some(function(pkg) {
+    return normalizedPath.includes(`/node_modules/${pkg}/`);
+  });
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function loadMapping(path) {
+  const raw = readFileSync(path, "utf8");
+  return JSON.parse(raw);
+}
+export {
+  loadMapping,
+  trussPlugin
+};
+//# sourceMappingURL=index.js.map