next-yak 7.0.0 → 8.0.0

package/dist/loaders/turbo-loader.js

@@ -0,0 +1,896 @@
+// loaders/turbo-loader.ts
+import { transform as swcTransform } from "@swc/core";
+import { dirname } from "path";
+import { createContext, runInContext } from "vm";
+
+// 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
+);
+async function resolveCrossFileConstant(context, filePath, css) {
+  const resolveCrossFileConstant2 = context.cache?.resolveCrossFileConstant;
+  if (resolveCrossFileConstant2 === void 0) {
+    return uncachedResolveCrossFileConstant(context, filePath, css);
+  }
+  const cacheKey = await sha1(filePath + ":" + css);
+  const cached = resolveCrossFileConstant2.get(cacheKey);
+  if (cached === void 0) {
+    const resolvedCrossFilConstantPromise = uncachedResolveCrossFileConstant(
+      context,
+      filePath,
+      css
+    );
+    resolveCrossFileConstant2.set(cacheKey, resolvedCrossFilConstantPromise);
+    if (resolveCrossFileConstant2.addDependency) {
+      resolveCrossFileConstant2.addDependency(cacheKey, filePath);
+      resolvedCrossFilConstantPromise.then((value) => {
+        for (const dep of value.dependencies) {
+          resolveCrossFileConstant2.addDependency(cacheKey, 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: [] };
+  }
+  try {
+    const dependencies = /* @__PURE__ */ new Set();
+    const resolvedValues = await Promise.all(
+      yakImports.map(async ({ moduleSpecifier, specifier }) => {
+        const { resolved: resolvedModule } = await resolveModule(
+          context,
+          moduleSpecifier
+        );
+        const resolvedValue = await resolveModuleSpecifierRecursively(
+          context,
+          resolvedModule,
+          specifier
+        );
+        for (const dependency of resolvedValue.from) {
+          dependencies.add(dependency);
+        }
+        return resolvedValue;
+      })
+    );
+    let result = css;
+    for (let i = yakImports.length - 1; i >= 0; i--) {
+      const { position, size, importKind, specifier, semicolon } = yakImports[i];
+      const resolved = resolvedValues[i];
+      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);
+      }
+      result = result.slice(0, position) + String(replacement) + result.slice(position + size);
+    }
+    return { resolved: result, dependencies: Array.from(dependencies) };
+  } catch (error) {
+    throw new CauseError(
+      `Error while resolving cross-file selectors in file "${filePath}"`,
+      { cause: error }
+    );
+  }
+}
+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 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 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`
+            });
+          }
+          current = next.value;
+        }
+        current[styledComponent.nameParts[styledComponent.nameParts.length - 1]] = {
+          type: "styled-component",
+          className: styledComponent.value
+        };
+      }
+    });
+  }
+  if (parsedModule.mixins) {
+    await Promise.all(
+      Object.values(parsedModule.mixins).map(async (mixin) => {
+        const { resolved, dependencies: deps } = await resolveCrossFileConstant(
+          context,
+          parsedModule.path,
+          mixin.value
+        );
+        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.named[mixin.nameParts[0]];
+          if (!exportEntry) {
+            exportEntry = { type: "record", value: {} };
+            exports.named[mixin.nameParts[0]] = exportEntry;
+          } else if (exportEntry.type !== "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 < mixin.nameParts.length - 1; i++) {
+            let next = current[mixin.nameParts[i]];
+            if (!next) {
+              next = { type: "record", value: {} };
+              current[mixin.nameParts[i]] = next;
+            } else if (next.type !== "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[mixin.nameParts[mixin.nameParts.length - 1]] = {
+            type: "mixin",
+            value: resolved
+          };
+        }
+      })
+    );
+  }
+  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 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/debugLogger.ts
+import { relative } from "path";
+function createDebugLogger(loaderContext, debugOptions) {
+  if (!debugOptions) {
+    return () => {
+    };
+  }
+  const currentPath = loaderContext._compiler ? relative(loaderContext._compiler.context, loaderContext.resourcePath) : loaderContext.resourcePath;
+  return (messageType, message) => {
+    const pathWithExtension = messageType !== "ts" ? currentPath + `.${messageType}` : currentPath;
+    if (debugOptions === true || new RegExp(debugOptions).test(pathWithExtension)) {
+      console.log("\u{1F42E} Yak", pathWithExtension, "\n\n", message);
+    }
+  };
+}
+
+// loaders/lib/extractCss.ts
+function extractCss(code, transpilationMode) {
+  let codeString;
+  if (typeof code === "string") {
+    codeString = code;
+  } else if (code instanceof Buffer) {
+    codeString = code.toString("utf-8");
+  } else if (code instanceof ArrayBuffer) {
+    codeString = new TextDecoder("utf-8").decode(code);
+  } else {
+    throw new Error(
+      "Invalid input type: code must be string, Buffer, or ArrayBuffer"
+    );
+  }
+  const codeParts = codeString.split("/*YAK Extracted CSS:\n");
+  let result = "";
+  for (let i = 1; i < codeParts.length; i++) {
+    const codeUntilEnd = codeParts[i].split("*/")[0];
+    result += codeUntilEnd;
+  }
+  if (result && transpilationMode !== "Css") {
+    result = "/* cssmodules-pure-no-check */\n" + result;
+  }
+  return result;
+}
+
+// loaders/lib/resolveCrossFileSelectors.ts
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+async function parseExports(sourceContents) {
+  const moduleExports = {
+    importYak: true,
+    named: {},
+    all: []
+  };
+  const variableDeclarations = {};
+  let defaultIdentifier = null;
+  try {
+    const ast = parse(sourceContents, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"]
+    });
+    traverse.default(ast, {
+      // Track all variable declarations in the file
+      VariableDeclarator({ node }) {
+        if (node.id.type === "Identifier" && node.init) {
+          variableDeclarations[node.id.name] = node.init;
+        }
+      },
+      ExportNamedDeclaration({ node }) {
+        if (node.source) {
+          node.specifiers.forEach((specifier) => {
+            if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier" && specifier.local.type === "Identifier") {
+              moduleExports.named[specifier.exported.name] = {
+                type: "re-export",
+                from: node.source.value,
+                name: specifier.local.name
+              };
+            }
+          });
+        } else if (node.declaration?.type === "VariableDeclaration") {
+          node.declaration.declarations.forEach((declaration) => {
+            if (declaration.id.type === "Identifier" && declaration.init) {
+              const parsed = parseExportValueExpression(declaration.init);
+              if (parsed) {
+                moduleExports.named[declaration.id.name] = parsed;
+              }
+            }
+          });
+        }
+      },
+      ExportDeclaration({ node }) {
+        if ("specifiers" in node && node.source) {
+          const { specifiers, source } = node;
+          specifiers.forEach((specifier) => {
+            if (specifier.type === "ExportNamespaceSpecifier" && specifier.exported.type === "Identifier") {
+              moduleExports.named[specifier.exported.name] = {
+                type: "namespace-re-export",
+                from: source.value
+              };
+            }
+          });
+        }
+      },
+      ExportDefaultDeclaration({ node }) {
+        if (node.declaration.type === "Identifier") {
+          defaultIdentifier = node.declaration.name;
+        } else if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
+          moduleExports.named["default"] = {
+            type: "unsupported",
+            hint: node.declaration.type
+          };
+        } else {
+          moduleExports.named["default"] = parseExportValueExpression(
+            node.declaration
+          );
+        }
+      },
+      ExportAllDeclaration({ node }) {
+        moduleExports.all.push(node.source.value);
+      }
+    });
+    if (defaultIdentifier && variableDeclarations[defaultIdentifier]) {
+      moduleExports.named["default"] = parseExportValueExpression(
+        variableDeclarations[defaultIdentifier]
+      );
+    }
+    return moduleExports;
+  } catch (error) {
+    throw new Error(`Error parsing exports: ${error.message}`);
+  }
+}
+function unpackTSAsExpression(node) {
+  if (node.type === "TSAsExpression") {
+    return unpackTSAsExpression(node.expression);
+  }
+  return node;
+}
+function parseExportValueExpression(node) {
+  const expression = unpackTSAsExpression(node);
+  if (expression.type === "CallExpression" || expression.type === "TaggedTemplateExpression") {
+    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") {
+    return { type: "constant", value: -expression.argument.value };
+  } else if (expression.type === "TemplateLiteral" && expression.quasis.length === 1) {
+    return { type: "constant", value: expression.quasis[0].value.raw };
+  } else if (expression.type === "ObjectExpression") {
+    return { type: "record", value: parseObjectExpression(expression) };
+  }
+  return { type: "unsupported", hint: expression.type };
+}
+function parseObjectExpression(node) {
+  let result = {};
+  for (const property of node.properties) {
+    if (property.type === "ObjectProperty" && property.key.type === "Identifier") {
+      const key = property.key.name;
+      const parsed = parseExportValueExpression(
+        property.value
+      );
+      if (parsed) {
+        result[key] = parsed;
+      }
+    }
+  }
+  return result;
+}
+
+// loaders/turbo-loader.ts
+async function cssExtractLoader(code, sourceMap) {
+  const callback = this.async();
+  if (!code.includes("next-yak")) {
+    return callback(null, code, sourceMap);
+  }
+  const {
+    yakPluginOptions,
+    yakOptions: { experiments }
+  } = this.getOptions();
+  const debugLog = createDebugLogger(this, experiments?.debug);
+  const resolveTurbopack = this.getResolve({});
+  const transform = createTransform(yakPluginOptions);
+  const resolveFn = (specifier, importer) => {
+    return new Promise((resolve, reject) => {
+      resolveTurbopack(dirname(importer), specifier, (err, result2) => {
+        if (err) return reject(err);
+        if (!result2) return reject(new Error(`Could not resolve ${specifier}`));
+        resolve(result2);
+      });
+    });
+  };
+  const fsReadFile = (filePath) => new Promise(
+    (resolve, reject) => this.fs.readFile(filePath, "utf-8", (err, result2) => {
+      if (err) return reject(err);
+      if (!result2) return reject(new Error(`File not found: ${filePath}`));
+      resolve(result2);
+    })
+  );
+  const result = await transform(
+    code,
+    this.resourcePath,
+    this.rootContext,
+    sourceMap
+  );
+  debugLog("ts", result.code);
+  let css = extractCss(result.code, "Css");
+  debugLog("css", css);
+  const { resolved } = await resolveCrossFileConstant(
+    {
+      parse: (modulePath) => {
+        return parseModule(
+          {
+            transpilationMode: "Css",
+            extractExports: async (modulePath2) => {
+              const sourceContents = await fsReadFile(modulePath2);
+              return parseExports(sourceContents);
+            },
+            getTransformed: async (modulePath2) => {
+              const sourceContent = await fsReadFile(modulePath2);
+              return transform(sourceContent, modulePath2, this.rootContext);
+            },
+            evaluateYakModule: async (modulePath2) => {
+              const code2 = await fsReadFile(modulePath2);
+              const transformed = await swcTransform(code2, {
+                filename: modulePath2,
+                sourceFileName: modulePath2,
+                jsc: {
+                  transform: {
+                    react: { runtime: "automatic" }
+                  },
+                  experimental: {
+                    plugins: [["yak-swc", yakPluginOptions]]
+                  }
+                },
+                module: {
+                  type: "commonjs"
+                }
+              });
+              const moduleObject = { exports: {} };
+              const context = createContext({
+                require: (path) => {
+                  throw new Error(
+                    `Yak files cannot have imports in turbopack.
+Found require/import usage in: ${modulePath2} to import: ${path}.
+Yak files should be self-contained and only export constants or styled components.
+This will be resolved once Vercel adds "this.importModule" support for turbopack.`
+                  );
+                },
+                __filename: modulePath2,
+                __dirname: dirname(modulePath2),
+                global: {},
+                console,
+                Buffer,
+                process,
+                setTimeout,
+                clearTimeout,
+                setInterval,
+                clearInterval,
+                setImmediate,
+                clearImmediate,
+                exports: moduleObject.exports,
+                module: moduleObject
+              });
+              runInContext(transformed.code, context);
+              return moduleObject.exports;
+            }
+          },
+          modulePath
+        );
+      },
+      resolve: resolveFn
+    },
+    this.resourcePath,
+    css
+  );
+  const dataUrl = result.code.split("\n").find((line) => line.includes("data:text/css;base64"));
+  const codeWithCrossFileResolved = result.code.replace(
+    dataUrl,
+    `import "data:text/css;base64,${Buffer.from(resolved).toString("base64")}"`
+  );
+  debugLog("css-resolved", resolved);
+  return callback(null, codeWithCrossFileResolved, result.map);
+}
+function createTransform(yakPluginOptions) {
+  return (data, modulePath, rootPath, sourceMap) => (
+    // https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack/loaders/next-swc-loader.ts#L143
+    swcTransform(data, {
+      filename: modulePath,
+      inputSourceMap: sourceMap,
+      sourceMaps: true,
+      sourceFileName: modulePath,
+      sourceRoot: rootPath,
+      jsc: {
+        experimental: {
+          plugins: [["yak-swc", yakPluginOptions]]
+        },
+        transform: {
+          react: {
+            runtime: "preserve"
+          }
+        },
+        target: "es2022",
+        loose: false,
+        minify: {
+          compress: false,
+          mangle: false
+        },
+        preserveAllComments: true
+      },
+      minify: false,
+      isModule: true
+    })
+  );
+}
+export {
+  cssExtractLoader as default
+};
+//# sourceMappingURL=turbo-loader.js.map