@absolutejs/absolute 0.20.0-beta.172 → 0.20.0-beta.173

package/dist/build/buildWorker.js

@@ -33,7 +33,7 @@ var inlineSourceMapComment = (map) => [
 `);
 
 // src/constants.ts
-var HOURS_IN_DAY = 24, MILLISECONDS_IN_A_SECOND = 1000, MINUTES_IN_AN_HOUR = 60, SECONDS_IN_A_MINUTE = 60, MILLISECONDS_IN_A_MINUTE, MILLISECONDS_IN_A_DAY, TWO_THIRDS;
+var BASE_36_RADIX = 36, HOURS_IN_DAY = 24, MILLISECONDS_IN_A_SECOND = 1000, MINUTES_IN_AN_HOUR = 60, SECONDS_IN_A_MINUTE = 60, MILLISECONDS_IN_A_MINUTE, MILLISECONDS_IN_A_DAY, TWO_THIRDS;
 var init_constants = __esm(() => {
   MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
   MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
@@ -772,26 +772,65 @@ var vueCompileCacheEnabled = () => process.env.ABSOLUTE_COMPILE_CACHE !== "0", h
 };
 var init_vueCompileCache = () => {};
 
+// src/build/vueModuleOutputPath.ts
+import {
+  dirname as dirname2,
+  isAbsolute,
+  join as join3,
+  parse,
+  relative,
+  resolve as resolve2,
+  sep
+} from "path";
+var EXTERNAL_DIR = "_external", UNRELATED_PREFIX = "h-", HASH_LENGTH = 13, toOutputName = (path) => path.replace(/\.(vue|ts)$/, ".js"), unrelatedMirrorPath = (absolutePath) => {
+  const directory = dirname2(absolutePath);
+  const directoryHash = Bun.hash(directory).toString(BASE_36_RADIX).padStart(HASH_LENGTH, "0");
+  return join3(EXTERNAL_DIR, `${UNRELATED_PREFIX}${directoryHash}`, toOutputName(relative(directory, absolutePath)));
+}, sourceMirrorPath = (sourcePath, projectRoot) => {
+  const absolutePath = resolve2(sourcePath);
+  const root = resolve2(projectRoot);
+  const fromRoot = relative(root, absolutePath);
+  if (isAbsolute(fromRoot))
+    return unrelatedMirrorPath(absolutePath);
+  const segments = fromRoot.split(sep);
+  const levelsUp = segments.findIndex((segment) => segment !== "..");
+  if (levelsUp === 0)
+    return toOutputName(fromRoot);
+  const sharedAncestor = join3(root, ...segments.slice(0, levelsUp));
+  if (levelsUp < 0 || parse(sharedAncestor).root === sharedAncestor)
+    return unrelatedMirrorPath(absolutePath);
+  return join3(EXTERNAL_DIR, String(levelsUp), toOutputName(segments.slice(levelsUp).join(sep)));
+}, vueRelativeOutputImport = (importerSource, targetSource, projectRoot = process.cwd()) => {
+  const specifier = relative(dirname2(sourceMirrorPath(importerSource, projectRoot)), sourceMirrorPath(targetSource, projectRoot)).replace(/\\/g, "/");
+  return specifier.startsWith("../") ? specifier : `./${specifier}`;
+}, mirrorRegion = (sourcePath, projectRoot) => {
+  const [first, second] = sourceMirrorPath(sourcePath, projectRoot).split(sep);
+  return first === EXTERNAL_DIR ? `${EXTERNAL_DIR}/${second}` : "";
+}, vueMirrorImport = (importerSource, specifier, targetSource, projectRoot = process.cwd()) => mirrorRegion(importerSource, projectRoot) === mirrorRegion(targetSource, projectRoot) ? specifier : vueRelativeOutputImport(importerSource, targetSource, projectRoot);
+var init_vueModuleOutputPath = __esm(() => {
+  init_constants();
+});
+
 // src/build/emitTsHelpers.ts
 var exports_emitTsHelpers = {};
 __export(exports_emitTsHelpers, {
   emitTsHelpers: () => emitTsHelpers
 });
 var {file, Transpiler, write } = globalThis.Bun;
-import { copyFileSync, existsSync as existsSync3, readdirSync } from "fs";
+import { copyFileSync, existsSync as existsSync3, readdirSync, statSync } from "fs";
 import { mkdir, rename, writeFile } from "fs/promises";
-import { dirname as dirname2, join as join3 } from "path";
-var CACHE_DIR_NAME = "vue-helpers", CACHE_FORMAT_VERSION = 1, HASH_LENGTH = 24, transpiler, cacheDir = () => join3(process.cwd(), ".absolutejs", "compile-cache", CACHE_DIR_NAME), cacheKey = (sourcePath, sourceCode) => {
+import { dirname as dirname3, join as join4, resolve as resolve3, sep as sep2 } from "path";
+var CACHE_DIR_NAME = "vue-helpers", CACHE_FORMAT_VERSION = 2, HASH_LENGTH2 = 24, transpiler, cacheDir = () => join4(process.cwd(), ".absolutejs", "compile-cache", CACHE_DIR_NAME), cacheKey = (sourcePath, sourceCode) => {
   const frameworkVersion = frameworkVersionForCache();
   if (!frameworkVersion || !vueCompileCacheEnabled())
     return null;
   return {
-    content: hashContent(sourceCode).slice(0, HASH_LENGTH),
+    content: hashContent(sourceCode).slice(0, HASH_LENGTH2),
     path: hashParts([
       String(CACHE_FORMAT_VERSION),
       frameworkVersion,
       sourcePath
-    ]).slice(0, HASH_LENGTH)
+    ]).slice(0, HASH_LENGTH2)
   };
 }, existingEntries, listCacheDir = (directory) => {
   try {
@@ -814,20 +853,20 @@ var CACHE_DIR_NAME = "vue-helpers", CACHE_FORMAT_VERSION = 1, HASH_LENGTH = 24,
 }, publishCacheEntry = async (directory, fileName, pathHash, content) => {
   try {
     await mkdir(directory, { recursive: true });
-    const target = join3(directory, fileName);
+    const target = join4(directory, fileName);
     const temporary = `${target}.${process.pid}.tmp`;
     await writeFile(temporary, content);
     await rename(temporary, target);
     const superseded = entriesForPath(directory, pathHash).filter((name) => name !== fileName);
     existingEntries?.set(pathHash, [fileName]);
-    await Promise.all(superseded.map((name) => Bun.file(join3(directory, name)).delete().catch(() => {
+    await Promise.all(superseded.map((name) => Bun.file(join4(directory, name)).delete().catch(() => {
       return;
     })));
   } catch {}
 }, writeBoth = async (clientOutputPath, serverOutputPath, content) => {
   await Promise.all([
-    mkdir(dirname2(clientOutputPath), { recursive: true }),
-    mkdir(dirname2(serverOutputPath), { recursive: true })
+    mkdir(dirname3(clientOutputPath), { recursive: true }),
+    mkdir(dirname3(serverOutputPath), { recursive: true })
   ]);
   await Promise.all([
     write(clientOutputPath, content),
@@ -835,11 +874,38 @@ var CACHE_DIR_NAME = "vue-helpers", CACHE_FORMAT_VERSION = 1, HASH_LENGTH = 24,
   ]);
 }, copyBoth = async (clientOutputPath, serverOutputPath, cachedPath) => {
   await Promise.all([
-    mkdir(dirname2(clientOutputPath), { recursive: true }),
-    mkdir(dirname2(serverOutputPath), { recursive: true })
+    mkdir(dirname3(clientOutputPath), { recursive: true }),
+    mkdir(dirname3(serverOutputPath), { recursive: true })
   ]);
   copyFileSync(cachedPath, clientOutputPath);
   copyFileSync(cachedPath, serverOutputPath);
+}, QUOTES, MIRRORED_MODULE, IMPORT_CANDIDATE_SUFFIXES, isFilePath = (path) => {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}, resolveImportTarget = (sourceDir, specifier) => {
+  const base = resolve3(sourceDir, specifier);
+  return IMPORT_CANDIDATE_SUFFIXES.map((suffix) => `${base}${suffix}`).find(isFilePath) ?? base;
+}, rewriteMirrorImports = (code, sourcePath) => {
+  const sourceDir = dirname3(sourcePath);
+  const rewrites = new Map;
+  for (const { path } of transpiler.scanImports(code)) {
+    if (!path.startsWith("./") && !path.startsWith("../"))
+      continue;
+    const target = resolveImportTarget(sourceDir, path);
+    if (!MIRRORED_MODULE.test(target))
+      continue;
+    const specifier = vueMirrorImport(sourcePath, path, target);
+    if (specifier !== path)
+      rewrites.set(path, specifier);
+  }
+  const replacements = Array.from(rewrites).flatMap(([written, mirrored]) => QUOTES.map((quote) => [
+    `${quote}${written}${quote}`,
+    `${quote}${mirrored}${quote}`
+  ]));
+  return replacements.reduce((rewritten, [written, mirrored]) => rewritten.replaceAll(written, mirrored), code);
 }, emitOne = async ({
   clientOutputPath,
   serverOutputPath,
@@ -849,12 +915,12 @@ var CACHE_DIR_NAME = "vue-helpers", CACHE_FORMAT_VERSION = 1, HASH_LENGTH = 24,
   const key = cacheKey(sourcePath, sourceCode);
   const directory = cacheDir();
   const fileName = key ? `${key.path}-${key.content}.js` : null;
-  const cachedPath = fileName ? join3(directory, fileName) : null;
+  const cachedPath = fileName ? join4(directory, fileName) : null;
   if (cachedPath && existsSync3(cachedPath)) {
     await copyBoth(clientOutputPath, serverOutputPath, cachedPath);
     return;
   }
-  const transpiledCode = transpiler.transformSync(sourceCode);
+  const transpiledCode = rewriteMirrorImports(transpiler.transformSync(sourceCode), sourcePath);
   const withMap = transpiledCode + inlineLineMapComment(sourcePath, sourceCode, transpiledCode);
   await writeBoth(clientOutputPath, serverOutputPath, withMap);
   if (key && fileName) {
@@ -869,7 +935,18 @@ var CACHE_DIR_NAME = "vue-helpers", CACHE_FORMAT_VERSION = 1, HASH_LENGTH = 24,
 var init_emitTsHelpers = __esm(() => {
   init_chainInlineSourcemaps();
   init_vueCompileCache();
+  init_vueModuleOutputPath();
   transpiler = new Transpiler({ loader: "ts", target: "browser" });
+  QUOTES = ['"', "'"];
+  MIRRORED_MODULE = /\.(?:[cm]?[jt]s|vue)$/;
+  IMPORT_CANDIDATE_SUFFIXES = [
+    "",
+    ".ts",
+    ".js",
+    ".mjs",
+    `${sep2}index.ts`,
+    `${sep2}index.js`
+  ];
 });
 
 // src/islands/sourceMetadata.ts
@@ -950,8 +1027,8 @@ var init_sourceMetadata = __esm(() => {
 });
 
 // src/utils/isFile.ts
-import { statSync } from "fs";
-var isFile = (path) => statSync(path, { throwIfNoEntry: false })?.isFile() ?? false;
+import { statSync as statSync2 } from "fs";
+var isFile = (path) => statSync2(path, { throwIfNoEntry: false })?.isFile() ?? false;
 var init_isFile = () => {};
 
 // src/utils/vueCompiler.ts
@@ -972,19 +1049,19 @@ var createVueCompiler = async () => {
 };
 
 // src/utils/runtimeMode.ts
-var ENV_VAR = "NODE_ENV", getNodeEnv = () => process.env[ENV_VAR];
+var ENV_VAR = "NODE_ENV", readEnv = () => typeof process === "undefined" ? undefined : process.env?.[ENV_VAR], getNodeEnv = () => readEnv();
 
 // src/build/stylePreprocessor.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import {
-  dirname as dirname3,
+  dirname as dirname4,
   extname,
-  isAbsolute,
-  join as join4,
-  relative,
-  resolve as resolve2
+  isAbsolute as isAbsolute2,
+  join as join5,
+  relative as relative2,
+  resolve as resolve4
 } from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "url";
 var CSS_EXTENSION_PATTERN, STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, importOptionalPeer, requireOptionalPeer, requireFromCwd, isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less|styl(?:us)?)$/i.test(filePath), getStyleLanguage = (filePathOrLanguage) => {
@@ -1020,9 +1097,9 @@ ${message}`);
     return requireOptionalPeer(specifier);
   }
 }, normalizeLoadPaths = (filePath, paths = []) => [
-  dirname3(filePath),
+  dirname4(filePath),
   process.cwd(),
-  ...paths.map((path) => resolve2(process.cwd(), path))
+  ...paths.map((path) => resolve4(process.cwd(), path))
 ], tsconfigAliasCache, stripJsonComments = (source) => source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1"), normalizeAliasEntries = (aliases) => Object.entries(aliases ?? {}).map(([pattern, value]) => ({
   pattern,
   replacements: Array.isArray(value) ? value : [value]
