tailwind-styled-v4 1.0.0 → 4.0.0

package/dist/compiler.cjs

@@ -0,0 +1,3594 @@
+'use strict';
+
+var module$1 = require('module');
+var tailwindMerge = require('tailwind-merge');
+var fs2 = require('fs');
+var path4 = require('path');
+var crypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+var path4__default = /*#__PURE__*/_interopDefault(path4);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
+/* tailwind-styled-v4 v4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+function requireNative() {
+  var _a2, _b2, _c, _d;
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      return require2(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err);
+    }
+  } else if (process.platform === "android") {
+    if (process.arch === "arm64") {
+      try {
+        return require2("./parser.android-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-android-arm64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-android-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm") {
+      try {
+        return require2("./parser.android-arm-eabi.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-android-arm-eabi");
+        const bindingPackageVersion = require2("@oxc-parser/binding-android-arm-eabi/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
+    }
+  } else if (process.platform === "win32") {
+    if (process.arch === "x64") {
+      if (((_b2 = (_a2 = process.config) == null ? void 0 : _a2.variables) == null ? void 0 : _b2.shlib_suffix) === "dll.a" || ((_d = (_c = process.config) == null ? void 0 : _c.variables) == null ? void 0 : _d.node_target_type) === "shared_library") {
+        try {
+          return require2("./parser.win32-x64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-win32-x64-gnu");
+          const bindingPackageVersion = require2("@oxc-parser/binding-win32-x64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.win32-x64-msvc.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-win32-x64-msvc");
+          const bindingPackageVersion = require2("@oxc-parser/binding-win32-x64-msvc/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "ia32") {
+      try {
+        return require2("./parser.win32-ia32-msvc.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-win32-ia32-msvc");
+        const bindingPackageVersion = require2("@oxc-parser/binding-win32-ia32-msvc/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./parser.win32-arm64-msvc.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-win32-arm64-msvc");
+        const bindingPackageVersion = require2("@oxc-parser/binding-win32-arm64-msvc/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+    }
+  } else if (process.platform === "darwin") {
+    try {
+      return require2("./parser.darwin-universal.node");
+    } catch (e) {
+      loadErrors.push(e);
+    }
+    try {
+      const binding = require2("@oxc-parser/binding-darwin-universal");
+      const bindingPackageVersion = require2("@oxc-parser/binding-darwin-universal/package.json").version;
+      if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+        throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+      }
+      return binding;
+    } catch (e) {
+      loadErrors.push(e);
+    }
+    if (process.arch === "x64") {
+      try {
+        return require2("./parser.darwin-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-darwin-x64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-darwin-x64/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./parser.darwin-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-darwin-arm64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-darwin-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+    }
+  } else if (process.platform === "freebsd") {
+    if (process.arch === "x64") {
+      try {
+        return require2("./parser.freebsd-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-freebsd-x64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-freebsd-x64/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./parser.freebsd-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-freebsd-arm64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-freebsd-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+    }
+  } else if (process.platform === "linux") {
+    if (process.arch === "x64") {
+      if (isMusl()) {
+        try {
+          return require2("./parser.linux-x64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-x64-musl");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-x64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.linux-x64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-x64-gnu");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-x64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "arm64") {
+      if (isMusl()) {
+        try {
+          return require2("./parser.linux-arm64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-arm64-musl");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.linux-arm64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-arm64-gnu");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "arm") {
+      if (isMusl()) {
+        try {
+          return require2("./parser.linux-arm-musleabihf.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-arm-musleabihf");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm-musleabihf/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.linux-arm-gnueabihf.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-arm-gnueabihf");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm-gnueabihf/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "loong64") {
+      if (isMusl()) {
+        try {
+          return require2("./parser.linux-loong64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-loong64-musl");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-loong64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.linux-loong64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-loong64-gnu");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-loong64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "riscv64") {
+      if (isMusl()) {
+        try {
+          return require2("./parser.linux-riscv64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-riscv64-musl");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-riscv64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./parser.linux-riscv64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@oxc-parser/binding-linux-riscv64-gnu");
+          const bindingPackageVersion = require2("@oxc-parser/binding-linux-riscv64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "ppc64") {
+      try {
+        return require2("./parser.linux-ppc64-gnu.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-linux-ppc64-gnu");
+        const bindingPackageVersion = require2("@oxc-parser/binding-linux-ppc64-gnu/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "s390x") {
+      try {
+        return require2("./parser.linux-s390x-gnu.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-linux-s390x-gnu");
+        const bindingPackageVersion = require2("@oxc-parser/binding-linux-s390x-gnu/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
+    }
+  } else if (process.platform === "openharmony") {
+    if (process.arch === "arm64") {
+      try {
+        return require2("./parser.openharmony-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-openharmony-arm64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-openharmony-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "x64") {
+      try {
+        return require2("./parser.openharmony-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-openharmony-x64");
+        const bindingPackageVersion = require2("@oxc-parser/binding-openharmony-x64/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm") {
+      try {
+        return require2("./parser.openharmony-arm.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@oxc-parser/binding-openharmony-arm");
+        const bindingPackageVersion = require2("@oxc-parser/binding-openharmony-arm/package.json").version;
+        if (bindingPackageVersion !== "0.118.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.118.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+  }
+}
+var import_meta, require2, readFileSync, nativeBinding, loadErrors, isMusl, isFileMusl, isMuslFromFilesystem, isMuslFromReport, isMuslFromChildProcess, _a, _b, Severity, ParseResult, ExportExportNameKind, ExportImportNameKind, ExportLocalNameKind, ImportNameKind, parse, parseSync, rawTransferSupported, getBufferOffset, parseRaw, parseRawSync;
+var init_bindings = __esm({
+  "../../node_modules/oxc-parser/src-js/bindings.js"() {
+    import_meta = {};
+    require2 = module$1.createRequire(import_meta.url);
+    new URL(".", import_meta.url).pathname;
+    ({ readFileSync } = require2("node:fs"));
+    nativeBinding = null;
+    loadErrors = [];
+    isMusl = () => {
+      let musl = false;
+      if (process.platform === "linux") {
+        musl = isMuslFromFilesystem();
+        if (musl === null) {
+          musl = isMuslFromReport();
+        }
+        if (musl === null) {
+          musl = isMuslFromChildProcess();
+        }
+      }
+      return musl;
+    };
+    isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+    isMuslFromFilesystem = () => {
+      try {
+        return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+      } catch (e) {
+        return null;
+      }
+    };
+    isMuslFromReport = () => {
+      var _a2;
+      let report = null;
+      if (typeof ((_a2 = process.report) == null ? void 0 : _a2.getReport) === "function") {
+        process.report.excludeNetwork = true;
+        report = process.report.getReport();
+      }
+      if (!report) {
+        return null;
+      }
+      if (report.header && report.header.glibcVersionRuntime) {
+        return false;
+      }
+      if (Array.isArray(report.sharedObjects)) {
+        if (report.sharedObjects.some(isFileMusl)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    isMuslFromChildProcess = () => {
+      try {
+        return require2("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+      } catch (e) {
+        return false;
+      }
+    };
+    nativeBinding = requireNative();
+    if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+      let wasiBinding = null;
+      let wasiBindingError = null;
+      try {
+        wasiBinding = require2("./parser.wasi.cjs");
+        nativeBinding = wasiBinding;
+      } catch (err) {
+        if (process.env.NAPI_RS_FORCE_WASI) {
+          wasiBindingError = err;
+        }
+      }
+      if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+        try {
+          wasiBinding = require2("@oxc-parser/binding-wasm32-wasi");
+          nativeBinding = wasiBinding;
+        } catch (err) {
+          if (process.env.NAPI_RS_FORCE_WASI) {
+            if (!wasiBindingError) {
+              wasiBindingError = err;
+            } else {
+              wasiBindingError.cause = err;
+            }
+            loadErrors.push(err);
+          }
+        }
+      }
+      if (process.env.NAPI_RS_FORCE_WASI === "error" && !wasiBinding) {
+        const error = new Error("WASI binding not found and NAPI_RS_FORCE_WASI is set to error");
+        error.cause = wasiBindingError;
+        throw error;
+      }
+    }
+    if (!nativeBinding && ((_b = (_a = globalThis.process) == null ? void 0 : _a.versions) == null ? void 0 : _b["webcontainer"])) {
+      try {
+        nativeBinding = require2("./webcontainer-fallback.cjs");
+      } catch (err) {
+        loadErrors.push(err);
+      }
+    }
+    if (!nativeBinding) {
+      if (loadErrors.length > 0) {
+        throw new Error(
+          `Cannot find native binding. npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). Please try \`npm i\` again after removing both package-lock.json and node_modules directory.`,
+          {
+            cause: loadErrors.reduce((err, cur) => {
+              cur.cause = err;
+              return cur;
+            })
+          }
+        );
+      }
+      throw new Error(`Failed to load native binding`);
+    }
+    ({ Severity, ParseResult, ExportExportNameKind, ExportImportNameKind, ExportLocalNameKind, ImportNameKind, parse, parseSync, rawTransferSupported } = nativeBinding);
+    ({ getBufferOffset, parseRaw, parseRawSync } = nativeBinding);
+  }
+});
+
+// ../../node_modules/oxc-parser/src-js/wrap.js
+function wrap(result) {
+  let program, module, comments, errors;
+  return {
+    get program() {
+      if (!program) program = jsonParseAst(result.program);
+      return program;
+    },
+    get module() {
+      if (!module) module = result.module;
+      return module;
+    },
+    get comments() {
+      if (!comments) comments = result.comments;
+      return comments;
+    },
+    get errors() {
+      if (!errors) errors = result.errors;
+      return errors;
+    }
+  };
+}
+function jsonParseAst(programJson) {
+  const { node: program, fixes } = JSON.parse(programJson);
+  for (const fixPath of fixes) {
+    applyFix(program, fixPath);
+  }
+  return program;
+}
+function applyFix(program, fixPath) {
+  let node = program;
+  for (const key of fixPath) {
+    node = node[key];
+  }
+  if (node.bigint) {
+    node.value = BigInt(node.bigint);
+  } else {
+    try {
+      node.value = RegExp(node.regex.pattern, node.regex.flags);
+    } catch (e) {
+    }
+  }
+}
+var init_wrap = __esm({
+  "../../node_modules/oxc-parser/src-js/wrap.js"() {
+  }
+});
+
+// ../../node_modules/oxc-parser/src-js/generated/visit/keys.js
+var freeze, $EMPTY, DECORATORS__KEY__TYPE_ANNOTATION__VALUE, LEFT__RIGHT, ARGUMENT, BODY, LABEL, CALLEE__TYPE_ARGUMENTS__ARGUMENTS, EXPRESSION, DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY, TEST__CONSEQUENT__ALTERNATE, LEFT__RIGHT__BODY, ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY, KEY__VALUE, LOCAL, OBJECT__PROPERTY, DECORATORS__KEY__TYPE_ANNOTATION, EXPRESSION__TYPE_ANNOTATION, TYPE_PARAMETERS__PARAMS__RETURN_TYPE, EXPRESSION__TYPE_ARGUMENTS, MEMBERS, ID__BODY, TYPES, TYPE_ANNOTATION, PARAMS, keys_default;
+var init_keys = __esm({
+  "../../node_modules/oxc-parser/src-js/generated/visit/keys.js"() {
+    ({ freeze } = Object);
+    $EMPTY = freeze([]);
+    DECORATORS__KEY__TYPE_ANNOTATION__VALUE = freeze([
+      "decorators",
+      "key",
+      "typeAnnotation",
+      "value"
+    ]);
+    LEFT__RIGHT = freeze(["left", "right"]);
+    ARGUMENT = freeze(["argument"]);
+    BODY = freeze(["body"]);
+    LABEL = freeze(["label"]);
+    CALLEE__TYPE_ARGUMENTS__ARGUMENTS = freeze(["callee", "typeArguments", "arguments"]);
+    EXPRESSION = freeze(["expression"]);
+    DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY = freeze([
+      "decorators",
+      "id",
+      "typeParameters",
+      "superClass",
+      "superTypeArguments",
+      "implements",
+      "body"
+    ]);
+    TEST__CONSEQUENT__ALTERNATE = freeze(["test", "consequent", "alternate"]);
+    LEFT__RIGHT__BODY = freeze(["left", "right", "body"]);
+    ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY = freeze([
+      "id",
+      "typeParameters",
+      "params",
+      "returnType",
+      "body"
+    ]);
+    KEY__VALUE = freeze(["key", "value"]);
+    LOCAL = freeze(["local"]);
+    OBJECT__PROPERTY = freeze(["object", "property"]);
+    DECORATORS__KEY__TYPE_ANNOTATION = freeze(["decorators", "key", "typeAnnotation"]);
+    EXPRESSION__TYPE_ANNOTATION = freeze(["expression", "typeAnnotation"]);
+    TYPE_PARAMETERS__PARAMS__RETURN_TYPE = freeze(["typeParameters", "params", "returnType"]);
+    EXPRESSION__TYPE_ARGUMENTS = freeze(["expression", "typeArguments"]);
+    MEMBERS = freeze(["members"]);
+    ID__BODY = freeze(["id", "body"]);
+    TYPES = freeze(["types"]);
+    TYPE_ANNOTATION = freeze(["typeAnnotation"]);
+    PARAMS = freeze(["params"]);
+    keys_default = freeze({
+      // Leaf nodes
+      DebuggerStatement: $EMPTY,
+      EmptyStatement: $EMPTY,
+      Literal: $EMPTY,
+      PrivateIdentifier: $EMPTY,
+      Super: $EMPTY,
+      TemplateElement: $EMPTY,
+      ThisExpression: $EMPTY,
+      JSXClosingFragment: $EMPTY,
+      JSXEmptyExpression: $EMPTY,
+      JSXIdentifier: $EMPTY,
+      JSXOpeningFragment: $EMPTY,
+      JSXText: $EMPTY,
+      TSAnyKeyword: $EMPTY,
+      TSBigIntKeyword: $EMPTY,
+      TSBooleanKeyword: $EMPTY,
+      TSIntrinsicKeyword: $EMPTY,
+      TSJSDocUnknownType: $EMPTY,
+      TSNeverKeyword: $EMPTY,
+      TSNullKeyword: $EMPTY,
+      TSNumberKeyword: $EMPTY,
+      TSObjectKeyword: $EMPTY,
+      TSStringKeyword: $EMPTY,
+      TSSymbolKeyword: $EMPTY,
+      TSThisType: $EMPTY,
+      TSUndefinedKeyword: $EMPTY,
+      TSUnknownKeyword: $EMPTY,
+      TSVoidKeyword: $EMPTY,
+      // Non-leaf nodes
+      AccessorProperty: DECORATORS__KEY__TYPE_ANNOTATION__VALUE,
+      ArrayExpression: freeze(["elements"]),
+      ArrayPattern: freeze(["decorators", "elements", "typeAnnotation"]),
+      ArrowFunctionExpression: freeze(["typeParameters", "params", "returnType", "body"]),
+      AssignmentExpression: LEFT__RIGHT,
+      AssignmentPattern: freeze(["decorators", "left", "right", "typeAnnotation"]),
+      AwaitExpression: ARGUMENT,
+      BinaryExpression: LEFT__RIGHT,
+      BlockStatement: BODY,
+      BreakStatement: LABEL,
+      CallExpression: CALLEE__TYPE_ARGUMENTS__ARGUMENTS,
+      CatchClause: freeze(["param", "body"]),
+      ChainExpression: EXPRESSION,
+      ClassBody: BODY,
+      ClassDeclaration: DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY,
+      ClassExpression: DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY,
+      ConditionalExpression: TEST__CONSEQUENT__ALTERNATE,
+      ContinueStatement: LABEL,
+      Decorator: EXPRESSION,
+      DoWhileStatement: freeze(["body", "test"]),
+      ExportAllDeclaration: freeze(["exported", "source", "attributes"]),
+      ExportDefaultDeclaration: freeze(["declaration"]),
+      ExportNamedDeclaration: freeze(["declaration", "specifiers", "source", "attributes"]),
+      ExportSpecifier: freeze(["local", "exported"]),
+      ExpressionStatement: EXPRESSION,
+      ForInStatement: LEFT__RIGHT__BODY,
+      ForOfStatement: LEFT__RIGHT__BODY,
+      ForStatement: freeze(["init", "test", "update", "body"]),
+      FunctionDeclaration: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
+      FunctionExpression: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
+      Identifier: freeze(["decorators", "typeAnnotation"]),
+      IfStatement: TEST__CONSEQUENT__ALTERNATE,
+      ImportAttribute: KEY__VALUE,
+      ImportDeclaration: freeze(["specifiers", "source", "attributes"]),
+      ImportDefaultSpecifier: LOCAL,
+      ImportExpression: freeze(["source", "options"]),
+      ImportNamespaceSpecifier: LOCAL,
+      ImportSpecifier: freeze(["imported", "local"]),
+      LabeledStatement: freeze(["label", "body"]),
+      LogicalExpression: LEFT__RIGHT,
+      MemberExpression: OBJECT__PROPERTY,
+      MetaProperty: freeze(["meta", "property"]),
+      MethodDefinition: freeze(["decorators", "key", "value"]),
+      NewExpression: CALLEE__TYPE_ARGUMENTS__ARGUMENTS,
+      ObjectExpression: freeze(["properties"]),
+      ObjectPattern: freeze(["decorators", "properties", "typeAnnotation"]),
+      ParenthesizedExpression: EXPRESSION,
+      Program: BODY,
+      Property: KEY__VALUE,
+      PropertyDefinition: DECORATORS__KEY__TYPE_ANNOTATION__VALUE,
+      RestElement: freeze(["decorators", "argument", "typeAnnotation"]),
+      ReturnStatement: ARGUMENT,
+      SequenceExpression: freeze(["expressions"]),
+      SpreadElement: ARGUMENT,
+      StaticBlock: BODY,
+      SwitchCase: freeze(["test", "consequent"]),
+      SwitchStatement: freeze(["discriminant", "cases"]),
+      TaggedTemplateExpression: freeze(["tag", "typeArguments", "quasi"]),
+      TemplateLiteral: freeze(["quasis", "expressions"]),
+      ThrowStatement: ARGUMENT,
+      TryStatement: freeze(["block", "handler", "finalizer"]),
+      UnaryExpression: ARGUMENT,
+      UpdateExpression: ARGUMENT,
+      V8IntrinsicExpression: freeze(["name", "arguments"]),
+      VariableDeclaration: freeze(["declarations"]),
+      VariableDeclarator: freeze(["id", "init"]),
+      WhileStatement: freeze(["test", "body"]),
+      WithStatement: freeze(["object", "body"]),
+      YieldExpression: ARGUMENT,
+      JSXAttribute: freeze(["name", "value"]),
+      JSXClosingElement: freeze(["name"]),
+      JSXElement: freeze(["openingElement", "children", "closingElement"]),
+      JSXExpressionContainer: EXPRESSION,
+      JSXFragment: freeze(["openingFragment", "children", "closingFragment"]),
+      JSXMemberExpression: OBJECT__PROPERTY,
+      JSXNamespacedName: freeze(["namespace", "name"]),
+      JSXOpeningElement: freeze(["name", "typeArguments", "attributes"]),
+      JSXSpreadAttribute: ARGUMENT,
+      JSXSpreadChild: EXPRESSION,
+      TSAbstractAccessorProperty: DECORATORS__KEY__TYPE_ANNOTATION,
+      TSAbstractMethodDefinition: KEY__VALUE,
+      TSAbstractPropertyDefinition: DECORATORS__KEY__TYPE_ANNOTATION,
+      TSArrayType: freeze(["elementType"]),
+      TSAsExpression: EXPRESSION__TYPE_ANNOTATION,
+      TSCallSignatureDeclaration: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+      TSClassImplements: EXPRESSION__TYPE_ARGUMENTS,
+      TSConditionalType: freeze(["checkType", "extendsType", "trueType", "falseType"]),
+      TSConstructSignatureDeclaration: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+      TSConstructorType: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+      TSDeclareFunction: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
+      TSEmptyBodyFunctionExpression: freeze(["id", "typeParameters", "params", "returnType"]),
+      TSEnumBody: MEMBERS,
+      TSEnumDeclaration: ID__BODY,
+      TSEnumMember: freeze(["id", "initializer"]),
+      TSExportAssignment: EXPRESSION,
+      TSExternalModuleReference: EXPRESSION,
+      TSFunctionType: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+      TSImportEqualsDeclaration: freeze(["id", "moduleReference"]),
+      TSImportType: freeze(["source", "options", "qualifier", "typeArguments"]),
+      TSIndexSignature: freeze(["parameters", "typeAnnotation"]),
+      TSIndexedAccessType: freeze(["objectType", "indexType"]),
+      TSInferType: freeze(["typeParameter"]),
+      TSInstantiationExpression: EXPRESSION__TYPE_ARGUMENTS,
+      TSInterfaceBody: BODY,
+      TSInterfaceDeclaration: freeze(["id", "typeParameters", "extends", "body"]),
+      TSInterfaceHeritage: EXPRESSION__TYPE_ARGUMENTS,
+      TSIntersectionType: TYPES,
+      TSJSDocNonNullableType: TYPE_ANNOTATION,
+      TSJSDocNullableType: TYPE_ANNOTATION,
+      TSLiteralType: freeze(["literal"]),
+      TSMappedType: freeze(["key", "constraint", "nameType", "typeAnnotation"]),
+      TSMethodSignature: freeze(["key", "typeParameters", "params", "returnType"]),
+      TSModuleBlock: BODY,
+      TSModuleDeclaration: ID__BODY,
+      TSNamedTupleMember: freeze(["label", "elementType"]),
+      TSNamespaceExportDeclaration: freeze(["id"]),
+      TSNonNullExpression: EXPRESSION,
+      TSOptionalType: TYPE_ANNOTATION,
+      TSParameterProperty: freeze(["decorators", "parameter"]),
+      TSParenthesizedType: TYPE_ANNOTATION,
+      TSPropertySignature: freeze(["key", "typeAnnotation"]),
+      TSQualifiedName: LEFT__RIGHT,
+      TSRestType: TYPE_ANNOTATION,
+      TSSatisfiesExpression: EXPRESSION__TYPE_ANNOTATION,
+      TSTemplateLiteralType: freeze(["quasis", "types"]),
+      TSTupleType: freeze(["elementTypes"]),
+      TSTypeAliasDeclaration: freeze(["id", "typeParameters", "typeAnnotation"]),
+      TSTypeAnnotation: TYPE_ANNOTATION,
+      TSTypeAssertion: freeze(["typeAnnotation", "expression"]),
+      TSTypeLiteral: MEMBERS,
+      TSTypeOperator: TYPE_ANNOTATION,
+      TSTypeParameter: freeze(["name", "constraint", "default"]),
+      TSTypeParameterDeclaration: PARAMS,
+      TSTypeParameterInstantiation: PARAMS,
+      TSTypePredicate: freeze(["parameterName", "typeAnnotation"]),
+      TSTypeQuery: freeze(["exprName", "typeArguments"]),
+      TSTypeReference: freeze(["typeName", "typeArguments"]),
+      TSUnionType: TYPES
+    });
+  }
+});
+var import_meta2, walkProgram, addVisitorToCompiled, createCompiledVisitor, finalizeCompiledVisitor, _compiledVisitor, Visitor;
+var init_visit = __esm({
+  "../../node_modules/oxc-parser/src-js/visit/index.js"() {
+    import_meta2 = {};
+    walkProgram = null;
+    Visitor = class {
+      constructor(visitor) {
+        __privateAdd(this, _compiledVisitor, null);
+        if (walkProgram === null) {
+          const require4 = module$1.createRequire(import_meta2.url);
+          ({ walkProgram } = require4("../generated/visit/walk.js"));
+          ({
+            addVisitorToCompiled,
+            createCompiledVisitor,
+            finalizeCompiledVisitor
+          } = require4("./visitor.js"));
+        }
+        const compiledVisitor = createCompiledVisitor();
+        addVisitorToCompiled(visitor);
+        const needsVisit = finalizeCompiledVisitor();
+        if (needsVisit) __privateSet(this, _compiledVisitor, compiledVisitor);
+      }
+      /**
+       * Visit AST.
+       * @param program - The AST to visit.
+       * @returns {undefined}
+       */
+      visit(program) {
+        const compiledVisitor = __privateGet(this, _compiledVisitor);
+        if (compiledVisitor !== null) walkProgram(program, compiledVisitor);
+      }
+    };
+    _compiledVisitor = new WeakMap();
+  }
+});
+
+// ../../node_modules/oxc-parser/src-js/raw-transfer/supported.js
+function rawTransferSupported2() {
+  if (rawTransferIsSupported === null) {
+    rawTransferIsSupported = rawTransferRuntimeSupported() && rawTransferSupported();
+  }
+  return rawTransferIsSupported;
+}
+function rawTransferRuntimeSupported() {
+  var _a2, _b2, _c, _d, _e, _f, _g;
+  let global;
+  try {
+    global = globalThis;
+  } catch (e) {
+    return false;
+  }
+  const isBun = !!global.Bun || !!((_b2 = (_a2 = global.process) == null ? void 0 : _a2.versions) == null ? void 0 : _b2.bun);
+  if (isBun) return false;
+  const isDeno = !!global.Deno;
+  if (isDeno) {
+    const match2 = (_d = (_c = Deno.version) == null ? void 0 : _c.deno) == null ? void 0 : _d.match(/^(\d+)\./);
+    return !!match2 && match2[1] * 1 >= 2;
+  }
+  const isNode = ((_f = (_e = global.process) == null ? void 0 : _e.release) == null ? void 0 : _f.name) === "node";
+  if (!isNode) return false;
+  const match = (_g = process.version) == null ? void 0 : _g.match(/^v(\d+)\./);
+  return !!match && match[1] * 1 >= 22;
+}
+var rawTransferIsSupported;
+var init_supported = __esm({
+  "../../node_modules/oxc-parser/src-js/raw-transfer/supported.js"() {
+    init_bindings();
+    rawTransferIsSupported = null;
+  }
+});
+
+// ../../node_modules/oxc-parser/src-js/index.js
+var src_js_exports = {};
+__export(src_js_exports, {
+  ExportExportNameKind: () => ExportExportNameKind,
+  ExportImportNameKind: () => ExportImportNameKind,
+  ExportLocalNameKind: () => ExportLocalNameKind,
+  ImportNameKind: () => ImportNameKind,
+  ParseResult: () => ParseResult,
+  Severity: () => Severity,
+  Visitor: () => Visitor,
+  experimentalGetLazyVisitor: () => experimentalGetLazyVisitor,
+  parse: () => parse2,
+  parseSync: () => parseSync2,
+  rawTransferSupported: () => rawTransferSupported2,
+  visitorKeys: () => keys_default
+});
+function loadRawTransfer() {
+  if (parseSyncRaw === null) {
+    ({ parseSyncRaw, parse: parseRaw2 } = require3("./raw-transfer/eager.js"));
+  }
+}
+function loadRawTransferLazy() {
+  if (parseSyncLazy === null) {
+    ({ parseSyncLazy, parse: parseLazy, Visitor: LazyVisitor } = require3("./raw-transfer/lazy.js"));
+  }
+}
+function parseSync2(filename, sourceText, options) {
+  if (options == null ? void 0 : options.experimentalRawTransfer) {
+    loadRawTransfer();
+    return parseSyncRaw(filename, sourceText, options);
+  }
+  if (options == null ? void 0 : options.experimentalLazy) {
+    loadRawTransferLazy();
+    return parseSyncLazy(filename, sourceText, options);
+  }
+  return wrap(parseSync(filename, sourceText, options));
+}
+async function parse2(filename, sourceText, options) {
+  if (options == null ? void 0 : options.experimentalRawTransfer) {
+    loadRawTransfer();
+    return await parseRaw2(filename, sourceText, options);
+  }
+  if (options == null ? void 0 : options.experimentalLazy) {
+    loadRawTransferLazy();
+    return await parseLazy(filename, sourceText, options);
+  }
+  return wrap(await parse(filename, sourceText, options));
+}
+function experimentalGetLazyVisitor() {
+  loadRawTransferLazy();
+  return LazyVisitor;
+}
+var import_meta3, require3, parseSyncRaw, parseRaw2, parseSyncLazy, parseLazy, LazyVisitor;
+var init_src_js = __esm({
+  "../../node_modules/oxc-parser/src-js/index.js"() {
+    init_bindings();
+    init_wrap();
+    init_keys();
+    init_visit();
+    init_bindings();
+    init_supported();
+    import_meta3 = {};
+    require3 = module$1.createRequire(import_meta3.url);
+    parseSyncRaw = null;
+    parseSyncLazy = null;
+  }
+});
+
+// ../compiler/src/atomicCss.ts
+var atomicCss_exports = {};
+__export(atomicCss_exports, {
+  clearAtomicRegistry: () => clearAtomicRegistry,
+  generateAtomicCss: () => generateAtomicCss,
+  getAtomicRegistry: () => getAtomicRegistry,
+  parseAtomicClass: () => parseAtomicClass,
+  toAtomicClasses: () => toAtomicClasses
+});
+function sizeValue(v) {
+  var _a2;
+  const num = Number(v);
+  if (!Number.isNaN(num)) return `${num * 0.25}rem`;
+  const special = {
+    full: "100%",
+    screen: "100vw",
+    auto: "auto",
+    min: "min-content",
+    max: "max-content",
+    fit: "fit-content",
+    svw: "100svw",
+    svh: "100svh"
+  };
+  return (_a2 = special[v]) != null ? _a2 : v;
+}
+function textSize(v) {
+  var _a2;
+  const map = {
+    xs: "0.75rem",
+    sm: "0.875rem",
+    base: "1rem",
+    lg: "1.125rem",
+    xl: "1.25rem",
+    "2xl": "1.5rem",
+    "3xl": "1.875rem",
+    "4xl": "2.25rem",
+    "5xl": "3rem",
+    "6xl": "3.75rem",
+    "7xl": "4.5rem",
+    "8xl": "6rem",
+    "9xl": "8rem"
+  };
+  return (_a2 = map[v]) != null ? _a2 : v;
+}
+function fontWeight(v) {
+  var _a2;
+  const map = {
+    thin: "100",
+    extralight: "200",
+    light: "300",
+    normal: "400",
+    medium: "500",
+    semibold: "600",
+    bold: "700",
+    extrabold: "800",
+    black: "900"
+  };
+  return (_a2 = map[v]) != null ? _a2 : v;
+}
+function leadingValue(v) {
+  var _a2;
+  const map = {
+    none: "1",
+    tight: "1.25",
+    snug: "1.375",
+    normal: "1.5",
+    relaxed: "1.625",
+    loose: "2"
+  };
+  return (_a2 = map[v]) != null ? _a2 : v;
+}
+function roundedValue(v) {
+  var _a2;
+  const map = {
+    "": "0.25rem",
+    sm: "0.125rem",
+    md: "0.375rem",
+    lg: "0.5rem",
+    xl: "0.75rem",
+    "2xl": "1rem",
+    "3xl": "1.5rem",
+    full: "9999px",
+    none: "0"
+  };
+  return (_a2 = map[v]) != null ? _a2 : `${v}rem`;
+}
+function sanitizeClassName(cls) {
+  return cls.replace(/[/:[\].!%]/g, "_");
+}
+function parseAtomicClass(twClass) {
+  if (REGISTRY.has(twClass)) return REGISTRY.get(twClass);
+  const colonIdx = twClass.lastIndexOf(":");
+  const modifier = colonIdx > -1 ? twClass.slice(0, colonIdx) : void 0;
+  const base = colonIdx > -1 ? twClass.slice(colonIdx + 1) : twClass;
+  const dashIdx = base.indexOf("-");
+  if (dashIdx === -1) return null;
+  const prefix = base.slice(0, dashIdx);
+  const value = base.slice(dashIdx + 1);
+  const mapping = TW_PROPERTY_MAP[prefix];
+  if (!mapping) return null;
+  const cssValue = mapping.transform ? mapping.transform(value) : value;
+  const atomicName = `_tw_${sanitizeClassName(twClass)}`;
+  const rule = {
+    twClass,
+    atomicName,
+    property: mapping.prop,
+    value: cssValue,
+    modifier
+  };
+  REGISTRY.set(twClass, rule);
+  return rule;
+}
+function generateAtomicCss(rules) {
+  const lines = [];
+  for (const rule of rules) {
+    const selector = `.${rule.atomicName}`;
+    if (rule.modifier) {
+      const breakpoints = {
+        sm: "640px",
+        md: "768px",
+        lg: "1024px",
+        xl: "1280px",
+        "2xl": "1536px"
+      };
+      if (breakpoints[rule.modifier]) {
+        lines.push(
+          `@media (min-width: ${breakpoints[rule.modifier]}) {`,
+          `  ${selector} { ${rule.property}: ${rule.value}; }`,
+          `}`
+        );
+        continue;
+      }
+      lines.push(`${selector}:${rule.modifier} { ${rule.property}: ${rule.value}; }`);
+    } else {
+      lines.push(`${selector} { ${rule.property}: ${rule.value}; }`);
+    }
+  }
+  return lines.join("\n");
+}
+function toAtomicClasses(twClasses) {
+  const parts = twClasses.split(/\s+/).filter(Boolean);
+  const atomicNames = [];
+  const rules = [];
+  const unknownClasses = [];
+  for (const cls of parts) {
+    const rule = parseAtomicClass(cls);
+    if (rule) {
+      atomicNames.push(rule.atomicName);
+      rules.push(rule);
+    } else {
+      unknownClasses.push(cls);
+      atomicNames.push(cls);
+    }
+  }
+  return {
+    atomicClasses: atomicNames.join(" "),
+    rules,
+    unknownClasses
+  };
+}
+function getAtomicRegistry() {
+  return REGISTRY;
+}
+function clearAtomicRegistry() {
+  REGISTRY.clear();
+}
+var REGISTRY, TW_PROPERTY_MAP;
+var init_atomicCss = __esm({
+  "../compiler/src/atomicCss.ts"() {
+    REGISTRY = /* @__PURE__ */ new Map();
+    TW_PROPERTY_MAP = {
+      // Spacing
+      p: { prop: "padding", transform: (v) => `${Number(v) * 0.25}rem` },
+      px: { prop: "padding-inline", transform: (v) => `${Number(v) * 0.25}rem` },
+      py: { prop: "padding-block", transform: (v) => `${Number(v) * 0.25}rem` },
+      pt: { prop: "padding-top", transform: (v) => `${Number(v) * 0.25}rem` },
+      pb: { prop: "padding-bottom", transform: (v) => `${Number(v) * 0.25}rem` },
+      pl: { prop: "padding-left", transform: (v) => `${Number(v) * 0.25}rem` },
+      pr: { prop: "padding-right", transform: (v) => `${Number(v) * 0.25}rem` },
+      m: { prop: "margin", transform: (v) => `${Number(v) * 0.25}rem` },
+      mx: { prop: "margin-inline", transform: (v) => `${Number(v) * 0.25}rem` },
+      my: { prop: "margin-block", transform: (v) => `${Number(v) * 0.25}rem` },
+      mt: { prop: "margin-top", transform: (v) => `${Number(v) * 0.25}rem` },
+      mb: { prop: "margin-bottom", transform: (v) => `${Number(v) * 0.25}rem` },
+      ml: { prop: "margin-left", transform: (v) => `${Number(v) * 0.25}rem` },
+      mr: { prop: "margin-right", transform: (v) => `${Number(v) * 0.25}rem` },
+      gap: { prop: "gap", transform: (v) => `${Number(v) * 0.25}rem` },
+      // Sizing
+      w: { prop: "width", transform: sizeValue },
+      h: { prop: "height", transform: sizeValue },
+      // Typography
+      text: { prop: "font-size", transform: textSize },
+      font: { prop: "font-weight", transform: fontWeight },
+      leading: { prop: "line-height", transform: leadingValue },
+      // Misc
+      opacity: { prop: "opacity", transform: (v) => String(Number(v) / 100) },
+      z: { prop: "z-index" },
+      rounded: { prop: "border-radius", transform: (v) => roundedValue(v) }
+    };
+  }
+});
+
+// ../preset/src/defaultPreset.ts
+var defaultPreset_exports = {};
+__export(defaultPreset_exports, {
+  defaultGlobalCss: () => defaultGlobalCss,
+  defaultPreset: () => defaultPreset,
+  designTokens: () => designTokens,
+  generateTailwindConfig: () => generateTailwindConfig
+});
+function generateTailwindConfig(safelistPath = ".tailwind-styled-safelist.json", contentPaths = STANDARD_CONTENT_PATHS) {
+  return `import type { Config } from "tailwindcss"
+import { defaultPreset } from "tailwind-styled-v4/preset"
+
+// Auto-generated safelist dari tailwind-styled-v4 compiler
+const safelist = (() => {
+  try { return require(${JSON.stringify(safelistPath)}) as string[] }
+  catch { return [] }
+})()
+
+export default {
+  presets: [defaultPreset],
+  content: ${JSON.stringify(contentPaths, null, 2)},
+  safelist,
+} satisfies Config
+`;
+}
+var STANDARD_CONTENT_PATHS, designTokens, defaultPreset, defaultGlobalCss;
+var init_defaultPreset = __esm({
+  "../preset/src/defaultPreset.ts"() {
+    STANDARD_CONTENT_PATHS = [
+      // Next.js App Router
+      "./src/**/*.{tsx,ts,jsx,js,mdx}",
+      "./app/**/*.{tsx,ts,jsx,js,mdx}",
+      "./pages/**/*.{tsx,ts,jsx,js,mdx}",
+      "./components/**/*.{tsx,ts,jsx,js,mdx}",
+      // Vite / React
+      "./src/**/*.{tsx,ts,jsx,js}",
+      "./index.html",
+      // Monorepo
+      "../../packages/**/src/**/*.{tsx,ts,jsx,js}"
+    ];
+    designTokens = {
+      colors: {
+        // Brand
+        primary: { DEFAULT: "#3b82f6", hover: "#2563eb", active: "#1d4ed8", foreground: "#ffffff" },
+        secondary: { DEFAULT: "#6366f1", hover: "#4f46e5", active: "#4338ca", foreground: "#ffffff" },
+        accent: { DEFAULT: "#f59e0b", hover: "#d97706", active: "#b45309", foreground: "#000000" },
+        // Semantic
+        success: { DEFAULT: "#10b981", foreground: "#ffffff" },
+        warning: { DEFAULT: "#f59e0b", foreground: "#000000" },
+        danger: { DEFAULT: "#ef4444", foreground: "#ffffff" },
+        info: { DEFAULT: "#3b82f6", foreground: "#ffffff" },
+        // Neutral
+        surface: "#18181b",
+        border: "#27272a",
+        muted: "#71717a",
+        subtle: "#3f3f46"
+      },
+      fontFamily: {
+        sans: ["InterVariable", "Inter", "system-ui", "sans-serif"],
+        mono: ["JetBrains Mono", "Fira Code", "Consolas", "monospace"]
+      },
+      borderRadius: {
+        sm: "0.25rem",
+        DEFAULT: "0.5rem",
+        md: "0.5rem",
+        lg: "0.75rem",
+        xl: "1rem",
+        "2xl": "1.5rem",
+        full: "9999px"
+      },
+      animation: {
+        "fade-in": "fadeIn 0.2s ease-out",
+        "fade-out": "fadeOut 0.2s ease-in",
+        "slide-up": "slideUp 0.3s cubic-bezier(0.16, 1, 0.3, 1)",
+        "slide-down": "slideDown 0.3s cubic-bezier(0.16, 1, 0.3, 1)",
+        "scale-in": "scaleIn 0.2s ease-out"
+      },
+      keyframes: {
+        fadeIn: { from: { opacity: "0" }, to: { opacity: "1" } },
+        fadeOut: { from: { opacity: "1" }, to: { opacity: "0" } },
+        slideUp: {
+          from: { transform: "translateY(8px)", opacity: "0" },
+          to: { transform: "translateY(0)", opacity: "1" }
+        },
+        slideDown: {
+          from: { transform: "translateY(-8px)", opacity: "0" },
+          to: { transform: "translateY(0)", opacity: "1" }
+        },
+        scaleIn: {
+          from: { transform: "scale(0.95)", opacity: "0" },
+          to: { transform: "scale(1)", opacity: "1" }
+        }
+      }
+    };
+    defaultPreset = {
+      content: STANDARD_CONTENT_PATHS,
+      darkMode: "class",
+      theme: {
+        extend: {
+          colors: designTokens.colors,
+          fontFamily: designTokens.fontFamily,
+          borderRadius: designTokens.borderRadius,
+          animation: designTokens.animation,
+          keyframes: designTokens.keyframes
+        }
+      },
+      plugins: []
+    };
+    defaultGlobalCss = `@import "tailwindcss";
+
+/* tailwind-styled-v4 \u2014 zero-config base styles */
+*, *::before, *::after {
+  box-sizing: border-box;
+}
+
+html {
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  text-rendering: optimizeLegibility;
+}
+
+body {
+  margin: 0;
+  font-family: var(--font-sans, system-ui, sans-serif);
+  background: var(--color-background, #09090b);
+  color: var(--color-foreground, #fafafa);
+}
+`;
+  }
+});
+function mergeClassesStatic(classes) {
+  return tailwindMerge.twMerge(classes);
+}
+function normalizeClasses(raw) {
+  return raw.split("\n").map((l) => l.trim()).filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+}
+
+// ../compiler/src/componentHoister.ts
+var INDENTED_TW_DECL_RE = /^([ \t]+)(const|let)\s+([A-Z]\w*)\s*=\s*tw\.[\w]+[`(]/gm;
+function hoistComponents(source) {
+  const hoisted = [];
+  const warnings = [];
+  const indentedDecls = [];
+  let m;
+  const re = new RegExp(INDENTED_TW_DECL_RE.source, "gm");
+  while ((m = re.exec(source)) !== null) {
+    const indent = m[1];
+    const keyword = m[2];
+    const name = m[3];
+    if (!/^[A-Z]/.test(name)) continue;
+    if (indent.length === 0) continue;
+    indentedDecls.push({
+      fullMatch: m[0],
+      indent,
+      keyword,
+      name,
+      startIndex: m.index
+    });
+  }
+  if (indentedDecls.length === 0) {
+    return { code: source, hoisted: [], warnings: [] };
+  }
+  let code = source;
+  const hoistedDecls = [];
+  for (const decl of [...indentedDecls].reverse()) {
+    const { startIndex, indent, name } = decl;
+    const lineStart = code.lastIndexOf("\n", startIndex) + 1;
+    const restFromDecl = code.slice(lineStart);
+    const fullStmt = extractFullStatement(restFromDecl);
+    if (!fullStmt) continue;
+    const dedented = fullStmt.split("\n").map((line) => line.startsWith(indent) ? line.slice(indent.length) : line).join("\n").trim();
+    code = code.slice(0, lineStart) + code.slice(lineStart + fullStmt.length);
+    hoistedDecls.unshift(dedented);
+    hoisted.push(name);
+    warnings.push(
+      `[tw-hoist] '${name}' moved to module scope for better performance. Avoid defining tw components inside render functions.`
+    );
+  }
+  if (hoistedDecls.length > 0) {
+    const insertPoint = findAfterImports(code);
+    const hoistBlock = `
+${hoistedDecls.join("\n\n")}
+`;
+    code = code.slice(0, insertPoint) + hoistBlock + code.slice(insertPoint);
+  }
+  return { code, hoisted, warnings };
+}
+function extractFullStatement(source) {
+  const templateRe = /^[ \t]*(const|let)\s+\w+\s*=\s*tw\.\w+`[^`]*`.*\n?/;
+  const templateMatch = source.match(templateRe);
+  if (templateMatch) return templateMatch[0];
+  const objStart = source.indexOf("tw.");
+  if (objStart === -1) return null;
+  const parenStart = source.indexOf("(", objStart);
+  if (parenStart === -1) return null;
+  let depth = 0;
+  let i = parenStart;
+  while (i < source.length) {
+    if (source[i] === "(") depth++;
+    if (source[i] === ")") {
+      depth--;
+      if (depth === 0) {
+        const end = source.indexOf("\n", i);
+        return source.slice(0, end === -1 ? i + 1 : end + 1);
+      }
+    }
+    i++;
+  }
+  return null;
+}
+function findAfterImports(source) {
+  const lines = source.split("\n");
+  let lastImportLine = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.startsWith("import ") || line.startsWith("'use client'") || line.startsWith('"use client"')) {
+      lastImportLine = i;
+    } else if (line && !line.startsWith("//") && !line.startsWith("/*") && lastImportLine > 0) {
+      break;
+    }
+  }
+  return lines.slice(0, lastImportLine + 1).join("\n").length + 1;
+}
+
+// ../compiler/src/rscAnalyzer.ts
+var CSS_INTERACTIVE_OK = [
+  /^hover:/,
+  // CSS :hover — no JS needed
+  /^focus:/,
+  // CSS :focus — no JS needed
+  /^focus-within:/,
+  // CSS :focus-within
+  /^focus-visible:/,
+  // CSS :focus-visible
+  /^active:/,
+  // CSS :active
+  /^group-hover:/,
+  // Tailwind group variant — CSS only
+  /^group-focus:/,
+  // CSS only
+  /^peer-/,
+  // Tailwind peer — CSS only
+  /^first:/,
+  // CSS :first-child
+  /^last:/,
+  // CSS :last-child
+  /^odd:/,
+  // CSS :nth-child(odd)
+  /^even:/,
+  // CSS :nth-child(even)
+  /^disabled:/,
+  // CSS :disabled
+  /^placeholder:/,
+  // CSS ::placeholder
+  /^dark:/,
+  // CSS @media prefers-color-scheme
+  /^print:/,
+  // CSS @media print
+  /^md:|^sm:|^lg:|^xl:|^2xl:/
+  // Responsive breakpoints — CSS only
+];
+var REQUIRES_JS_PATTERNS = [
+  // React hooks
+  /\buseState\b/,
+  /\buseEffect\b/,
+  /\buseRef\b/,
+  /\buseCallback\b/,
+  /\buseMemo\b/,
+  /\buseReducer\b/,
+  /\buseContext\b/,
+  // Event handlers
+  /\bon[A-Z][a-zA-Z]+\s*[=:]/,
+  // onClick=, onMouseEnter:, etc.
+  // Browser APIs
+  /\bwindow\./,
+  /\bdocument\./,
+  /\blocalStorage\b/,
+  /\bsessionStorage\b/,
+  // Dynamic imports
+  /import\s*\(/
+];
+function analyzeFile(source, _filename = "") {
+  const clientReasons = [];
+  const interactiveClasses = [];
+  const hasClientDirective = source.trimStart().startsWith('"use client"') || source.trimStart().startsWith("'use client'");
+  if (hasClientDirective) {
+    clientReasons.push("explicit 'use client' directive");
+  }
+  for (const pattern of REQUIRES_JS_PATTERNS) {
+    if (pattern.test(source)) {
+      const match = source.match(pattern);
+      if (match) clientReasons.push(`uses ${match[0].trim()}`);
+    }
+  }
+  const hasServerMarker = source.includes("tw.server.");
+  const templateRe = /\btw\.(?:server\.)?(\w+)`((?:[^`\\]|\\.)*)`/g;
+  let m;
+  while ((m = templateRe.exec(source)) !== null) {
+    const classes = m[2];
+    const parts = classes.split(/\s+/).filter(Boolean);
+    for (const cls of parts) {
+      const isOk = CSS_INTERACTIVE_OK.some((re) => re.test(cls));
+      if (!isOk && /^[a-z-]+:/.test(cls)) {
+        interactiveClasses.push(cls);
+        clientReasons.push(`uses JS-interactive class: ${cls}`);
+      }
+    }
+  }
+  const needsClientDirective = !hasServerMarker && (hasClientDirective || clientReasons.length > 0);
+  const isServer = !needsClientDirective || hasServerMarker;
+  return {
+    isServer,
+    needsClientDirective,
+    clientReasons: [...new Set(clientReasons)],
+    interactiveClasses: [...new Set(interactiveClasses)],
+    canStaticResolveVariants: isServer
+  };
+}
+function analyzeVariantUsage(source, componentName, variantKeys) {
+  const resolved = {};
+  const dynamic = [];
+  for (const key of variantKeys) {
+    const staticRe = new RegExp(`<${componentName}[^>]*\\b${key}=["']([^"']+)["'][^>]*>`, "g");
+    const dynamicRe = new RegExp(`<${componentName}[^>]*\\b${key}=\\{[^"'][^}]*\\}[^>]*>`, "g");
+    const staticMatch = source.match(staticRe);
+    const dynamicMatch = source.match(dynamicRe);
+    if (dynamicMatch) {
+      dynamic.push(key);
+    } else if (staticMatch) {
+      const valMatch = staticMatch[0].match(new RegExp(`${key}=["']([^"']+)["']`));
+      if (valMatch) resolved[key] = valMatch[1];
+    }
+  }
+  return { resolved, dynamic };
+}
+function resolveServerVariant(base, table, defaults, resolved) {
+  var _a2;
+  const parts = [base];
+  for (const key in table) {
+    const val = (_a2 = resolved[key]) != null ? _a2 : defaults[key];
+    if (val && table[key][val]) {
+      parts.push(table[key][val]);
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    for (const cls of part.split(/\s+/).filter(Boolean)) {
+      const prefix = cls.replace(/^(?:[\w-]+:)*/, "").split("-")[0];
+      seen.set(prefix, cls);
+    }
+  }
+  return Array.from(seen.values()).join(" ");
+}
+function injectClientDirective(code) {
+  if (code.startsWith('"use client"') || code.startsWith("'use client'")) {
+    return code;
+  }
+  return `"use client";
+${code}`;
+}
+function injectServerOnlyComment(code) {
+  return `/* @tw-server-only */
+${code}`;
+}
+
+// ../compiler/src/twDetector.ts
+var TEMPLATE_RE = /\btw\.(server\.)?(\w+)`((?:[^`\\]|\\.)*)`/g;
+var OBJECT_RE = /\btw\.(server\.)?(\w+)\(\s*(\{[\s\S]*?\})\s*\)/g;
+var EXTEND_RE = /(\w+)\.extend`((?:[^`\\]|\\.)*)`/g;
+var IMPORT_RE = /from\s*["']tailwind-styled-v4["']/;
+var TRANSFORM_MARKER = "/* @tw-transformed */";
+function hasTwUsage(source) {
+  return IMPORT_RE.test(source) || source.includes("tw.");
+}
+function isAlreadyTransformed(source) {
+  return source.includes(TRANSFORM_MARKER);
+}
+function isDynamic(content) {
+  return content.includes("${");
+}
+function isServerComponent(source) {
+  return !source.includes('"use client"') && !source.includes("'use client'");
+}
+function hasInteractiveFeatures(content) {
+  return /\b(hover:|focus:|active:|group-hover:|peer-|on[A-Z]|useState|useEffect|useRef)\b/.test(
+    content
+  );
+}
+
+// ../compiler/src/astParser.ts
+function oxcKey(node) {
+  if (!node) return null;
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "Literal" && typeof node.value === "string") return node.value;
+  return null;
+}
+function oxcStringVal(node) {
+  var _a2;
+  if (!node) return null;
+  if (node.type === "Literal" && typeof node.value === "string") return node.value;
+  if (node.type === "TemplateLiteral" && ((_a2 = node.expressions) == null ? void 0 : _a2.length) === 0) {
+    return node.quasis.map((q) => {
+      var _a3, _b2, _c, _d;
+      return (_d = (_c = (_a3 = q.value) == null ? void 0 : _a3.cooked) != null ? _c : (_b2 = q.value) == null ? void 0 : _b2.raw) != null ? _d : "";
+    }).join("");
+  }
+  return null;
+}
+function oxcWalkObject(node) {
+  var _a2;
+  const result = {};
+  if ((node == null ? void 0 : node.type) !== "ObjectExpression") return result;
+  for (const prop of (_a2 = node.properties) != null ? _a2 : []) {
+    if (prop.type !== "Property") continue;
+    const key = oxcKey(prop.key);
+    if (!key) continue;
+    const val = prop.value;
+    const strVal = oxcStringVal(val);
+    if (strVal !== null) {
+      result[key] = strVal;
+    } else if ((val == null ? void 0 : val.type) === "ObjectExpression") {
+      result[key] = oxcWalkObject(val);
+    } else if ((val == null ? void 0 : val.type) === "ArrayExpression") {
+      result[key] = val.elements.filter((el) => (el == null ? void 0 : el.type) === "ObjectExpression").map((el) => oxcWalkObject(el));
+    }
+  }
+  return result;
+}
+function parseWithOxc(objectStr) {
+  var _a2, _b2, _c;
+  let parseSync3;
+  try {
+    parseSync3 = (init_src_js(), __toCommonJS(src_js_exports)).parseSync;
+  } catch (e) {
+    return null;
+  }
+  try {
+    const source = `const __c = ${objectStr}`;
+    const { program, errors } = parseSync3("config.ts", source, { sourceType: "script" });
+    if ((errors == null ? void 0 : errors.length) > 0 || !((_a2 = program == null ? void 0 : program.body) == null ? void 0 : _a2[0])) return null;
+    const varDecl = program.body[0];
+    if (varDecl.type !== "VariableDeclaration") return null;
+    const init = (_c = (_b2 = varDecl.declarations) == null ? void 0 : _b2[0]) == null ? void 0 : _c.init;
+    if ((init == null ? void 0 : init.type) !== "ObjectExpression") return null;
+    const raw = oxcWalkObject(init);
+    const base = typeof raw.base === "string" ? raw.base.trim() : "";
+    const variants = {};
+    const rawVariants = raw.variants;
+    if (rawVariants && typeof rawVariants === "object" && !Array.isArray(rawVariants)) {
+      for (const [vName, vMap] of Object.entries(rawVariants)) {
+        if (vMap && typeof vMap === "object" && !Array.isArray(vMap)) {
+          variants[vName] = {};
+          for (const [vVal, cls] of Object.entries(vMap)) {
+            if (typeof cls === "string") variants[vName][vVal] = cls.trim();
+          }
+        }
+      }
+    }
+    const compounds = [];
+    const rawCompounds = raw.compoundVariants;
+    if (Array.isArray(rawCompounds)) {
+      for (const item of rawCompounds) {
+        if (item && typeof item.class === "string") {
+          compounds.push(item);
+        }
+      }
+    }
+    const defaults = {};
+    const rawDefaults = raw.defaultVariants;
+    if (rawDefaults && typeof rawDefaults === "object" && !Array.isArray(rawDefaults)) {
+      for (const [k, v] of Object.entries(rawDefaults)) {
+        if (typeof v === "string") defaults[k] = v;
+      }
+    }
+    return { base, variants, compounds, defaults };
+  } catch (e) {
+    return null;
+  }
+}
+function tokenize(src) {
+  const tokens = [];
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      let j = i + 1;
+      let str = ch;
+      while (j < src.length) {
+        if (src[j] === "\\" && quote !== "`") {
+          str += src[j] + src[j + 1];
+          j += 2;
+          continue;
+        }
+        if (src[j] === "\\" && quote === "`") {
+          str += src[j] + src[j + 1];
+          j += 2;
+          continue;
+        }
+        str += src[j];
+        if (src[j] === quote) {
+          j++;
+          break;
+        }
+        j++;
+      }
+      tokens.push({ type: "string", value: str.slice(1, -1), pos: i });
+      i = j;
+      continue;
+    }
+    if (ch === ":") {
+      tokens.push({ type: "colon", value: ":", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === ",") {
+      tokens.push({ type: "comma", value: ",", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "{") {
+      tokens.push({ type: "lbrace", value: "{", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      tokens.push({ type: "rbrace", value: "}", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      tokens.push({ type: "lbracket", value: "[", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "]") {
+      tokens.push({ type: "rbracket", value: "]", pos: i });
+      i++;
+      continue;
+    }
+    if (/[\w$]/.test(ch)) {
+      let j = i;
+      while (j < src.length && /[\w$]/.test(src[j])) j++;
+      tokens.push({ type: "key", value: src.slice(i, j), pos: i });
+      i = j;
+      continue;
+    }
+    tokens.push({ type: "other", value: ch, pos: i });
+    i++;
+  }
+  return tokens;
+}
+function parseObject(tokens, startIdx) {
+  var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j;
+  const obj = {};
+  let i = startIdx;
+  if (((_a2 = tokens[i]) == null ? void 0 : _a2.type) !== "lbrace") return { obj, endIdx: i };
+  i++;
+  while (i < tokens.length && ((_b2 = tokens[i]) == null ? void 0 : _b2.type) !== "rbrace") {
+    if (((_c = tokens[i]) == null ? void 0 : _c.type) === "comma") {
+      i++;
+      continue;
+    }
+    let key = null;
+    if (((_d = tokens[i]) == null ? void 0 : _d.type) === "string") {
+      key = tokens[i].value;
+      i++;
+    } else if (((_e = tokens[i]) == null ? void 0 : _e.type) === "key") {
+      key = tokens[i].value;
+      i++;
+    } else {
+      i++;
+      continue;
+    }
+    if (((_f = tokens[i]) == null ? void 0 : _f.type) !== "colon") continue;
+    i++;
+    if (((_g = tokens[i]) == null ? void 0 : _g.type) === "lbrace") {
+      const { obj: nested, endIdx } = parseObject(tokens, i);
+      obj[key] = nested;
+      i = endIdx + 1;
+    } else if (((_h = tokens[i]) == null ? void 0 : _h.type) === "lbracket") {
+      const { arr, endIdx } = parseArray(tokens, i);
+      obj[key] = arr;
+      i = endIdx + 1;
+    } else if (((_i = tokens[i]) == null ? void 0 : _i.type) === "string") {
+      obj[key] = tokens[i].value;
+      i++;
+    } else if (((_j = tokens[i]) == null ? void 0 : _j.type) === "key") {
+      obj[key] = tokens[i].value;
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return { obj, endIdx: i };
+}
+function parseArray(tokens, startIdx) {
+  var _a2, _b2, _c, _d;
+  const arr = [];
+  let i = startIdx;
+  if (((_a2 = tokens[i]) == null ? void 0 : _a2.type) !== "lbracket") return { arr, endIdx: i };
+  i++;
+  while (i < tokens.length && ((_b2 = tokens[i]) == null ? void 0 : _b2.type) !== "rbracket") {
+    if (((_c = tokens[i]) == null ? void 0 : _c.type) === "comma") {
+      i++;
+      continue;
+    }
+    if (((_d = tokens[i]) == null ? void 0 : _d.type) === "lbrace") {
+      const { obj, endIdx } = parseObject(tokens, i);
+      arr.push(obj);
+      i = endIdx + 1;
+    } else {
+      i++;
+    }
+  }
+  return { arr, endIdx: i };
+}
+function parseComponentConfigFallback(objectStr) {
+  const tokens = tokenize(objectStr);
+  const { obj } = parseObject(tokens, 0);
+  const base = typeof obj.base === "string" ? obj.base.trim() : "";
+  const variants = {};
+  const rawVariants = obj.variants;
+  if (rawVariants && typeof rawVariants === "object" && !Array.isArray(rawVariants)) {
+    for (const [variantName, variantValues] of Object.entries(rawVariants)) {
+      if (typeof variantValues === "object" && !Array.isArray(variantValues)) {
+        variants[variantName] = {};
+        for (const [valueName, cls] of Object.entries(variantValues)) {
+          if (typeof cls === "string") variants[variantName][valueName] = cls.trim();
+        }
+      }
+    }
+  }
+  const compounds = [];
+  const rawCompounds = obj.compoundVariants;
+  if (Array.isArray(rawCompounds)) {
+    for (const item of rawCompounds) {
+      if (item && typeof item.class === "string") compounds.push(item);
+    }
+  }
+  const defaults = {};
+  const rawDefaults = obj.defaultVariants;
+  if (rawDefaults && typeof rawDefaults === "object" && !Array.isArray(rawDefaults)) {
+    for (const [k, v] of Object.entries(rawDefaults)) {
+      if (typeof v === "string") defaults[k] = v;
+    }
+  }
+  return { base, variants, compounds, defaults };
+}
+function parseComponentConfig(objectStr) {
+  const oxcResult = parseWithOxc(objectStr);
+  if (oxcResult !== null) return oxcResult;
+  return parseComponentConfigFallback(objectStr);
+}
+
+// ../compiler/src/variantCompiler.ts
+function compileVariants(base, variants, compounds = [], defaults = {}) {
+  const table = {};
+  for (const key in variants) {
+    table[key] = {};
+    for (const val in variants[key]) {
+      table[key][val] = normalizeClasses(variants[key][val]);
+    }
+  }
+  return { base, table, compounds, defaults };
+}
+function generateVariantCode(id, compiled) {
+  const { table, compounds, defaults } = compiled;
+  const tableJson = JSON.stringify(table, null, 2);
+  const compoundsJson = JSON.stringify(compounds, null, 2);
+  const defaultsJson = JSON.stringify(defaults, null, 2);
+  return `const __vt_${id} = ${tableJson};
+const __vc_${id} = ${compoundsJson};
+const __vd_${id} = ${defaultsJson};`;
+}
+function parseObjectConfig(objectStr) {
+  return parseComponentConfig(objectStr);
+}
+
+// ../compiler/src/astTransform.ts
+var TEMPLATE_RE2 = /\btw\.(server\.)?(\w+)`((?:[^`\\]|\\.)*)`/g;
+var OBJECT_RE2 = /\btw\.(server\.)?(\w+)\(\s*(\{[\s\S]*?\})\s*\)/g;
+var EXTEND_RE2 = /(\w+)\.extend`((?:[^`\\]|\\.)*)`/g;
+var WRAP_RE = /\btw\((\w+)\)`((?:[^`\\]|\\.)*)`/g;
+var _idCounter = 0;
+function genId() {
+  return `c${(++_idCounter).toString(36)}`;
+}
+function renderStaticComponent(tag, classes, opts) {
+  const { addDataAttr, compName } = opts;
+  const fnName = compName ? `_Tw_${compName}` : `_Tw_${tag}`;
+  const dataAttr = addDataAttr ? `, "data-tw": "${fnName}:${classes.split(" ").slice(0, 3).join(" ")}${classes.split(" ").length > 3 ? "..." : ""}"` : "";
+  return `React.forwardRef(function ${fnName}(props, ref) {
+  var _c = props.className;
+  var _r = Object.assign({}, props);
+  delete _r.className;
+  return React.createElement("${tag}", Object.assign({ ref }, _r${dataAttr}, { className: [${JSON.stringify(classes)}, _c].filter(Boolean).join(" ") }));
+})`;
+}
+function renderVariantComponent(tag, id, base, variantKeys, defaults, opts) {
+  const { addDataAttr } = opts;
+  const fnName = `_TwV_${tag}_${id}`;
+  const dataAttr = addDataAttr ? `, "data-tw": "${fnName}"` : "";
+  const vKeys = variantKeys.map((k) => `"${k}"`).join(", ");
+  const destructure = variantKeys.length > 0 ? `var _vp = {}; [${vKeys}].forEach(function(k){ _vp[k] = props[k]; delete _rest[k]; });` : "";
+  const variantLookup = variantKeys.length > 0 ? variantKeys.map(
+    (k) => {
+      var _a2;
+      return `(__vt_${id}["${k}"] && __vt_${id}["${k}"][_vp["${k}"] ?? ${JSON.stringify((_a2 = defaults[k]) != null ? _a2 : "")}] || "")`;
+    }
+  ).join(", ") : "";
+  const classParts = variantKeys.length > 0 ? `[${JSON.stringify(base)}, ${variantLookup}, _rest.className]` : `[${JSON.stringify(base)}, _rest.className]`;
+  return `React.forwardRef(function ${fnName}(props, ref) {
+  var _rest = Object.assign({}, props);
+  delete _rest.className;
+  ${destructure}
+  return React.createElement("${tag}", Object.assign({ ref }, _rest${dataAttr}, { className: ${classParts}.filter(Boolean).join(" ") }));
+})`;
+}
+function transformSource(source, opts = {}) {
+  const {
+    mode = "zero-runtime",
+    autoClientBoundary = true,
+    addDataAttr = false,
+    hoist = true,
+    filename = ""
+  } = opts;
+  if (!hasTwUsage(source)) {
+    return { code: source, classes: [], changed: false };
+  }
+  if (isAlreadyTransformed(source)) {
+    return { code: source, classes: [], changed: false };
+  }
+  if (mode === "runtime" || mode === "extract-only") {
+    return { code: source, classes: [], changed: false };
+  }
+  const rscAnalysis = analyzeFile(source, filename);
+  let code = source;
+  if (hoist) {
+    const hoistResult = hoistComponents(source);
+    if (hoistResult.hoisted.length > 0) {
+      code = hoistResult.code;
+      if (process.env.NODE_ENV !== "production") {
+        for (const w of hoistResult.warnings) {
+          console.warn(w);
+        }
+      }
+    }
+  }
+  let changed = false;
+  const allClasses = [];
+  const prelude = [];
+  let needsReact = false;
+  code = code.replace(
+    TEMPLATE_RE2,
+    (match, serverMark, tag, content) => {
+      if (isDynamic(content)) return match;
+      const classes = normalizeClasses(content);
+      if (!classes) return match;
+      const isServerOnly = !!serverMark;
+      allClasses.push(...classes.split(/\s+/).filter(Boolean));
+      changed = true;
+      needsReact = true;
+      const rendered = renderStaticComponent(tag, classes, {
+        addDataAttr,
+        isServer: rscAnalysis.isServer || isServerOnly
+      });
+      return isServerOnly ? `/* @server-only */ ${rendered}` : rendered;
+    }
+  );
+  code = code.replace(
+    OBJECT_RE2,
+    (match, serverMark, tag, objectStr) => {
+      const { base, variants, compounds, defaults } = parseObjectConfig(objectStr);
+      if (!base && Object.keys(variants).length === 0) return match;
+      const isServerOnly = !!serverMark;
+      allClasses.push(...base.split(/\s+/).filter(Boolean));
+      for (const vMap of Object.values(variants)) {
+        for (const cls of Object.values(vMap)) {
+          allClasses.push(...cls.split(/\s+/).filter(Boolean));
+        }
+      }
+      changed = true;
+      needsReact = true;
+      const id = genId();
+      const compiled = compileVariants(base, variants, compounds, defaults);
+      prelude.push(generateVariantCode(id, compiled));
+      const variantKeys = Object.keys(variants);
+      const rendered = renderVariantComponent(tag, id, base, variantKeys, defaults, {
+        addDataAttr,
+        isServer: rscAnalysis.isServer || isServerOnly
+      });
+      return isServerOnly ? `/* @server-only */ ${rendered}` : rendered;
+    }
+  );
+  code = code.replace(WRAP_RE, (match, compName, content) => {
+    if (isDynamic(content)) return match;
+    const classes = normalizeClasses(content);
+    if (!classes) return match;
+    allClasses.push(...classes.split(/\s+/).filter(Boolean));
+    changed = true;
+    needsReact = true;
+    return `React.forwardRef(function _TwWrap_${compName}(props, ref) {
+  var _c = [${JSON.stringify(classes)}, props.className].filter(Boolean).join(" ");
+  return React.createElement(${compName}, Object.assign({}, props, { ref, className: _c }));
+})`;
+  });
+  code = code.replace(EXTEND_RE2, (match, compName, content) => {
+    if (isDynamic(content)) return match;
+    const extra = normalizeClasses(content);
+    if (!extra) return match;
+    allClasses.push(...extra.split(/\s+/).filter(Boolean));
+    changed = true;
+    needsReact = true;
+    return `React.forwardRef(function _TwExt_${compName}(props, ref) {
+  var _c = [${JSON.stringify(extra)}, props.className].filter(Boolean).join(" ");
+  return React.createElement(${compName}, Object.assign({}, props, { ref, className: _c }));
+})`;
+  });
+  if (!changed) {
+    return { code: source, classes: [], rsc: rscAnalysis, changed: false };
+  }
+  if (prelude.length > 0) {
+    const importEnd = findAfterImports2(code);
+    code = `${code.slice(0, importEnd)}
+${prelude.join("\n")}
+${code.slice(importEnd)}`;
+  }
+  if (needsReact && !hasReactImport(source)) {
+    code = `import React from "react";
+${code}`;
+  }
+  if (autoClientBoundary && rscAnalysis.needsClientDirective) {
+    code = injectClientDirective(code);
+  }
+  const stillUsesTw = /\btw\.(server\.)?\w+[`(]/.test(code) || /\btw\(\w+\)/.test(code);
+  if (!stillUsesTw) {
+    code = code.replace(
+      /import\s*\{[^}]*\btw\b[^}]*\}\s*from\s*["']tailwind-styled-v4["'];?\n?/g,
+      ""
+    );
+  }
+  code = `${TRANSFORM_MARKER}
+${code}`;
+  return {
+    code,
+    classes: Array.from(new Set(allClasses)),
+    rsc: {
+      isServer: rscAnalysis.isServer,
+      needsClientDirective: rscAnalysis.needsClientDirective,
+      clientReasons: rscAnalysis.clientReasons
+    },
+    changed: true
+  };
+}
+function hasReactImport(source) {
+  return source.includes("import React") || source.includes("from 'react'") || source.includes('from "react"');
+}
+function findAfterImports2(source) {
+  const lines = source.split("\n");
+  let lastImportIdx = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.startsWith("import ") || line.startsWith('"use client"') || line.startsWith("'use client'") || line.startsWith(TRANSFORM_MARKER) || line === "") {
+      lastImportIdx = i;
+    } else if (line && !line.startsWith("//") && !line.startsWith("/*")) {
+      break;
+    }
+  }
+  return lines.slice(0, lastImportIdx + 1).join("\n").length + 1;
+}
+
+// ../compiler/src/index.ts
+init_atomicCss();
+
+// ../compiler/src/classExtractor.ts
+var VALID_CLASS_RE = /^[-a-z0-9:/[\]!.()+%]+$/;
+function parseClasses(raw) {
+  return raw.split(/[\n\s]+/).map((c) => c.trim()).filter((c) => c.length > 0 && VALID_CLASS_RE.test(c));
+}
+function extractAllClasses(source) {
+  const classes = /* @__PURE__ */ new Set();
+  const add = (str) => {
+    for (const c of parseClasses(str)) classes.add(c);
+  };
+  let m;
+  const re1 = new RegExp(TEMPLATE_RE.source, "g");
+  while ((m = re1.exec(source)) !== null) {
+    add(m[3]);
+  }
+  const re2 = new RegExp(OBJECT_RE.source, "g");
+  while ((m = re2.exec(source)) !== null) {
+    const parsed = parseComponentConfig(m[3]);
+    if (parsed.base) add(parsed.base);
+    for (const vMap of Object.values(parsed.variants)) {
+      for (const cls of Object.values(vMap)) add(cls);
+    }
+    for (const compound of parsed.compounds) {
+      if (compound.class) add(compound.class);
+    }
+  }
+  const re3 = new RegExp(EXTEND_RE.source, "g");
+  while ((m = re3.exec(source)) !== null) add(m[2]);
+  const classNameRe = /className\s*=\s*["']([^"']+)["']/g;
+  while ((m = classNameRe.exec(source)) !== null) add(m[1]);
+  return Array.from(classes).sort();
+}
+function extractComponentUsage(source) {
+  const usage = {};
+  const jsxRe = /<([A-Z][A-Za-z0-9]*)\s([^>]*?)(?:\/?>)/g;
+  let m;
+  while ((m = jsxRe.exec(source)) !== null) {
+    const compName = m[1];
+    const propsStr = m[2];
+    if (!usage[compName]) usage[compName] = {};
+    const propRe = /(\w+)=["']([^"']+)["']/g;
+    let p;
+    while ((p = propRe.exec(propsStr)) !== null) {
+      const [, propName, propValue] = p;
+      if (["className", "style", "id", "href", "src", "alt", "type"].includes(propName)) continue;
+      if (!usage[compName][propName]) {
+        usage[compName][propName] = /* @__PURE__ */ new Set();
+      }
+      usage[compName][propName].add(propValue);
+    }
+  }
+  return usage;
+}
+var SCAN_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", "dist", ".git", "out"]);
+function scanFiles(dir) {
+  const files = [];
+  function walk(current) {
+    if (!fs2__default.default.existsSync(current)) return;
+    const entries = fs2__default.default.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const fullPath = path4__default.default.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (SCAN_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
+        files.push(fullPath);
+      }
+    }
+  }
+  walk(dir);
+  return files;
+}
+function scanProjectUsage(dirs, cwd = process.cwd()) {
+  const combined = {};
+  for (const dir of dirs) {
+    const absDir = path4__default.default.isAbsolute(dir) ? dir : path4__default.default.resolve(cwd, dir);
+    const files = scanFiles(absDir);
+    for (const file of files) {
+      try {
+        const source = fs2__default.default.readFileSync(file, "utf-8");
+        const usage = extractComponentUsage(source);
+        for (const [comp, props] of Object.entries(usage)) {
+          if (!combined[comp]) combined[comp] = {};
+          for (const [prop, values] of Object.entries(props)) {
+            if (!combined[comp][prop]) combined[comp][prop] = /* @__PURE__ */ new Set();
+            values.forEach((v) => combined[comp][prop].add(v));
+          }
+        }
+      } catch (e) {
+      }
+    }
+  }
+  return combined;
+}
+function findDeadVariants(registered, projectUsage) {
+  var _a2, _b2;
+  const report = {
+    unusedCount: 0,
+    bytesSaved: 0,
+    components: {}
+  };
+  for (const component of registered) {
+    const usage = (_a2 = projectUsage[component.name]) != null ? _a2 : {};
+    const usedVariants = {};
+    const unusedVariants = {};
+    for (const [variantKey, variantValues] of Object.entries(component.variants)) {
+      usedVariants[variantKey] = [];
+      unusedVariants[variantKey] = [];
+      const usedValueSet = (_b2 = usage[variantKey]) != null ? _b2 : /* @__PURE__ */ new Set();
+      for (const [valueName, classes] of Object.entries(variantValues)) {
+        if (usedValueSet.has(valueName)) {
+          usedVariants[variantKey].push(valueName);
+        } else {
+          unusedVariants[variantKey].push(valueName);
+          report.unusedCount++;
+          report.bytesSaved += classes.split(/\s+/).length * 20;
+        }
+      }
+    }
+    if (report.unusedCount > 0) {
+      report.components[component.name] = { usedVariants, unusedVariants };
+    }
+  }
+  return report;
+}
+function eliminateDeadCss(css, deadClasses) {
+  if (deadClasses.size === 0) return css;
+  const lines = css.split("\n");
+  const kept = [];
+  let inBlock = false;
+  let removeBlock = false;
+  let depth = 0;
+  for (const line of lines) {
+    if (!inBlock) {
+      const isDead = Array.from(deadClasses).some((cls) => {
+        const escaped = cls.replace(/[:/[\].!%]/g, "\\$&");
+        return line.includes(`.${escaped}`) || line.includes(`.${cls}`);
+      });
+      if (isDead && line.includes("{")) {
+        removeBlock = true;
+        inBlock = true;
+        depth = 1;
+        continue;
+      } else if (line.includes("{") && !line.trim().startsWith("@")) {
+        inBlock = true;
+        depth = 1;
+        removeBlock = false;
+      }
+    } else {
+      if (line.includes("{")) depth++;
+      if (line.includes("}")) {
+        depth--;
+        if (depth <= 0) {
+          inBlock = false;
+          if (removeBlock) {
+            removeBlock = false;
+            continue;
+          }
+        }
+      }
+      if (removeBlock) continue;
+    }
+    kept.push(line);
+  }
+  return kept.join("\n");
+}
+function optimizeCss(css) {
+  const ruleMap = /* @__PURE__ */ new Map();
+  const ruleRe = /^(\.[\w-]+)\s*\{([^}]+)\}$/gm;
+  const mediaRe = /@media[^{]+\{[\s\S]*?\}\s*\}/g;
+  let m;
+  let remaining = css;
+  const mediaBlocks = [];
+  remaining = remaining.replace(mediaRe, (block) => {
+    mediaBlocks.push(block);
+    return "";
+  });
+  while ((m = ruleRe.exec(remaining)) !== null) {
+    const selector = m[1].trim();
+    const declaration = m[2].trim();
+    if (!ruleMap.has(declaration)) {
+      ruleMap.set(declaration, /* @__PURE__ */ new Set());
+    }
+    ruleMap.get(declaration).add(selector);
+  }
+  const lines = [];
+  for (const [declaration, selectors] of ruleMap) {
+    lines.push(`${Array.from(selectors).join(",")} { ${declaration} }`);
+  }
+  lines.push(...mediaBlocks);
+  return lines.join("\n");
+}
+function runElimination(opts) {
+  const { dirs = ["src"], cwd = process.cwd(), registered = [], inputCss, verbose = false } = opts;
+  const usage = scanProjectUsage(dirs, cwd);
+  const report = findDeadVariants(registered, usage);
+  const deadClasses = /* @__PURE__ */ new Set();
+  for (const [, { unusedVariants }] of Object.entries(report.components)) {
+    for (const values of Object.values(unusedVariants)) {
+      values.forEach((v) => deadClasses.add(v));
+    }
+  }
+  let css = eliminateDeadCss(inputCss, deadClasses);
+  css = optimizeCss(css);
+  if (verbose) {
+    const saved = (report.bytesSaved / 1024).toFixed(1);
+    console.log(`[tailwind-styled-v4] Dead style elimination:`);
+    console.log(`  Unused variants: ${report.unusedCount}`);
+    console.log(`  Estimated savings: ~${saved}KB`);
+    for (const [comp, { unusedVariants }] of Object.entries(report.components)) {
+      for (const [variant, values] of Object.entries(unusedVariants)) {
+        if (values.length > 0) {
+          console.log(`  ${comp}.${variant}: ${values.join(", ")} (unused)`);
+        }
+      }
+    }
+  }
+  return { css, report };
+}
+var CACHE_DIR = ".tw-cache";
+var HASH_CACHE_FILE = path4__default.default.join(CACHE_DIR, "file-hashes.json");
+var GRAPH_CACHE_FILE = path4__default.default.join(CACHE_DIR, "dep-graph.json");
+function ensureCacheDir() {
+  if (!fs2__default.default.existsSync(CACHE_DIR)) {
+    fs2__default.default.mkdirSync(CACHE_DIR, { recursive: true });
+  }
+}
+function loadHashCache() {
+  try {
+    if (fs2__default.default.existsSync(HASH_CACHE_FILE)) {
+      const raw = fs2__default.default.readFileSync(HASH_CACHE_FILE, "utf-8");
+      return new Map(Object.entries(JSON.parse(raw)));
+    }
+  } catch (e) {
+  }
+  return /* @__PURE__ */ new Map();
+}
+function saveHashCache(cache) {
+  try {
+    ensureCacheDir();
+    const obj = Object.fromEntries(cache);
+    fs2__default.default.writeFileSync(HASH_CACHE_FILE, JSON.stringify(obj, null, 2));
+  } catch (e) {
+  }
+}
+function loadGraphCache() {
+  try {
+    if (fs2__default.default.existsSync(GRAPH_CACHE_FILE)) {
+      const raw = fs2__default.default.readFileSync(GRAPH_CACHE_FILE, "utf-8");
+      const data = JSON.parse(raw);
+      return new Map(Object.entries(data));
+    }
+  } catch (e) {
+  }
+  return /* @__PURE__ */ new Map();
+}
+function saveGraphCache(graph) {
+  try {
+    ensureCacheDir();
+    const obj = Object.fromEntries(graph);
+    fs2__default.default.writeFileSync(GRAPH_CACHE_FILE, JSON.stringify(obj, null, 2));
+  } catch (e) {
+  }
+}
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = h * 16777619 >>> 0;
+  }
+  return h;
+}
+function toBase36(n, len = 4) {
+  const chars = "0123456789abcdefghijklmnopqrstuvwxyz";
+  let result = "";
+  let num = n;
+  for (let i = 0; i < len; i++) {
+    result = chars[num % 36] + result;
+    num = Math.floor(num / 36);
+  }
+  return result;
+}
+function hashFileContent(content) {
+  return crypto__default.default.createHash("md5").update(content).digest("hex").slice(0, 8);
+}
+function makeAtomicClass(declaration, modifier) {
+  const key = modifier ? `${declaration}::${modifier}` : declaration;
+  return `tw-${toBase36(fnv1a(key))}`;
+}
+function computeDiff(oldNodes, newNodes) {
+  const oldMap = new Map(oldNodes.map((n) => [n.atomicClass, n]));
+  const newMap = new Map(newNodes.map((n) => [n.atomicClass, n]));
+  const added = [];
+  const removed = [];
+  for (const [cls, node] of newMap) {
+    if (!oldMap.has(cls)) added.push(node);
+  }
+  for (const cls of oldMap.keys()) {
+    if (!newMap.has(cls)) removed.push(cls);
+  }
+  return {
+    added,
+    removed,
+    noChange: added.length === 0 && removed.length === 0
+  };
+}
+var GlobalAtomicRegistry = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  /** Tambah node dari file tertentu */
+  add(filepath, node) {
+    const existing = this.entries.get(node.atomicClass);
+    if (existing) {
+      existing.sources.add(filepath);
+    } else {
+      this.entries.set(node.atomicClass, {
+        node,
+        sources: /* @__PURE__ */ new Set([filepath])
+      });
+    }
+  }
+  /** Hapus referensi dari file tertentu; jika tidak ada source lain, rule dihapus */
+  remove(filepath, atomicClass) {
+    const entry = this.entries.get(atomicClass);
+    if (!entry) return false;
+    entry.sources.delete(filepath);
+    if (entry.sources.size === 0) {
+      this.entries.delete(atomicClass);
+      return true;
+    }
+    return false;
+  }
+  /** Cek apakah rule ada di registry global */
+  has(atomicClass) {
+    return this.entries.has(atomicClass);
+  }
+  /** Semua entries untuk CSS generation */
+  all() {
+    return Array.from(this.entries.values()).map((e) => e.node);
+  }
+  /** Total unique rules */
+  size() {
+    return this.entries.size;
+  }
+};
+function nodeToCSS(node) {
+  const { atomicClass, declaration, modifier } = node;
+  if (!modifier) {
+    return `.${atomicClass}{${declaration}}`;
+  }
+  if (modifier.startsWith("@")) {
+    return `${modifier}{.${atomicClass}{${declaration}}}`;
+  }
+  return `.${atomicClass}${modifier}{${declaration}}`;
+}
+var CssDiffWriter = class {
+  constructor(outputPath) {
+    this.ruleMap = /* @__PURE__ */ new Map();
+    this.dirty = false;
+    this.outputPath = outputPath;
+    this.loadFromDisk();
+  }
+  loadFromDisk() {
+    try {
+      if (fs2__default.default.existsSync(this.outputPath)) {
+        const css = fs2__default.default.readFileSync(this.outputPath, "utf-8");
+        const ruleRe = /(\.tw-[a-z0-9]+(?::[\w-]+)?)\{([^}]+)\}|(@[^{]+)\{(\.tw-[a-z0-9]+)\{([^}]+)\}\}/g;
+        let m;
+        while ((m = ruleRe.exec(css)) !== null) {
+          if (m[1]) {
+            const cls = m[1].replace(/\.[^:]+:.*/, (match) => match.split(".")[1].split(":")[0]);
+            this.ruleMap.set(cls, m[0]);
+          }
+        }
+      }
+    } catch (e) {
+    }
+  }
+  /** Apply diff ke internal map */
+  applyDiff(diff) {
+    if (diff.noChange) return;
+    for (const node of diff.added) {
+      this.ruleMap.set(node.atomicClass, nodeToCSS(node));
+    }
+    for (const cls of diff.removed) {
+      this.ruleMap.delete(cls);
+    }
+    this.dirty = true;
+  }
+  /** Write ke disk jika ada perubahan. Async untuk tidak block loader. */
+  async flush() {
+    if (!this.dirty) return;
+    try {
+      ensureCacheDir();
+      const css = Array.from(this.ruleMap.values()).join("\n");
+      await fs2__default.default.promises.writeFile(this.outputPath, css, "utf-8");
+      this.dirty = false;
+    } catch (e) {
+    }
+  }
+  /** Sync flush untuk build end */
+  flushSync() {
+    if (!this.dirty) return;
+    try {
+      ensureCacheDir();
+      const css = Array.from(this.ruleMap.values()).join("\n");
+      fs2__default.default.writeFileSync(this.outputPath, css, "utf-8");
+      this.dirty = false;
+    } catch (e) {
+    }
+  }
+  size() {
+    return this.ruleMap.size;
+  }
+};
+var IncrementalEngine = class {
+  constructor(opts = {}) {
+    // Stats untuk current build session
+    this.stats = {
+      totalFiles: 0,
+      changedFiles: 0,
+      skippedFiles: 0,
+      addedRules: 0,
+      removedRules: 0,
+      buildTimeMs: 0
+    };
+    this.sessionStart = Date.now();
+    var _a2, _b2, _c;
+    this.opts = {
+      outputPath: (_a2 = opts.outputPath) != null ? _a2 : path4__default.default.join(CACHE_DIR, "atomic.css"),
+      persistCache: (_b2 = opts.persistCache) != null ? _b2 : true,
+      verbose: (_c = opts.verbose) != null ? _c : false
+    };
+    this.hashCache = this.opts.persistCache ? loadHashCache() : /* @__PURE__ */ new Map();
+    this.depGraph = this.opts.persistCache ? loadGraphCache() : /* @__PURE__ */ new Map();
+    this.globalReg = new GlobalAtomicRegistry();
+    this.cssWriter = new CssDiffWriter(this.opts.outputPath);
+    for (const [filepath, nodes] of this.depGraph) {
+      for (const node of nodes) {
+        this.globalReg.add(filepath, node);
+      }
+    }
+  }
+  /**
+   * Proses satu file. Core method dipanggil oleh webpack/turbopack loader.
+   *
+   * @param filepath      - Absolute path ke file
+   * @param source        - Source code file (untuk hashing)
+   * @param extractedNodes - Style nodes yang di-extract compiler dari file ini
+   * @returns ProcessResult dengan diff dan stats
+   */
+  processFile(filepath, source, extractedNodes) {
+    var _a2;
+    const t0 = Date.now();
+    this.stats.totalFiles++;
+    const currentHash = hashFileContent(source);
+    const cachedHash = this.hashCache.get(filepath);
+    if (cachedHash === currentHash) {
+      this.stats.skippedFiles++;
+      this.log(`[skip] ${path4__default.default.relative(process.cwd(), filepath)}`);
+      return {
+        filepath,
+        changed: false,
+        diff: { added: [], removed: [], noChange: true },
+        durationMs: Date.now() - t0
+      };
+    }
+    this.hashCache.set(filepath, currentHash);
+    this.stats.changedFiles++;
+    this.log(`[change] ${path4__default.default.relative(process.cwd(), filepath)}`);
+    const oldNodes = (_a2 = this.depGraph.get(filepath)) != null ? _a2 : [];
+    const diff = computeDiff(oldNodes, extractedNodes);
+    this.depGraph.set(filepath, extractedNodes);
+    const trulyRemoved = [];
+    for (const cls of diff.removed) {
+      const wasRemoved = this.globalReg.remove(filepath, cls);
+      if (wasRemoved) trulyRemoved.push(cls);
+    }
+    const trulyAdded = [];
+    for (const node of diff.added) {
+      if (!this.globalReg.has(node.atomicClass)) {
+        trulyAdded.push(node);
+      }
+      this.globalReg.add(filepath, node);
+    }
+    const finalDiff = {
+      added: trulyAdded,
+      removed: trulyRemoved,
+      noChange: trulyAdded.length === 0 && trulyRemoved.length === 0
+    };
+    this.cssWriter.applyDiff(finalDiff);
+    this.stats.addedRules += trulyAdded.length;
+    this.stats.removedRules += trulyRemoved.length;
+    return {
+      filepath,
+      changed: true,
+      diff: finalDiff,
+      durationMs: Date.now() - t0
+    };
+  }
+  /**
+   * Dipanggil di akhir build. Flush CSS ke disk, persist cache.
+   */
+  async buildEnd() {
+    this.stats.buildTimeMs = Date.now() - this.sessionStart;
+    await this.cssWriter.flush();
+    if (this.opts.persistCache) {
+      saveHashCache(this.hashCache);
+      saveGraphCache(this.depGraph);
+    }
+    this.log(
+      `[build] done in ${this.stats.buildTimeMs}ms | changed: ${this.stats.changedFiles}/${this.stats.totalFiles} files | +${this.stats.addedRules} -${this.stats.removedRules} rules | total rules: ${this.cssWriter.size()}`
+    );
+  }
+  /** Sync version untuk webpack buildEnd hook */
+  buildEndSync() {
+    this.stats.buildTimeMs = Date.now() - this.sessionStart;
+    this.cssWriter.flushSync();
+    if (this.opts.persistCache) {
+      saveHashCache(this.hashCache);
+      saveGraphCache(this.depGraph);
+    }
+  }
+  /**
+   * Invalidate satu file (untuk hot reload — file dihapus atau renamed).
+   */
+  invalidateFile(filepath) {
+    var _a2;
+    const oldNodes = (_a2 = this.depGraph.get(filepath)) != null ? _a2 : [];
+    for (const node of oldNodes) {
+      this.globalReg.remove(filepath, node.atomicClass);
+    }
+    this.depGraph.delete(filepath);
+    this.hashCache.delete(filepath);
+    this.log(`[invalidate] ${path4__default.default.relative(process.cwd(), filepath)}`);
+  }
+  /** Get all active style nodes — untuk full CSS generation */
+  getAllNodes() {
+    return this.globalReg.all();
+  }
+  /** Get stats untuk current build session */
+  getStats() {
+    return __spreadProps(__spreadValues({}, this.stats), { buildTimeMs: Date.now() - this.sessionStart });
+  }
+  /** Get output CSS path */
+  getOutputPath() {
+    return this.opts.outputPath;
+  }
+  /** Reset stats untuk build session baru */
+  resetStats() {
+    this.stats = {
+      totalFiles: 0,
+      changedFiles: 0,
+      skippedFiles: 0,
+      addedRules: 0,
+      removedRules: 0,
+      buildTimeMs: 0
+    };
+    this.sessionStart = Date.now();
+  }
+  /** Reset semua cache — untuk clean build */
+  reset() {
+    this.hashCache.clear();
+    this.depGraph.clear();
+    this.globalReg = new GlobalAtomicRegistry();
+    this.cssWriter = new CssDiffWriter(this.opts.outputPath);
+    this.resetStats();
+    this.log("[reset] incremental cache cleared");
+  }
+  log(msg) {
+    if (this.opts.verbose) {
+      console.log(`[tailwind-styled/incremental] ${msg}`);
+    }
+  }
+};
+function parseClassesToNodes(classes) {
+  const nodes = [];
+  for (const cls of classes) {
+    const node = parseOneClass(cls);
+    if (node) nodes.push(node);
+  }
+  return nodes;
+}
+function parseOneClass(cls) {
+  const colonIdx = cls.lastIndexOf(":");
+  let modifier;
+  let utility;
+  if (colonIdx > 0) {
+    const modStr = cls.slice(0, colonIdx);
+    utility = cls.slice(colonIdx + 1);
+    modifier = resolveModifier(modStr);
+  } else {
+    utility = cls;
+  }
+  const declaration = twToDeclaration(utility);
+  if (!declaration) return null;
+  const atomicClass = makeAtomicClass(declaration, modifier);
+  return { twClass: cls, declaration, modifier, atomicClass };
+}
+function resolveModifier(mod) {
+  var _a2, _b2;
+  const pseudoMap = {
+    hover: ":hover",
+    focus: ":focus",
+    active: ":active",
+    disabled: ":disabled",
+    visited: ":visited",
+    checked: ":checked",
+    first: ":first-child",
+    last: ":last-child",
+    odd: ":nth-child(odd)",
+    even: ":nth-child(even)"
+  };
+  const mediaMap = {
+    sm: "@media (min-width: 640px)",
+    md: "@media (min-width: 768px)",
+    lg: "@media (min-width: 1024px)",
+    xl: "@media (min-width: 1280px)",
+    "2xl": "@media (min-width: 1536px)",
+    dark: "@media (prefers-color-scheme: dark)",
+    print: "@media print"
+  };
+  return (_b2 = (_a2 = pseudoMap[mod]) != null ? _a2 : mediaMap[mod]) != null ? _b2 : `:${mod}`;
+}
+function twToDeclaration(cls) {
+  var _a2;
+  const sp = cls.match(/^(p|px|py|pt|pb|pl|pr|m|mx|my|mt|mb|ml|mr|gap)-([\d.]+)$/);
+  if (sp) {
+    const propMap = {
+      p: "padding",
+      px: "padding-inline",
+      py: "padding-block",
+      pt: "padding-top",
+      pb: "padding-bottom",
+      pl: "padding-left",
+      pr: "padding-right",
+      m: "margin",
+      mx: "margin-inline",
+      my: "margin-block",
+      mt: "margin-top",
+      mb: "margin-bottom",
+      ml: "margin-left",
+      mr: "margin-right",
+      gap: "gap"
+    };
+    return `${propMap[sp[1]]}: ${parseFloat(sp[2]) * 0.25}rem`;
+  }
+  const w = cls.match(/^w-(.+)$/);
+  if (w) return `width: ${sizeVal(w[1])}`;
+  const h = cls.match(/^h-(.+)$/);
+  if (h) return `height: ${sizeVal(h[1])}`;
+  const op = cls.match(/^opacity-(\d+)$/);
+  if (op) return `opacity: ${parseInt(op[1], 10) / 100}`;
+  const z = cls.match(/^z-(\d+)$/);
+  if (z) return `z-index: ${z[1]}`;
+  const map = {
+    block: "display: block",
+    "inline-block": "display: inline-block",
+    flex: "display: flex",
+    "inline-flex": "display: inline-flex",
+    grid: "display: grid",
+    hidden: "display: none",
+    relative: "position: relative",
+    absolute: "position: absolute",
+    fixed: "position: fixed",
+    sticky: "position: sticky",
+    "flex-row": "flex-direction: row",
+    "flex-col": "flex-direction: column",
+    "items-center": "align-items: center",
+    "items-start": "align-items: flex-start",
+    "items-end": "align-items: flex-end",
+    "justify-center": "justify-content: center",
+    "justify-between": "justify-content: space-between",
+    "justify-start": "justify-content: flex-start",
+    "justify-end": "justify-content: flex-end",
+    "font-thin": "font-weight: 100",
+    "font-light": "font-weight: 300",
+    "font-normal": "font-weight: 400",
+    "font-medium": "font-weight: 500",
+    "font-semibold": "font-weight: 600",
+    "font-bold": "font-weight: 700",
+    "font-extrabold": "font-weight: 800",
+    "text-xs": "font-size: 0.75rem",
+    "text-sm": "font-size: 0.875rem",
+    "text-base": "font-size: 1rem",
+    "text-lg": "font-size: 1.125rem",
+    "text-xl": "font-size: 1.25rem",
+    "text-2xl": "font-size: 1.5rem",
+    "text-3xl": "font-size: 1.875rem",
+    "text-4xl": "font-size: 2.25rem",
+    rounded: "border-radius: 0.25rem",
+    "rounded-md": "border-radius: 0.375rem",
+    "rounded-lg": "border-radius: 0.5rem",
+    "rounded-xl": "border-radius: 0.75rem",
+    "rounded-full": "border-radius: 9999px",
+    "overflow-hidden": "overflow: hidden",
+    "overflow-auto": "overflow: auto",
+    "cursor-pointer": "cursor: pointer",
+    "cursor-default": "cursor: default",
+    "select-none": "user-select: none",
+    "pointer-events-none": "pointer-events: none",
+    truncate: "overflow: hidden; text-overflow: ellipsis; white-space: nowrap",
+    transition: "transition-property: color,background-color,border-color,opacity,box-shadow,transform; transition-duration: 150ms"
+  };
+  return (_a2 = map[cls]) != null ? _a2 : null;
+}
+function sizeVal(v) {
+  var _a2;
+  const num = parseFloat(v);
+  if (!Number.isNaN(num)) return `${num * 0.25}rem`;
+  const special = {
+    full: "100%",
+    screen: "100vw",
+    auto: "auto",
+    min: "min-content",
+    max: "max-content",
+    fit: "fit-content"
+  };
+  return (_a2 = special[v]) != null ? _a2 : v;
+}
+var _engine = null;
+function getIncrementalEngine(opts) {
+  if (!_engine) {
+    _engine = new IncrementalEngine(opts);
+  }
+  return _engine;
+}
+function resetIncrementalEngine() {
+  _engine = null;
+}
+var CONFIG_FILES = [
+  "tailwind.config.ts",
+  "tailwind.config.js",
+  "tailwind.config.mjs",
+  "tailwind.config.cjs"
+];
+var _cachedConfig = null;
+var _cachedCwd = "";
+function loadTailwindConfig(cwd = process.cwd()) {
+  var _a2;
+  if (_cachedConfig && _cachedCwd === cwd) return _cachedConfig;
+  _cachedCwd = cwd;
+  for (const file of CONFIG_FILES) {
+    const fullPath = path4__default.default.join(cwd, file);
+    if (fs2__default.default.existsSync(fullPath)) {
+      try {
+        const mod = __require(fullPath);
+        const config = (_a2 = mod.default) != null ? _a2 : mod;
+        _cachedConfig = config;
+        console.log(`[tailwind-styled-v4] Using config: ${file}`);
+        return config;
+      } catch (e) {
+      }
+    }
+  }
+  console.log("[tailwind-styled-v4] No tailwind config found \u2192 using built-in preset");
+  const { defaultPreset: defaultPreset2 } = (init_defaultPreset(), __toCommonJS(defaultPreset_exports));
+  _cachedConfig = defaultPreset2;
+  return defaultPreset2;
+}
+function getContentPaths(config, cwd = process.cwd()) {
+  var _a2;
+  const paths = [];
+  if (Array.isArray(config.content)) {
+    for (const item of config.content) {
+      if (typeof item === "string") paths.push(item);
+      else if (typeof item === "object" && item.raw) ;
+    }
+    return paths;
+  }
+  if ((_a2 = config.content) == null ? void 0 : _a2.files) {
+    return config.content.files.filter((f) => typeof f === "string");
+  }
+  return ["src", "app", "pages", "components"].filter((d) => fs2__default.default.existsSync(path4__default.default.join(cwd, d))).map((d) => `./${d}/**/*.{tsx,ts,jsx,js}`);
+}
+function invalidateConfigCache() {
+  _cachedConfig = null;
+  _cachedCwd = "";
+}
+function isZeroConfig(cwd = process.cwd()) {
+  return !CONFIG_FILES.some((f) => fs2__default.default.existsSync(path4__default.default.join(cwd, f)));
+}
+function bootstrapZeroConfig(cwd = process.cwd()) {
+  let generatedConfig = false;
+  let generatedCss = false;
+  generatedConfig = false;
+  const cssPaths = [
+    "src/app/globals.css",
+    "app/globals.css",
+    "src/index.css",
+    "src/styles/globals.css"
+  ];
+  const hasGlobalCss = cssPaths.some((p) => fs2__default.default.existsSync(path4__default.default.join(cwd, p)));
+  if (!hasGlobalCss) {
+    const { defaultGlobalCss: defaultGlobalCss2 } = (init_defaultPreset(), __toCommonJS(defaultPreset_exports));
+    const appDir = fs2__default.default.existsSync(path4__default.default.join(cwd, "src/app")) ? "src/app" : fs2__default.default.existsSync(path4__default.default.join(cwd, "app")) ? "app" : "src";
+    const cssPath = path4__default.default.join(cwd, appDir, "globals.css");
+    if (fs2__default.default.existsSync(path4__default.default.dirname(cssPath))) {
+      fs2__default.default.writeFileSync(cssPath, defaultGlobalCss2);
+      generatedCss = true;
+      console.log(`[tailwind-styled-v4] Generated ${cssPath}`);
+    }
+  }
+  return { generatedConfig, generatedCss };
+}
+
+// ../compiler/src/routeCssCollector.ts
+var _collector = {
+  files: /* @__PURE__ */ new Map(),
+  routes: /* @__PURE__ */ new Map(),
+  global: /* @__PURE__ */ new Set()
+};
+function registerFileClasses(filepath, classes) {
+  if (!_collector.files.has(filepath)) {
+    _collector.files.set(filepath, /* @__PURE__ */ new Set());
+  }
+  const fileSet = _collector.files.get(filepath);
+  classes.forEach((c) => fileSet.add(c));
+  const route = fileToRoute(filepath);
+  if (route) {
+    if (!_collector.routes.has(route)) {
+      _collector.routes.set(route, /* @__PURE__ */ new Set());
+    }
+    _collector.routes.get(route).add(filepath);
+  }
+}
+function registerGlobalClasses(classes) {
+  classes.forEach((c) => _collector.global.add(c));
+}
+function getRouteClasses(route) {
+  var _a2, _b2;
+  const result = new Set(_collector.global);
+  const routeFiles = (_a2 = _collector.routes.get(route)) != null ? _a2 : /* @__PURE__ */ new Set();
+  for (const filepath of routeFiles) {
+    const fileClasses = (_b2 = _collector.files.get(filepath)) != null ? _b2 : /* @__PURE__ */ new Set();
+    fileClasses.forEach((c) => result.add(c));
+  }
+  return result;
+}
+function getAllRoutes() {
+  return Array.from(_collector.routes.keys()).sort();
+}
+function getCollector() {
+  return _collector;
+}
+function resetCollector() {
+  _collector = {
+    files: /* @__PURE__ */ new Map(),
+    routes: /* @__PURE__ */ new Map(),
+    global: /* @__PURE__ */ new Set()
+  };
+}
+function fileToRoute(filepath) {
+  const normalized = filepath.replace(/\\/g, "/");
+  if (normalized.includes("/layout.") || normalized.includes("/loading.") || normalized.includes("/error.")) {
+    return "__global";
+  }
+  const pageMatch = normalized.match(/\/app\/(.+?)\/page\.[tj]sx?$/);
+  if (pageMatch) return `/${pageMatch[1]}`;
+  const rootPage = normalized.match(/\/app\/page\.[tj]sx?$/);
+  if (rootPage) return "/";
+  const pagesMatch = normalized.match(/\/pages\/(.+?)\.[tj]sx?$/);
+  if (pagesMatch) {
+    const route = pagesMatch[1].replace(/\/index$/, "");
+    return `/${route}`;
+  }
+  if (normalized.includes("/components/") || normalized.includes("/ui/") || normalized.includes("/shared/")) {
+    return "__global";
+  }
+  return null;
+}
+function getCollectorSummary() {
+  const routes = getAllRoutes();
+  const totalFiles = _collector.files.size;
+  const totalGlobal = _collector.global.size;
+  const lines = [
+    `[tailwind-styled-v4] Route CSS Summary:`,
+    `  Files processed: ${totalFiles}`,
+    `  Global classes: ${totalGlobal}`,
+    `  Routes found: ${routes.length}`,
+    ...routes.map((r) => {
+      const cls = getRouteClasses(r).size;
+      return `    ${r} \u2192 ${cls} classes`;
+    })
+  ];
+  return lines.join("\n");
+}
+var SCAN_EXTENSIONS2 = [".tsx", ".ts", ".jsx", ".js"];
+function scanDir(dir, files = []) {
+  if (!fs2__default.default.existsSync(dir)) return files;
+  const entries = fs2__default.default.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist") continue;
+    const fullPath = path4__default.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      scanDir(fullPath, files);
+    } else if (SCAN_EXTENSIONS2.some((ext) => entry.name.endsWith(ext))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function generateSafelist(scanDirs, outputPath = ".tailwind-styled-safelist.json", cwd = process.cwd()) {
+  const allClasses = /* @__PURE__ */ new Set();
+  for (const dir of scanDirs) {
+    const absDir = path4__default.default.isAbsolute(dir) ? dir : path4__default.default.resolve(cwd, dir);
+    const files = scanDir(absDir);
+    for (const file of files) {
+      try {
+        const source = fs2__default.default.readFileSync(file, "utf-8");
+        const classes = extractAllClasses(source);
+        classes.forEach((c) => allClasses.add(c));
+      } catch (e) {
+      }
+    }
+  }
+  const sorted = Array.from(allClasses).sort();
+  const absOutput = path4__default.default.isAbsolute(outputPath) ? outputPath : path4__default.default.resolve(cwd, outputPath);
+  fs2__default.default.writeFileSync(absOutput, JSON.stringify(sorted, null, 2));
+  console.log(`[tailwind-styled-v4] Safelist: ${sorted.length} classes \u2192 ${absOutput}`);
+  return sorted;
+}
+function loadSafelist(safelistPath) {
+  try {
+    const content = fs2__default.default.readFileSync(safelistPath, "utf-8");
+    return JSON.parse(content);
+  } catch (e) {
+    return [];
+  }
+}
+function generateSafelistCss(scanDirs, outputPath = "src/app/__tw-safelist.css", cwd = process.cwd()) {
+  const allClasses = /* @__PURE__ */ new Set();
+  for (const dir of scanDirs) {
+    const absDir = path4__default.default.isAbsolute(dir) ? dir : path4__default.default.resolve(cwd, dir);
+    const files = scanDir(absDir);
+    for (const file of files) {
+      try {
+        const source = fs2__default.default.readFileSync(file, "utf-8");
+        const classes = extractAllClasses(source);
+        classes.forEach((c) => allClasses.add(c));
+      } catch (e) {
+      }
+    }
+  }
+  const sorted = Array.from(allClasses).sort();
+  const absOutput = path4__default.default.isAbsolute(outputPath) ? outputPath : path4__default.default.resolve(cwd, outputPath);
+  fs2__default.default.mkdirSync(path4__default.default.dirname(absOutput), { recursive: true });
+  const css = sorted.length > 0 ? `/* Auto-generated by tailwind-styled-v4 \u2014 DO NOT EDIT */
+@source inline("${sorted.join(" ")}");
+` : `/* Auto-generated by tailwind-styled-v4 \u2014 DO NOT EDIT */
+/* No safelist classes found */
+`;
+  fs2__default.default.writeFileSync(absOutput, css);
+  console.log(`[tailwind-styled-v4] Safelist: ${sorted.length} classes \u2192 ${absOutput}`);
+  return sorted;
+}
+
+// ../compiler/src/styleBucketSystem.ts
+var BUCKET_ORDER = [
+  "reset",
+  "layout",
+  "spacing",
+  "sizing",
+  "typography",
+  "visual",
+  "interaction",
+  "responsive",
+  "unknown"
+];
+var PROPERTY_BUCKET_MAP = {
+  // Layout
+  display: "layout",
+  position: "layout",
+  flex: "layout",
+  "flex-direction": "layout",
+  "flex-wrap": "layout",
+  "flex-grow": "layout",
+  "flex-shrink": "layout",
+  "flex-basis": "layout",
+  grid: "layout",
+  "grid-template": "layout",
+  "grid-column": "layout",
+  "grid-row": "layout",
+  "align-items": "layout",
+  "align-self": "layout",
+  "align-content": "layout",
+  "justify-content": "layout",
+  "justify-items": "layout",
+  "justify-self": "layout",
+  "place-items": "layout",
+  "place-content": "layout",
+  overflow: "layout",
+  "overflow-x": "layout",
+  "overflow-y": "layout",
+  "z-index": "layout",
+  float: "layout",
+  clear: "layout",
+  visibility: "layout",
+  // Spacing
+  padding: "spacing",
+  "padding-top": "spacing",
+  "padding-bottom": "spacing",
+  "padding-left": "spacing",
+  "padding-right": "spacing",
+  "padding-inline": "spacing",
+  "padding-block": "spacing",
+  margin: "spacing",
+  "margin-top": "spacing",
+  "margin-bottom": "spacing",
+  "margin-left": "spacing",
+  "margin-right": "spacing",
+  "margin-inline": "spacing",
+  "margin-block": "spacing",
+  gap: "spacing",
+  "column-gap": "spacing",
+  "row-gap": "spacing",
+  inset: "spacing",
+  "inset-inline": "spacing",
+  "inset-block": "spacing",
+  top: "spacing",
+  bottom: "spacing",
+  left: "spacing",
+  right: "spacing",
+  // Sizing
+  width: "sizing",
+  height: "sizing",
+  "max-width": "sizing",
+  "min-width": "sizing",
+  "max-height": "sizing",
+  "min-height": "sizing",
+  "aspect-ratio": "sizing",
+  // Typography
+  "font-size": "typography",
+  "font-weight": "typography",
+  "font-family": "typography",
+  "font-style": "typography",
+  "line-height": "typography",
+  "letter-spacing": "typography",
+  "text-align": "typography",
+  "text-decoration": "typography",
+  "text-transform": "typography",
+  "text-overflow": "typography",
+  "white-space": "typography",
+  "word-break": "typography",
+  "word-wrap": "typography",
+  "vertical-align": "typography",
+  // Visual
+  color: "visual",
+  background: "visual",
+  "background-color": "visual",
+  "background-image": "visual",
+  "background-size": "visual",
+  "background-position": "visual",
+  "background-repeat": "visual",
+  border: "visual",
+  "border-top": "visual",
+  "border-bottom": "visual",
+  "border-left": "visual",
+  "border-right": "visual",
+  "border-inline": "visual",
+  "border-block": "visual",
+  "border-color": "visual",
+  "border-width": "visual",
+  "border-style": "visual",
+  "border-radius": "visual",
+  "box-shadow": "visual",
+  opacity: "visual",
+  outline: "visual",
+  "outline-color": "visual",
+  "outline-width": "visual",
+  fill: "visual",
+  stroke: "visual",
+  "text-shadow": "visual",
+  "mix-blend-mode": "visual",
+  "object-fit": "visual",
+  "object-position": "visual",
+  // Interaction
+  cursor: "interaction",
+  "pointer-events": "interaction",
+  "user-select": "interaction",
+  transition: "interaction",
+  "transition-property": "interaction",
+  "transition-duration": "interaction",
+  "transition-timing-function": "interaction",
+  "transition-delay": "interaction",
+  transform: "interaction",
+  translate: "interaction",
+  rotate: "interaction",
+  scale: "interaction",
+  animation: "interaction",
+  "will-change": "interaction",
+  "scroll-behavior": "interaction",
+  "scroll-snap-type": "interaction",
+  // Reset (jarang dipakai langsung tapi handle untuk completeness)
+  "box-sizing": "reset",
+  appearance: "reset",
+  all: "reset"
+};
+function classifyNode(node) {
+  var _a2, _b2, _c;
+  if ((_a2 = node.modifier) == null ? void 0 : _a2.startsWith("@")) return "responsive";
+  const declarations = node.declaration.split(";").map((d) => d.trim()).filter(Boolean);
+  const firstProp = (_c = (_b2 = declarations[0]) == null ? void 0 : _b2.split(":")[0]) == null ? void 0 : _c.trim();
+  if (!firstProp) return "unknown";
+  if (PROPERTY_BUCKET_MAP[firstProp]) return PROPERTY_BUCKET_MAP[firstProp];
+  for (const [prefix, bucket] of Object.entries(PROPERTY_BUCKET_MAP)) {
+    if (firstProp.startsWith(prefix)) return bucket;
+  }
+  return "unknown";
+}
+var BucketEngine = class {
+  constructor() {
+    this.buckets = /* @__PURE__ */ new Map();
+    for (const b of BUCKET_ORDER) {
+      this.buckets.set(b, /* @__PURE__ */ new Map());
+    }
+  }
+  /**
+   * Tambah StyleNode ke bucket yang tepat.
+   * Idempotent — atomic class yang sama tidak akan duplikat.
+   */
+  add(node) {
+    const bucket = classifyNode(node);
+    this.buckets.get(bucket).set(node.atomicClass, node);
+  }
+  /**
+   * Hapus node dari bucket (untuk incremental update).
+   */
+  remove(atomicClass) {
+    for (const bucket of this.buckets.values()) {
+      if (bucket.delete(atomicClass)) break;
+    }
+  }
+  /**
+   * Apply CssDiff dari incremental engine.
+   */
+  applyDiff(diff) {
+    for (const node of diff.added) this.add(node);
+    for (const cls of diff.removed) this.remove(cls);
+  }
+  /**
+   * Emit seluruh CSS dalam urutan bucket yang deterministic.
+   *
+   * @param comments - Tambahkan komentar section per bucket. Default: true
+   * @returns CSS string yang siap di-write ke file
+   */
+  emit(comments = true) {
+    const sections = [];
+    for (const bucketName of BUCKET_ORDER) {
+      const nodes = this.buckets.get(bucketName);
+      if (nodes.size === 0) continue;
+      const rules = [];
+      for (const node of nodes.values()) {
+        rules.push(nodeToCSS2(node));
+      }
+      if (rules.length === 0) continue;
+      if (comments) {
+        sections.push(`/* \u2500\u2500 ${bucketName} \u2500\u2500 */`);
+      }
+      sections.push(...rules);
+    }
+    return sections.join("\n");
+  }
+  /**
+   * Emit dengan @layer CSS untuk native browser layering.
+   * Lebih powerful — browser respects layer order untuk specificity.
+   *
+   * @example output:
+   * @layer tw-layout, tw-spacing, tw-visual, tw-responsive;
+   * @layer tw-layout { .tw-a1 { display: flex } }
+   */
+  emitLayered() {
+    const layerNames = BUCKET_ORDER.filter(
+      (b) => b !== "unknown" && this.buckets.get(b).size > 0
+    ).map((b) => `tw-${b}`);
+    if (layerNames.length === 0) return "";
+    const parts = [`@layer ${layerNames.join(", ")};`, ""];
+    for (const bucketName of BUCKET_ORDER) {
+      const nodes = this.buckets.get(bucketName);
+      if (nodes.size === 0) continue;
+      const rules = Array.from(nodes.values()).map(nodeToCSS2).join("\n  ");
+      parts.push(`@layer tw-${bucketName} {
+  ${rules}
+}`);
+    }
+    return parts.join("\n");
+  }
+  /** Semua nodes dari semua bucket (untuk full registry access) */
+  allNodes() {
+    const all = [];
+    for (const bucket of this.buckets.values()) {
+      for (const node of bucket.values()) {
+        all.push(node);
+      }
+    }
+    return all;
+  }
+  /** Stats per bucket */
+  stats() {
+    const perBucket = {};
+    let total = 0;
+    for (const [name, nodes] of this.buckets) {
+      perBucket[name] = nodes.size;
+      total += nodes.size;
+    }
+    return { totalNodes: total, perBucket };
+  }
+  /** Clear semua bucket */
+  clear() {
+    for (const bucket of this.buckets.values()) {
+      bucket.clear();
+    }
+  }
+};
+function bucketSort(nodes) {
+  const bucketIndex = Object.fromEntries(BUCKET_ORDER.map((b, i) => [b, i]));
+  return [...nodes].sort((a, b) => {
+    const ai = bucketIndex[classifyNode(a)];
+    const bi = bucketIndex[classifyNode(b)];
+    return ai - bi;
+  });
+}
+function nodeToCSS2(node) {
+  const { atomicClass, declaration, modifier } = node;
+  if (!modifier) {
+    return `.${atomicClass}{${declaration}}`;
+  }
+  if (modifier.startsWith("@")) {
+    return `${modifier}{.${atomicClass}{${declaration}}}`;
+  }
+  return `.${atomicClass}${modifier}{${declaration}}`;
+}
+function detectConflicts(nodes) {
+  var _a2, _b2, _c;
+  const seen = /* @__PURE__ */ new Map();
+  const warnings = [];
+  for (const node of nodes) {
+    if ((_a2 = node.modifier) == null ? void 0 : _a2.startsWith("@")) continue;
+    const firstProp = (_b2 = node.declaration.split(":")[0]) == null ? void 0 : _b2.trim();
+    if (!firstProp) continue;
+    const key = `${firstProp}::${(_c = node.modifier) != null ? _c : ""}`;
+    const prev = seen.get(key);
+    if (prev) {
+      warnings.push({
+        property: firstProp,
+        classes: [prev.twClass, node.twClass],
+        bucket: classifyNode(node),
+        message: `Possible conflict: "${prev.twClass}" and "${node.twClass}" both set "${firstProp}"`
+      });
+    } else {
+      seen.set(key, node);
+    }
+  }
+  return warnings;
+}
+var _bucketEngine = null;
+function getBucketEngine() {
+  if (!_bucketEngine) _bucketEngine = new BucketEngine();
+  return _bucketEngine;
+}
+function resetBucketEngine() {
+  _bucketEngine = null;
+}
+async function generateCssForClasses(classes, config, cwd = process.cwd()) {
+  const twConfig = config != null ? config : loadTailwindConfig(cwd);
+  try {
+    return await generateViaTailwindV4(classes, twConfig, cwd);
+  } catch (e) {
+  }
+  try {
+    return await generateViaTailwindV3(classes, twConfig);
+  } catch (e) {
+  }
+  return generateManualCss(classes);
+}
+async function generateViaTailwindV4(classes, _config, cwd) {
+  const virtualCss = [
+    `@import "tailwindcss";`,
+    `@layer utilities {`,
+    `  /* Generated by tailwind-styled-v4 */`,
+    `}`
+  ].join("\n");
+  const postcss = __require("postcss");
+  const tailwindcss = __require("@tailwindcss/postcss");
+  const result = await postcss([
+    tailwindcss({
+      optimize: { minify: false }
+    })
+  ]).process(virtualCss, {
+    from: path4__default.default.join(cwd, "virtual.css")
+  });
+  return filterCssForClasses(result.css, classes);
+}
+async function generateViaTailwindV3(classes, config) {
+  const postcss = __require("postcss");
+  const tailwindcss = __require("tailwindcss");
+  const virtualContent = classes.map((c) => `<div class="${c}">`).join("\n");
+  const twConfigWithContent = __spreadProps(__spreadValues({}, config), {
+    content: [{ raw: virtualContent, extension: "html" }],
+    safelist: classes
+  });
+  const inputCss = `@tailwind base;
+@tailwind components;
+@tailwind utilities;`;
+  const result = await postcss([tailwindcss(twConfigWithContent)]).process(inputCss, {
+    from: void 0
+  });
+  return result.css;
+}
+function generateManualCss(classes) {
+  const { generateAtomicCss: generateAtomicCss2, parseAtomicClass: parseAtomicClass2 } = (init_atomicCss(), __toCommonJS(atomicCss_exports));
+  const rules = classes.map((c) => parseAtomicClass2(c)).filter(Boolean);
+  if (rules.length === 0) return "";
+  const header = `/* Generated by tailwind-styled-v4 \u2014 ${(/* @__PURE__ */ new Date()).toISOString()} */
+`;
+  return header + generateAtomicCss2(rules);
+}
+function filterCssForClasses(fullCss, classes) {
+  new Set(classes);
+  const lines = fullCss.split("\n");
+  const kept = [];
+  let inBlock = false;
+  let keepBlock = false;
+  let braceDepth = 0;
+  for (const line of lines) {
+    if (line.includes("@layer base") || line.includes("*, *::before")) {
+      kept.push(line);
+      continue;
+    }
+    if (!inBlock) {
+      const isOurClass = classes.some((cls) => {
+        const escaped = cls.replace(/[:/[\].!%]/g, "\\$&");
+        return line.includes(`.${escaped}`) || line.includes(`.${cls}`);
+      });
+      if (isOurClass) {
+        keepBlock = true;
+        inBlock = true;
+        braceDepth = 0;
+      }
+    }
+    if (inBlock) {
+      if (keepBlock) kept.push(line);
+      if (line.includes("{")) braceDepth++;
+      if (line.includes("}")) {
+        braceDepth--;
+        if (braceDepth <= 0) {
+          inBlock = false;
+          keepBlock = false;
+        }
+      }
+    }
+  }
+  return kept.join("\n");
+}
+async function generateAllRouteCss(opts = {}) {
+  const { cwd = process.cwd(), outputDir, config, minify = true } = opts;
+  const results = [];
+  const routes = getAllRoutes();
+  const twConfig = config != null ? config : loadTailwindConfig(cwd);
+  for (const route of routes) {
+    const classes = Array.from(getRouteClasses(route));
+    if (classes.length === 0) continue;
+    try {
+      let css = await generateCssForClasses(classes, twConfig, cwd);
+      if (minify) {
+        css = minifyCss(css);
+      }
+      results.push({
+        route,
+        css,
+        classes,
+        sizeBytes: Buffer.byteLength(css, "utf8")
+      });
+    } catch (e) {
+      console.warn(`[tailwind-styled-v4] CSS generation failed for route ${route}:`, e);
+    }
+  }
+  if (outputDir) {
+    const fs5 = __require("fs");
+    fs5.mkdirSync(outputDir, { recursive: true });
+    for (const result of results) {
+      const filename = routeToFilename(result.route);
+      const filepath = path4__default.default.join(outputDir, filename);
+      fs5.mkdirSync(path4__default.default.dirname(filepath), { recursive: true });
+      fs5.writeFileSync(filepath, result.css);
+    }
+    const totalSize = results.reduce((sum, r) => sum + r.sizeBytes, 0);
+    console.log(
+      `[tailwind-styled-v4] Route CSS generated: ${results.length} routes, ${formatBytes(totalSize)} total`
+    );
+  }
+  return results;
+}
+function routeToFilename(route) {
+  if (route === "/") return "index.css";
+  if (route === "__global") return "_global.css";
+  return `${route.replace(/^\//, "").replace(/\//g, "_")}.css`;
+}
+function minifyCss(css) {
+  return css.replace(/\/\*[^*]*\*+([^/*][^*]*\*+)*\//g, "").replace(/\s+/g, " ").replace(/\s*{\s*/g, "{").replace(/\s*}\s*/g, "}").replace(/\s*:\s*/g, ":").replace(/\s*;\s*/g, ";").trim();
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}
+
+exports.BucketEngine = BucketEngine;
+exports.IncrementalEngine = IncrementalEngine;
+exports.analyzeFile = analyzeFile;
+exports.analyzeVariantUsage = analyzeVariantUsage;
+exports.bootstrapZeroConfig = bootstrapZeroConfig;
+exports.bucketSort = bucketSort;
+exports.classifyNode = classifyNode;
+exports.clearAtomicRegistry = clearAtomicRegistry;
+exports.compileVariants = compileVariants;
+exports.detectConflicts = detectConflicts;
+exports.extractAllClasses = extractAllClasses;
+exports.extractComponentUsage = extractComponentUsage;
+exports.fileToRoute = fileToRoute;
+exports.generateAllRouteCss = generateAllRouteCss;
+exports.generateAtomicCss = generateAtomicCss;
+exports.generateCssForClasses = generateCssForClasses;
+exports.generateSafelist = generateSafelist;
+exports.generateSafelistCss = generateSafelistCss;
+exports.getAllRoutes = getAllRoutes;
+exports.getAtomicRegistry = getAtomicRegistry;
+exports.getBucketEngine = getBucketEngine;
+exports.getCollector = getCollector;
+exports.getCollectorSummary = getCollectorSummary;
+exports.getContentPaths = getContentPaths;
+exports.getIncrementalEngine = getIncrementalEngine;
+exports.getRouteClasses = getRouteClasses;
+exports.hasInteractiveFeatures = hasInteractiveFeatures;
+exports.hasTwUsage = hasTwUsage;
+exports.hoistComponents = hoistComponents;
+exports.injectClientDirective = injectClientDirective;
+exports.injectServerOnlyComment = injectServerOnlyComment;
+exports.invalidateConfigCache = invalidateConfigCache;
+exports.isDynamic = isDynamic;
+exports.isServerComponent = isServerComponent;
+exports.isZeroConfig = isZeroConfig;
+exports.loadSafelist = loadSafelist;
+exports.loadTailwindConfig = loadTailwindConfig;
+exports.mergeClassesStatic = mergeClassesStatic;
+exports.normalizeClasses = normalizeClasses;
+exports.parseAtomicClass = parseAtomicClass;
+exports.parseClassesToNodes = parseClassesToNodes;
+exports.registerFileClasses = registerFileClasses;
+exports.registerGlobalClasses = registerGlobalClasses;
+exports.resetBucketEngine = resetBucketEngine;
+exports.resetCollector = resetCollector;
+exports.resetIncrementalEngine = resetIncrementalEngine;
+exports.resolveServerVariant = resolveServerVariant;
+exports.runElimination = runElimination;
+exports.scanProjectUsage = scanProjectUsage;
+exports.shouldProcess = hasTwUsage;
+exports.toAtomicClasses = toAtomicClasses;
+exports.transformSource = transformSource;
+//# sourceMappingURL=compiler.cjs.map
+//# sourceMappingURL=compiler.cjs.map