tailwind-styled-v4 5.0.9 → 5.0.10

package/dist/turbopackLoader.mjs

@@ -1,6 +1,10 @@
 import { createRequire } from 'module';
-import fs from 'fs';
-import path from 'path';
+import * as fs3 from 'fs';
+import fs3__default from 'fs';
+import * as path from 'path';
+import path__default from 'path';
+import 'crypto';
+import { fileURLToPath } from 'url';
 
 /* tailwind-styled-v4 v5.0.4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -13,45 +17,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-
-// packages/domain/shared/src/native-resolution.ts
-function getNodeModuleRef() {
-  if (isBrowser) return null;
-  if (nodeModuleRef !== null) return nodeModuleRef;
-  try {
-    const test = typeof __require === "function" ? __require("module") : null;
-    nodeModuleRef = test;
-    return test;
-  } catch {
-    nodeModuleRef = null;
-    return null;
-  }
-}
-function getNodeFs() {
-  if (isBrowser) return { existsSync: () => false };
-  const nodeRequire = getNodeModuleRef();
-  if (!nodeRequire) return { existsSync: () => false };
-  if (!_nodeFs) _nodeFs = nodeRequire.createRequire(import.meta.url)("node:fs");
-  return _nodeFs;
-}
-function getNodePath() {
-  if (isBrowser) return { resolve: () => "", dirname: "" };
-  const nodeRequire = getNodeModuleRef();
-  if (!nodeRequire) return { resolve: () => "", dirname: "" };
-  if (!_nodePath) _nodePath = nodeRequire.createRequire(import.meta.url)("node:path");
-  return _nodePath;
-}
-function getRequire(_importMetaUrl) {
-  if (isBrowser) return () => {
-    throw new Error("node:module not available");
-  };
-  const nodeRequire = getNodeModuleRef();
-  if (!nodeRequire) return () => {
-    throw new Error("require not available");
-  };
-  if (!_require) _require = nodeRequire.createRequire(_importMetaUrl);
-  return _require;
-}
 function platformKey() {
   if (isBrowser) return "browser";
   return `${process.platform}-${process.arch}`;
@@ -62,24 +27,21 @@ function resolveNativeBinary(runtimeDir) {
   if (isBrowser) {
     return { path: null, source: "not-found", platform, tried: ["not available in browser"] };
   }
-  const fs2 = getNodeFs();
-  const path2 = getNodePath();
-  const _req = getRequire(import.meta.url);
+  if (process.env.TWS_DISABLE_NATIVE === "1") {
+    return { path: null, source: "not-found", platform, tried: [] };
+  }
   const envPath = process.env.TW_NATIVE_PATH?.trim();
   if (envPath) {
-    if (fs2.existsSync(envPath)) {
+    if (fs3.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
   }
-  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1" || process.env.TWS_DISABLE_NATIVE === "1") {
-    return { path: null, source: "not-found", platform, tried: ["disabled by env"] };
-  }
   const prebuiltPkgs = PLATFORM_MAP[platform] ?? [];
   for (const pkg of prebuiltPkgs) {
     try {
-      const candidate = _req.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs2.existsSync(candidate)) {
+      const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
+      if (fs3.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -89,30 +51,43 @@ function resolveNativeBinary(runtimeDir) {
   }
   const cwd = process.cwd();
   const base = runtimeDir ?? cwd;
-  const localCandidates = [
-    path2.resolve(base, "tailwind_styled_parser.node"),
-    path2.resolve(base, "..", "tailwind_styled_parser.node"),
-    path2.resolve(cwd, "native", "tailwind_styled_parser.node"),
-    path2.resolve(cwd, "native", "target", "release", "tailwind_styled_parser.node"),
-    // napi-rs conventional output
-    path2.resolve(base, `tailwind_styled_parser.${platform}.node`)
-  ];
+  const napiPlatform = platform === "linux-x64" ? "linux-x64-gnu" : platform === "linux-arm64" ? "linux-arm64-gnu" : platform;
+  const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
+  const localCandidates = [];
+  for (const bin of BINARY_NAMES) {
+    localCandidates.push(path.resolve(base, `${bin}.node`));
+    localCandidates.push(path.resolve(base, "..", `${bin}.node`));
+    localCandidates.push(path.resolve(base, `${bin}.${platform}.node`));
+    localCandidates.push(path.resolve(base, `${bin}.${napiPlatform}.node`));
+  }
+  for (const startDir of [cwd, base]) {
+    let dir = startDir;
+    for (let i = 0; i < 6; i++) {
+      const nativeDir = path.resolve(dir, "native");
+      for (const bin of BINARY_NAMES) {
+        localCandidates.push(path.resolve(nativeDir, `${bin}.node`));
+        localCandidates.push(path.resolve(nativeDir, `${bin}.${platform}.node`));
+        localCandidates.push(path.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
+        localCandidates.push(path.resolve(nativeDir, "target", "release", `${bin}.node`));
+      }
+      const parent = path.resolve(dir, "..");
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs2.existsSync(candidate)) {
+    if (fs3.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
   return { path: null, source: "not-found", platform, tried };
 }
-var isBrowser, nodeModuleRef, _nodeFs, _nodePath, _require, PLATFORM_MAP;
+var isBrowser, _require, PLATFORM_MAP;
 var init_native_resolution = __esm({
   "packages/domain/shared/src/native-resolution.ts"() {
     isBrowser = typeof window !== "undefined" || typeof document !== "undefined";
-    nodeModuleRef = null;
-    _nodeFs = null;
-    _nodePath = null;
-    _require = null;
+    _require = typeof __require !== "undefined" ? __require : createRequire(import.meta.url);
     PLATFORM_MAP = {
       "linux-x64": ["@tailwind-styled/native-linux-x64"],
       "linux-arm64": ["@tailwind-styled/native-linux-arm64"],
@@ -123,59 +98,26 @@ var init_native_resolution = __esm({
     };
   }
 });
-
-// packages/domain/shared/src/index.ts
-function getNodeModuleRef2() {
-  if (isBrowser2) return null;
-  if (nodeModuleRef2 !== null) return nodeModuleRef2;
-  try {
-    const test = typeof __require === "function" ? __require("module") : null;
-    nodeModuleRef2 = test;
-    return test;
-  } catch {
-    nodeModuleRef2 = null;
-    return null;
-  }
-}
-function getNodeUrl() {
-  if (isBrowser2) throw new Error("node:url not available in browser");
-  const nodeRequire = getNodeModuleRef2();
-  if (!nodeRequire) throw new Error("require not available");
-  if (!_nodeUrl) _nodeUrl = nodeRequire.createRequire(import.meta.url)("node:url");
-  return _nodeUrl;
-}
-function getRequire2() {
-  if (isBrowser2) return (() => {
-    throw new Error("require not available in browser");
-  });
-  const nodeRequire = getNodeModuleRef2();
-  if (!nodeRequire) return (() => {
-    throw new Error("require not available");
-  });
-  return nodeRequire.createRequire(import.meta.url);
-}
 function resolveRuntimeDir(dir, importMetaUrl) {
-  if (isBrowser2) return "";
   try {
-    return getNodeUrl().fileURLToPath(importMetaUrl);
+    return path__default.dirname(fileURLToPath(importMetaUrl));
   } catch {
     return process.cwd();
   }
 }
-var isBrowser2, nodeModuleRef2, _nodeUrl;
 var init_src = __esm({
   "packages/domain/shared/src/index.ts"() {
     init_native_resolution();
-    isBrowser2 = typeof window !== "undefined" || typeof document !== "undefined";
-    nodeModuleRef2 = null;
-    _nodeUrl = null;
-    getRequire2();
+    createRequire(import.meta.url);
   }
 });
-var log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge;
+
+// packages/domain/compiler/src/nativeBridge.ts
+var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge;
 var init_nativeBridge = __esm({
   "packages/domain/compiler/src/nativeBridge.ts"() {
     init_src();
+    _loadNative = (path4) => __require(path4);
     log = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -202,11 +144,10 @@ var init_nativeBridge = __esm({
       bridgeLoadAttempted = true;
       try {
         const runtimeDir = resolveRuntimeDir(void 0, import.meta.url);
-        const require2 = createRequire(import.meta.url);
         const result = resolveNativeBinary(runtimeDir);
         if (result.path && result.path.endsWith(".node")) {
           try {
-            const binding = require2(result.path);
+            const binding = _loadNative(result.path);
             if (isValidNativeBridge(binding)) {
               nativeBridge = binding;
               log("Native bridge loaded successfully from:", result.path);
@@ -256,7 +197,7 @@ var runLoaderTransform = (ctx) => {
     classes: result?.classes || []
   };
 };
-var registerFileClasses = (filepath, classes) => {
+var registerFileClasses = (_filepath, _classes) => {
 };
 function parseBool(val, fallback = false) {
   if (typeof val === "boolean") return val;
@@ -293,29 +234,29 @@ var CYCLE_SENTINEL = "_cycle.txt";
 var START_SENTINEL = "_start.txt";
 var _workerCache = /* @__PURE__ */ new Map();
 function getTwClassesDir(safelistPath) {
-  return path.join(path.dirname(safelistPath), "tw-classes");
+  return path__default.join(path__default.dirname(safelistPath), "tw-classes");
 }
 function readSentinel(filePath) {
   try {
-    return fs.readFileSync(filePath, "utf-8").trim();
+    return fs3__default.readFileSync(filePath, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function clearAndMarkCycle(twClassesDir, startId) {
   try {
-    if (fs.existsSync(twClassesDir)) {
-      for (const file of fs.readdirSync(twClassesDir)) {
+    if (fs3__default.existsSync(twClassesDir)) {
+      for (const file of fs3__default.readdirSync(twClassesDir)) {
         if (file === START_SENTINEL || file === "_webpack-merged.css") continue;
         try {
-          fs.unlinkSync(path.join(twClassesDir, file));
+          fs3__default.unlinkSync(path__default.join(twClassesDir, file));
         } catch {
         }
       }
     } else {
-      fs.mkdirSync(twClassesDir, { recursive: true });
+      fs3__default.mkdirSync(twClassesDir, { recursive: true });
     }
-    fs.writeFileSync(path.join(twClassesDir, CYCLE_SENTINEL), startId, "utf-8");
+    fs3__default.writeFileSync(path__default.join(twClassesDir, CYCLE_SENTINEL), startId, "utf-8");
     _workerCache.set(twClassesDir, startId);
   } catch {
   }
@@ -323,32 +264,32 @@ function clearAndMarkCycle(twClassesDir, startId) {
 function getPerFileSafelistPath(safelistDir, resourcePath) {
   const normalized = resourcePath.replace(/\\/g, "/");
   const slug = normalized.replace(/^.*\/src\//, "").replace(/\.[tj]sx?$/, "").replace(/[^a-zA-Z0-9]/g, "_").slice(0, 80);
-  return path.join(safelistDir, `${slug}.css`);
+  return path__default.join(safelistDir, `${slug}.css`);
 }
 function writePerFileSafelist(safelistPath, resourcePath, classes) {
   if (!safelistPath || classes.length === 0) return;
   try {
     const twClassesDir = getTwClassesDir(safelistPath);
-    const startId = readSentinel(path.join(twClassesDir, START_SENTINEL));
-    const cachedCycle = _workerCache.get(twClassesDir) ?? readSentinel(path.join(twClassesDir, CYCLE_SENTINEL));
+    const startId = readSentinel(path__default.join(twClassesDir, START_SENTINEL));
+    const cachedCycle = _workerCache.get(twClassesDir) ?? readSentinel(path__default.join(twClassesDir, CYCLE_SENTINEL));
     if (startId && cachedCycle !== startId) {
       clearAndMarkCycle(twClassesDir, startId);
-    } else if (!fs.existsSync(twClassesDir)) {
-      fs.mkdirSync(twClassesDir, { recursive: true });
+    } else if (!fs3__default.existsSync(twClassesDir)) {
+      fs3__default.mkdirSync(twClassesDir, { recursive: true });
     }
     const outPath = getPerFileSafelistPath(twClassesDir, resourcePath);
     const sorted = [...new Set(classes)].sort();
     const css = [
-      `/* tw-safelist: ${path.basename(resourcePath)} \u2014 auto-generated */`,
+      `/* tw-safelist: ${path__default.basename(resourcePath)} \u2014 auto-generated */`,
       "@layer utilities {",
       sorted.map((cls) => `.${cls.replace(/([^a-zA-Z0-9_-])/g, "\\$1")} {}`).join("\n"),
       "}"
     ].join("\n");
     try {
-      if (fs.readFileSync(outPath, "utf-8") === css) return;
+      if (fs3__default.readFileSync(outPath, "utf-8") === css) return;
     } catch {
     }
-    fs.writeFileSync(outPath, css, "utf-8");
+    fs3__default.writeFileSync(outPath, css, "utf-8");
   } catch {
   }
 }
@@ -357,7 +298,7 @@ function turbopackLoader(source, options = {}) {
   const router = detectRouter(this.resourcePath);
   const nextMajor = parseNum(options.nextMajor);
   const debug = parseBool(options.debug);
-  const filename = path.basename(this.resourcePath);
+  const filename = path__default.basename(this.resourcePath);
   const effective = {
     addDataAttr: parseBool(options.addDataAttr),
     // App Router: selalu auto-detect client boundary