@@ -1030,7 +1107,7 @@ ${message}`);
   const cwd = process.cwd();
   if (tsconfigAliasCache?.cwd === cwd)
     return tsconfigAliasCache;
-  const tsconfigPath = resolve2(cwd, "tsconfig.json");
+  const tsconfigPath = resolve4(cwd, "tsconfig.json");
   const empty = { aliases: [], baseUrl: cwd, cwd };
   if (!existsSync4(tsconfigPath)) {
     tsconfigAliasCache = empty;
@@ -1039,7 +1116,7 @@ ${message}`);
   try {
     const parsed = JSON.parse(stripJsonComments(readFileSync4(tsconfigPath, "utf-8")));
     const compilerOptions = parsed.compilerOptions ?? {};
-    const baseUrl = resolve2(cwd, compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve4(cwd, compilerOptions.baseUrl ?? ".");
     tsconfigAliasCache = {
       aliases: normalizeAliasEntries(compilerOptions.paths),
       baseUrl,
@@ -1067,7 +1144,7 @@ ${message}`);
       continue;
     const wildcard = match[1] ?? "";
     for (const replacement of alias.replacements) {
-      targets.push(resolve2(baseUrl, replacement.replace("*", wildcard)));
+      targets.push(resolve4(baseUrl, replacement.replace("*", wildcard)));
     }
   }
   return targets;
@@ -1081,21 +1158,21 @@ ${message}`);
   const ext = extname(basePath);
   const paths = ext ? [basePath] : getLanguageExtensions(language).flatMap((extension) => [
     `${basePath}${extension}`,
-    join4(basePath, `index${extension}`)
+    join5(basePath, `index${extension}`)
   ]);
   if (language === "scss" || language === "sass") {
     return paths.flatMap((path) => {
-      const dir = dirname3(path);
+      const dir = dirname4(path);
       const base = path.slice(dir.length + 1);
-      return [path, join4(dir, `_${base}`)];
+      return [path, join5(dir, `_${base}`)];
     });
   }
   return paths;
 }, resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
   const rawCandidates = [
     ...resolveAliasTargets(specifier, config),
-    isAbsolute(specifier) ? specifier : resolve2(fromDirectory, specifier),
-    ...loadPaths.map((path) => resolve2(path, specifier))
+    isAbsolute2(specifier) ? specifier : resolve4(fromDirectory, specifier),
+    ...loadPaths.map((path) => resolve4(path, specifier))
   ];
   for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
     if (existsSync4(candidate))
@@ -1111,8 +1188,8 @@ ${message}`);
     path: url.slice(0, markerIndex)
   };
 }, rebaseCssUrls = (contents, sourceFile, entryFile) => {
-  const sourceDir = dirname3(sourceFile);
-  const entryDir = dirname3(entryFile);
+  const sourceDir = dirname4(sourceFile);
+  const entryDir = dirname4(entryFile);
   if (sourceDir === entryDir)
     return contents;
   return contents.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (match, quote, rawUrl) => {
@@ -1120,15 +1197,15 @@ ${message}`);
     if (!trimmedUrl || isExternalCssUrl(trimmedUrl))
       return match;
     const { marker, path } = splitCssUrl(trimmedUrl);
