praxis-kit 3.1.1 → 4.0.0

package/dist/vite-plugin/index.js

@@ -1,13 +1,185 @@
-// ../vite-plugin/src/ast.ts
+// ../../plugins/vite/src/ast.ts
 import ts from "typescript";
+
+// ../../lib/primitive/src/utils/iterate.ts
+function find(iterable, callback) {
+  for (const value of iterable) {
+    const result = callback(value);
+    if (result != null) {
+      return result;
+    }
+  }
+  return null;
+}
+function some(iterable, predicate) {
+  for (const value of iterable) {
+    if (predicate(value)) return true;
+  }
+  return false;
+}
+function every(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (!predicate(value, index++)) {
+      return false;
+    }
+  }
+  return true;
+}
+function* filter(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (predicate(value, index++)) {
+      yield value;
+    }
+  }
+}
+function* map(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    yield callback(value, index++);
+  }
+}
+function forEach(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    callback(value, index++);
+  }
+}
+function reduce(iterable, initial, callback) {
+  let accumulator = initial;
+  let index = 0;
+  for (const value of iterable) {
+    accumulator = callback(accumulator, value, index++);
+  }
+  return accumulator;
+}
+function collect(iterable, callback) {
+  const result = {};
+  let index = 0;
+  for (const value of iterable) {
+    const entry = callback(value, index++);
+    if (entry === null) {
+      return null;
+    }
+    result[entry[0]] = entry[1];
+  }
+  return result;
+}
+function findLast(value, callback) {
+  for (let index = value.length - 1; index >= 0; index--) {
+    const result = callback(value[index], index);
+    if (result != null) {
+      return result;
+    }
+  }
+  return null;
+}
+function* items(collection) {
+  for (let i = 0; i < collection.length; i++) {
+    const item = collection.item(i);
+    if (item !== null) {
+      yield item;
+    }
+  }
+}
+function nodeList(list) {
+  return {
+    *[Symbol.iterator]() {
+      for (let i = 0; i < list.length; i++) {
+        const node = list.item(i);
+        if (node !== null) {
+          yield node;
+        }
+      }
+    }
+  };
+}
+function mapEntries(m) {
+  return m.entries();
+}
+function set(s) {
+  return s.values();
+}
+function hasOwn(object, key) {
+  return Object.hasOwn(object, key);
+}
+function* entries(object) {
+  for (const key in object) {
+    if (!hasOwn(object, key)) continue;
+    yield [key, object[key]];
+  }
+}
+function* keys(object) {
+  for (const [key] of entries(object)) {
+    yield key;
+  }
+}
+function* values(object) {
+  for (const [, value] of entries(object)) {
+    yield value;
+  }
+}
+function mapValues(object, callback) {
+  const result = {};
+  for (const [key, value] of entries(object)) {
+    result[key] = callback(value, key);
+  }
+  return result;
+}
+function forEachEntry(object, callback) {
+  for (const [key, value] of entries(object)) {
+    callback(key, value);
+  }
+}
+function forEachKey(object, callback) {
+  for (const key of keys(object)) {
+    callback(key);
+  }
+}
+function forEachValue(object, callback) {
+  for (const value of values(object)) {
+    callback(value);
+  }
+}
+function forEachSet(s, callback) {
+  for (const value of s) {
+    callback(value);
+  }
+}
+var iterate = Object.freeze({
+  entries,
+  filter,
+  find,
+  findLast,
+  forEach,
+  forEachEntry,
+  forEachKey,
+  forEachSet,
+  forEachValue,
+  items,
+  keys,
+  map,
+  mapEntries,
+  mapValues,
+  nodeList,
+  reduce,
+  collect,
+  set,
+  some,
+  every,
+  values
+});
+
+// ../../plugins/vite/src/ast.ts
 function getProperty(obj, key) {
-  for (const prop of obj.properties) {
-    if (!ts.isPropertyAssignment(prop)) continue;
-    const name = prop.name;
+  return iterate.find(obj.properties, (prop) => {
+    if (!ts.isPropertyAssignment(prop)) return null;
+    const { name } = prop;
     if ((ts.isIdentifier(name) || ts.isStringLiteral(name)) && name.text === key)
       return prop.initializer;
-  }
-  return void 0;
+    return null;
+  }) ?? void 0;
 }
 function asObject(node) {
   if (!node) return void 0;
@@ -35,15 +207,26 @@ function firstObjectArg(call) {
   const [first] = call.arguments;
   return first && ts.isObjectLiteralExpression(first) ? first : void 0;
 }
-function walk(node, visitor) {
-  visitor(node);
-  ts.forEachChild(node, (child) => walk(child, visitor));
+function* walk(node) {
+  yield node;
+  const children = [];
+  ts.forEachChild(node, (child) => {
+    children.push(child);
+  });
+  for (const child of children) {
+    yield* walk(child);
+  }
+}
+function walkEach(node, visitor) {
+  for (const child of walk(node)) {
+    visitor(child);
+  }
 }
 function parseSource(filename, code) {
   return ts.createSourceFile(filename, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
 }
 
-// ../vite-plugin/src/class-extract.ts
+// ../../plugins/vite/src/class-extract.ts
 import ts2 from "typescript";
 var MAX_COMBINATIONS = 512;
 function asString(node) {
@@ -53,12 +236,14 @@ function asStringOrStringArray(node) {
   if (!node) return void 0;
   if (ts2.isStringLiteral(node)) return node.text;
   if (ts2.isArrayLiteralExpression(node)) {
-    const items = [];
-    for (const elem of node.elements) {
-      if (!ts2.isStringLiteral(elem)) return void 0;
-      items.push(elem.text);
-    }
-    return items;
+    const items2 = [];
+    const allStrings = iterate.every(node.elements, (elem) => {
+      if (!ts2.isStringLiteral(elem)) return false;
+      items2.push(elem.text);
+      return true;
+    });
+    if (!allStrings) return void 0;
+    return items2;
   }
   return void 0;
 }
@@ -70,67 +255,67 @@ function propKey(prop) {
 function extractVariantMap(stylingObj) {
   const variantsObj = asObject(getProperty(stylingObj, "variants"));
   if (!variantsObj) return null;
-  const result = {};
-  for (const prop of variantsObj.properties) {
+  return iterate.collect(variantsObj.properties, (prop) => {
     const key = propKey(prop);
     if (!key || !ts2.isPropertyAssignment(prop)) return null;
     const valuesObj = asObject(prop.initializer);
     if (!valuesObj) return null;
-    const values = {};
-    for (const vp of valuesObj.properties) {
+    const values2 = iterate.collect(valuesObj.properties, (vp) => {
       const vk = propKey(vp);
       if (!vk || !ts2.isPropertyAssignment(vp)) return null;
-      const v = asStringOrStringArray(vp.initializer);
-      if (v === void 0) return null;
-      values[vk] = v;
-    }
-    result[key] = values;
-  }
-  return result;
+      const value = asStringOrStringArray(vp.initializer);
+      if (value === void 0) return null;
+      return [vk, value];
+    });
+    if (!values2) return null;
+    return [key, values2];
+  });
 }
 function extractDefaults(stylingObj) {
   const defaultsObj = asObject(getProperty(stylingObj, "defaults"));
   if (!defaultsObj) return {};
-  const result = {};
-  for (const prop of defaultsObj.properties) {
+  return iterate.collect(defaultsObj.properties, (prop) => {
     const key = propKey(prop);
-    if (!key || !ts2.isPropertyAssignment(prop)) return {};
-    const v = asString(prop.initializer);
-    if (v === void 0) return {};
-    result[key] = v;
-  }
-  return result;
+    if (!key || !ts2.isPropertyAssignment(prop)) return null;
+    const value = asString(prop.initializer);
+    if (value === void 0) return null;
+    return [key, value];
+  }) ?? {};
 }
 function extractCompounds(stylingObj) {
   const compoundsArr = asArray(getProperty(stylingObj, "compounds"));
   if (!compoundsArr) return [];
   const result = [];
-  for (const elem of compoundsArr.elements) {
+  const resultReturned = iterate.every(compoundsArr.elements, (elem) => {
     const obj = asObject(elem);
-    if (!obj) return null;
+    if (!obj) return false;
     const cls = asStringOrStringArray(getProperty(obj, "class"));
-    if (cls === void 0) return null;
+    if (cls === void 0) return false;
     const conditions = {};
-    for (const cp of obj.properties) {
+    const keyOrVNotDefined = iterate.every(obj.properties, (cp) => {
       const key = propKey(cp);
-      if (!key || !ts2.isPropertyAssignment(cp)) return null;
-      if (key === "class") continue;
+      if (!key || !ts2.isPropertyAssignment(cp)) return false;
+      if (key === "class") return true;
       const v = asStringOrStringArray(cp.initializer);
-      if (v === void 0) return null;
+      if (v === void 0) return false;
       conditions[key] = v;
-    }
+      return true;
+    });
+    if (!keyOrVNotDefined) return false;
     result.push({ conditions, cls });
-  }
-  return result;
+    return true;
+  });
+  return resultReturned ? result : null;
 }
 function enumerateCombinations(variantMap) {
-  const keys = Object.keys(variantMap);
-  if (keys.length === 0) return [{}];
+  const keys2 = Object.keys(variantMap);
+  if (keys2.length === 0) return [{}];
   let total = 1;
-  for (const key of keys) {
+  const totalUnderMaxLimit = iterate.every(keys2, (key) => {
     total *= Object.keys(variantMap[key]).length + 1;
-    if (total > MAX_COMBINATIONS) return null;
-  }
+    return total <= MAX_COMBINATIONS;
+  });
+  if (!totalUnderMaxLimit) return null;
   function rec(remaining) {
     if (remaining.length === 0) return [{}];
     const first = remaining[0];
@@ -138,15 +323,15 @@ function enumerateCombinations(variantMap) {
     const restCombos = rec(rest);
     const valueKeys = Object.keys(variantMap[first]);
     const out = [];
-    for (const combo of restCombos) {
+    iterate.forEach(restCombos, (combo) => {
       out.push(combo);
-      for (const v of valueKeys) {
+      iterate.forEach(valueKeys, (v) => {
         out.push({ [first]: v, ...combo });
-      }
-    }
+      });
+    });
     return out;
   }
-  return rec(keys);
+  return rec(keys2);
 }
 function buildCacheKey(props) {
   const parts = Object.keys(props).sort().map((k) => `${k}:s:${props[k]}`);
@@ -156,35 +341,24 @@ function computeClasses(config, props) {
   const { variantMap, defaults, compounds } = config;
   const effective = { ...defaults, ...props };
   const classes = [];
-  for (const [key, values] of Object.entries(variantMap)) {
+  iterate.forEachEntry(variantMap, (key, values2) => {
     const v = effective[key];
-    if (v === void 0) continue;
-    const cls = values[v];
-    if (cls === void 0) continue;
+    if (v === void 0) return;
+    const cls = values2[v];
+    if (cls === void 0) return;
     if (Array.isArray(cls)) classes.push(...cls);
     else classes.push(cls);
-  }
-  for (const { conditions, cls } of compounds) {
-    let ok = true;
-    for (const [key, cond] of Object.entries(conditions)) {
-      const v = effective[key];
-      if (Array.isArray(cond)) {
-        if (v === void 0 || !cond.includes(v)) {
-          ok = false;
-          break;
-        }
-      } else {
-        if (v !== cond) {
-          ok = false;
-          break;
-        }
-      }
-    }
+  });
+  iterate.forEach(compounds, ({ conditions, cls }) => {
+    const ok = iterate.every(iterate.entries(conditions), ([key, cond]) => {
+      const value = effective[key];
+      return Array.isArray(cond) ? value !== void 0 && cond.includes(value) : value === cond;
+    });
     if (ok) {
       if (Array.isArray(cls)) classes.push(...cls);
       else classes.push(cls);
     }
-  }
+  });
   return classes.filter(Boolean).join(" ");
 }
 function buildPrecomputedClasses(stylingObj) {
@@ -197,11 +371,10 @@ function buildPrecomputedClasses(stylingObj) {
   const combos = enumerateCombinations(variantMap);
   if (!combos) return null;
   const config = { variantMap, defaults, compounds };
-  const map = {};
-  for (const combo of combos) {
-    map[buildCacheKey(combo)] = computeClasses(config, combo);
-  }
-  return map;
+  return iterate.collect(
+    combos,
+    (combo) => [buildCacheKey(combo), computeClasses(config, combo)]
+  );
 }
 function createClassExtractTransformer(factory, calleeNames, onInjected) {
   return (context) => {
@@ -213,13 +386,16 @@ function createClassExtractTransformer(factory, calleeNames, onInjected) {
       const stylingNode = getProperty(arg, "styling");
       const stylingObj = asObject(stylingNode);
       if (!stylingObj) return ts2.visitEachChild(node, visit, context);
-      const map = buildPrecomputedClasses(stylingObj);
-      if (!map) return ts2.visitEachChild(node, visit, context);
+      const map2 = buildPrecomputedClasses(stylingObj);
+      if (!map2) return ts2.visitEachChild(node, visit, context);
       onInjected();
-      const mapProps = Object.entries(map).map(
-        ([k, v]) => factory.createPropertyAssignment(
-          factory.createStringLiteral(k),
-          factory.createStringLiteral(v)
+      const mapProps = Array.from(
+        iterate.map(
+          iterate.entries(map2),
+          ([key, value]) => factory.createPropertyAssignment(
+            factory.createStringLiteral(key),
+            factory.createStringLiteral(value)
+          )
         )
       );
       const mapLiteral = factory.createObjectLiteralExpression(mapProps, true);
@@ -247,12 +423,10 @@ function createClassExtractTransformer(factory, calleeNames, onInjected) {
   };
 }
 function injectPrecomputedClasses(source, calleeNames) {
-  let hasVariants = false;
-  walk(source, (n) => {
-    if (hasVariants) return;
-    if (ts2.isPropertyAssignment(n) && (ts2.isIdentifier(n.name) || ts2.isStringLiteral(n.name)) && n.name.text === "variants")
-      hasVariants = true;
-  });
+  const hasVariants = iterate.some(
+    walk(source),
+    (node) => ts2.isPropertyAssignment(node) && (ts2.isIdentifier(node.name) || ts2.isStringLiteral(node.name)) && node.name.text === "variants"
+  );
   if (!hasVariants) return null;
   let didInject = false;
   const result = ts2.transform(
@@ -274,7 +448,7 @@ function injectPrecomputedClasses(source, calleeNames) {
   return output;
 }
 
-// ../vite-plugin/src/collect.ts
+// ../../plugins/vite/src/collect.ts
 import ts3 from "typescript";
 function extractBound(element) {
   const obj = asObject(element);
@@ -310,11 +484,12 @@ function cardinalityMax(c) {
   return c.kind === "bounded" ? c.max : Infinity;
 }
 function processVariableStatement(node, calleeNames, out) {
-  for (const decl of node.declarationList.declarations) {
-    if (!decl.initializer || !ts3.isCallExpression(decl.initializer)) continue;
-    if (!isFactoryCall(decl.initializer, calleeNames)) continue;
-    const arg = firstObjectArg(decl.initializer);
-    if (!arg) continue;
+  iterate.forEach(node.declarationList.declarations, (decl) => {
+    const { initializer, name } = decl;
+    if (!initializer || !ts3.isCallExpression(initializer)) return;
+    if (!isFactoryCall(initializer, calleeNames)) return;
+    const arg = firstObjectArg(initializer);
+    if (!arg) return;
     const tagNode = getProperty(arg, "tag");
     const defaultTag = tagNode && ts3.isStringLiteral(tagNode) ? tagNode.text : void 0;
     const enforcementProp = getProperty(arg, "enforcement");
@@ -326,21 +501,21 @@ function processVariableStatement(node, calleeNames, out) {
     const childrenArr = asArray(childrenProp);
     const rules = [];
     if (childrenArr) {
-      for (const element of childrenArr.elements) {
+      iterate.forEach(childrenArr.elements, (element) => {
         const bound = extractBound(element);
         if (bound) rules.push(bound);
-      }
+      });
     }
-    if (rules.length === 0 && !hasAriaRules && !defaultTag) continue;
+    if (rules.length === 0 && !hasAriaRules && !defaultTag) return;
     let totalMin = 0;
     let totalMax = 0;
-    for (const rule of rules) {
+    iterate.forEach(rules, (rule) => {
       totalMin += cardinalityMin(rule.cardinality);
       const max = cardinalityMax(rule.cardinality);
       totalMax = totalMax === Infinity || max === Infinity ? Infinity : totalMax + max;
-    }
-    const componentName = ts3.isIdentifier(decl.name) ? decl.name.text : void 0;
-    if (!componentName) continue;
+    });
+    const componentName = ts3.isIdentifier(name) ? name.text : void 0;
+    if (!componentName) return;
     out.push({
       name: componentName,
       rules,
@@ -349,11 +524,11 @@ function processVariableStatement(node, calleeNames, out) {
       ...defaultTag !== void 0 && { defaultTag },
       hasAriaRules
     });
-  }
+  });
 }
 function collectConstraints(source, calleeNames) {
   const constraints = [];
-  walk(source, (node) => {
+  walkEach(source, (node) => {
     if (ts3.isVariableStatement(node)) processVariableStatement(node, calleeNames, constraints);
   });
   return constraints;
@@ -361,7 +536,7 @@ function collectConstraints(source, calleeNames) {
 function collectFileDeclarations(source, calleeNames) {
   const constraints = [];
   const importSpecifiers = /* @__PURE__ */ new Map();
-  walk(source, (node) => {
+  walkEach(source, (node) => {
     if (ts3.isVariableStatement(node)) {
       processVariableStatement(node, calleeNames, constraints);
     } else if (ts3.isImportDeclaration(node)) {
@@ -370,57 +545,62 @@ function collectFileDeclarations(source, calleeNames) {
       const namedBindings = node.importClause?.namedBindings;
       if (!namedBindings || !ts3.isNamedImports(namedBindings)) return;
       const specifier = spec.text;
-      for (const el of namedBindings.elements) {
-        if (el.isTypeOnly) continue;
-        const localName = el.name.text;
-        const importedName = el.propertyName?.text ?? localName;
+      iterate.forEach(namedBindings.elements, ({ isTypeOnly, name, propertyName }) => {
+        if (isTypeOnly) return;
+        const localName = name.text;
+        const importedName = propertyName?.text ?? localName;
         importSpecifiers.set(localName, { importedName, specifier });
-      }
+      });
     }
   });
   return { constraints, importSpecifiers };
 }
 
-// ../vite-plugin/src/compound-prune.ts
+// ../../plugins/vite/src/compound-prune.ts
 import ts4 from "typescript";
 function extractVariantMap2(stylingObj) {
   const result = /* @__PURE__ */ new Map();
   const variantsObj = asObject(getProperty(stylingObj, "variants"));
   if (!variantsObj) return result;
-  for (const prop of variantsObj.properties) {
-    if (!ts4.isPropertyAssignment(prop)) continue;
-    const key = ts4.isIdentifier(prop.name) || ts4.isStringLiteral(prop.name) ? prop.name.text : void 0;
-    if (!key) continue;
+  iterate.forEach(variantsObj.properties, (prop) => {
+    if (!ts4.isPropertyAssignment(prop)) return;
+    const { name } = prop;
+    const key = ts4.isIdentifier(name) || ts4.isStringLiteral(name) ? name.text : void 0;
+    if (!key) return;
     const valuesObj = asObject(prop.initializer);
-    if (!valuesObj) continue;
+    if (!valuesObj) return;
     const valid = /* @__PURE__ */ new Set();
-    for (const vp of valuesObj.properties) {
-      if (!ts4.isPropertyAssignment(vp)) continue;
-      const vk = ts4.isIdentifier(vp.name) || ts4.isStringLiteral(vp.name) ? vp.name.text : void 0;
+    iterate.forEach(valuesObj.properties, (vp) => {
+      if (!ts4.isPropertyAssignment(vp)) return;
+      const { name: name2 } = vp;
+      const vk = ts4.isIdentifier(name2) || ts4.isStringLiteral(name2) ? name2.text : void 0;
       if (vk) valid.add(vk);
-    }
+    });
     result.set(key, valid);
-  }
+  });
   return result;
 }
 function isDeadCompound(entry, variantMap) {
-  for (const prop of entry.properties) {
-    if (!ts4.isPropertyAssignment(prop)) continue;
-    const key = ts4.isIdentifier(prop.name) || ts4.isStringLiteral(prop.name) ? prop.name.text : void 0;
-    if (!key || key === "class") continue;
+  return iterate.find(entry.properties, (prop) => {
+    if (!ts4.isPropertyAssignment(prop)) return null;
+    const { name } = prop;
+    const key = ts4.isIdentifier(name) || ts4.isStringLiteral(name) ? name.text : void 0;
+    if (!key || key === "class") return null;
     const validValues = variantMap.get(key);
     if (!validValues) return true;
-    const val = prop.initializer;
+    const { initializer: val } = prop;
     if (ts4.isStringLiteral(val)) {
       if (!validValues.has(val.text)) return true;
     } else if (ts4.isArrayLiteralExpression(val)) {
       const allLiterals = val.elements.every(ts4.isStringLiteral);
-      if (!allLiterals) continue;
-      const hasAnyValid = val.elements.some((e) => ts4.isStringLiteral(e) && validValues.has(e.text));
+      if (!allLiterals) return null;
+      const hasAnyValid = val.elements.some(
+        (e) => ts4.isStringLiteral(e) && validValues.has(e.text)
+      );
       if (!hasAnyValid) return true;
     }
-  }
-  return false;
+    return null;
+  }) ?? false;
 }
 function createCompoundPruner(factory, calleeNames, onPruned) {
   return (context) => {
@@ -470,7 +650,7 @@ function createCompoundPruner(factory, calleeNames, onPruned) {
 }
 function pruneDeadCompounds(source, calleeNames) {
   let hasCompounds = false;
-  walk(source, (n) => {
+  walkEach(source, (n) => {
     if (hasCompounds) return;
     if (ts4.isPropertyAssignment(n)) {
       const key = ts4.isIdentifier(n.name) || ts4.isStringLiteral(n.name) ? n.name.text : void 0;
@@ -498,13 +678,36 @@ function pruneDeadCompounds(source, calleeNames) {
   return output;
 }
 
-// ../vite-plugin/src/constants.ts
-var DEFAULT_CALLEE_NAMES = ["createPolymorphicComponent", "createContractComponent"];
+// ../../plugins/vite/src/constants.ts
+var DEFAULT_CALLEE_NAMES = ["createContractComponent", "createPolymorphicComponent"];
 var JSX_EXTS = /* @__PURE__ */ new Set(["tsx", "jsx"]);
 var ALL_EXTS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx"]);
 
-// ../vite-plugin/src/diagnose.ts
+// ../../plugins/vite/src/diagnose.ts
 import ts5 from "typescript";
+
+// ../../plugins/vite/src/vite-diagnostics.ts
+var ViteDiagnostics = {
+  cardinalityViolation(name, totalMin, totalMax, receivedMin, receivedMax) {
+    const rangeText = totalMax === Infinity ? `at least ${totalMin}` : totalMin === totalMax ? `exactly ${totalMin}` : `${totalMin}\u2013${totalMax}`;
+    const childWord = totalMax === 1 && totalMin === 1 ? "child" : "children";
+    const receivedText = receivedMin === receivedMax ? `${receivedMin}` : `${receivedMin}\u2013${receivedMax}`;
+    return {
+      code: "LINT5015" /* LintCardinalityViolation */,
+      category: 9 /* Lint */,
+      message: `<${name}> expects ${rangeText} ${childWord} but received ${receivedText}.`
+    };
+  },
+  ariaTagOverride(tagName, asValue, defaultTag) {
+    return {
+      code: "LINT5016" /* LintAriaTagOverride */,
+      category: 9 /* Lint */,
+      message: `<${tagName} as="${asValue}"> changes the element type from '${defaultTag}' \u2014 ARIA enforcement rules may not apply as expected.`
+    };
+  }
+};
+
+// ../../plugins/vite/src/diagnose.ts
 function analyzeJsxSites(source, constraints, severity) {
   const byName = new Map(constraints.filter((c) => c.rules.length > 0).map((c) => [c.name, c]));
   const byNameAria = new Map(
@@ -512,7 +715,7 @@ function analyzeJsxSites(source, constraints, severity) {
   );
   const diagnostics = [];
   const usages = [];
-  walk(source, (node) => {
+  walkEach(source, (node) => {
     let tagName;
     let attributes;
     let count;
@@ -533,11 +736,14 @@ function analyzeJsxSites(source, constraints, severity) {
       const c = byName.get(tagName);
       if (c && (count.max < c.totalMin || count.min > c.totalMax)) {
         const { line, character } = getPos();
-        const { totalMin, totalMax, name } = c;
-        const rangeText = totalMax === Infinity ? `at least ${totalMin}` : totalMin === totalMax ? `exactly ${totalMin}` : `${totalMin}\u2013${totalMax}`;
-        const receivedText = count.min === count.max ? `${count.min}` : `${count.min}\u2013${count.max}`;
         diagnostics.push({
-          message: `<${name}> expects ${rangeText} ${totalMax === 1 && totalMin === 1 ? "child" : "children"} but received ${receivedText}.`,
+          diagnostic: ViteDiagnostics.cardinalityViolation(
+            c.name,
+            c.totalMin,
+            c.totalMax,
+            count.min,
+            count.max
+          ),
           line: line + 1,
           col: character + 1,
           severity
@@ -547,26 +753,27 @@ function analyzeJsxSites(source, constraints, severity) {
     if (attributes) {
       const c = byNameAria.get(tagName);
       if (c) {
-        for (const attr of attributes.properties) {
-          if (!ts5.isJsxAttribute(attr)) continue;
-          const attrName = ts5.isIdentifier(attr.name) ? attr.name.text : void 0;
-          if (attrName !== "as" || !attr.initializer) continue;
+        iterate.forEach(attributes.properties, (attr) => {
+          if (!ts5.isJsxAttribute(attr)) return;
+          const { initializer, name } = attr;
+          const attrName = ts5.isIdentifier(name) ? name.text : void 0;
+          if (attrName !== "as" || !initializer) return;
           let asValue;
-          if (ts5.isStringLiteral(attr.initializer)) {
-            asValue = attr.initializer.text;
-          } else if (ts5.isJsxExpression(attr.initializer) && attr.initializer.expression !== void 0 && ts5.isStringLiteral(attr.initializer.expression)) {
-            asValue = attr.initializer.expression.text;
+          if (ts5.isStringLiteral(initializer)) {
+            asValue = initializer.text;
+          } else if (ts5.isJsxExpression(initializer) && initializer.expression !== void 0 && ts5.isStringLiteral(initializer.expression)) {
+            asValue = initializer.expression.text;
           }
           if (asValue !== void 0 && asValue !== c.defaultTag) {
             const { line, character } = getPos();
             diagnostics.push({
-              message: `<${tagName} as="${asValue}"> changes the element type from '${c.defaultTag}' \u2014 ARIA enforcement rules may not apply as expected.`,
+              diagnostic: ViteDiagnostics.ariaTagOverride(tagName, asValue, c.defaultTag),
               line: line + 1,
               col: character + 1,
               severity
             });
           }
-        }
+        });
       }
     }
     if (/^[A-Z]/.test(tagName)) {
@@ -646,7 +853,7 @@ function diagnoseUsages(source, constraints, severity) {
   if (constraints.length === 0) return [];
   const byName = new Map(constraints.filter((c) => c.rules.length > 0).map((c) => [c.name, c]));
   const diagnostics = [];
-  walk(source, (node) => {
+  walkEach(source, (node) => {
     let tagName;
     let count;
     if (ts5.isJsxElement(node)) {
@@ -664,10 +871,14 @@ function diagnoseUsages(source, constraints, severity) {
     const { totalMin, totalMax, name } = constraint;
     if (count.max < totalMin || count.min > totalMax) {
       const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
-      const rangeText = totalMax === Infinity ? `at least ${totalMin}` : totalMin === totalMax ? `exactly ${totalMin}` : `${totalMin}\u2013${totalMax}`;
-      const receivedText = count.min === count.max ? `${count.min}` : `${count.min}\u2013${count.max}`;
       diagnostics.push({
-        message: `<${name}> expects ${rangeText} ${totalMax === 1 && totalMin === 1 ? "child" : "children"} but received ${receivedText}.`,
+        diagnostic: ViteDiagnostics.cardinalityViolation(
+          name,
+          totalMin,
+          totalMax,
+          count.min,
+          count.max
+        ),
         line: line + 1,
         col: character + 1,
         severity
@@ -677,11 +888,34 @@ function diagnoseUsages(source, constraints, severity) {
   return diagnostics;
 }
 
-// ../vite-plugin/src/registry.ts
+// ../../plugins/vite/src/imports.ts
+import ts6 from "typescript";
+function extractImportSpecifiers(source) {
+  const result = /* @__PURE__ */ new Map();
+  walkEach(source, (node) => {
+    if (!ts6.isImportDeclaration(node)) return;
+    const moduleSpecifier = node.moduleSpecifier;
+    if (!ts6.isStringLiteral(moduleSpecifier)) return;
+    const specifier = moduleSpecifier.text;
+    const namedBindings = node.importClause?.namedBindings;
+    if (!namedBindings || !ts6.isNamedImports(namedBindings)) return;
+    iterate.forEach(namedBindings.elements, (element) => {
+      const { isTypeOnly, name, propertyName } = element;
+      if (isTypeOnly) return;
+      const { text: localName } = name;
+      const importedName = propertyName?.text ?? localName;
+      result.set(localName, { importedName, specifier });
+    });
+  });
+  return result;
+}
+
+// ../../plugins/vite/src/registry.ts
 var ConstraintRegistry = class {
   constraints = /* @__PURE__ */ new Map();
   importMap = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
+  /** Records the component constraints declared in a source file, keyed by component name. */
   registerConstraints(fileId, cs) {
     this.constraints.set(fileId, new Map(cs.map((c) => [c.name, c])));
   }
@@ -689,6 +923,7 @@ var ConstraintRegistry = class {
   registerImports(fileId, resolvedImports) {
     this.importMap.set(fileId, resolvedImports);
   }
+  /** Queues a JSX usage site whose constraint lives in another file for deferred cross-file validation at buildEnd. */
   addPendingUsage(fileId, usage) {
     let list = this.pending.get(fileId);
     if (!list) {
@@ -708,72 +943,70 @@ var ConstraintRegistry = class {
   /** Returns cardinality violations across all pending cross-file usages. */
   diagnostics(severity) {
     const result = [];
-    for (const [fileId, usages] of this.pending) {
-      for (const usage of usages) {
-        if (usage.count === void 0) continue;
-        const constraint = this.resolveConstraint(fileId, usage.tagName);
-        if (!constraint) continue;
+    iterate.forEach(this.pending, ([fileId, usages]) => {
+      iterate.forEach(usages, ({ col, count, line, tagName }) => {
+        if (count === void 0) return;
+        const constraint = this.resolveConstraint(fileId, tagName);
+        if (!constraint) return;
         const { totalMin, totalMax, name } = constraint;
-        if (usage.count.max >= totalMin && usage.count.min <= totalMax) continue;
-        const rangeText = totalMax === Infinity ? `at least ${totalMin}` : totalMin === totalMax ? `exactly ${totalMin}` : `${totalMin}\u2013${totalMax}`;
-        const childWord = totalMax === 1 && totalMin === 1 ? "child" : "children";
-        const receivedText = usage.count.min === usage.count.max ? `${usage.count.min}` : `${usage.count.min}\u2013${usage.count.max}`;
+        const { min, max } = count;
+        if (max >= totalMin && min <= totalMax) return;
         result.push({
           fileId,
-          message: `<${name}> expects ${rangeText} ${childWord} but received ${receivedText}.`,
-          line: usage.line,
-          col: usage.col,
+          diagnostic: ViteDiagnostics.cardinalityViolation(name, totalMin, totalMax, min, max),
+          line,
+          col,
           severity
         });
-      }
-    }
+      });
+    });
     return result;
   }
 };
 
-// ../vite-plugin/src/slot-transform.ts
-import ts6 from "typescript";
+// ../../plugins/vite/src/slot-transform.ts
+import ts7 from "typescript";
 function isUpperCase(s) {
   return s.charCodeAt(0) >= 65 && s.charCodeAt(0) <= 90;
 }
 function jsxAttrName(attr) {
-  return ts6.isIdentifier(attr.name) ? attr.name.text : "";
+  return ts7.isIdentifier(attr.name) ? attr.name.text : "";
 }
 function getStaticClassName(child) {
-  const attrs = ts6.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties;
+  const attrs = ts7.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties;
   for (const attr of attrs) {
-    if (!ts6.isJsxAttribute(attr) || jsxAttrName(attr) !== "className") continue;
+    if (!ts7.isJsxAttribute(attr) || jsxAttrName(attr) !== "className") continue;
     const init = attr.initializer;
     if (!init) return { absent: false, value: "" };
-    if (ts6.isStringLiteral(init)) return { absent: false, value: init.text };
-    if (ts6.isJsxExpression(init) && init.expression !== void 0 && ts6.isStringLiteral(init.expression))
+    if (ts7.isStringLiteral(init)) return { absent: false, value: init.text };
+    if (ts7.isJsxExpression(init) && init.expression !== void 0 && ts7.isStringLiteral(init.expression))
       return { absent: false, value: init.expression.text };
     return null;
   }
   return { absent: true };
 }
 function getStyleInfo(child) {
-  const attrs = ts6.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties;
+  const attrs = ts7.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties;
   for (const attr of attrs) {
-    if (!ts6.isJsxAttribute(attr) || jsxAttrName(attr) !== "style") continue;
+    if (!ts7.isJsxAttribute(attr) || jsxAttrName(attr) !== "style") continue;
     const init = attr.initializer;
-    if (!init || ts6.isStringLiteral(init)) return null;
-    if (ts6.isJsxExpression(init) && init.expression !== void 0)
+    if (!init || ts7.isStringLiteral(init)) return null;
+    if (ts7.isJsxExpression(init) && init.expression !== void 0)
       return { absent: false, expr: init.expression };
     return null;
   }
   return { absent: true };
 }
 function getEventHandlers(child) {
-  const attrs = ts6.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties;
+  const attrs = ts7.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties;
   const handlers = [];
   for (const attr of attrs) {
-    if (!ts6.isJsxAttribute(attr)) continue;
+    if (!ts7.isJsxAttribute(attr)) continue;
     const name = jsxAttrName(attr);
     if (!/^on[A-Z]/.test(name)) continue;
     const init = attr.initializer;
     if (!init) return null;
-    if (ts6.isJsxExpression(init) && init.expression !== void 0) {
+    if (ts7.isJsxExpression(init) && init.expression !== void 0) {
       handlers.push({ name, expr: init.expression });
       continue;
     }
@@ -783,10 +1016,10 @@ function getEventHandlers(child) {
 }
 function hasAsChild(opening) {
   for (const attr of opening.attributes.properties) {
-    if (!ts6.isJsxAttribute(attr)) continue;
+    if (!ts7.isJsxAttribute(attr)) continue;
     if (jsxAttrName(attr) !== "asChild") continue;
     if (attr.initializer === void 0) return true;
-    if (ts6.isJsxExpression(attr.initializer) && attr.initializer.expression !== void 0 && attr.initializer.expression.kind === ts6.SyntaxKind.TrueKeyword)
+    if (ts7.isJsxExpression(attr.initializer) && attr.initializer.expression !== void 0 && attr.initializer.expression.kind === ts7.SyntaxKind.TrueKeyword)
       return true;
   }
   return false;
@@ -794,12 +1027,12 @@ function hasAsChild(opening) {
 function getSingleElementChild(node) {
   const meaningful = [];
   for (const child of node.children) {
-    if (ts6.isJsxText(child)) {
+    if (ts7.isJsxText(child)) {
       if (child.text.trim().length > 0) return void 0;
       continue;
     }
-    if (ts6.isJsxExpression(child)) return void 0;
-    if (ts6.isJsxElement(child) || ts6.isJsxSelfClosingElement(child)) {
+    if (ts7.isJsxExpression(child)) return void 0;
+    if (ts7.isJsxElement(child) || ts7.isJsxSelfClosingElement(child)) {
       meaningful.push(child);
       continue;
     }
@@ -808,26 +1041,26 @@ function getSingleElementChild(node) {
   return meaningful.length === 1 ? meaningful[0] : void 0;
 }
 function getTagName(child) {
-  const tag = ts6.isJsxElement(child) ? child.openingElement.tagName : child.tagName;
-  return ts6.isIdentifier(tag) ? tag.text : void 0;
+  const tag = ts7.isJsxElement(child) ? child.openingElement.tagName : child.tagName;
+  return ts7.isIdentifier(tag) ? tag.text : void 0;
 }
 function buildTransformedAttributes(factory, original, child, tagName, clsResult, styleInfo, handlers) {
   const parentAttrs = original.attributes.properties.filter(
-    (attr) => !(ts6.isJsxAttribute(attr) && jsxAttrName(attr) === "asChild")
+    (attr) => !(ts7.isJsxAttribute(attr) && jsxAttrName(attr) === "asChild")
   );
   const hasStaticCls = !clsResult.absent;
   const hasStyle = !styleInfo.absent;
-  const handlerNames = new Set(handlers.map((h) => h.name));
-  const childOpeningAttrs = (ts6.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties).filter(
-    (attr) => !(ts6.isJsxAttribute(attr) && (jsxAttrName(attr) === "ref" || hasStaticCls && jsxAttrName(attr) === "className" || hasStyle && jsxAttrName(attr) === "style" || handlerNames.has(jsxAttrName(attr))))
+  const handlerNames = new Set(iterate.map(handlers, (h) => h.name));
+  const childOpeningAttrs = (ts7.isJsxElement(child) ? child.openingElement.attributes.properties : child.attributes.properties).filter(
+    (attr) => !(ts7.isJsxAttribute(attr) && (jsxAttrName(attr) === "ref" || hasStaticCls && jsxAttrName(attr) === "className" || hasStyle && jsxAttrName(attr) === "style" || handlerNames.has(jsxAttrName(attr))))
   );
-  const childContent = ts6.isJsxElement(child) ? child.children : void 0;
+  const childContent = ts7.isJsxElement(child) ? child.children : void 0;
   const spreadProp = factory.createJsxSpreadAttribute(factory.createIdentifier("_p"));
   const extraAttrs = [];
   if (hasStaticCls && clsResult.value !== "") {
     const mergedExpr = factory.createBinaryExpression(
       factory.createPropertyAccessExpression(factory.createIdentifier("_p"), "className"),
-      ts6.SyntaxKind.PlusToken,
+      ts7.SyntaxKind.PlusToken,
       factory.createStringLiteral(` ${clsResult.value}`)
     );
     extraAttrs.push(
@@ -843,7 +1076,7 @@ function buildTransformedAttributes(factory, original, child, tagName, clsResult
       factory.createPropertyAccessExpression(factory.createIdentifier("_p"), "style")
     );
     let mergedStyleObj;
-    if (ts6.isObjectLiteralExpression(styleExpr)) {
+    if (ts7.isObjectLiteralExpression(styleExpr)) {
       mergedStyleObj = factory.createObjectLiteralExpression(
         [pStyleSpread, ...styleExpr.properties],
         false
@@ -871,7 +1104,7 @@ function buildTransformedAttributes(factory, original, child, tagName, clsResult
     const callParent = factory.createExpressionStatement(
       factory.createCallChain(
         factory.createPropertyAccessExpression(factory.createIdentifier("_p"), name),
-        factory.createToken(ts6.SyntaxKind.QuestionDotToken),
+        factory.createToken(ts7.SyntaxKind.QuestionDotToken),
         void 0,
         [factory.createIdentifier("_e")]
       )
@@ -881,7 +1114,7 @@ function buildTransformedAttributes(factory, original, child, tagName, clsResult
       void 0,
       [eParam],
       void 0,
-      factory.createToken(ts6.SyntaxKind.EqualsGreaterThanToken),
+      factory.createToken(ts7.SyntaxKind.EqualsGreaterThanToken),
       factory.createBlock([callChild, callParent], true)
     );
     extraAttrs.push(
@@ -896,7 +1129,7 @@ function buildTransformedAttributes(factory, original, child, tagName, clsResult
     spreadProp,
     ...extraAttrs
   ]);
-  const childElement = ts6.isJsxElement(child) ? factory.createJsxElement(
+  const childElement = ts7.isJsxElement(child) ? factory.createJsxElement(
     factory.createJsxOpeningElement(
       factory.createIdentifier(tagName),
       void 0,
@@ -914,7 +1147,7 @@ function buildTransformedAttributes(factory, original, child, tagName, clsResult
     void 0,
     [factory.createParameterDeclaration(void 0, void 0, "_p")],
     void 0,
-    factory.createToken(ts6.SyntaxKind.EqualsGreaterThanToken),
+    factory.createToken(ts7.SyntaxKind.EqualsGreaterThanToken),
     factory.createParenthesizedExpression(childElement)
   );
   const renderAttr = factory.createJsxAttribute(
@@ -926,23 +1159,23 @@ function buildTransformedAttributes(factory, original, child, tagName, clsResult
 function createAsChildTransformer(factory) {
   return (context) => {
     function visit(node) {
-      if (!ts6.isJsxElement(node)) return ts6.visitEachChild(node, visit, context);
+      if (!ts7.isJsxElement(node)) return ts7.visitEachChild(node, visit, context);
       const opening = node.openingElement;
-      const tagName = ts6.isIdentifier(opening.tagName) ? opening.tagName.text : void 0;
+      const tagName = ts7.isIdentifier(opening.tagName) ? opening.tagName.text : void 0;
       if (!tagName || !isUpperCase(tagName)) {
-        return ts6.visitEachChild(node, visit, context);
+        return ts7.visitEachChild(node, visit, context);
       }
-      if (!hasAsChild(opening)) return ts6.visitEachChild(node, visit, context);
+      if (!hasAsChild(opening)) return ts7.visitEachChild(node, visit, context);
       const child = getSingleElementChild(node);
-      if (!child) return ts6.visitEachChild(node, visit, context);
+      if (!child) return ts7.visitEachChild(node, visit, context);
       const clsResult = getStaticClassName(child);
-      if (clsResult === null) return ts6.visitEachChild(node, visit, context);
+      if (clsResult === null) return ts7.visitEachChild(node, visit, context);
       const styleInfo = getStyleInfo(child);
-      if (styleInfo === null) return ts6.visitEachChild(node, visit, context);
+      if (styleInfo === null) return ts7.visitEachChild(node, visit, context);
       const handlers = getEventHandlers(child);
-      if (handlers === null) return ts6.visitEachChild(node, visit, context);
+      if (handlers === null) return ts7.visitEachChild(node, visit, context);
       const childTag = getTagName(child);
-      if (!childTag) return ts6.visitEachChild(node, visit, context);
+      if (!childTag) return ts7.visitEachChild(node, visit, context);
       const newAttrs = buildTransformedAttributes(
         factory,
         opening,
@@ -954,43 +1187,42 @@ function createAsChildTransformer(factory) {
       );
       return factory.createJsxSelfClosingElement(opening.tagName, opening.typeArguments, newAttrs);
     }
-    return (sourceFile) => ts6.visitEachChild(sourceFile, visit, context);
+    return (sourceFile) => ts7.visitEachChild(sourceFile, visit, context);
   };
 }
 function transformAsChild(source) {
-  let hasAny = false;
-  walk(source, (n) => {
-    if (hasAny) return;
-    if (ts6.isJsxAttribute(n) && jsxAttrName(n) === "asChild") hasAny = true;
-  });
+  const hasAny = iterate.some(
+    walk(source),
+    (node) => ts7.isJsxAttribute(node) && jsxAttrName(node) === "asChild"
+  );
   if (!hasAny) return null;
-  const result = ts6.transform(source, [createAsChildTransformer(ts6.factory)], {
-    jsx: ts6.JsxEmit.Preserve,
-    target: ts6.ScriptTarget.Latest
+  const result = ts7.transform(source, [createAsChildTransformer(ts7.factory)], {
+    jsx: ts7.JsxEmit.Preserve,
+    target: ts7.ScriptTarget.Latest
   });
-  const printer = ts6.createPrinter({ newLine: ts6.NewLineKind.LineFeed, removeComments: false });
+  const printer = ts7.createPrinter({ newLine: ts7.NewLineKind.LineFeed, removeComments: false });
   const output = printer.printFile(result.transformed[0]);
   result.dispose();
   return output;
 }
 
-// ../vite-plugin/src/static-compose.ts
-import ts7 from "typescript";
+// ../../plugins/vite/src/static-compose.ts
+import ts8 from "typescript";
 function asStringLiteral(node) {
-  return node !== void 0 && ts7.isStringLiteral(node) ? node.text : void 0;
+  return node !== void 0 && ts8.isStringLiteral(node) ? node.text : void 0;
 }
 function extractStaticComponents(source, calleeNames) {
   const result = /* @__PURE__ */ new Map();
-  walk(source, (node) => {
-    if (!ts7.isVariableDeclaration(node)) return;
-    if (!ts7.isIdentifier(node.name)) return;
+  walkEach(source, (node) => {
+    if (!ts8.isVariableDeclaration(node)) return;
+    if (!ts8.isIdentifier(node.name)) return;
     const varName = node.name.text;
     const init = node.initializer;
     if (!init) return;
     let call;
-    if (ts7.isCallExpression(init) && isFactoryCall(init, calleeNames)) {
+    if (ts8.isCallExpression(init) && isFactoryCall(init, calleeNames)) {
       call = init;
-    } else if (ts7.isAsExpression(init) && ts7.isCallExpression(init.expression) && isFactoryCall(init.expression, calleeNames)) {
+    } else if (ts8.isAsExpression(init) && ts8.isCallExpression(init.expression) && isFactoryCall(init.expression, calleeNames)) {
       call = init.expression;
     }
     if (!call) return;
@@ -1003,23 +1235,29 @@ function extractStaticComponents(source, calleeNames) {
     const precomputedNode = asObject(getProperty(stylingObj, "precomputedClasses"));
     if (!precomputedNode) return;
     const precomputedClasses = {};
-    for (const prop of precomputedNode.properties) {
-      if (!ts7.isPropertyAssignment(prop)) return;
-      const key = ts7.isStringLiteral(prop.name) ? prop.name.text : void 0;
-      const val = asStringLiteral(prop.initializer);
-      if (key === void 0 || val === void 0) return;
-      precomputedClasses[key] = val;
-    }
+    const isNotPrecomputed = iterate.find(
+      precomputedNode.properties,
+      (prop) => {
+        if (!ts8.isPropertyAssignment(prop)) return true;
+        const { initializer, name } = prop;
+        const key = ts8.isStringLiteral(name) ? name.text : void 0;
+        const val = asStringLiteral(initializer);
+        if (key === void 0 || val === void 0) return true;
+        precomputedClasses[key] = val;
+        return null;
+      }
+    );
+    if (isNotPrecomputed) return;
     if (getProperty(arg, "defaults") !== void 0) return;
     if (getProperty(arg, "enforcement") !== void 0) return;
     const variantKeys = /* @__PURE__ */ new Set();
     const variantsObj = asObject(getProperty(stylingObj, "variants"));
     if (variantsObj) {
-      for (const prop of variantsObj.properties) {
-        if (ts7.isPropertyAssignment(prop) && (ts7.isIdentifier(prop.name) || ts7.isStringLiteral(prop.name))) {
+      iterate.forEach(variantsObj.properties, (prop) => {
+        if (ts8.isPropertyAssignment(prop) && (ts8.isIdentifier(prop.name) || ts8.isStringLiteral(prop.name))) {
           variantKeys.add(prop.name.text);
         }
-      }
+      });
     }
     result.set(varName, { defaultTag, variantKeys, precomputedClasses });
   });
@@ -1027,13 +1265,13 @@ function extractStaticComponents(source, calleeNames) {
 }
 function readAttrValue(attrs, name) {
   for (const attr of attrs) {
-    if (!ts7.isJsxAttribute(attr)) continue;
-    if (!(ts7.isIdentifier(attr.name) && attr.name.text === name)) continue;
+    if (!ts8.isJsxAttribute(attr)) continue;
+    if (!(ts8.isIdentifier(attr.name) && attr.name.text === name)) continue;
     const init = attr.initializer;
     if (!init) return { kind: "string", value: "" };
-    if (ts7.isStringLiteral(init)) return { kind: "string", value: init.text };
-    if (ts7.isJsxExpression(init) && init.expression !== void 0) {
-      if (ts7.isStringLiteral(init.expression))
+    if (ts8.isStringLiteral(init)) return { kind: "string", value: init.text };
+    if (ts8.isJsxExpression(init) && init.expression !== void 0) {
+      if (ts8.isStringLiteral(init.expression))
         return { kind: "string", value: init.expression.text };
       return { kind: "dynamic" };
     }
@@ -1044,21 +1282,21 @@ function readAttrValue(attrs, name) {
 function createStaticCompositionTransformer(factory, components, onInlined) {
   return (context) => {
     function visit(node) {
-      const isSelfClose = ts7.isJsxSelfClosingElement(node);
-      const isOpen = ts7.isJsxElement(node);
-      if (!isSelfClose && !isOpen) return ts7.visitEachChild(node, visit, context);
+      const isSelfClose = ts8.isJsxSelfClosingElement(node);
+      const isOpen = ts8.isJsxElement(node);
+      if (!isSelfClose && !isOpen) return ts8.visitEachChild(node, visit, context);
       const tagNode = isOpen ? node.openingElement.tagName : node.tagName;
-      if (!ts7.isIdentifier(tagNode)) return ts7.visitEachChild(node, visit, context);
+      if (!ts8.isIdentifier(tagNode)) return ts8.visitEachChild(node, visit, context);
       const info = components.get(tagNode.text);
-      if (!info) return ts7.visitEachChild(node, visit, context);
+      if (!info) return ts8.visitEachChild(node, visit, context);
       const attrList = isOpen ? node.openingElement.attributes.properties : node.attributes.properties;
-      if (attrList.some(ts7.isJsxSpreadAttribute)) return ts7.visitEachChild(node, visit, context);
+      if (attrList.some(ts8.isJsxSpreadAttribute)) return ts8.visitEachChild(node, visit, context);
       if (readAttrValue(attrList, "asChild").kind !== "absent")
-        return ts7.visitEachChild(node, visit, context);
+        return ts8.visitEachChild(node, visit, context);
       if (readAttrValue(attrList, "render").kind !== "absent")
-        return ts7.visitEachChild(node, visit, context);
+        return ts8.visitEachChild(node, visit, context);
       const asVal = readAttrValue(attrList, "as");
-      if (asVal.kind === "dynamic") return ts7.visitEachChild(node, visit, context);
+      if (asVal.kind === "dynamic") return ts8.visitEachChild(node, visit, context);
       const outputTag = asVal.kind === "string" ? asVal.value : info.defaultTag;
       const variantProps = {};
       for (const propName of info.variantKeys) {
@@ -1068,13 +1306,13 @@ function createStaticCompositionTransformer(factory, components, onInlined) {
           variantProps[propName] = val.value;
           continue;
         }
-        return ts7.visitEachChild(node, visit, context);
+        return ts8.visitEachChild(node, visit, context);
       }
       const cacheKey = buildCacheKey(variantProps);
       const baseClass = info.precomputedClasses[cacheKey];
-      if (baseClass === void 0) return ts7.visitEachChild(node, visit, context);
+      if (baseClass === void 0) return ts8.visitEachChild(node, visit, context);
       const clsVal = readAttrValue(attrList, "className");
-      if (clsVal.kind === "dynamic") return ts7.visitEachChild(node, visit, context);
+      if (clsVal.kind === "dynamic") return ts8.visitEachChild(node, visit, context);
       const finalClass = clsVal.kind === "string" && clsVal.value ? `${baseClass} ${clsVal.value}` : baseClass;
       const strip = /* @__PURE__ */ new Set([...info.variantKeys, "as", "asChild", "render", "className"]);
       const outputAttrs = [
@@ -1084,9 +1322,9 @@ function createStaticCompositionTransformer(factory, components, onInlined) {
         )
       ];
       for (const attr of attrList) {
-        if (ts7.isJsxSpreadAttribute(attr)) continue;
-        if (!ts7.isJsxAttribute(attr)) continue;
-        const name = ts7.isIdentifier(attr.name) ? attr.name.text : "";
+        if (ts8.isJsxSpreadAttribute(attr)) continue;
+        if (!ts8.isJsxAttribute(attr)) continue;
+        const name = ts8.isIdentifier(attr.name) ? attr.name.text : "";
         if (strip.has(name)) continue;
         outputAttrs.push(attr);
       }
@@ -1097,14 +1335,14 @@ function createStaticCompositionTransformer(factory, components, onInlined) {
         return factory.createJsxSelfClosingElement(outputTagIdent, void 0, newAttrs);
       }
       const openNode = node;
-      const visitedChildren = openNode.children.map((c) => ts7.visitNode(c, visit));
+      const visitedChildren = openNode.children.map((c) => ts8.visitNode(c, visit));
       return factory.createJsxElement(
         factory.createJsxOpeningElement(outputTagIdent, void 0, newAttrs),
         visitedChildren,
         factory.createJsxClosingElement(outputTagIdent)
       );
     }
-    return (sourceFile) => ts7.visitEachChild(sourceFile, visit, context);
+    return (sourceFile) => ts8.visitEachChild(sourceFile, visit, context);
   };
 }
 function composeStatically(source, calleeNames, importedComponents = /* @__PURE__ */ new Map()) {
@@ -1113,55 +1351,34 @@ function composeStatically(source, calleeNames, importedComponents = /* @__PURE_
   if (components.size === 0) return null;
   const componentNames = new Set(components.keys());
   let hasEligibleTag = false;
-  walk(source, (n) => {
+  walkEach(source, (n) => {
     if (hasEligibleTag) return;
-    const tagNode = ts7.isJsxElement(n) ? n.openingElement.tagName : ts7.isJsxSelfClosingElement(n) ? n.tagName : void 0;
-    if (tagNode && ts7.isIdentifier(tagNode) && componentNames.has(tagNode.text))
+    const tagNode = ts8.isJsxElement(n) ? n.openingElement.tagName : ts8.isJsxSelfClosingElement(n) ? n.tagName : void 0;
+    if (tagNode && ts8.isIdentifier(tagNode) && componentNames.has(tagNode.text))
       hasEligibleTag = true;
   });
   if (!hasEligibleTag) return null;
   let didInline = false;
-  const transformResult = ts7.transform(
+  const transformResult = ts8.transform(
     source,
     [
-      createStaticCompositionTransformer(ts7.factory, components, () => {
+      createStaticCompositionTransformer(ts8.factory, components, () => {
         didInline = true;
       })
     ],
-    { jsx: ts7.JsxEmit.Preserve, target: ts7.ScriptTarget.Latest }
+    { jsx: ts8.JsxEmit.Preserve, target: ts8.ScriptTarget.Latest }
   );
   if (!didInline) {
     transformResult.dispose();
     return null;
   }
-  const printer = ts7.createPrinter({ newLine: ts7.NewLineKind.LineFeed, removeComments: false });
+  const printer = ts8.createPrinter({ newLine: ts8.NewLineKind.LineFeed, removeComments: false });
   const output = printer.printFile(transformResult.transformed[0]);
   transformResult.dispose();
   return output;
 }
 
-// ../vite-plugin/src/imports.ts
-import ts8 from "typescript";
-function extractImportSpecifiers(source) {
-  const result = /* @__PURE__ */ new Map();
-  walk(source, (node) => {
-    if (!ts8.isImportDeclaration(node)) return;
-    const moduleSpecifier = node.moduleSpecifier;
-    if (!ts8.isStringLiteral(moduleSpecifier)) return;
-    const specifier = moduleSpecifier.text;
-    const namedBindings = node.importClause?.namedBindings;
-    if (!namedBindings || !ts8.isNamedImports(namedBindings)) return;
-    for (const element of namedBindings.elements) {
-      if (element.isTypeOnly) continue;
-      const localName = element.name.text;
-      const importedName = element.propertyName?.text ?? localName;
-      result.set(localName, { importedName, specifier });
-    }
-  });
-  return result;
-}
-
-// ../vite-plugin/src/analyze.ts
+// ../../plugins/vite/src/analyze.ts
 function analyze(code, filename, options) {
   const ext = filename.split(".").pop() ?? "";
   if (!JSX_EXTS.has(ext)) return [];
@@ -1172,7 +1389,7 @@ function analyze(code, filename, options) {
   return diagnoseUsages(source, constraints, severity);
 }
 
-// ../vite-plugin/src/design-tokens.ts
+// ../../plugins/vite/src/design-tokens.ts
 import { writeFileSync } from "fs";
 import { resolve } from "path";
 import ts9 from "typescript";
@@ -1183,7 +1400,9 @@ function collectStringValues(node, out) {
     return;
   }
   if (ts9.isArrayLiteralExpression(node)) {
-    for (const elem of node.elements) collectStringValues(elem, out);
+    iterate.forEach(node.elements, (elem) => {
+      collectStringValues(elem, out);
+    });
   }
 }
 function extractStylingTokens(stylingObj) {
@@ -1194,30 +1413,30 @@ function extractStylingTokens(stylingObj) {
   collectStringValues(getProperty(stylingObj, "base"), base);
   const variantsObj = asObject(getProperty(stylingObj, "variants"));
   if (variantsObj) {
-    for (const dimProp of variantsObj.properties) {
-      if (!ts9.isPropertyAssignment(dimProp)) continue;
+    iterate.forEach(variantsObj.properties, (dimProp) => {
+      if (!ts9.isPropertyAssignment(dimProp)) return;
       const valuesObj = asObject(dimProp.initializer);
-      if (!valuesObj) continue;
-      for (const vp of valuesObj.properties) {
-        if (!ts9.isPropertyAssignment(vp)) continue;
+      if (!valuesObj) return;
+      iterate.forEach(valuesObj.properties, (vp) => {
+        if (!ts9.isPropertyAssignment(vp)) return;
         collectStringValues(vp.initializer, variantClasses);
-      }
-    }
+      });
+    });
   }
   const compoundsArr = asArray(getProperty(stylingObj, "compounds"));
   if (compoundsArr) {
-    for (const elem of compoundsArr.elements) {
+    iterate.forEach(compoundsArr.elements, (elem) => {
       const obj = asObject(elem);
-      if (!obj) continue;
+      if (!obj) return;
       collectStringValues(getProperty(obj, "class"), compoundClasses);
-    }
+    });
   }
   const tagsObj = asObject(getProperty(stylingObj, "tags"));
   if (tagsObj) {
-    for (const tp of tagsObj.properties) {
-      if (!ts9.isPropertyAssignment(tp)) continue;
+    iterate.forEach(tagsObj.properties, (tp) => {
+      if (!ts9.isPropertyAssignment(tp)) return;
       collectStringValues(tp.initializer, tagClasses);
-    }
+    });
   }
   return { base, variantClasses, compoundClasses, tagClasses };
 }
@@ -1225,18 +1444,19 @@ function collectFileTokens(source, calleeNames) {
   const result = /* @__PURE__ */ new Map();
   ts9.forEachChild(source, (stmt) => {
     if (!ts9.isVariableStatement(stmt)) return;
-    for (const decl of stmt.declarationList.declarations) {
-      if (!decl.initializer || !ts9.isCallExpression(decl.initializer)) continue;
-      if (!isFactoryCall(decl.initializer, calleeNames)) continue;
-      const arg = firstObjectArg(decl.initializer);
-      if (!arg) continue;
+    iterate.forEach(stmt.declarationList.declarations, (decl) => {
+      const { initializer, name } = decl;
+      if (!initializer || !ts9.isCallExpression(initializer)) return;
+      if (!isFactoryCall(initializer, calleeNames)) return;
+      const arg = firstObjectArg(initializer);
+      if (!arg) return;
       const stylingNode = getProperty(arg, "styling");
       const stylingObj = asObject(stylingNode);
-      if (!stylingObj) continue;
-      const name = ts9.isIdentifier(decl.name) ? decl.name.text : void 0;
-      if (!name) continue;
-      result.set(name, extractStylingTokens(stylingObj));
-    }
+      if (!stylingObj) return;
+      const definedName = ts9.isIdentifier(name) ? name.text : void 0;
+      if (!definedName) return;
+      result.set(definedName, extractStylingTokens(stylingObj));
+    });
   });
   return result;
 }
@@ -1252,19 +1472,17 @@ function mergeTokens(existing, incoming) {
 function buildManifest(allTokens) {
   const components = {};
   const seen = /* @__PURE__ */ new Set();
-  for (const [name, tokens] of allTokens) {
+  iterate.forEach(allTokens, ([name, tokens]) => {
     components[name] = tokens;
-    for (const cls of [
-      ...tokens.base,
-      ...tokens.variantClasses,
-      ...tokens.compoundClasses,
-      ...tokens.tagClasses
-    ]) {
-      for (const part of cls.split(/\s+/)) {
-        if (part) seen.add(part);
+    iterate.forEach(
+      [...tokens.base, ...tokens.variantClasses, ...tokens.compoundClasses, ...tokens.tagClasses],
+      (cls) => {
+        iterate.forEach(cls.split(/\s+/), (part) => {
+          if (part) seen.add(part);
+        });
       }
-    }
-  }
+    );
+  });
   return {
     components,
     allClasses: [...seen].sort()
@@ -1280,9 +1498,9 @@ function designTokensPlugin(options) {
       const ext = id.split(".").pop() ?? "";
       if (!ALL_EXTS.has(ext)) return null;
       const source = parseSource(id, code);
-      for (const [name, tokens] of collectFileTokens(source, calleeNames)) {
+      iterate.forEach(collectFileTokens(source, calleeNames), ([name, tokens]) => {
         accumulated.set(name, mergeTokens(accumulated.get(name), tokens));
-      }
+      });
       return null;
     },
     writeBundle() {
@@ -1294,7 +1512,7 @@ function designTokensPlugin(options) {
   };
 }
 
-// ../vite-plugin/src/index.ts
+// ../../plugins/vite/src/index.ts
 function contractPlugin(options) {
   const registry = new ConstraintRegistry();
   const calleeNames = new Set(options?.calleeNames ?? DEFAULT_CALLEE_NAMES);
@@ -1308,14 +1526,14 @@ function contractPlugin(options) {
       const { constraints, importSpecifiers } = collectFileDeclarations(source, calleeNames);
       registry.registerConstraints(id, constraints);
       const { diagnostics, usages: allUsages } = analyzeJsxSites(source, constraints, severity);
-      for (const d of diagnostics) {
-        const loc = { file: id, line: d.line, column: d.col };
-        if (d.severity === "error") {
-          this.error({ message: d.message, loc });
+      iterate.forEach(diagnostics, ({ col, diagnostic, line, severity: severity2 }) => {
+        const loc = { file: id, line, column: col };
+        if (severity2 === "error") {
+          this.error({ message: diagnostic.message, loc });
         } else {
-          this.warn({ message: d.message, loc });
+          this.warn({ message: diagnostic.message, loc });
         }
-      }
+      });
       const localNames = new Set(constraints.map((c) => c.name));
       const importedTagsInUse = new Set(
         allUsages.filter((u) => !localNames.has(u.tagName) && importSpecifiers.has(u.tagName)).map((u) => u.tagName)
@@ -1328,22 +1546,25 @@ function contractPlugin(options) {
           if (resolved) resolvedImports.set(localName, resolved.id);
         }
         registry.registerImports(id, resolvedImports);
-        for (const usage of allUsages) {
+        iterate.forEach(allUsages, (usage) => {
           if (importedTagsInUse.has(usage.tagName)) {
             registry.addPendingUsage(id, usage);
           }
-        }
+        });
       }
     },
     buildEnd() {
-      for (const d of registry.diagnostics(severity)) {
-        const loc = { file: d.fileId, line: d.line, column: d.col };
-        if (d.severity === "error") {
-          this.error({ message: d.message, loc });
-        } else {
-          this.warn({ message: d.message, loc });
+      iterate.forEach(
+        registry.diagnostics(severity),
+        ({ col, diagnostic, fileId, line, severity: severity2 }) => {
+          const loc = { file: fileId, line, column: col };
+          if (severity2 === "error") {
+            this.error({ message: diagnostic.message, loc });
+          } else {
+            this.warn({ message: diagnostic.message, loc });
+          }
         }
-      }
+      );
     }
   };
 }