weapp-tailwindcss 4.4.0 → 4.5.0-alpha.0

package/dist/{chunk-QXCC745G.js → chunk-AMP5MSHS.js}

@@ -1,16 +1,20 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 var _chunk6GP37C26js = require('./chunk-6GP37C26.js');
 
 
 
+var _chunkWVKK6TBLjs = require('./chunk-WVKK6TBL.js');
+
+
+
 var _chunk2NRTWL47js = require('./chunk-2NRTWL47.js');
 
 
 var _chunkOGROHM4Ljs = require('./chunk-OGROHM4L.js');
 
 
-var _chunkGQAB52GEjs = require('./chunk-GQAB52GE.js');
+var _chunkBMXULECQjs = require('./chunk-BMXULECQ.js');
 
 
 var _chunkUW3WHSZ5js = require('./chunk-UW3WHSZ5.js');
@@ -18,10 +22,11 @@ var _chunkUW3WHSZ5js = require('./chunk-UW3WHSZ5.js');
 // src/bundlers/webpack/BaseUnifiedPlugin/v5.ts
 var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
 var debug = _chunk2NRTWL47js.createDebug.call(void 0, );
 var UnifiedWebpackPluginV5 = class {
   constructor(options = {}) {
-    this.options = _chunkGQAB52GEjs.getCompilerContext.call(void 0, options);
+    this.options = _chunkBMXULECQjs.getCompilerContext.call(void 0, options);
     this.appType = this.options.appType;
   }
   apply(compiler) {
@@ -85,6 +90,59 @@ var UnifiedWebpackPluginV5 = class {
             }
           }
           const entries = Object.entries(assets);
+          const compilerOutputPath = _nullishCoalesce(_optionalChain([compilation, 'access', _ => _.compiler, 'optionalAccess', _2 => _2.outputPath]), () => ( compiler.outputPath));
+          const outputDir = compilerOutputPath ? _path2.default.resolve(compilerOutputPath) : _nullishCoalesce(_optionalChain([compilation, 'access', _3 => _3.outputOptions, 'optionalAccess', _4 => _4.path]), () => ( _process2.default.cwd()));
+          const jsAssets = /* @__PURE__ */ new Map();
+          for (const [file] of entries) {
+            if (this.options.jsMatcher(file) || this.options.wxsMatcher(file)) {
+              const absolute = _chunkWVKK6TBLjs.toAbsoluteOutputPath.call(void 0, file, outputDir);
+              jsAssets.set(absolute, file);
+            }
+          }
+          const moduleGraphOptions = {
+            resolve(specifier, importer) {
+              return _chunkWVKK6TBLjs.resolveOutputSpecifier.call(void 0, specifier, importer, outputDir, (candidate) => jsAssets.has(candidate));
+            },
+            load: (id) => {
+              const assetName = jsAssets.get(id);
+              if (!assetName) {
+                return void 0;
+              }
+              const asset = compilation.getAsset(assetName);
+              if (!asset) {
+                return void 0;
+              }
+              const source = asset.source.source();
+              return typeof source === "string" ? source : source.toString();
+            },
+            filter(id) {
+              return jsAssets.has(id);
+            }
+          };
+          const applyLinkedResults = (linked) => {
+            if (!linked) {
+              return;
+            }
+            for (const [id, { code }] of Object.entries(linked)) {
+              const assetName = jsAssets.get(id);
+              if (!assetName) {
+                continue;
+              }
+              const asset = compilation.getAsset(assetName);
+              if (!asset) {
+                continue;
+              }
+              const previousSource = asset.source.source();
+              const previous = typeof previousSource === "string" ? previousSource : previousSource.toString();
+              if (previous === code) {
+                continue;
+              }
+              const source = new ConcatSource(code);
+              compilation.updateAsset(assetName, source);
+              onUpdate(assetName, previous, code);
+              debug("js linked handle: %s", assetName);
+            }
+          };
           const groupedEntries = _chunkUW3WHSZ5js.getGroupedEntries.call(void 0, entries, this.options);
           const runtimeSet = await twPatcher.getClassSet();
           setMangleRuntimeSet(runtimeSet);
@@ -122,32 +180,45 @@ var UnifiedWebpackPluginV5 = class {
             }
           }
           if (Array.isArray(groupedEntries.js)) {
-            for (const element of groupedEntries.js) {
-              const [file, originalSource] = element;
+            for (const [file] of groupedEntries.js) {
               const cacheKey = _chunk6GP37C26js.getCacheKey.call(void 0, file);
-              const rawSource = originalSource.source().toString();
-              tasks.push(
-                _chunk2NRTWL47js.processCachedTask.call(void 0, {
-                  cache,
-                  cacheKey,
-                  rawSource,
-                  applyResult(source) {
-                    compilation.updateAsset(file, source);
-                  },
-                  onCacheHit() {
-                    debug("js cache hit: %s", file);
-                  },
-                  transform: async () => {
-                    const { code } = await jsHandler(rawSource, runtimeSet);
-                    const source = new ConcatSource(code);
-                    onUpdate(file, rawSource, code);
-                    debug("js handle: %s", file);
-                    return {
-                      result: source
-                    };
-                  }
-                })
-              );
+              const asset = compilation.getAsset(file);
+              if (!asset) {
+                continue;
+              }
+              const absoluteFile = _chunkWVKK6TBLjs.toAbsoluteOutputPath.call(void 0, file, outputDir);
+              const initialSource = asset.source.source();
+              const initialRawSource = typeof initialSource === "string" ? initialSource : initialSource.toString();
+              await _chunk2NRTWL47js.processCachedTask.call(void 0, {
+                cache,
+                cacheKey,
+                rawSource: initialRawSource,
+                applyResult(source) {
+                  compilation.updateAsset(file, source);
+                },
+                onCacheHit() {
+                  debug("js cache hit: %s", file);
+                },
+                transform: async () => {
+                  const currentAsset = compilation.getAsset(file);
+                  const currentSourceValue = _optionalChain([currentAsset, 'optionalAccess', _5 => _5.source, 'access', _6 => _6.source, 'call', _7 => _7()]);
+                  const currentSource = typeof currentSourceValue === "string" ? currentSourceValue : _nullishCoalesce(_optionalChain([currentSourceValue, 'optionalAccess', _8 => _8.toString, 'call', _9 => _9()]), () => ( ""));
+                  const { code, linked } = await jsHandler(currentSource, runtimeSet, {
+                    filename: absoluteFile,
+                    moduleGraph: moduleGraphOptions,
+                    babelParserOptions: {
+                      sourceFilename: absoluteFile
+                    }
+                  });
+                  const source = new ConcatSource(code);
+                  onUpdate(file, currentSource, code);
+                  debug("js handle: %s", file);
+                  applyLinkedResults(linked);
+                  return {
+                    result: source
+                  };
+                }
+              });
             }
           }
           if (Array.isArray(groupedEntries.css)) {

package/dist/{chunk-GQAB52GE.js → chunk-BMXULECQ.js}

@@ -10,7 +10,7 @@ var _chunkFOSGDQZ7js = require('./chunk-FOSGDQZ7.js');
 var _chunkUW3WHSZ5js = require('./chunk-UW3WHSZ5.js');
 
 
-var _chunkRBRSMHFSjs = require('./chunk-RBRSMHFS.js');
+var _chunkNHB7NFQCjs = require('./chunk-NHB7NFQC.js');
 
 // src/context/index.ts
 var _logger = require('@weapp-tailwindcss/logger');
@@ -20,10 +20,7 @@ var _mangle = require('@weapp-tailwindcss/mangle');
 var _lrucache = require('lru-cache');
 
 // src/cache/md5.ts
-var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
-function md5Hash(data) {
-  return _crypto2.default.createHash("md5").update(data).digest("hex");
-}
+var _node = require('@weapp-tailwindcss/shared/node');
 
 // src/cache/index.ts
 function isProcessResult(value) {
@@ -57,7 +54,7 @@ function createCache(options) {
       return instance.set(key, value);
     },
     computeHash(message) {
-      return md5Hash(message);
+      return _node.md5.call(void 0, message);
     },
     calcHashValueChanged(key, hash) {
       const hit = hashMap.get(key);
@@ -398,6 +395,274 @@ var JsTokenUpdater = class {
   }
 };
 
+// src/js/ModuleGraph.ts
+var JsModuleGraph = class {
+  constructor(entry, graphOptions) {
+    this.modules = /* @__PURE__ */ new Map();
+    this.queue = [];
+    this.ignoredExportNames = /* @__PURE__ */ new Map();
+    this.resolve = graphOptions.resolve;
+    this.load = graphOptions.load;
+    this.filter = graphOptions.filter;
+    this.maxDepth = _nullishCoalesce(graphOptions.maxDepth, () => ( Number.POSITIVE_INFINITY));
+    const { moduleGraph: _moduleGraph, filename: _ignoredFilename, ...rest } = entry.handlerOptions;
+    this.baseOptions = {
+      ...rest,
+      filename: entry.filename
+    };
+    this.parserOptions = entry.handlerOptions.babelParserOptions;
+    this.rootFilename = entry.filename;
+    this.modules.set(entry.filename, {
+      filename: entry.filename,
+      source: entry.source,
+      analysis: entry.analysis
+    });
+    this.queue.push({ filename: entry.filename, depth: 0 });
+  }
+  build() {
+    this.collectDependencies();
+    const linked = {};
+    for (const [filename, state] of this.modules) {
+      if (filename === this.rootFilename) {
+        continue;
+      }
+      const childOptions = {
+        ...this.baseOptions,
+        filename
+      };
+      const ms = processUpdatedSource(state.source, childOptions, state.analysis);
+      const code = ms.toString();
+      if (code !== state.source) {
+        linked[filename] = { code };
+      }
+    }
+    return linked;
+  }
+  addIgnoredExport(filename, exportName) {
+    if (!exportName) {
+      return;
+    }
+    let pending = this.ignoredExportNames.get(filename);
+    if (!pending) {
+      pending = /* @__PURE__ */ new Set();
+      this.ignoredExportNames.set(filename, pending);
+    }
+    if (pending.has(exportName)) {
+      return;
+    }
+    pending.add(exportName);
+    const existing = this.modules.get(filename);
+    if (existing) {
+      this.applyIgnoredExportsToAnalysis(filename, existing.analysis);
+    }
+  }
+  registerIgnoredExportsFromTokens(resolved, tokens) {
+    for (const token of tokens) {
+      if (token.type === "ImportSpecifier") {
+        this.addIgnoredExport(resolved, token.imported);
+      } else if (token.type === "ImportDefaultSpecifier") {
+        this.addIgnoredExport(resolved, "default");
+      }
+    }
+  }
+  applyIgnoredExportsToAnalysis(filename, analysis) {
+    const pending = this.ignoredExportNames.get(filename);
+    if (!pending || pending.size === 0) {
+      return;
+    }
+    const names = new Set(pending);
+    pending.clear();
+    const propagate = [];
+    for (const exportPath of analysis.exportDeclarations) {
+      if (names.size === 0) {
+        break;
+      }
+      if (exportPath.isExportDefaultDeclaration()) {
+        if (names.has("default")) {
+          analysis.walker.walkExportDefaultDeclaration(exportPath);
+          names.delete("default");
+        }
+        continue;
+      }
+      if (exportPath.isExportNamedDeclaration()) {
+        const source = _optionalChain([exportPath, 'access', _9 => _9.node, 'access', _10 => _10.source, 'optionalAccess', _11 => _11.value]);
+        if (typeof source === "string") {
+          for (const spec of exportPath.get("specifiers")) {
+            if (!spec.isExportSpecifier()) {
+              continue;
+            }
+            const exported = spec.get("exported");
+            let exportedName;
+            if (exported.isIdentifier()) {
+              exportedName = exported.node.name;
+            } else if (exported.isStringLiteral()) {
+              exportedName = exported.node.value;
+            }
+            if (!exportedName || !names.has(exportedName)) {
+              continue;
+            }
+            const local = spec.get("local");
+            if (local.isIdentifier()) {
+              propagate.push({
+                specifier: source,
+                exportName: local.node.name
+              });
+              names.delete(exportedName);
+            } else if (local.isStringLiteral()) {
+              propagate.push({
+                specifier: source,
+                exportName: local.node.value
+              });
+              names.delete(exportedName);
+            }
+          }
+          continue;
+        }
+        const declaration = exportPath.get("declaration");
+        if (declaration.isVariableDeclaration()) {
+          for (const decl of declaration.get("declarations")) {
+            const id = decl.get("id");
+            if (id.isIdentifier()) {
+              const exportName = id.node.name;
+              if (names.has(exportName)) {
+                analysis.walker.walkVariableDeclarator(decl);
+                names.delete(exportName);
+              }
+            }
+          }
+        }
+        for (const spec of exportPath.get("specifiers")) {
+          if (!spec.isExportSpecifier()) {
+            continue;
+          }
+          const exported = spec.get("exported");
+          let exportedName;
+          if (exported.isIdentifier()) {
+            exportedName = exported.node.name;
+          } else if (exported.isStringLiteral()) {
+            exportedName = exported.node.value;
+          }
+          if (!exportedName || !names.has(exportedName)) {
+            continue;
+          }
+          const local = spec.get("local");
+          analysis.walker.walkNode(local);
+          names.delete(exportedName);
+        }
+        continue;
+      }
+      if (exportPath.isExportAllDeclaration()) {
+        const source = _optionalChain([exportPath, 'access', _12 => _12.node, 'access', _13 => _13.source, 'optionalAccess', _14 => _14.value]);
+        if (typeof source === "string") {
+          for (const exportName of names) {
+            propagate.push({
+              specifier: source,
+              exportName
+            });
+          }
+          names.clear();
+        }
+      }
+    }
+    for (const { specifier, exportName } of propagate) {
+      let resolved;
+      try {
+        resolved = this.resolve(specifier, filename);
+      } catch (e2) {
+        resolved = void 0;
+      }
+      if (!resolved) {
+        pending.add(exportName);
+        continue;
+      }
+      if (this.filter && !this.filter(resolved, specifier, filename)) {
+        pending.add(exportName);
+        continue;
+      }
+      this.addIgnoredExport(resolved, exportName);
+    }
+    for (const name of names) {
+      pending.add(name);
+    }
+  }
+  collectDependencies() {
+    while (this.queue.length > 0) {
+      const { filename, depth } = this.queue.shift();
+      if (depth >= this.maxDepth) {
+        continue;
+      }
+      const state = this.modules.get(filename);
+      if (!state) {
+        continue;
+      }
+      const dependencySpecifiers = /* @__PURE__ */ new Map();
+      for (const token of state.analysis.walker.imports) {
+        if (!dependencySpecifiers.has(token.source)) {
+          dependencySpecifiers.set(token.source, []);
+        }
+        dependencySpecifiers.get(token.source).push(token);
+      }
+      for (const exportPath of state.analysis.exportDeclarations) {
+        if (exportPath.isExportAllDeclaration() || exportPath.isExportNamedDeclaration()) {
+          const source = _optionalChain([exportPath, 'access', _15 => _15.node, 'access', _16 => _16.source, 'optionalAccess', _17 => _17.value]);
+          if (typeof source === "string" && !dependencySpecifiers.has(source)) {
+            dependencySpecifiers.set(source, []);
+          }
+        }
+      }
+      for (const [specifier, tokens] of dependencySpecifiers) {
+        let resolved;
+        try {
+          resolved = this.resolve(specifier, filename);
+        } catch (e3) {
+          continue;
+        }
+        if (!resolved) {
+          continue;
+        }
+        if (this.filter && !this.filter(resolved, specifier, filename)) {
+          continue;
+        }
+        if (tokens.length > 0) {
+          this.registerIgnoredExportsFromTokens(resolved, tokens);
+        }
+        if (this.modules.has(resolved)) {
+          continue;
+        }
+        let source;
+        try {
+          source = this.load(resolved);
+        } catch (e4) {
+          continue;
+        }
+        if (typeof source !== "string") {
+          continue;
+        }
+        let analysis;
+        try {
+          const ast = babelParse(source, {
+            ...this.parserOptions,
+            sourceFilename: resolved
+          });
+          analysis = analyzeSource(ast, {
+            ...this.baseOptions,
+            filename: resolved
+          });
+          this.applyIgnoredExportsToAnalysis(resolved, analysis);
+        } catch (e5) {
+          continue;
+        }
+        this.modules.set(resolved, {
+          filename: resolved,
+          source,
+          analysis
+        });
+        this.queue.push({ filename: resolved, depth: depth + 1 });
+      }
+    }
+  }
+};
+
 // src/js/NodePathWalker.ts
 var NodePathWalker = class {
   constructor({ ignoreCallExpressionIdentifiers, callback } = {}) {
@@ -497,6 +762,7 @@ var NodePathWalker = class {
                 declaration: importDeclaration,
                 specifier: arg,
                 imported: imported.node.name,
+                local: arg.node.local.name,
                 source: importDeclaration.node.source.value,
                 type: "ImportSpecifier"
               }
@@ -507,6 +773,7 @@ var NodePathWalker = class {
             {
               declaration: importDeclaration,
               specifier: arg,
+              local: arg.node.local.name,
               source: importDeclaration.node.source.value,
               type: "ImportDefaultSpecifier"
             }
@@ -558,6 +825,8 @@ var NodePathWalker = class {
     const decl = path2.get("declaration");
     if (decl.isIdentifier()) {
       this.walkNode(decl);
+    } else {
+      this.walkNode(decl);
     }
   }
   walkExportAllDeclaration(path2) {
@@ -785,12 +1054,28 @@ function jsHandler(rawSource, options) {
   }
   const analysis = analyzeSource(ast, options);
   const ms = processUpdatedSource(rawSource, options, analysis);
-  return {
+  const result = {
     code: ms.toString(),
     get map() {
       return ms.generateMap();
     }
   };
+  if (options.moduleGraph && options.filename) {
+    const graph = new JsModuleGraph(
+      {
+        filename: options.filename,
+        source: rawSource,
+        analysis,
+        handlerOptions: options
+      },
+      options.moduleGraph
+    );
+    const linked = graph.build();
+    if (Object.keys(linked).length > 0) {
+      result.linked = linked;
+    }
+  }
+  return result;
 }
 
 // src/js/index.ts
@@ -1003,7 +1288,7 @@ function generateCode(match, options = {}) {
           if (t.isMemberExpression(path2.parent)) {
             return;
           }
-          if (t.isBinaryExpression(path2.parent) && (t.isConditionalExpression(_optionalChain([path2, 'access', _9 => _9.parentPath, 'optionalAccess', _10 => _10.parent])) || t.isLogicalExpression(_optionalChain([path2, 'access', _11 => _11.parentPath, 'optionalAccess', _12 => _12.parent])))) {
+          if (t.isBinaryExpression(path2.parent) && (t.isConditionalExpression(_optionalChain([path2, 'access', _18 => _18.parentPath, 'optionalAccess', _19 => _19.parent])) || t.isLogicalExpression(_optionalChain([path2, 'access', _20 => _20.parentPath, 'optionalAccess', _21 => _21.parent])))) {
             return;
           }
           jsTokenUpdater.addToken(
@@ -1024,7 +1309,7 @@ function generateCode(match, options = {}) {
       jsTokenUpdater.updateMagicString(ms);
       return ms.toString();
     }
-  } catch (e2) {
+  } catch (e6) {
     return match;
   }
 }
@@ -1328,8 +1613,38 @@ var _localpkg = require('local-pkg');
 // src/tailwindcss/patcher.ts
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+
 var _shared = require('@weapp-tailwindcss/shared');
 var _tailwindcsspatch = require('tailwindcss-patch');
+function createFallbackTailwindcssPatcher() {
+  const packageInfo = {
+    name: "tailwindcss",
+    version: void 0,
+    rootPath: "",
+    packageJsonPath: "",
+    packageJson: {}
+  };
+  return {
+    packageInfo,
+    majorVersion: 0,
+    patch() {
+    },
+    async getClassSet() {
+      return /* @__PURE__ */ new Set();
+    },
+    getClassSetV3() {
+      return /* @__PURE__ */ new Set();
+    },
+    async extract(_options) {
+      const classSet = /* @__PURE__ */ new Set();
+      return {
+        classList: [],
+        classSet
+      };
+    }
+  };
+}
+var hasLoggedMissingTailwind = false;
 function createTailwindcssPatcher(options) {
   const { basedir, cacheDir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions } = options || {};
   const cache = {};
@@ -1342,7 +1657,7 @@ function createTailwindcssPatcher(options) {
       cache.dir = _path2.default.resolve(_process2.default.cwd(), cacheDir);
     }
   }
-  return new (0, _tailwindcsspatch.TailwindcssPatcher)(_shared.defuOverrideArray.call(void 0, 
+  const resolvedOptions = _shared.defuOverrideArray.call(void 0, 
     tailwindcssPatcherOptions,
     {
       cache,
@@ -1355,12 +1670,24 @@ function createTailwindcssPatcher(options) {
         tailwindcss,
         resolve: {
           paths: [
-            _chunkRBRSMHFSjs.importMetaUrl
+            _chunkNHB7NFQCjs.importMetaUrl
           ]
         }
       }
     }
-  ));
+  );
+  try {
+    return new (0, _tailwindcsspatch.TailwindcssPatcher)(resolvedOptions);
+  } catch (error) {
+    if (error instanceof Error && /tailwindcss not found/i.test(error.message)) {
+      if (!hasLoggedMissingTailwind) {
+        _logger.logger.warn("Tailwind CSS \u672A\u5B89\u88C5\uFF0C\u5DF2\u8DF3\u8FC7 Tailwind \u76F8\u5173\u8865\u4E01\u3002\u82E5\u9700\u4F7F\u7528 Tailwind \u80FD\u529B\uFF0C\u8BF7\u5B89\u88C5 tailwindcss\u3002");
+        hasLoggedMissingTailwind = true;
+      }
+      return createFallbackTailwindcssPatcher();
+    }
+    throw error;
+  }
 }
 
 // src/context/tailwindcss.ts
@@ -1402,7 +1729,11 @@ function getCompilerContext(opts) {
   ctx.escapeMap = ctx.customReplaceDictionary;
   applyLoggerLevel(ctx.logLevel);
   const twPatcher = createTailwindcssPatcherFromContext(ctx);
-  _logger.logger.success(`\u5F53\u524D\u4F7F\u7528 ${_logger.pc.cyanBright("Tailwind CSS")} \u7248\u672C\u4E3A: ${_logger.pc.underline(_logger.pc.bold(_logger.pc.green(twPatcher.packageInfo.version)))}`);
+  if (_optionalChain([twPatcher, 'access', _22 => _22.packageInfo, 'optionalAccess', _23 => _23.version])) {
+    _logger.logger.success(`\u5F53\u524D\u4F7F\u7528 ${_logger.pc.cyanBright("Tailwind CSS")} \u7248\u672C\u4E3A: ${_logger.pc.underline(_logger.pc.bold(_logger.pc.green(twPatcher.packageInfo.version)))}`);
+  } else {
+    _logger.logger.warn(`${_logger.pc.cyanBright("Tailwind CSS")} \u672A\u5B89\u88C5\uFF0C\u5DF2\u8DF3\u8FC7\u7248\u672C\u68C0\u6D4B\u4E0E\u8865\u4E01\u5E94\u7528\u3002`);
+  }
   const cssCalcOptions = _nullishCoalesce(ctx.cssCalc, () => ( twPatcher.majorVersion === 4));
   const customAttributesEntities = toCustomAttributesEntities(ctx.customAttributes);
   const { initMangle, mangleContext, setMangleRuntimeSet } = _mangle.useMangleStore.call(void 0, );

package/dist/{chunk-FBGUUXQV.mjs → chunk-FWIGQ4RY.mjs}

@@ -1,4 +1,4 @@
-// ../../node_modules/.pnpm/tsup@8.5.0_@swc+core@1.13.5_jiti@2.6.1_postcss@8.5.6_tsx@4.20.6_typescript@5.9.3_yaml@2.8.1/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.0_@microsoft+api-extractor@7.53.1_@types+node@24.8.1__@swc+core@1.13.5_jiti@2._cec5ee635e8b2932d274eae561437dbd/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var getFilename = () => fileURLToPath(import.meta.url);