-    const rebased = relative(entryDir, resolve2(sourceDir, path)).replace(/\\/g, "/");
+    const rebased = relative2(entryDir, resolve4(sourceDir, path)).replace(/\\/g, "/");
     const normalized = rebased.startsWith(".") ? rebased : `./${rebased}`;
     const nextQuote = quote || '"';
     return `url(${nextQuote}${normalized}${marker}${nextQuote})`;
   });
 }, rewriteAliasedStyleImports = (contents, sourceFile, loadPaths, language, config) => contents.replace(/(@(?:use|forward|import|require)\s+)(["'])([^"']+)\2/g, (match, prefix, quote, specifier) => {
-  if (specifier.startsWith(".") || isAbsolute(specifier) || isExternalCssUrl(specifier))
+  if (specifier.startsWith(".") || isAbsolute2(specifier) || isExternalCssUrl(specifier))
     return match;
-  const resolved = resolveImportPath(specifier, dirname3(sourceFile), loadPaths, language, config);
+  const resolved = resolveImportPath(specifier, dirname4(sourceFile), loadPaths, language, config);
   return resolved ? `${prefix}${quote}${resolved}${quote}` : match;
 }), preprocessLoadedStyle = (contents, sourceFile, entryFile, loadPaths = [], language, config) => {
   const rebased = rebaseCssUrls(contents, sourceFile, entryFile);
@@ -1158,7 +1235,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   }
   return mod;
 }, loadPostcssConfigFile = async (configPath) => {
-  const resolved = resolve2(process.cwd(), configPath);
+  const resolved = resolve4(process.cwd(), configPath);
   const loaded = resolved.endsWith(".cjs") || resolved.endsWith(".cts") ? requireOptionalPeerSync(resolved) : await importOptionalPeer(`${new URL(`file://${resolved}`).href}?t=${Date.now()}`);
   const config = normalizePostcssModule(loaded);
   const value = typeof config === "function" ? await config({
@@ -1218,9 +1295,9 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   return result.css;
 }, createSassImporter = (entryFile, loadPaths, language, config, deps) => ({
   canonicalize(specifier, options) {
-    const fromDirectory = options.containingUrl ? dirname3(fileURLToPath(options.containingUrl)) : dirname3(entryFile);
+    const fromDirectory = options.containingUrl ? dirname4(fileURLToPath(options.containingUrl)) : dirname4(entryFile);
     const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
-    return resolved ? new URL(pathToFileURL2(resolve2(resolved)).href) : null;
+    return resolved ? new URL(pathToFileURL2(resolve4(resolved)).href) : null;
   },
   load(canonicalUrl) {
     const filePath = fileURLToPath(canonicalUrl);
@@ -1237,9 +1314,9 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   install(less, pluginManager) {
     const baseManager = new less.FileManager;
     const manager = Object.create(baseManager);
-    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve2(currentDirectory), loadPaths, "less", config));
+    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve4(currentDirectory), loadPaths, "less", config));
     manager.loadFile = async (filename, currentDirectory) => {
-      const resolved = resolveImportPath(filename, resolve2(currentDirectory), loadPaths, "less", config);
+      const resolved = resolveImportPath(filename, resolve4(currentDirectory), loadPaths, "less", config);
       if (!resolved) {
         throw new Error(`Unable to resolve Less import "${filename}"`);
       }
@@ -1276,17 +1353,17 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         const stylusDeps = renderer.deps?.();
         if (Array.isArray(stylusDeps)) {
           for (const dep of stylusDeps)
-            deps.add(resolve2(dep));
+            deps.add(resolve4(dep));
         }
       }
       resolveCss(css ?? "");
     });
   });
 }, styleDependencyGraph, styleOutputHashes, recordStyleDeps = (entry, deps) => {
-  const key = resolve2(entry);
+  const key = resolve4(entry);
   const stripped = new Set;
   for (const dep of deps) {
-    const resolved = resolve2(dep);
+    const resolved = resolve4(dep);
     if (resolved !== key)
       stripped.add(resolved);
   }
@@ -1314,7 +1391,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         loadPaths,
         style: "expanded",
         syntax: language === "sass" ? "indented" : "scss",
-        url: new URL(pathToFileURL2(resolve2(filePath)).href)
+        url: new URL(pathToFileURL2(resolve4(filePath)).href)
       });
       const css = await runPostcss(result.css, filePath, config);
       const loadedUrls = result.loadedUrls ?? [];
