@tailwind-styled/next 2.0.0

package/dist/turbopackLoader.cjs

@@ -0,0 +1,2711 @@
+"use strict";
+var __create = Object.create;
+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 __getProtoOf = Object.getPrototypeOf;
+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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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"), getter ? getter.call(obj) : 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"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// ../../node_modules/oxc-parser/src-js/bindings.js
+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_node_module, import_meta, require2, __dirname, 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"() {
+    "use strict";
+    import_node_module = require("module");
+    import_meta = {};
+    require2 = (0, import_node_module.createRequire)(import_meta.url);
+    __dirname = 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, module2, comments, errors;
+  return {
+    get program() {
+      if (!program) program = jsonParseAst(result.program);
+      return program;
+    },
+    get module() {
+      if (!module2) module2 = result.module;
+      return module2;
+    },
+    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"() {
+    "use strict";
+  }
+});
+
+// ../../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"() {
+    "use strict";
+    ({ 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
+    });
+  }
+});
+
+// ../../node_modules/oxc-parser/src-js/visit/index.js
+var import_node_module2, import_meta2, walkProgram, addVisitorToCompiled, createCompiledVisitor, finalizeCompiledVisitor, _compiledVisitor, Visitor;
+var init_visit = __esm({
+  "../../node_modules/oxc-parser/src-js/visit/index.js"() {
+    "use strict";
+    import_node_module2 = require("module");
+    import_meta2 = {};
+    walkProgram = null;
+    Visitor = class {
+      constructor(visitor) {
+        __privateAdd(this, _compiledVisitor, null);
+        if (walkProgram === null) {
+          const require4 = (0, import_node_module2.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"() {
+    "use strict";
+    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_node_module3, import_meta3, require3, parseSyncRaw, parseRaw2, parseSyncLazy, parseLazy, LazyVisitor;
+var init_src_js = __esm({
+  "../../node_modules/oxc-parser/src-js/index.js"() {
+    "use strict";
+    import_node_module3 = require("module");
+    init_bindings();
+    init_wrap();
+    init_keys();
+    init_visit();
+    init_bindings();
+    init_supported();
+    import_meta3 = {};
+    require3 = (0, import_node_module3.createRequire)(import_meta3.url);
+    parseSyncRaw = null;
+    parseSyncLazy = null;
+  }
+});
+
+// ../compiler/src/incrementalEngine.ts
+var incrementalEngine_exports = {};
+__export(incrementalEngine_exports, {
+  IncrementalEngine: () => IncrementalEngine,
+  getIncrementalEngine: () => getIncrementalEngine,
+  parseClassesToNodes: () => parseClassesToNodes,
+  resetIncrementalEngine: () => resetIncrementalEngine
+});
+function ensureCacheDir() {
+  if (!import_node_fs.default.existsSync(CACHE_DIR)) {
+    import_node_fs.default.mkdirSync(CACHE_DIR, { recursive: true });
+  }
+}
+function loadHashCache() {
+  try {
+    if (import_node_fs.default.existsSync(HASH_CACHE_FILE)) {
+      const raw = import_node_fs.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);
+    import_node_fs.default.writeFileSync(HASH_CACHE_FILE, JSON.stringify(obj, null, 2));
+  } catch (e) {
+  }
+}
+function loadGraphCache() {
+  try {
+    if (import_node_fs.default.existsSync(GRAPH_CACHE_FILE)) {
+      const raw = import_node_fs.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);
+    import_node_fs.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 import_node_crypto.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
+  };
+}
+function nodeToCSS(node) {
+  const { atomicClass, declaration, modifier } = node;
+  if (!modifier) {
+    return `.${atomicClass}{${declaration}}`;
+  }
+  if (modifier.startsWith("@")) {
+    return `${modifier}{.${atomicClass}{${declaration}}}`;
+  }
+  return `.${atomicClass}${modifier}{${declaration}}`;
+}
+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;
+}
+function getIncrementalEngine(opts) {
+  if (!_engine) {
+    _engine = new IncrementalEngine(opts);
+  }
+  return _engine;
+}
+function resetIncrementalEngine() {
+  _engine = null;
+}
+var import_node_crypto, import_node_fs, import_node_path, CACHE_DIR, HASH_CACHE_FILE, GRAPH_CACHE_FILE, GlobalAtomicRegistry, CssDiffWriter, IncrementalEngine, _engine;
+var init_incrementalEngine = __esm({
+  "../compiler/src/incrementalEngine.ts"() {
+    "use strict";
+    import_node_crypto = __toESM(require("crypto"), 1);
+    import_node_fs = __toESM(require("fs"), 1);
+    import_node_path = __toESM(require("path"), 1);
+    CACHE_DIR = ".tw-cache";
+    HASH_CACHE_FILE = import_node_path.default.join(CACHE_DIR, "file-hashes.json");
+    GRAPH_CACHE_FILE = import_node_path.default.join(CACHE_DIR, "dep-graph.json");
+    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;
+      }
+    };
+    CssDiffWriter = class {
+      constructor(outputPath) {
+        this.ruleMap = /* @__PURE__ */ new Map();
+        this.dirty = false;
+        this.outputPath = outputPath;
+        this.loadFromDisk();
+      }
+      loadFromDisk() {
+        try {
+          if (import_node_fs.default.existsSync(this.outputPath)) {
+            const css = import_node_fs.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 import_node_fs.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");
+          import_node_fs.default.writeFileSync(this.outputPath, css, "utf-8");
+          this.dirty = false;
+        } catch (e) {
+        }
+      }
+      size() {
+        return this.ruleMap.size;
+      }
+    };
+    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 : import_node_path.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] ${import_node_path.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] ${import_node_path.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] ${import_node_path.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}`);
+        }
+      }
+    };
+    _engine = null;
+  }
+});
+
+// ../compiler/src/styleBucketSystem.ts
+var styleBucketSystem_exports = {};
+__export(styleBucketSystem_exports, {
+  BucketEngine: () => BucketEngine,
+  bucketSort: () => bucketSort,
+  classifyNode: () => classifyNode,
+  detectConflicts: () => detectConflicts,
+  getBucketEngine: () => getBucketEngine,
+  resetBucketEngine: () => resetBucketEngine
+});
+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";
+}
+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;
+}
+function getBucketEngine() {
+  if (!_bucketEngine) _bucketEngine = new BucketEngine();
+  return _bucketEngine;
+}
+function resetBucketEngine() {
+  _bucketEngine = null;
+}
+var BUCKET_ORDER, PROPERTY_BUCKET_MAP, BucketEngine, _bucketEngine;
+var init_styleBucketSystem = __esm({
+  "../compiler/src/styleBucketSystem.ts"() {
+    "use strict";
+    BUCKET_ORDER = [
+      "reset",
+      "layout",
+      "spacing",
+      "sizing",
+      "typography",
+      "visual",
+      "interaction",
+      "responsive",
+      "unknown"
+    ];
+    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"
+    };
+    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();
+        }
+      }
+    };
+    _bucketEngine = null;
+  }
+});
+
+// src/turbopackLoader.ts
+var turbopackLoader_exports = {};
+__export(turbopackLoader_exports, {
+  default: () => turbopackLoader
+});
+module.exports = __toCommonJS(turbopackLoader_exports);
+
+// ../compiler/src/classMerger.ts
+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;
+  const _objectRe = /\btw\.(?:server\.)?(\w+)\(\s*(\{[\s\S]*?\})\s*\)/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 injectClientDirective(code) {
+  if (code.startsWith('"use client"') || code.startsWith("'use client'")) {
+    return code;
+  }
+  return `"use client";
+${code}`;
+}
+
+// ../compiler/src/twDetector.ts
+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("${");
+}
+
+// ../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_RE = /\btw\.(server\.)?(\w+)`((?:[^`\\]|\\.)*)`/g;
+var OBJECT_RE = /\btw\.(server\.)?(\w+)\(\s*(\{[\s\S]*?\})\s*\)/g;
+var EXTEND_RE = /(\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_RE,
+    (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_RE,
+    (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_RE, (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/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 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;
+}
+
+// src/turbopackLoader.ts
+function turbopackLoader(source, options = {}) {
+  const filepath = this.resourcePath;
+  if (filepath.includes("node_modules") || filepath.includes(".next")) {
+    return source;
+  }
+  if (!/\.(tsx|ts|jsx|js)$/.test(filepath)) {
+    return source;
+  }
+  if (isAlreadyTransformed(source)) {
+    return source;
+  }
+  if (options.incremental !== false) {
+    const { getIncrementalEngine: getIncrementalEngine2, parseClassesToNodes: parseClassesToNodes2 } = (init_incrementalEngine(), __toCommonJS(incrementalEngine_exports));
+    const engine = getIncrementalEngine2({ verbose: options.verbose });
+    const quickResult = engine.processFile(filepath, source, []);
+    if (!quickResult.changed) {
+      return source;
+    }
+    let result;
+    try {
+      result = transformSource(source, __spreadProps(__spreadValues({}, options), { filename: filepath }));
+    } catch (err) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn(`[tailwind-styled-v4] Transform failed for ${filepath}:`, err);
+      }
+      return source;
+    }
+    if (options.routeCss && result.changed && result.classes.length > 0) {
+      registerFileClasses(filepath, result.classes);
+    }
+    const nodes = parseClassesToNodes2(result.classes);
+    const diff = engine.processFile(filepath, source, nodes);
+    const { getBucketEngine: getBucketEngine2 } = (init_styleBucketSystem(), __toCommonJS(styleBucketSystem_exports));
+    getBucketEngine2().applyDiff(diff.diff);
+    if (options.verbose && result.changed && process.env.NODE_ENV !== "production") {
+      const rsc = result.rsc;
+      const env = (rsc == null ? void 0 : rsc.isServer) ? "server" : "client";
+      console.log(
+        `[tailwind-styled-v4] ${filepath.split("/").pop()} \u2192 ${result.classes.length} classes, ${env} component` + ((rsc == null ? void 0 : rsc.needsClientDirective) ? " (auto use-client)" : "")
+      );
+    }
+    return result.code;
+  }
+  try {
+    const result = transformSource(source, __spreadProps(__spreadValues({}, options), { filename: filepath }));
+    if (options.routeCss && result.changed && result.classes.length > 0) {
+      registerFileClasses(filepath, result.classes);
+    }
+    if (options.verbose && result.changed && process.env.NODE_ENV !== "production") {
+      const rsc = result.rsc;
+      const env = (rsc == null ? void 0 : rsc.isServer) ? "server" : "client";
+      console.log(
+        `[tailwind-styled-v4] ${filepath.split("/").pop()} \u2192 ${result.classes.length} classes, ${env} component` + ((rsc == null ? void 0 : rsc.needsClientDirective) ? " (auto use-client)" : "")
+      );
+    }
+    return result.code;
+  } catch (err) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(`[tailwind-styled-v4] Transform failed for ${filepath}:`, err);
+    }
+    return source;
+  }
+}