next-yak 6.0.0 → 6.1.0-next.0

package/dist/loaders/css-loader.js

@@ -1,215 +1,677 @@
 // loaders/css-loader.ts
 import { relative } from "path";
 
-// loaders/lib/resolveCrossFileSelectors.ts
-import { parse } from "@babel/parser";
-import traverse from "@babel/traverse";
-import path from "path";
+// cross-file-resolver/parseModule.ts
+async function parseModule(context, modulePath) {
+  try {
+    const isYak = modulePath.endsWith(".yak.ts") || modulePath.endsWith(".yak.tsx") || modulePath.endsWith(".yak.js") || modulePath.endsWith(".yak.jsx");
+    if (isYak && context.evaluateYakModule) {
+      const yakModule = await context.evaluateYakModule(modulePath);
+      const yakExports = objectToModuleExport(yakModule);
+      return {
+        type: "yak",
+        exports: { importYak: false, named: yakExports, all: [] },
+        path: modulePath
+      };
+    }
+    if (context.cache?.parse === void 0) {
+      return uncachedParseModule(context, modulePath);
+    }
+    const cached = context.cache.parse.get(modulePath);
+    if (cached === void 0) {
+      const parsedModule = await uncachedParseModule(context, modulePath);
+      context.cache.parse.set(modulePath, parsedModule);
+      if (context.cache.parse.addDependency) {
+        context.cache.parse.addDependency(modulePath, modulePath);
+      }
+      return parsedModule;
+    }
+    return cached;
+  } catch (error) {
+    throw new Error(
+      `Error parsing file ${modulePath}: ${error.message}`
+    );
+  }
+}
+async function uncachedParseModule(context, modulePath) {
+  const exports = await context.extractExports(modulePath);
+  if (!exports.importYak) {
+    return {
+      type: "regular",
+      path: modulePath,
+      exports
+    };
+  }
+  const transformed = await context.getTransformed(modulePath);
+  const mixins = parseMixins(transformed.code);
+  const styledComponents = parseStyledComponents(
+    transformed.code,
+    context.transpilationMode
+  );
+  return {
+    type: "regular",
+    path: modulePath,
+    js: transformed,
+    exports,
+    styledComponents,
+    mixins
+  };
+}
+function parseMixins(sourceContents) {
+  const mixinParts = sourceContents.split("/*YAK EXPORTED MIXIN:");
+  let mixins = {};
+  for (let i = 1; i < mixinParts.length; i++) {
+    const [comment] = mixinParts[i].split("*/", 1);
+    const position = comment.indexOf("\n");
+    const name = comment.slice(0, position);
+    const value = comment.slice(position + 1);
+    mixins[name] = {
+      type: "mixin",
+      value,
+      nameParts: name.split(":").map((part) => decodeURIComponent(part))
+    };
+  }
+  return mixins;
+}
+function parseStyledComponents(sourceContents, transpilationMode) {
+  const styledParts = sourceContents.split("/*YAK EXPORTED STYLED:");
+  let styledComponents = {};
+  for (let i = 1; i < styledParts.length; i++) {
+    const [comment] = styledParts[i].split("*/", 1);
+    const [componentName, className] = comment.split(":");
+    styledComponents[componentName] = {
+      type: "styled-component",
+      nameParts: componentName.split("."),
+      value: transpilationMode === "Css" ? `.${className}` : `:global(.${className})`
+    };
+  }
+  return styledComponents;
+}
+function objectToModuleExport(object) {
+  return Object.fromEntries(
+    Object.entries(object).map(([key, value]) => {
+      if (typeof value === "string" || typeof value === "number") {
+        return [key, { type: "constant", value }];
+      } else if (value && (typeof value === "object" || Array.isArray(value))) {
+        return [
+          key,
+          { type: "record", value: objectToModuleExport(value) }
+        ];
+      } else {
+        return [key, { type: "unsupported", hint: String(value) }];
+      }
+    })
+  );
+}
+
+// cross-file-resolver/Errors.ts
+var CauseError = class _CauseError extends Error {
+  constructor(message, options) {
+    super(
+      `${message}${options?.cause ? `
+  Caused by: ${typeof options.cause === "object" && options.cause !== null && "message" in options.cause ? options.cause.message : String(options.cause)}` : ""}`
+    );
+    if (options?.cause instanceof _CauseError && options.cause.circular) {
+      this.circular = true;
+    }
+  }
+};
+var ResolveError = class extends CauseError {
+};
+var CircularDependencyError = class extends CauseError {
+  constructor(message, options) {
+    super(message, options);
+    this.circular = true;
+  }
+};
+
+// cross-file-resolver/resolveCrossFileConstant.ts
 var yakCssImportRegex = (
   // Make mixin and selector non optional once we dropped support for the babel plugin
   /--yak-css-import\:\s*url\("([^"]+)",?(|mixin|selector)\)(;?)/g
 );
