next-yak 9.0.0 → 9.1.0

package/dist/loaders/vite-plugin.js

@@ -0,0 +1,1068 @@
+// loaders/vite-plugin.ts
+import { transform as swcTransform } from "@swc/core";
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname2, relative, resolve } 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("");
+}
+
+// withYak/index.ts
+import { existsSync } from "fs";
+import path, { dirname } from "path";
+import { fileURLToPath } from "url";
+var currentDir = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
+function resolveYakContext(contextPath, cwd) {
+  const yakContext = contextPath ? path.resolve(cwd, contextPath) : path.resolve(cwd, "yak.context");
+  const extensions = ["", ".ts", ".tsx", ".js", ".jsx"];
+  for (const extension in extensions) {
+    const fileName = yakContext + extensions[extension];
+    if (existsSync(fileName)) {
+      return fileName;
+    }
+  }
+  if (contextPath) {
+    throw new Error(`Could not find yak context file at ${yakContext}`);
+  }
+}
+
+// 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/vite-plugin.ts
+var require2 = createRequire(import.meta.url);
+var defaultSwcOptions = {
+  jsc: {
+    parser: {
+      syntax: "typescript",
+      tsx: true,
+      decorators: false,
+      dynamicImport: true
+    },
+    transform: {
+      react: {
+        runtime: "preserve"
+      }
+    },
+    target: "es2022",
+    loose: false,
+    minify: {
+      compress: false,
+      mangle: false
+    },
+    preserveAllComments: true
+  },
+  minify: false,
+  isModule: true
+};
+async function viteYak(userOptions = {}) {
+  const yakOptions = {
+    experiments: {
+      transpilationMode: "Css",
+      suppressDeprecationWarnings: false,
+      ...userOptions.experiments
+    },
+    minify: userOptions.minify ?? process.env.NODE_ENV === "production",
+    prefix: userOptions.prefix,
+    contextPath: userOptions.contextPath,
+    swcOptions: deepMerge(defaultSwcOptions, userOptions.swcOptions ?? {})
+  };
+  yakOptions.displayNames = userOptions.displayNames ?? yakOptions.displayNames ?? !yakOptions.minify;
+  let root = process.cwd();
+  const debugLog = createDebugLogger(yakOptions.experiments?.debug, root);
+  const sourceFileRegex = /\.(tsx?|m?jsx?)\??/;
+  const virtualModuleRegex = /^virtual:yak-css:/;
+  const virtualCssModuleRegex = /^\0virtual:yak-css:/;
+  const yakSwcPath = await findYakSwcPlugin();
+  return {
+    name: "vite-plugin-yak:css:pre",
+    enforce: "pre",
+    config: (config) => {
+      const context = resolveYakContext(
+        yakOptions.contextPath,
+        config.root ?? root
+      );
+      if (!context) {
+        return;
+      }
+      config.resolve ||= {};
+      if (Array.isArray(config.resolve.alias)) {
+        config.resolve.alias.push({
+          find: "next-yak/context/baseContext",
+          replacement: context
+        });
+      } else {
+        config.resolve.alias = {
+          ...config.resolve.alias,
+          "next-yak/context/baseContext": context
+        };
+      }
+    },
+    configResolved(config) {
+      root = config.root;
+    },
+    resolveId: {
+      filter: {
+        id: virtualModuleRegex
+      },
+      handler(id) {
+        return "\0" + id;
+      }
+    },
+    load: {
+      filter: {
+        id: virtualCssModuleRegex
+      },
+      async handler(id) {
+        const originalId = id.slice(17, -4);
+        this.addWatchFile(originalId);
+        const sourceContent = await this.fs.readFile(originalId, {
+          encoding: "utf8"
+        });
+        const code = await transform(
+          sourceContent,
+          originalId,
+          root,
+          yakSwcPath,
+          yakOptions
+        );
+        const extractedCss = extractCss(code.code, "Css");
+        debugLog("css", extractedCss, originalId);
+        const { resolved } = await resolveCrossFileConstant(
+          {
+            parse: (modulePath) => {
+              return parseModule(
+                {
+                  transpilationMode: "Css",
+                  extractExports: async (modulePath2) => {
+                    const sourceContent2 = await this.fs.readFile(modulePath2, {
+                      encoding: "utf8"
+                    });
+                    this.addWatchFile(modulePath2);
+                    return parseExports(sourceContent2);
+                  },
+                  getTransformed: async (modulePath2) => {
+                    const sourceContent2 = await this.fs.readFile(modulePath2, {
+                      encoding: "utf8"
+                    });
+                    return transform(
+                      sourceContent2,
+                      modulePath2,
+                      root,
+                      yakSwcPath,
+                      yakOptions
+                    );
+                  },
+                  evaluateYakModule: async (modulePath2) => {
+                    this.addWatchFile(modulePath2);
+                    const sourceContent2 = await this.fs.readFile(modulePath2, {
+                      encoding: "utf8"
+                    });
+                    const transformed = await swcTransform(sourceContent2, {
+                      filename: modulePath2,
+                      sourceFileName: modulePath2,
+                      ...yakOptions.swcOptions,
+                      jsc: {
+                        ...yakOptions.swcOptions?.jsc,
+                        experimental: {
+                          plugins: [
+                            [
+                              yakSwcPath,
+                              {
+                                minify: yakOptions.minify,
+                                basePath: root,
+                                prefix: yakOptions.prefix,
+                                displayNames: yakOptions.displayNames,
+                                suppressDeprecationWarnings: yakOptions.experiments?.suppressDeprecationWarnings,
+                                importMode: {
+                                  value: "virtual:yak-css:{{__MODULE_PATH__}}.css",
+                                  transpilation: "Css",
+                                  encoding: "None"
+                                }
+                              }
+                            ]
+                          ]
+                        }
+                      },
+                      module: {
+                        type: "commonjs"
+                      }
+                    });
+                    const moduleObject = { exports: {} };
+                    const context = createContext({
+                      require: (path2) => {
+                        throw new Error(
+                          `Yak files cannot have imports in vite.
+Found require/import usage in: ${modulePath2} to import: ${path2}.
+Yak files should be self-contained and only export constants or styled components.
+`
+                        );
+                      },
+                      __filename: modulePath2,
+                      __dirname: dirname2(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: async (moduleSpecifier, context) => {
+              let importer = context;
+              const resolved2 = await this.resolve(moduleSpecifier, importer);
+              if (!resolved2) {
+                throw new Error(
+                  `Could not resolve ${moduleSpecifier} from ${context}`
+                );
+              }
+              return resolved2.id;
+            }
+          },
+          originalId,
+          extractedCss
+        );
+        debugLog("css-resolved", resolved, originalId);
+        return resolved;
+      }
+    },
+    transform: {
+      filter: {
+        id: {
+          include: sourceFileRegex,
+          exclude: [/packages\/next-yak/]
+        },
+        code: "next-yak"
+      },
+      async handler(code, id) {
+        try {
+          const result = await transform(
+            code,
+            id.split("?")[0],
+            root,
+            yakSwcPath,
+            yakOptions
+          );
+          debugLog("ts", result.code, id);
+          return {
+            code: result.code,
+            map: result.map
+          };
+        } catch (error) {
+          this.error(
+            `[YAK Plugin] Error transforming ${id}: ${error.message}`
+          );
+        }
+      }
+    }
+  };
+}
+async function findYakSwcPlugin() {
+  try {
+    const packageJsonPath = require2.resolve("yak-swc/package.json");
+    const packageRoot = dirname2(packageJsonPath);
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const wasmPath = resolve(packageRoot, packageJson.main);
+    return wasmPath;
+  } catch (e) {
+    throw new Error(`Could not resolve yak-swc plugin: ${e}`);
+  }
+}
+function transform(data, modulePath, rootPath, yakSwcPath, yakOptions) {
+  return swcTransform(data, {
+    filename: modulePath,
+    inputSourceMap: void 0,
+    sourceMaps: true,
+    sourceFileName: modulePath,
+    sourceRoot: rootPath,
+    ...yakOptions.swcOptions,
+    jsc: {
+      ...yakOptions.swcOptions?.jsc,
+      experimental: {
+        plugins: [
+          [
+            yakSwcPath,
+            {
+              minify: yakOptions.minify,
+              basePath: rootPath,
+              prefix: yakOptions.prefix,
+              displayNames: yakOptions.displayNames,
+              suppressDeprecationWarnings: yakOptions.experiments?.suppressDeprecationWarnings,
+              importMode: {
+                value: "virtual:yak-css:{{__MODULE_PATH__}}.css",
+                transpilation: "Css",
+                encoding: "None"
+              }
+            }
+          ]
+        ]
+      }
+    }
+  });
+}
+function createDebugLogger(debugOptions, root) {
+  if (!debugOptions) {
+    return () => {
+    };
+  }
+  return (messageType, message, filePath) => {
+    const pathWithExtension = messageType !== "ts" ? filePath + `.${messageType}` : filePath;
+    if (debugOptions === true || new RegExp(debugOptions).test(pathWithExtension)) {
+      console.log("\u{1F42E} Yak", relative(root, pathWithExtension), "\n\n", message);
+    }
+  };
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (sourceValue !== void 0 && typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+export {
+  createDebugLogger,
+  viteYak
+};
+//# sourceMappingURL=vite-plugin.js.map