praxis-kit 3.1.1 → 4.0.0

package/dist/tailwind/index.d.ts

@@ -1,6 +1,7 @@
-import { VariantMap, ClassPipelineOptions, StrictMode, ClassPlugin } from '@praxis-kit/core';
+import { VariantMap, ClassPipelineOptions, ClassPlugin } from '@praxis-kit/core';
 import { Simplify } from 'type-fest';
-import { EmptyRecord } from '@praxis-kit/shared';
+import { Diagnostics } from '@praxis-kit/diagnostics';
+import { EmptyRecord } from '@praxis-kit/primitive';
 
 declare const LAYOUT_FAMILY_MAP: {
     readonly flex: "flex";
@@ -56,7 +57,7 @@ type GapToken = Token<'gap'>;
 type UtilityToken = Token<'utility', {
     base: string;
 }>;
-type ClassifiedToken = LayoutToken | ConditionalToken | GapToken | UtilityToken;
+type ClassifiedToken = Simplify<LayoutToken | ConditionalToken | GapToken | UtilityToken>;
 
 type VariantSelection = Record<string, string>;
 type CompoundVariant = {
@@ -96,7 +97,7 @@ type CompoundVariant = {
  * flex-family modes strip `grid-*`; grid-family modes strip `flex-*`; all other
  * display values (and no prop) strip both `flex-*` and `grid-*`.
  */
-declare function createTailwindPipeline<V extends VariantMap = VariantMap>(options: ClassPipelineOptions<V>, strict: StrictMode): ClassPlugin<LayoutProps>;
+declare function createTailwindPipeline<V extends VariantMap = VariantMap>(options: ClassPipelineOptions<V>, diagnostics: Diagnostics): ClassPlugin<LayoutProps>;
 
 declare class ClassBuilder {
     #private;

package/dist/tailwind/index.js

@@ -14,6 +14,288 @@ function cn(...inputs) {
   return clsx(...inputs);
 }
 
+// ../../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
+});
+
+// ../../lib/diagnostics/src/category.ts
+var DiagnosticCategory = /* @__PURE__ */ ((DiagnosticCategory2) => {
+  DiagnosticCategory2[DiagnosticCategory2["Contract"] = 0] = "Contract";
+  DiagnosticCategory2[DiagnosticCategory2["HTML"] = 1] = "HTML";
+  DiagnosticCategory2[DiagnosticCategory2["ARIA"] = 2] = "ARIA";
+  DiagnosticCategory2[DiagnosticCategory2["Composition"] = 3] = "Composition";
+  DiagnosticCategory2[DiagnosticCategory2["Rendering"] = 4] = "Rendering";
+  DiagnosticCategory2[DiagnosticCategory2["Accessibility"] = 5] = "Accessibility";
+  DiagnosticCategory2[DiagnosticCategory2["Performance"] = 6] = "Performance";
+  DiagnosticCategory2[DiagnosticCategory2["Internal"] = 7] = "Internal";
+  DiagnosticCategory2[DiagnosticCategory2["Deprecation"] = 8] = "Deprecation";
+  DiagnosticCategory2[DiagnosticCategory2["Lint"] = 9] = "Lint";
+  return DiagnosticCategory2;
+})(DiagnosticCategory || {});
+
+// ../../lib/diagnostics/src/error.ts
+var PraxisError = class extends Error {
+  diagnostic;
+  constructor(diagnostic) {
+    super(diagnostic.message);
+    this.name = "PraxisError";
+    this.diagnostic = diagnostic;
+  }
+};
+
+// ../../lib/diagnostics/src/severity.ts
+var Severity = /* @__PURE__ */ ((Severity2) => {
+  Severity2[Severity2["Debug"] = 0] = "Debug";
+  Severity2[Severity2["Info"] = 1] = "Info";
+  Severity2[Severity2["Warning"] = 2] = "Warning";
+  Severity2[Severity2["Error"] = 3] = "Error";
+  Severity2[Severity2["Fatal"] = 4] = "Fatal";
+  return Severity2;
+})(Severity || {});
+
+// ../../lib/diagnostics/src/policy.ts
+var DefaultPolicy = class {
+  reportThreshold;
+  throwThreshold;
+  constructor({
+    reportThreshold = 1 /* Info */,
+    throwThreshold = 4 /* Fatal */
+  } = {}) {
+    this.reportThreshold = reportThreshold;
+    this.throwThreshold = throwThreshold;
+  }
+  resolve(diagnostic) {
+    if (diagnostic.severity >= this.throwThreshold) return 2 /* Throw */;
+    if (diagnostic.severity >= this.reportThreshold) return 1 /* Report */;
+    return 0 /* Ignore */;
+  }
+};
+
+// ../../lib/diagnostics/src/diagnostics.ts
+var Diagnostics = class {
+  reporter;
+  policy;
+  // Pre-computed at construction time: true if Warning-level diagnostics are not ignored.
+  active;
+  constructor(reporter, policy = new DefaultPolicy()) {
+    this.reporter = reporter;
+    this.policy = policy;
+    this.active = policy.resolve({ severity: 2 /* Warning */ }) !== 0 /* Ignore */;
+  }
+  report(diagnostic) {
+    const enforcement = this.policy.resolve(diagnostic);
+    if (enforcement === 0 /* Ignore */) return diagnostic;
+    if (enforcement === 2 /* Throw */) throw new PraxisError(diagnostic);
+    this.reporter.report(diagnostic);
+    return diagnostic;
+  }
+  warn(input) {
+    return this.report({ ...input, severity: 2 /* Warning */ });
+  }
+  error(input) {
+    return this.report({ ...input, severity: 3 /* Error */ });
+  }
+  info(input) {
+    return this.report({ ...input, severity: 1 /* Info */ });
+  }
+};
+
+// ../../lib/diagnostics/src/formatter.ts
+function formatDiagnostic(diagnostic) {
+  const level = Severity[diagnostic.severity];
+  const category = DiagnosticCategory[diagnostic.category];
+  const prefix = category !== void 0 ? `[${category}] ` : "";
+  return `${level} ${diagnostic.code}: ${prefix}${diagnostic.message}`;
+}
+
+// ../../lib/diagnostics/src/console-reporter.ts
+var ConsoleReporter = class {
+  report(diagnostic) {
+    const message = formatDiagnostic(diagnostic);
+    switch (diagnostic.severity) {
+      case 0 /* Debug */:
+        console.debug(message);
+        break;
+      case 1 /* Info */:
+        console.info(message);
+        break;
+      case 2 /* Warning */:
+        console.warn(message);
+        break;
+      case 3 /* Error */:
+      case 4 /* Fatal */:
+        console.error(message);
+        break;
+    }
+  }
+};
+
 // ../../node_modules/.pnpm/class-variance-authority@0.7.1/node_modules/class-variance-authority/dist/index.mjs
 import { clsx as clsx2 } from "clsx";
 var falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
@@ -143,15 +425,15 @@ var VariantClassResolver = class _VariantClassResolver {
   #createCacheKey(props, recipe) {
     if (this.#variantKeys !== null) {
       let key2 = recipe;
-      for (const k of this.#variantKeys) {
+      iterate.forEachSet(this.#variantKeys, (k) => {
         if (k in props) key2 += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
-      }
+      });
       return key2;
     }
     let key = recipe;
-    for (const k of Object.keys(props).sort()) {
+    iterate.forEach(Object.keys(props).sort(), (k) => {
       key += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
-    }
+    });
     return key;
   }
   static #serializeValue(value) {
@@ -188,12 +470,12 @@ function createClassPipeline(resolved) {
   };
 }
 