-var compilationCache = /* @__PURE__ */ new WeakMap();
-var getCompilationCache = (loader) => {
-  const compilation = loader._compilation;
-  if (!compilation) {
-    throw new Error("Webpack compilation object not available");
+async function resolveCrossFileConstant(context, filePath, css) {
+  if (context.cache?.resolveCrossFileConstant === void 0) {
+    return uncachedResolveCrossFileConstant(context, filePath, css);
   }
-  let cache = compilationCache.get(compilation);
-  if (!cache) {
-    cache = {
-      parsedFiles: /* @__PURE__ */ new Map()
-    };
-    compilationCache.set(compilation, cache);
+  const cacheKey = await sha1(filePath + ":" + css);
+  const cached = context.cache.resolveCrossFileConstant.get(cacheKey);
+  if (cached === void 0) {
+    const resolvedCrossFilConstantPromise = uncachedResolveCrossFileConstant(
+      context,
+      filePath,
+      css
+    );
+    context.cache.resolveCrossFileConstant.set(
+      filePath,
+      resolvedCrossFilConstantPromise
+    );
+    if (context.cache.resolveCrossFileConstant.addDependency) {
+      context.cache.resolveCrossFileConstant.addDependency(filePath, filePath);
+      resolvedCrossFilConstantPromise.then((value) => {
+        for (const dep of value.dependencies) {
+          context.cache.resolveCrossFileConstant.addDependency(
+            filePath,
+            dep
+          );
+        }
+      });
+    }
+    return resolvedCrossFilConstantPromise;
+  }
+  return cached;
+}
+async function uncachedResolveCrossFileConstant(context, filePath, css) {
+  const yakImports = await parseYakCssImport(context, filePath, css);
+  if (yakImports.length === 0) {
+    return { resolved: css, dependencies: [] };
   }
-  return cache;
-};
-async function resolveCrossFileConstant(loader, pathContext, css) {
-  const matches = [...css.matchAll(yakCssImportRegex)].map((match) => {
-    const [fullMatch, encodedArguments, importKind, semicolon] = match;
-    const [moduleSpecifier, ...specifier] = encodedArguments.split(":").map((entry) => decodeURIComponent(entry));
-    return {
-      encodedArguments,
-      moduleSpecifier,
-      specifier,
-      importKind,
-      semicolon,
-      position: match.index,
-      size: fullMatch.length
-    };
-  });
-  if (matches.length === 0) return css;
   try {
+    const dependencies = /* @__PURE__ */ new Set();
     const resolvedValues = await Promise.all(
-      matches.map(async ({ moduleSpecifier, specifier }) => {
-        const parsedModule = await parseModule(
-          loader,
-          moduleSpecifier,
-          pathContext
+      yakImports.map(async ({ moduleSpecifier, specifier }) => {
+        const { resolved: resolvedModule } = await resolveModule(
+          context,
+          moduleSpecifier
         );
         const resolvedValue = await resolveModuleSpecifierRecursively(
-          loader,
-          parsedModule,
+          context,
+          resolvedModule,
           specifier
         );
+        for (const dependency of resolvedValue.from) {
+          dependencies.add(dependency);
+        }
         return resolvedValue;
       })
     );
     let result = css;
-    for (let i = matches.length - 1; i >= 0; i--) {
-      const { position, size, importKind, specifier, semicolon } = matches[i];
+    for (let i = yakImports.length - 1; i >= 0; i--) {
+      const { position, size, importKind, specifier, semicolon } = yakImports[i];
       const resolved = resolvedValues[i];
-      if (importKind === "selector") {
-        if (resolved.type !== "styled-component" && resolved.type !== "constant") {
-          throw new Error(
-            `Found ${resolved.type} but expected a selector - did you forget a semicolon after \`${specifier.join(
-              "."
-            )}\`?`
-          );
+      let replacement;
+      if (resolved.type === "unresolved-tag") {
+        replacement = importKind === "mixin" ? "" : "undefined";
+      } else {
+        if (importKind === "selector") {
+          if (resolved.type !== "styled-component" && resolved.type !== "constant") {
+            throw new Error(
+              `Found "${resolved.type}" but expected a selector - did you forget a semicolon after "${specifier.join(
+                "."
+              )}"?`
+            );
+          }
         }
+        replacement = resolved.type === "styled-component" ? resolved.value : resolved.value + // resolved.value can be of two different types:
+        // - mixin:
+        //   ${mixinName};
+        // - constant:
+        //   color: ${value};
+        // For mixins the semicolon is already included in the value
+        // but for constants it has to be added manually
+        (["}", ";"].includes(String(resolved.value).trimEnd().slice(-1)) ? "" : semicolon);
       }
-      const replacement = resolved.type === "styled-component" ? resolved.value : resolved.value + // resolved.value can be of two different types:
-      // - mixin:
-      //   ${mixinName};
-      // - constant:
-      //   color: ${value};
-      // For mixins the semicolon is already included in the value
-      // but for constants it has to be added manually
-      (["}", ";"].includes(String(resolved.value).trimEnd().slice(-1)) ? "" : semicolon);
       result = result.slice(0, position) + String(replacement) + result.slice(position + size);
     }
-    return result;
+    return { resolved: result, dependencies: Array.from(dependencies) };
   } catch (error) {
-    throw new Error(
-      `Error resolving cross-file selectors: ${error.message}
-File: ${loader.resourcePath}`
+    throw new CauseError(
+      `Error while resolving cross-file selectors in file "${filePath}"`,
+      { cause: error }
     );
   }
 }
-async function resolveModule(loader, moduleSpecifier, context) {
-  return new Promise((resolve, reject) => {
-    loader.resolve(context, moduleSpecifier, (err, result) => {
-      if (err) return reject(err);
-      if (!result)
-        return reject(new Error(`Could not resolve ${moduleSpecifier}`));
-      resolve(result);
+async function parseYakCssImport(context, filePath, css) {
+  const yakImports = [];
+  for (const match of css.matchAll(yakCssImportRegex)) {
+    const [fullMatch, encodedArguments, importKind, semicolon] = match;
+    const [moduleSpecifier, ...specifier] = encodedArguments.split(":").map((entry) => decodeURIComponent(entry));
+    yakImports.push({
+      encodedArguments,
+      moduleSpecifier: await context.resolve(moduleSpecifier, filePath),
+      specifier,
+      importKind,
+      semicolon,
+      position: match.index,
+      size: fullMatch.length
     });
-  });
+  }
+  return yakImports;
 }
-async function parseModule(loader, moduleSpecifier, context) {
-  const cache = getCompilationCache(loader).parsedFiles;
-  const resolvedModule = await resolveModule(loader, moduleSpecifier, context);
-  let parsedFile = cache.get(resolvedModule);
-  if (!parsedFile) {
-    parsedFile = await parseFile(loader, resolvedModule);
-    cache.set(resolvedModule, parsedFile);
-  }
-  loader.addDependency(parsedFile.filePath);
-  return parsedFile;
+async function resolveModule(context, filePath) {
+  if (context.cache?.resolve === void 0) {
+    return uncachedResolveModule(context, filePath);
+  }
+  const cached = context.cache.resolve.get(filePath);
+  if (cached === void 0) {
+    const resolvedPromise = uncachedResolveModule(context, filePath);
+    context.cache.resolve.set(filePath, resolvedPromise);
+    if (context.cache.resolve.addDependency) {
+      context.cache.resolve.addDependency(filePath, filePath);
+      resolvedPromise.then((value) => {
+        for (const dep of value.dependencies) {
+          context.cache.resolve.addDependency(filePath, dep);
+        }
+      });
+    }
+    return resolvedPromise;
+  }
+  return cached;
 }
-async function parseFile(loader, filePath) {
-  const isYak = filePath.endsWith(".yak.ts") || filePath.endsWith(".yak.tsx") || filePath.endsWith(".yak.js") || filePath.endsWith(".yak.jsx");
-  try {
-    if (isYak) {
-      const module = await loader.importModule(filePath);
-      const mappedModule = Object.fromEntries(
-        Object.entries(module).map(([key, value]) => {
-          if (typeof value === "string" || typeof value === "number") {
-            return [key, { type: "constant", value }];
-          } else if (value && (typeof value === "object" || Array.isArray(value))) {
-            return [key, { type: "record", value }];
-          } else {
-            return [key, { type: "unsupported", hint: String(value) }];
+async function uncachedResolveModule(context, filePath) {
+  const parsedModule = await context.parse(filePath);
+  const exports = parsedModule.exports;
+  if (parsedModule.type !== "regular") {
+    return {
+      resolved: {
+        path: parsedModule.path,
+        exports
+      },
+      dependencies: []
+    };
+  }
+  const dependencies = /* @__PURE__ */ new Set();
+  if (parsedModule.styledComponents) {
+    Object.values(parsedModule.styledComponents).map((styledComponent) => {
+      if (styledComponent.nameParts.length === 1) {
+        exports.named[styledComponent.nameParts[0]] = {
+          type: "styled-component",
+          className: styledComponent.value
+        };
+      } else {
+        let exportEntry = exports.named[styledComponent.nameParts[0]];
+        if (!exportEntry) {
+          exportEntry = { type: "record", value: {} };
+          exports.named[styledComponent.nameParts[0]] = exportEntry;
+        } else if (exportEntry.type !== "record") {
+          throw new CauseError(`Error parsing file "${parsedModule.path}"`, {
+            cause: `"${styledComponent.nameParts[0]}" is not a record`
+          });
+        }
+        let current = exportEntry.value;
+        for (let i = 1; i < styledComponent.nameParts.length - 1; i++) {
+          let next = current[styledComponent.nameParts[i]];
+          if (!next) {
+            next = { type: "record", value: {} };
+            current[styledComponent.nameParts[i]] = next;
+          } else if (next.type !== "record") {
+            throw new CauseError(`Error parsing file "${parsedModule.path}"`, {
+              cause: `"${styledComponent.nameParts.slice(0, i + 1).join(".")}" is not a record`
+            });
           }
-        })
-      );
-      return { type: "yak", exports: mappedModule, filePath };
-    }
-    const sourceContents = new Promise(
-      (resolve, reject) => loader.fs.readFile(filePath, "utf-8", (err, result) => {
-        if (err) return reject(err);
-        resolve(result || "");
-      })
-    );
-    const tranformedSource = new Promise((resolve, reject) => {
-      loader.loadModule(filePath, (err, source) => {
-        if (err) return reject(err);
-        let sourceString;
-        if (typeof source === "string") {
-          sourceString = source;
-        } else if (source instanceof Buffer) {
-          sourceString = source.toString("utf-8");
-        } else if (source instanceof ArrayBuffer) {
-          sourceString = new TextDecoder("utf-8").decode(source);
-        } else {
-          throw new Error(
-            "Invalid input type: code must be string, Buffer, or ArrayBuffer"
-          );
+          current = next.value;
         }
-        resolve(sourceString || "");
-      });
+        current[styledComponent.nameParts[styledComponent.nameParts.length - 1]] = {
+          type: "styled-component",
+          className: styledComponent.value
+        };
+      }
     });
-    const exports = await parseExports(await sourceContents);
-    const mixins = parseMixins(await tranformedSource);
-    Object.assign(
-      exports,
-      parseStyledComponents(
-        await tranformedSource,
-        loader.getOptions().experiments?.transpilationMode
-      )
-    );
+  }
+  if (parsedModule.mixins) {
     await Promise.all(
-      Object.entries(mixins).map(async ([name, { value, nameParts }]) => {
-        const resolvedValue = await resolveCrossFileConstant(
-          loader,
-          path.dirname(filePath),
-          value
+      Object.values(parsedModule.mixins).map(async (mixin) => {
+        const { resolved, dependencies: deps } = await resolveCrossFileConstant(
+          context,
+          parsedModule.path,
+          mixin.value
         );
-        if (nameParts.length === 1) {
-          exports[name] = { type: "mixin", value: resolvedValue };
+        for (const dep of deps) {
+          dependencies.add(dep);
+        }
+        if (mixin.nameParts.length === 1) {
+          exports.named[mixin.nameParts[0]] = {
+            type: "mixin",
+            value: resolved
+          };
         } else {
-          let exportEntry = exports[nameParts[0]];
+          let exportEntry = exports.named[mixin.nameParts[0]];
           if (!exportEntry) {
             exportEntry = { type: "record", value: {} };
-            exports[nameParts[0]] = exportEntry;
+            exports.named[mixin.nameParts[0]] = exportEntry;
           } else if (exportEntry.type !== "record") {
-            throw new Error(
-              `Error parsing file ${filePath}: ${nameParts[0]} is not a record`
-            );
+            throw new CauseError(`Error parsing file "${parsedModule.path}"`, {
+              cause: `"${mixin.nameParts[0]}" is not a record`
+            });
           }
           let current = exportEntry.value;
-          for (let i = 1; i < nameParts.length - 1; i++) {
-            let next = current[nameParts[i]];
+          for (let i = 1; i < mixin.nameParts.length - 1; i++) {
+            let next = current[mixin.nameParts[i]];
             if (!next) {
               next = { type: "record", value: {} };
-              current[nameParts[i]] = next;
+              current[mixin.nameParts[i]] = next;
             } else if (next.type !== "record") {
-              throw new Error(
-                `Error parsing file ${filePath}: ${nameParts[i]} is not a record`
+              throw new CauseError(
+                `Error parsing file "${parsedModule.path}"`,
+                {
+                  cause: `"${mixin.nameParts.slice(0, i + 1).join(".")}" is not a record`
+                }
               );
             }
             current = next.value;
           }
-          current[nameParts[nameParts.length - 1]] = {
+          current[mixin.nameParts[mixin.nameParts.length - 1]] = {
             type: "mixin",
-            value: resolvedValue
+            value: resolved
           };
         }
       })
     );
-    return {
-      type: "regular",
-      exports,
-      filePath
-    };
+  }
+  return {
+    resolved: {
+      path: parsedModule.path,
+      exports
+    },
+    dependencies: Array.from(dependencies)
+  };
+}
+async function resolveModuleSpecifierRecursively(context, resolvedModule, specifiers, seen = /* @__PURE__ */ new Set()) {
+  const exportName = specifiers[0];
+  const exportValue = resolvedModule.exports.named[exportName];
+  if (exportValue !== void 0) {
+    if (seen.has(resolvedModule.path + ":" + exportName)) {
+      throw new CircularDependencyError(
+        `Unable to resolve "${specifiers.join(".")}" in module "${resolvedModule.path}"`,
+        { cause: "Circular dependency detected" }
+      );
+    }
+    seen.add(resolvedModule.path + ":" + exportName);
+    return resolveModuleExport(
+      context,
+      resolvedModule.path,
+      exportValue,
+      specifiers,
+      seen
+    );
+  }
+  let i = 1;
+  for (const from of resolvedModule.exports.all) {
+    if (context.exportAllLimit && i++ > context.exportAllLimit) {
+      throw new ResolveError(
+        `Unable to resolve "${specifiers.join(".")}" in module "${resolvedModule.path}"`,
+        {
+          cause: `More than ${context.exportAllLimit} star exports are not supported for performance reasons`
+        }
+      );
+    }
+    try {
+      const resolved = await resolveModuleExport(
+        context,
+        resolvedModule.path,
+        {
+          type: "re-export",
+          from,
+          name: exportName
+        },
+        specifiers,
+        seen
+      );
+      if (seen.has(resolvedModule.path + ":*")) {
+        throw new CircularDependencyError(
+          `Unable to resolve "${specifiers.join(".")}" in module "${resolvedModule.path}"`,
+          { cause: "Circular dependency detected" }
+        );
+      }
+      seen.add(resolvedModule.path + ":*");
+      return resolved;
+    } catch (error) {
+      if (!(error instanceof ResolveError)) {
+        throw error;
+      }
+      if (error.circular) {
+        throw error;
+      }
+    }
+  }
+  throw new ResolveError(`Unable to resolve "${specifiers.join(".")}"`, {
+    cause: `no matching export found in module "${resolvedModule.path}"`
+  });
+}
+async function resolveModuleExport(context, filePath, moduleExport, specifiers, seen) {
+  try {
+    switch (moduleExport.type) {
+      case "re-export": {
+        const { resolved: reExportedModule } = await resolveModule(
+          context,
+          await context.resolve(moduleExport.from, filePath)
+        );
+        const resolved = await resolveModuleSpecifierRecursively(
+          context,
+          reExportedModule,
+          [moduleExport.name, ...specifiers.slice(1)],
+          seen
+        );
+        if (resolved) {
+          resolved.from.push(filePath);
+        }
+        return resolved;
+      }
+      case "namespace-re-export": {
+        const { resolved: reExportedModule } = await resolveModule(
+          context,
+          await context.resolve(moduleExport.from, filePath)
+        );
+        const resolved = await resolveModuleSpecifierRecursively(
+          context,
+          reExportedModule,
+          specifiers.slice(1),
+          seen
+        );
+        if (resolved) {
+          resolved.from.push(filePath);
+        }
+        return resolved;
+      }
+      case "styled-component": {
+        return {
+          type: "styled-component",
+          from: [filePath],
+          source: filePath,
+          name: specifiers[specifiers.length - 1],
+          value: moduleExport.className
+        };
+      }
+      // usually at this point `tag-template` exports where already resolved to
+      // styled-components if a matching styled-component comment was generated
+      // by yak-swc. So resolving a value to a `tag-template` at this stage
+      // would mean that the user tried to use the result of a call to a
+      // different tag-template than yak's styled in a template. This is usually
+      // invalid.
+      //
+      // But there is an issue with Nextjs. Next build in two passes, once for
+      // the server bundle, once for the client bundle. During the server-side
+      // build, each module with the `"use client"` directive is transformed to
+      // throw errors if the exported symbol are used. This transformation
+      // removes the comments generated by `yak-swc`, so instead of the expected
+      // `styled-component`, calls to `styled` resolve to a `tag-template`
+      // (because no classname was found in the now absent comments).
+      //
+      // To summarize, if a "use client" bundle exports a styled component that
+      // is used in a "standard" module, the resolve logic would throw with
+      // "unknown type tag-template".
+      //
+      // To avoid this error, the resolve logic must handle those `tag-template`
+      // with a special type `unresolved-tag`. Those will be interpolated to
+      // valid CSS with minimal effect (to avoid CSS syntax error in the case of
+      // Nextjs server build)
+      case "tag-template": {
+        return {
+          type: "unresolved-tag",
+          from: [filePath],
+          source: filePath,
+          name: specifiers[specifiers.length - 1]
+        };
+      }
+      case "constant": {
+        return {
+          type: "constant",
+          from: [filePath],
+          source: filePath,
+          value: moduleExport.value
+        };
+      }
+      case "record": {
+        const resolvedInRecord = resolveSpecifierInRecord(
+          moduleExport,
+          specifiers[0],
+          specifiers.slice(1)
+        );
+        return resolveModuleExport(
+          context,
+          filePath,
+          resolvedInRecord,
+          specifiers,
+          seen
+        );
+      }
+      case "mixin": {
+        return {
+          type: "mixin",
+          from: [filePath],
+          source: filePath,
+          value: moduleExport.value
+        };
+      }
+    }
   } catch (error) {
-    throw new Error(
-      `Error parsing file ${filePath}: ${error.message}`
+    throw new ResolveError(
+      `Unable to resolve "${specifiers.join(".")}" in module "${filePath}"`,
+      { cause: error }
+    );
+  }
+  throw new ResolveError(
+    `Unable to resolve "${specifiers.join(".")}" in module "${filePath}"`,
+    { cause: `unknown type "${moduleExport.type}"` }
+  );
+}
+function resolveSpecifierInRecord(record, name, specifiers) {
+  if (specifiers.length === 0) {
+    throw new ResolveError("did not expect an object");
+  }
+  let depth = 0;
+  let current = record;
+  while (current && current.type === "record" && depth < specifiers.length) {
+    current = current.value[specifiers[depth]];
+    depth += 1;
+  }
+  if (current === void 0 || depth !== specifiers.length) {
+    throw new ResolveError(
+      `Unable to resolve "${specifiers.join(".")}" in object/array "${name}"`,
+      { cause: "path not found" }
     );
   }
+  if (current.type === "constant" || current.type === "styled-component" || current.type === "mixin") {
+    return current;
+  }
+  if (current.type === "record" && "__yak" in current.value && current.value.__yak.type === "constant") {
+    return { type: "mixin", value: String(current.value.__yak.value) };
+  }
+  throw new ResolveError(
+    `Unable to resolve "${specifiers.join(".")}" in object/array "${name}"`,
+    { cause: "only string and numbers are supported" }
+  );
+}
+async function sha1(message) {
+  const resultBuffer = await globalThis.crypto.subtle.digest(
+    "SHA-1",
+    new TextEncoder().encode(message)
+  );
+  return Array.from(
+    new Uint8Array(resultBuffer),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+}
+
+// loaders/lib/resolveCrossFileSelectors.ts
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+var compilationCache = /* @__PURE__ */ new WeakMap();
+async function resolveCrossFileConstant2(loader, pathContext, css) {
+  const { resolved } = await resolveCrossFileConstant(
+    getResolveContext(loader),
+    loader.resourcePath,
+    css
+  );
+  return resolved;
+}
+function getCompilationCache(loader) {
+  const compilation = loader._compilation;
+  if (!compilation) {
+    throw new Error("Webpack compilation object not available");
+  }
+  let cache = compilationCache.get(compilation);
+  if (!cache) {
+    cache = {
+      parsedFiles: /* @__PURE__ */ new Map()
+    };
+    compilationCache.set(compilation, cache);
+  }
+  return cache;
+}
+function getParseContext(loader) {
+  return {
+    cache: { parse: getCompilationCache(loader).parsedFiles },
+    async extractExports(modulePath) {
+      const sourceContents = new Promise(
+        (resolve, reject) => loader.fs.readFile(modulePath, "utf-8", (err, result) => {
+          if (err) return reject(err);
+          resolve(result || "");
+        })
+      );
+      return parseExports(await sourceContents);
+    },
+    async getTransformed(modulePath) {
+      const tranformedSource = new Promise((resolve, reject) => {
+        loader.loadModule(modulePath, (err, source) => {
+          if (err) return reject(err);
+          let sourceString;
+          if (typeof source === "string") {
+            sourceString = source;
+          } else if (source instanceof Buffer) {
+            sourceString = source.toString("utf-8");
+          } else if (source instanceof ArrayBuffer) {
+            sourceString = new TextDecoder("utf-8").decode(source);
+          } else {
+            throw new Error(
+              "Invalid input type: code must be string, Buffer, or ArrayBuffer"
+            );
+          }
+          resolve(sourceString || "");
+        });
+      });
+      return { code: await tranformedSource };
+    },
+    async evaluateYakModule(modulePath) {
+      return loader.importModule(modulePath);
+    }
+  };
+}
+function getResolveContext(loader) {
+  const parseContext = getParseContext(loader);
+  return {
+    parse: (modulePath) => parseModule(parseContext, modulePath),
+    resolve: async (specifier, importer) => {
+      return resolveModule2(loader, specifier, dirname(importer));
+    }
+  };
+}
+async function resolveModule2(loader, moduleSpecifier, context) {
+  return new Promise((resolve, reject) => {
+    loader.resolve(context, moduleSpecifier, (err, result) => {
+      if (err) return reject(err);
+      if (!result)
+        return reject(new Error(`Could not resolve ${moduleSpecifier}`));
+      resolve(result);
+    });
+  });
 }
 async function parseExports(sourceContents) {
-  let exports = {};
+  const moduleExports = {
+    importYak: true,
+    named: {},
+    all: []
+  };
   const variableDeclarations = {};
   let defaultIdentifier = null;
   try {
@@ -228,10 +690,10 @@ async function parseExports(sourceContents) {
         if (node.source) {
           node.specifiers.forEach((specifier) => {
             if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier" && specifier.local.type === "Identifier") {
-              exports[specifier.exported.name] = {
+              moduleExports.named[specifier.exported.name] = {
                 type: "re-export",
                 from: node.source.value,
-                imported: specifier.local.name
+                name: specifier.local.name
               };
             }
           });
@@ -240,7 +702,7 @@ async function parseExports(sourceContents) {
             if (declaration.id.type === "Identifier" && declaration.init) {
               const parsed = parseExportValueExpression(declaration.init);
               if (parsed) {
-                exports[declaration.id.name] = parsed;
+                moduleExports.named[declaration.id.name] = parsed;
               }
             }
           });
@@ -251,9 +713,9 @@ async function parseExports(sourceContents) {
           const { specifiers, source } = node;
           specifiers.forEach((specifier) => {
             if (specifier.type === "ExportNamespaceSpecifier" && specifier.exported.type === "Identifier") {
-              exports[specifier.exported.name] = {
-                type: "star-export",
-                from: [source.value]
+              moduleExports.named[specifier.exported.name] = {
+                type: "namespace-re-export",
+                from: source.value
               };
             }
           });
@@ -263,68 +725,30 @@ async function parseExports(sourceContents) {
         if (node.declaration.type === "Identifier") {
           defaultIdentifier = node.declaration.name;
         } else if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
-          exports["default"] = {
+          moduleExports.named["default"] = {
             type: "unsupported",
             hint: node.declaration.type
           };
         } else {
-          exports["default"] = parseExportValueExpression(
+          moduleExports.named["default"] = parseExportValueExpression(
             node.declaration
           );
         }
       },
       ExportAllDeclaration({ node }) {
-        if (Object.keys(exports).length === 0) {
-          exports["*"] ||= {
-            type: "star-export",
-            from: []
-          };
-          if (exports["*"].type !== "star-export") {
-            throw new Error("Invalid star export state");
-          }
-          exports["*"].from.push(node.source.value);
-        }
+        moduleExports.all.push(node.source.value);
       }
     });
     if (defaultIdentifier && variableDeclarations[defaultIdentifier]) {
-      exports["default"] = parseExportValueExpression(
+      moduleExports.named["default"] = parseExportValueExpression(
         variableDeclarations[defaultIdentifier]
       );
     }
-    return exports;
+    return moduleExports;
   } catch (error) {
     throw new Error(`Error parsing exports: ${error.message}`);
   }
 }
-function parseMixins(sourceContents) {
-  const mixinParts = sourceContents.split("/*YAK EXPORTED MIXIN:");
-  let mixins = {};
-  for (let i = 1; i < mixinParts.length; i++) {
-    const [comment] = mixinParts[i].split("*/", 1);
-    const position = comment.indexOf("\n");
-    const name = comment.slice(0, position);
-    const value = comment.slice(position + 1);
-    mixins[name] = {
-      type: "mixin",
-      value,
-      nameParts: name.split(":").map((part) => decodeURIComponent(part))
-    };
-  }
-  return mixins;
-}
-function parseStyledComponents(sourceContents, transpilationMode) {
-  const styledParts = sourceContents.split("/*YAK EXPORTED STYLED:");
-  let styledComponents = {};
-  for (let i = 1; i < styledParts.length; i++) {
-    const [comment] = styledParts[i].split("*/", 1);
-    const [componentName, className] = comment.split(":");
-    styledComponents[componentName] = {
-      type: "styled-component",
-      value: transpilationMode === "Css" ? `.${className}` : `:global(.${className})`
-    };
-  }
-  return styledComponents;
-}
 function unpackTSAsExpression(node) {
   if (node.type === "TSAsExpression") {
     return unpackTSAsExpression(node.expression);
@@ -334,7 +758,7 @@ function unpackTSAsExpression(node) {
 function parseExportValueExpression(node) {
   const expression = unpackTSAsExpression(node);
   if (expression.type === "CallExpression" || expression.type === "TaggedTemplateExpression") {
-    return { type: "styled-component", value: void 0 };
+    return { type: "tag-template" };
   } else if (expression.type === "StringLiteral" || expression.type === "NumericLiteral") {
     return { type: "constant", value: expression.value };
   } else if (expression.type === "UnaryExpression" && expression.operator === "-" && expression.argument.type === "NumericLiteral") {
@@ -361,106 +785,17 @@ function parseObjectExpression(node) {
   }
   return result;
 }
-async function resolveModuleSpecifierRecursively(loader, module, specifier) {
-  try {
-    const exportName = specifier[0];
-    let exportValue = module.exports[exportName];
-    if (exportValue === void 0) {
-      const starExport = module.exports["*"];
-      if (starExport?.type === "star-export") {
-        if (starExport.from.length > 1) {
-          throw new Error(
-            `Could not resolve ${specifier.join(".")} in module ${module.filePath} - Multiple star exports are not supported for performance reasons`
-          );
-        }
-        exportValue = {
-          type: "re-export",
-          from: starExport.from[0],
-          imported: exportName
-        };
-      } else {
-        throw new Error(
-          `Could not resolve "${specifier.join(".")}" in module ${module.filePath}`
-        );
-      }
-    }
-    if (exportValue.type === "re-export") {
-      const importedModule = await parseModule(
-        loader,
-        exportValue.from,
-        path.dirname(module.filePath)
-      );
-      return resolveModuleSpecifierRecursively(loader, importedModule, [
-        exportValue.imported,
-        ...specifier.slice(1)
-      ]);
-    } else if (exportValue.type === "star-export") {
-      const importedModule = await parseModule(
-        loader,
-        exportValue.from[0],
-        path.dirname(module.filePath)
-      );
-      return resolveModuleSpecifierRecursively(
-        loader,
-        importedModule,
-        specifier.slice(1)
-      );
-    }
-    if (exportValue.type === "styled-component") {
-      return {
-        type: "styled-component",
-        from: module.filePath,
-        name: specifier[specifier.length - 1],
-        value: exportValue.value
-      };
-    } else if (exportValue.type === "constant") {
-      return { type: "constant", value: exportValue.value };
-    } else if (exportValue.type === "record") {
-      let current = exportValue.value;
-      let depth = 0;
-      do {
-        if (typeof current === "string" || typeof current === "number") {
-          return {
-            type: "constant",
-            value: current
-          };
-        } else if (!current || typeof current !== "object" && !Array.isArray(current)) {
-          throw new Error(
-            `Error unpacking Record/Array "${exportName}".
-Key "${specifier[depth]}" was of type "${typeof current}" but only String and Number are supported`
-          );
-        }
-        depth++;
-        if (depth === specifier.length && "__yak" in current) {
-          return { type: "mixin", value: current["__yak"] };
-        } else if (depth === specifier.length && "value" in current) {
-          return { type: "constant", value: current["value"] };
-        } else if ("value" in current) {
-          current = current.value[specifier[depth]];
-        } else {
-          current = current[specifier[depth]];
-        }
-      } while (current);
-      if (specifier[depth] === void 0) {
-        throw new Error(
-          `Error unpacking Record/Array - could not extract \`${specifier.slice(0, depth).join(".")}\` is not a string or number`
-        );
-      }
-      throw new Error(
-        `Error unpacking Record/Array - could not extract \`${specifier[depth]}\` from \`${specifier.slice(0, depth).join(".")}\``
-      );
-    } else if (exportValue.type === "mixin") {
-      return { type: "mixin", value: exportValue.value };
-    }
-    throw new Error(
-      `Error unpacking Record/Array - unexpected exportValue "${exportValue.type}" for specifier "${specifier.join(".")}"`
-    );
-  } catch (error) {
-    throw new Error(
-      `Error resolving from module ${module.filePath}: ${error.message}
-Extracted values: ${JSON.stringify(module.exports, null, 2)}`
-    );
+var DIRNAME_POSIX_REGEX = /^((?:\.(?![^\/]))|(?:(?:\/?|)(?:[\s\S]*?)))(?:\/+?|)(?:(?:\.{1,2}|[^\/]+?|)(?:\.[^.\/]*|))(?:[\/]*)$/;
+var DIRNAME_WIN32_REGEX = /^((?:\.(?![^\\]))|(?:(?:\\?|)(?:[\s\S]*?)))(?:\\+?|)(?:(?:\.{1,2}|[^\\]+?|)(?:\.[^.\\]*|))(?:[\\]*)$/;
+function dirname(path) {
+  let dirname2 = DIRNAME_POSIX_REGEX.exec(path)?.[1];
+  if (!dirname2) {
+    dirname2 = DIRNAME_WIN32_REGEX.exec(path)?.[1];
+  }
+  if (!dirname2) {
+    throw new Error(`Can't extract dirname from ${path}`);
   }
+  return dirname2;
 }
 
 // loaders/css-loader.ts
@@ -480,7 +815,7 @@ async function cssExtractLoader(_code, sourceMap) {
     debugLog("ts", source);
     const css = extractCss(source, experiments?.transpilationMode);
     debugLog("css", css);
-    return resolveCrossFileConstant(this, this.context, css).then((result) => {
+    return resolveCrossFileConstant2(this, this.context, css).then((result) => {
       debugLog("css resolved", css);
       return callback(null, result, sourceMap);
     }, callback);