@@ -1322,7 +1399,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         if (url.protocol !== "file:")
           continue;
         const dep = fileURLToPath(url);
-        if (resolve2(dep) === resolve2(filePath))
+        if (resolve4(dep) === resolve4(filePath))
           continue;
         deps.add(dep);
       }
@@ -1423,7 +1500,7 @@ var init_stylePreprocessor = __esm(() => {
   STYLE_MODULE_EXTENSION_PATTERN = /\.module\.(s[ac]ss|less|styl(?:us)?)$/i;
   importOptionalPeer = new Function("specifier", "return import(specifier)");
   requireOptionalPeer = new Function("specifier", "return require(specifier)");
-  requireFromCwd = createRequire(join4(process.cwd(), "package.json"));
+  requireFromCwd = createRequire(join5(process.cwd(), "package.json"));
   styleDependencyGraph = new Map;
   styleOutputHashes = new Map;
   stylePreprocessorPlugin = createStylePreprocessorPlugin();
@@ -1431,7 +1508,7 @@ var init_stylePreprocessor = __esm(() => {
 
 // src/build/inlineCssImports.ts
 import { readFileSync as readFileSync5, realpathSync } from "fs";
-import { dirname as dirname4, resolve as resolve3 } from "path";
+import { dirname as dirname5, resolve as resolve5 } from "path";
 var inlineCssImports = (cssContent, cssFilePath, visited = new Set) => {
   const resolved = realpathSync(cssFilePath);
   if (visited.has(resolved))
@@ -1439,7 +1516,7 @@ var inlineCssImports = (cssContent, cssFilePath, visited = new Set) => {
   visited.add(resolved);
   const importRegex = /@import\s+(?:url\(\s*)?(['"])(\.{1,2}\/[^'"]+)\1\s*\)?\s*;?/g;
   return cssContent.replace(importRegex, (match, _quote, relPath) => {
-    const importedPath = resolve3(dirname4(cssFilePath), relPath);
+    const importedPath = resolve5(dirname5(cssFilePath), relPath);
     if (!isFile(importedPath))
       return match;
     const importedContent = readFileSync5(importedPath, "utf-8");
@@ -1452,7 +1529,7 @@ var init_inlineCssImports = __esm(() => {
 
 // src/build/compileVueSfc.ts
 import { existsSync as existsSync5, readFileSync as readFileSync6, realpathSync as realpathSync2 } from "fs";
-import { dirname as dirname5, relative as relative2, resolve as resolve4 } from "path";
+import { dirname as dirname6, join as join6, relative as relative3, resolve as resolve6 } from "path";
 var {Transpiler: Transpiler2 } = globalThis.Bun;
 var transpiler2, toJs = (filePath, sourceDir) => {
   if (filePath.endsWith(".vue"))
@@ -1461,15 +1538,15 @@ var transpiler2, toJs = (filePath, sourceDir) => {
     return filePath.replace(/\.ts$/, ".js");
   if (isStylePath(filePath)) {
     if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-      return resolve4(sourceDir, filePath);
+      return resolve6(sourceDir, filePath);
     }
     return filePath;
   }
   if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-    const directTs = resolve4(sourceDir, `${filePath}.ts`);
+    const directTs = resolve6(sourceDir, `${filePath}.ts`);
     if (existsSync5(directTs))
       return `${filePath}.js`;
-    const indexedTs = resolve4(sourceDir, filePath, "index.ts");
+    const indexedTs = resolve6(sourceDir, filePath, "index.ts");
     if (existsSync5(indexedTs))
       return `${filePath}/index.js`;
   }
@@ -1517,7 +1594,7 @@ const ${localName} = (source) => ${importedName}(
     : { ...source, loader: () => __absoluteResolveAsyncVueComponent(source.loader) },
 );`;
   return code.replace(vueImportRegex, `import { ${specifiers.join(", ")} } from 'vue';${wrapper}`);
-}, rewriteRelativeImports = (code, sourceDir) => code.replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toJs(relativeImport, sourceDir)}${quoteEnd}`), compileVueSfc = async ({
+}, toOutputImport = (specifier, sourceDir) => specifier.startsWith("./") || specifier.startsWith("../") ? vueMirrorImport(join6(sourceDir, "__importer__"), specifier, resolve6(sourceDir, specifier)) : specifier, rewriteRelativeImports = (code, sourceDir) => code.replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toOutputImport(toJs(relativeImport, sourceDir), sourceDir)}${quoteEnd}`), compileVueSfc = async ({
   clientOutputPath,
   componentId,
   hmrId,
@@ -1557,7 +1634,7 @@ const ${localName} = (source) => ${importedName}(
     typeDepHashes[dep] = hashContent(readFileSync6(dep, "utf-8"));
   }
   const strippedScript = stripExports(compiledScript.content);
-  const sourceDir = dirname5(sourceFilePath);
+  const sourceDir = dirname6(sourceFilePath);
   const transpiledScript = rewriteRelativeImports(transpiler2.transformSync(strippedScript), sourceDir);
   const generateRenderFunction = (ssr) => {
     const rendered = compiler.compileTemplate({
@@ -1612,7 +1689,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     let result = code;
     for (const [bareImport, paths] of packageImportRewrites) {
       const targetPath = mode === "server" ? paths.server : paths.client;
-      let rel = relative2(dirname5(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative3(dirname6(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result = result.replaceAll(bareImport, rel);
@@ -1648,6 +1725,7 @@ var init_compileVueSfc = __esm(() => {
   init_stylePreprocessor();
   init_inlineCssImports();
   init_vueCompileCache();
+  init_vueModuleOutputPath();
   transpiler2 = new Transpiler2({ loader: "ts", target: "browser" });
 });