-// ../tailwind/src/class-builder.ts
+// ../../lib/tailwind/src/class-builder.ts
 var ClassBuilder = class {
   build(tokens) {
     const layout = [];
     const normal = [];
-    for (const token of tokens) {
+    iterate.forEach(tokens, (token) => {
       switch (token.kind) {
         case "layout": {
           layout.push(token.raw);
@@ -208,7 +490,7 @@ var ClassBuilder = class {
         default:
           throw assertNever(token);
       }
-    }
+    });
     return [...this.#dedupe(layout).toSorted(), ...this.#dedupe(normal)].join(" ");
   }
   #dedupe(arr) {
@@ -216,7 +498,7 @@ var ClassBuilder = class {
   }
 };
 
-// ../tailwind/src/layout-keys.ts
+// ../../lib/tailwind/src/layout-keys.ts
 var layoutKeys = [
   "flex",
   "inline-flex",
@@ -240,7 +522,7 @@ var layoutKeys = [
   "table-row"
 ];
 
-// ../tailwind/src/constants.ts
+// ../../lib/tailwind/src/constants.ts
 var LAYOUT_OWNED_KEYS = new Set(layoutKeys);
 var LAYOUT_FAMILY_MAP = {
   flex: "flex",
@@ -267,7 +549,7 @@ var LAYOUT_FAMILY_MAP = {
 var EMPTY_SET = /* @__PURE__ */ new Set();
 var COMPOUND_META_KEYS = /* @__PURE__ */ new Set(["class"]);
 
-// ../tailwind/src/class-classifier.ts
+// ../../lib/tailwind/src/class-classifier.ts
 var CONDITIONALS = {
   "[&.flex": "flex",
   "[&.grid": "grid"
@@ -275,15 +557,14 @@ var CONDITIONALS = {
 var ClassClassifier = class _ClassClassifier {
   static #getBaseUtility(token) {
     let depth = 0;
-    for (let i = token.length - 1; i >= 0; i--) {
-      const char = token[i];
+    return iterate.findLast(token, (char, index) => {
       if (char === "]") depth++;
       else if (char === "[") depth--;
-      else if (char === ":" && depth === 0 && token[i - 1] !== "\\") {
-        return token.slice(i + 1);
+      else if (char === ":" && depth === 0 && token[index - 1] !== "\\") {
+        return token.slice(index + 1);
       }
-    }
-    return token;
+      return null;
+    }) ?? token;
   }
   classify(token) {
     const base = _ClassClassifier.#getBaseUtility(token);
@@ -294,15 +575,17 @@ var ClassClassifier = class _ClassClassifier {
         raw: token
       };
     }
-    for (const [prefix, requires] of Object.entries(CONDITIONALS)) {
-      if (token.startsWith(prefix)) {
-        return {
+    const conditional = iterate.find(
+      Object.entries(CONDITIONALS),
+      ([prefix, requires]) => {
+        return token.startsWith(prefix) ? {
           kind: "conditional",
           requires,
           raw: token
-        };
+        } : null;
       }
-    }
+    );
+    if (conditional !== null) return conditional;
     return base === "gap" || base.startsWith("gap-") ? {
       kind: "gap",
       raw: token
@@ -314,13 +597,13 @@ var ClassClassifier = class _ClassClassifier {
   }
 };
 
-// ../tailwind/src/dependency-rules.ts
+// ../../lib/tailwind/src/dependency-rules.ts
 var defaultDependencyRules = {
   flex: [/^flex-/, /^grow/, /^shrink/, /^basis-/],
   grid: [/^grid-/, /^col-/, /^row-/, /^auto-cols-/, /^auto-rows-/]
 };
 
-// ../tailwind/src/dependency-evaluator.ts
+// ../../lib/tailwind/src/dependency-evaluator.ts
 var DependencyEvaluator = class {
   constructor(rules) {
     this.rules = rules;
@@ -335,12 +618,10 @@ var DependencyEvaluator = class {
         return token.requires === state.family;
       }
       case "utility": {
-        for (const layout of Object.keys(this.rules)) {
-          if (this.rules[layout].some((r) => r.test(token.base))) {
-            return state.family === layout;
-          }
-        }
-        return true;
+        return iterate.find(
+          Object.keys(this.rules),
+          (layout) => this.rules[layout].some((rule) => rule.test(token.base)) ? state.family === layout : null
+        ) ?? true;
       }
       case "gap": {
         return state.family !== "none";
@@ -351,7 +632,7 @@ var DependencyEvaluator = class {
   }
 };
 
-// ../tailwind/src/layout-state.ts
+// ../../lib/tailwind/src/layout-state.ts
 var LayoutState = class {
   #mode;
   #family;
@@ -368,31 +649,37 @@ var LayoutState = class {
   }
 };
 
-// ../tailwind/src/create-tailwind-pipeline.ts
-var DEV = process.env.NODE_ENV !== "production";
-var pendingAsyncWarns = /* @__PURE__ */ new Set();
-var asyncWarnScheduled = false;
-function flushAsyncWarns() {
-  asyncWarnScheduled = false;
-  const messages = [...pendingAsyncWarns];
-  pendingAsyncWarns.clear();
-  for (const msg of messages) {
-    console.warn(msg);
-  }
-}
-function pipelineWarn(strict, message) {
-  if (!strict) return;
-  if (strict === "async-warn") {
-    if (pendingAsyncWarns.has(message)) return;
-    pendingAsyncWarns.add(message);
-    if (!asyncWarnScheduled) {
-      asyncWarnScheduled = true;
-      queueMicrotask(flushAsyncWarns);
-    }
-    return;
+// ../../lib/tailwind/src/diagnostics.ts
+var TailwindDiagnostics = {
+  multipleDisplayProps(active) {
+    return {
+      code: "CSS6001" /* TailwindMultipleDisplayProps */,
+      category: 0 /* Contract */,
+      message: `[createTailwindPipeline] Multiple display props set (${active.join(", ")}); "${active[0]}" takes precedence.`
+    };
+  },
+  reservedLayoutLiteral(reserved) {
+    return {
+      code: "CSS6002" /* TailwindReservedLayoutLiteral */,
+      category: 0 /* Contract */,
+      message: `[createTailwindPipeline] Reserved display class(es) ${reserved.map((r) => `"${r}"`).join(", ")} found in resolved classes. The display mode is controlled by the display props (flex, inline-flex, grid, block, hidden, etc.), not by class strings.`
+    };
+  },
+  deadVariantClass(dim, value, mode, classStr) {
+    return {
+      code: "CSS6003" /* TailwindDeadVariantClass */,
+      category: 0 /* Contract */,
+      message: `[createTailwindPipeline] Variant "${dim}=${value}" contributes only classes stripped under layout mode "${mode}" ("${classStr}") \u2014 it produces nothing in this mode.`
+    };
   }
-  console.warn(message);
-}
+};
+
+// ../../lib/tailwind/src/create-tailwind-pipeline.ts
+var DEV = process.env.NODE_ENV !== "production";
+var devDiagnostics = new Diagnostics(
+  new ConsoleReporter(),
+  new DefaultPolicy({ reportThreshold: 2 /* Warning */, throwThreshold: 4 /* Fatal */ })
+);
 var classifier = new ClassClassifier();
 var evaluator = new DependencyEvaluator(defaultDependencyRules);
 var builder = new ClassBuilder();
@@ -400,29 +687,23 @@ function normalizeVariantValue(value) {
   if (isString(value)) return value;
   return value.join(" ");
 }
-function resolveLayout(props) {
+function resolveLayout(diagnostics, props) {
   const active = [];
-  for (const key of layoutKeys) {
+  iterate.forEach(layoutKeys, (key) => {
     if (props[key]) active.push(key);
-  }
+  });
   if (DEV && active.length > 1) {
-    console.warn(
-      `[createTailwindPipeline] Multiple display props set (${active.join(", ")}); "${active[0]}" takes precedence.`
-    );
+    diagnostics.warn(TailwindDiagnostics.multipleDisplayProps(active));
   }
   return active[0] ?? "none";
 }
-function warnReservedLayoutLiterals(strict, tokens) {
-  if (!strict) return;
+function warnReservedLayoutLiterals(diagnostics, tokens) {
   const reserved = [];
-  for (const token of tokens) {
+  iterate.forEach(tokens, (token) => {
     if (token.kind === "layout") reserved.push(token.raw);
-  }
+  });
   if (reserved.length === 0) return;
-  pipelineWarn(
-    strict,
-    `[createTailwindPipeline] Reserved display class(es) ${reserved.map((r) => `"${r}"`).join(", ")} found in resolved classes. The display mode is controlled by the display props (flex, inline-flex, grid, block, hidden, etc.), not by class strings.`
-  );
+  diagnostics.warn(TailwindDiagnostics.reservedLayoutLiteral(reserved));
 }
 function getVariantConfig(options) {
   return options.variants;
@@ -436,11 +717,11 @@ function classifyTokens(className) {
 function compoundDimensions(compounds) {
   if (compounds.length === 0) return EMPTY_SET;
   const dims = /* @__PURE__ */ new Set();
-  for (const compound of compounds) {
-    for (const key in compound) {
+  iterate.forEach(compounds, (compound) => {
+    iterate.forEachKey(compound, (key) => {
       if (!COMPOUND_META_KEYS.has(key)) dims.add(key);
-    }
-  }
+    });
+  });
   return dims;
 }
 function getDefaultVariants(options) {
@@ -450,46 +731,41 @@ function resolveActiveSelection(options, variants, props, recipe) {
   const preset = recipe ? options.recipeMap?.[recipe] : void 0;
   const defaults = getDefaultVariants(options);
   const selection = {};
-  for (const dim in variants) {
+  iterate.forEachKey(variants, (dim) => {
     const value = props[dim] ?? preset?.[dim] ?? defaults?.[dim];
     if (value !== void 0 && value !== null) selection[dim] = String(value);
-  }
+  });
   return selection;
 }
-function warnDeadVariants(strict, options, compoundDims, props, recipe, state) {
-  if (!strict) return;
+function warnDeadVariants(diagnostics, options, compoundDims, props, recipe, state) {
   const variants = getVariantConfig(options);
   if (!variants) return;
   const selection = resolveActiveSelection(options, variants, props, recipe);
-  for (const dim in selection) {
-    if (compoundDims.has(dim)) continue;
-    const value = selection[dim];
+  iterate.forEachEntry(selection, (dim, value) => {
+    if (compoundDims.has(dim)) return;
     const raw = variants[dim]?.[value];
-    if (raw == null) continue;
+    if (raw == null) return;
     const classStr = normalizeVariantValue(raw);
     const tokens = classifyTokens(classStr);
-    if (tokens.length === 0) continue;
+    if (tokens.length === 0) return;
     if (tokens.every((t) => !evaluator.evaluate(t, state))) {
-      pipelineWarn(
-        strict,
-        `[createTailwindPipeline] Variant "${dim}=${value}" contributes only classes stripped under layout mode "${state.mode}" ("${classStr}") \u2014 it produces nothing in this mode.`
-      );
+      diagnostics.warn(TailwindDiagnostics.deadVariantClass(dim, value, state.mode, classStr));
     }
-  }
+  });
 }
-function createTailwindPipeline(options, strict) {
+function createTailwindPipeline(options, diagnostics) {
   const pipeline = createClassPipeline(options);
   const compoundDims = compoundDimensions(getCompoundVariants(options));
   return {
     ownedKeys: LAYOUT_OWNED_KEYS,
     pipeline(tag, props, className, recipe) {
-      const mode = resolveLayout(props);
+      const mode = resolveLayout(devDiagnostics, props);
       const raw = pipeline(tag, props, className, recipe);
       const tokens = classifyTokens(raw);
       const state = new LayoutState(mode);
       if (DEV) {
-        warnReservedLayoutLiterals(strict, tokens);
-        warnDeadVariants(strict, options, compoundDims, props, recipe, state);
+        warnReservedLayoutLiterals(diagnostics, tokens);
+        warnDeadVariants(diagnostics, options, compoundDims, props, recipe, state);
       }
       const filtered = tokens.filter((token) => evaluator.evaluate(token, state));
       const built = builder.build(filtered);

package/dist/ts-plugin/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 
-// ../ts-plugin/src/ast.ts
+// ../../plugins/typescript/src/ast.ts
 function getObjectProperty(ts, obj, key) {
   for (const prop of obj.properties) {
     if (!ts.isPropertyAssignment(prop)) continue;
@@ -39,7 +39,7 @@ function getFirstObjectArg(ts, node) {
   return ts.isObjectLiteralExpression(first) ? first : void 0;
 }
 
-// ../ts-plugin/src/diagnostics/walk-enforcement.ts
+// ../../plugins/typescript/src/diagnostics/walk-enforcement.ts
 function walkEnforcement(ts, sourceFile, calleeNames, cb) {
   function visit(node) {
     if (ts.isCallExpression(node) && isFactoryCall(ts, node, calleeNames)) {
@@ -57,7 +57,7 @@ function walkEnforcement(ts, sourceFile, calleeNames, cb) {
   visit(sourceFile);
 }
 
-// ../ts-plugin/src/diagnostics/no-enforcement-without-strict.ts
+// ../../plugins/typescript/src/diagnostics/no-enforcement-without-strict.ts
 var MISSING_STRICT_CODE = 90001;
 function checkNoEnforcementWithoutStrict(ts, sourceFile, calleeNames) {
   const diagnostics = [];
@@ -87,7 +87,7 @@ function checkNoEnforcementWithoutStrict(ts, sourceFile, calleeNames) {
   return diagnostics;
 }
 
-// ../ts-plugin/src/diagnostics/valid-cardinality.ts
+// ../../plugins/typescript/src/diagnostics/valid-cardinality.ts
 var NEGATIVE_MIN_CODE = 90002;
 var NEGATIVE_MAX_CODE = 90003;
 var MAX_LESS_THAN_MIN_CODE = 90004;
@@ -158,7 +158,7 @@ function checkValidCardinality(ts, sourceFile, calleeNames) {
   return diagnostics;
 }
 
-// ../ts-plugin/src/index.ts
+// ../../plugins/typescript/src/index.ts
 var DEFAULT_CALLEE_NAMES = ["createContractComponent"];
 function init(modules) {
   const ts = modules.typescript;