@absolutejs/absolute 0.19.0-beta.1022 → 0.19.0-beta.1024

package/dist/islands/index.js

@@ -342,9 +342,12 @@ var initDominoAdapter = (platformServer) => {
   return {
     APP_BASE_HREF: common.APP_BASE_HREF,
     bootstrapApplication: platformBrowser.bootstrapApplication,
+    Component: core.Component,
     DomSanitizer: platformBrowser.DomSanitizer,
     ENVIRONMENT_INITIALIZER: core.ENVIRONMENT_INITIALIZER,
     inject: core.inject,
+    InjectionToken: core.InjectionToken,
+    NgComponentOutlet: common.NgComponentOutlet,
     provideClientHydration: platformBrowser.provideClientHydration,
     provideServerRendering: platformServer.provideServerRendering,
     provideZonelessChangeDetection: core.provideZonelessChangeDetection,
@@ -600,9 +603,8 @@ var angularIslandSelector = "abs-angular-island", isAngularComponent = (value) =
   const componentName = typeof component.name === "string" && component.name.length > 0 ? component.name : "AngularIsland";
   return `${componentName}:${JSON.stringify(props)}`;
 }, buildAngularIslandWrapperMetadata = async (component, islandId, wrapperKey) => {
-  const { Component, InjectionToken, inject } = await import("@angular/core");
-  const { NgComponentOutlet } = await import("@angular/common");
   const deps = await getAngularDeps();
+  const { Component, InjectionToken, NgComponentOutlet, inject } = deps;
   const selector = getAngularIslandSelector(islandId);
   const propsToken = new InjectionToken(`${wrapperKey}:props`);
 
@@ -708,7 +710,15 @@ var init_islands2 = __esm(() => {
 var renderAngularIslandToHtmlInternal = async (component, props, islandId) => {
   const { renderAngularIslandToHtml: renderAngularIslandToHtml2 } = await Promise.resolve().then(() => (init_islands2(), exports_islands));
   return renderAngularIslandToHtml2(component, props, islandId);
-}, renderAngularIslandToHtml2, renderReactIslandToHtml = (component, props) => import("react").then(({ createElement }) => import("react-dom/server").then(({ renderToStaticMarkup }) => renderToStaticMarkup(createElement(component, props)))), renderSvelteIslandToHtml = (component, props) => import("svelte/server").then(({ render }) => {
+}, renderAngularIslandToHtml2, LEADING_HOISTED_RESOURCE_RE, stripLeadingHoistedResources = (html) => {
+  let result = html;
+  let match = LEADING_HOISTED_RESOURCE_RE.exec(result);
+  while (match) {
+    result = result.slice(match[0].length);
+    match = LEADING_HOISTED_RESOURCE_RE.exec(result);
+  }
+  return result.trimStart();
+}, renderReactIslandToHtml = (component, props) => import("react").then(({ createElement }) => import("react-dom/server").then(({ renderToString }) => stripLeadingHoistedResources(renderToString(createElement(component, props))))), renderSvelteIslandToHtml = (component, props) => import("svelte/server").then(({ render }) => {
   const { body } = render(component, { props });
   return body;
 }), renderVueIslandToHtml = (component, props) => import("vue").then(({ createSSRApp, h: createVueVNode }) => {
@@ -719,10 +729,311 @@ var renderAngularIslandToHtmlInternal = async (component, props, islandId) => {
 });
 var init_islandSsr = __esm(() => {
   renderAngularIslandToHtml2 = renderAngularIslandToHtmlInternal;
+  LEADING_HOISTED_RESOURCE_RE = /^\s*(?:<link\b[^>]*\/?>|<meta\b[^>]*\/?>|<title\b[^>]*>[\s\S]*?<\/title>|<style\b[^>]*>[\s\S]*?<\/style>|<script\b[^>]*>[\s\S]*?<\/script>)/i;
+});
+
+// src/build/nativeRewrite.ts
+import { dlopen, FFIType, ptr } from "bun:ffi";
+import { platform, arch } from "os";
+import { resolve as resolve2 } from "path";
+var ffiDefinition, nativeLib = null, loadNative = () => {
+  if (nativeLib !== null)
+    return nativeLib;
+  const osPlatform = platform();
+  const cpu = arch();
+  const platformMap = {
+    "darwin-arm64": "darwin-arm64/fast_ops.dylib",
+    "darwin-x64": "darwin-x64/fast_ops.dylib",
+    "linux-arm64": "linux-arm64/fast_ops.so",
+    "linux-x64": "linux-x64/fast_ops.so",
+    "win32-arm64": "windows-arm64/fast_ops.dll",
+    "win32-x64": "windows-x64/fast_ops.dll"
+  };
+  const libPath = platformMap[`${osPlatform}-${cpu}`];
+  if (!libPath)
+    return null;
+  try {
+    const fullPath = resolve2(import.meta.dir, "../../native/packages", libPath);
+    const lib = dlopen(fullPath, ffiDefinition);
+    nativeLib = lib.symbols;
+    return nativeLib;
+  } catch {
+    return null;
+  }
+}, nativeRewriteImports = (content, replacements) => {
+  const lib = loadNative();
+  if (!lib)
+    return null;
+  const jsonStr = JSON.stringify(replacements);
+  const contentBuf = Buffer.from(content);
+  const jsonBuf = Buffer.from(jsonStr);
+  const outBuf = Buffer.alloc(content.length * 2);
+  const outLenBuf = new BigUint64Array([BigInt(outBuf.length)]);
+  const result = lib.rewrite_imports(ptr(contentBuf), contentBuf.length, ptr(jsonBuf), jsonBuf.length, ptr(outBuf), ptr(new Uint8Array(outLenBuf.buffer)));
+  if (result < 0)
+    return null;
+  if (result === 0)
+    return content;
+  const outLen = Number(outLenBuf[0]);
+  return outBuf.subarray(0, outLen).toString("utf-8");
+};
+var init_nativeRewrite = __esm(() => {
+  ffiDefinition = {
+    rewrite_imports: {
+      args: [
+        FFIType.ptr,
+        FFIType.u64,
+        FFIType.ptr,
+        FFIType.u64,
+        FFIType.ptr,
+        FFIType.ptr
+      ],
+      returns: FFIType.i32
+    }
+  };
+});
+
+// src/build/rewriteImportsPlugin.ts
+var exports_rewriteImportsPlugin = {};
+__export(exports_rewriteImportsPlugin, {
+  rewriteVendorDirectories: () => rewriteVendorDirectories,
+  rewriteImportsInContent: () => rewriteImportsInContent,
+  rewriteBuildOutputsWith: () => rewriteBuildOutputsWith,
+  rewriteBuildOutputs: () => rewriteBuildOutputs,
+  jsRewriteImports: () => jsRewriteImports,
+  fixMissingReExportNamespacesInContent: () => fixMissingReExportNamespacesInContent,
+  buildWithImportRewrite: () => buildWithImportRewrite
+});
+import { readdir } from "fs/promises";
+import { join as join2 } from "path";
+var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
+  let result = content;
+  for (const [specifier, webPath] of replacements) {
+    const escaped = escapeRegex(specifier);
+    const fromRegex = new RegExp(`(from\\s*["'])${escaped}(["'])`, "g");
+    const sideEffectRegex = new RegExp(`(import\\s*["'])${escaped}(["'])`, "g");
+    const dynamicRegex = new RegExp(`(import\\s*\\(\\s*["'])${escaped}(["']\\s*\\))`, "g");
+    result = result.replace(fromRegex, `$1${webPath}$2`);
+    result = result.replace(sideEffectRegex, `$1${webPath}$2`);
+    result = result.replace(dynamicRegex, `$1${webPath}$2`);
+  }
+  return result;
+}, rewriteImportsInContent = (content, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return content;
+  const replacements = Object.entries(vendorPaths).sort(([keyA], [keyB]) => keyB.length - keyA.length);
+  const native = nativeRewriteImports(content, replacements);
+  return native ?? jsRewriteImports(content, replacements);
+}, fixMissingReExportNamespacesInContent = (content) => {
+  const REEXPORT_PATTERN = /__reExport\(\s*[A-Za-z_$][\w$]*\s*,\s*([A-Za-z_$][\w$]*)\s*\)/g;
+  REEXPORT_PATTERN.lastIndex = 0;
+  const missing = [];
+  let match;
+  while ((match = REEXPORT_PATTERN.exec(content)) !== null) {
+    const ident = match[1];
+    if (!ident)
+      continue;
+    const nsImportRe = new RegExp(`\\bimport\\s*\\*\\s*as\\s+${ident}\\s+from\\b`);
+    if (nsImportRe.test(content))
+      continue;
+    const declRe = new RegExp(`\\b(?:const|let|var|function|class)\\s+${ident}\\b`);
+    if (declRe.test(content))
+      continue;
+    const namedImportRe = new RegExp(`\\bimport\\s*\\{[^}]*\\b${ident}\\b[^}]*\\}\\s*from\\b`);
+    if (namedImportRe.test(content))
+      continue;
+    const importPathRe = /(?:from\s+|import\s*)["']([^"']+)["']/g;
+    let pathMatch;
+    let sourcePath;
+    while ((pathMatch = importPathRe.exec(content)) !== null) {
+      const p = pathMatch[1];
+      if (!p)
+        continue;
+      const base = p.split("/").pop()?.replace(/\.[mc]?js$/, "");
+      if (!base)
+        continue;
+      const normalized = base.startsWith("_") ? base.slice(1) : base;
+      if (normalized === ident || normalized.endsWith(`_${ident}`)) {
+        sourcePath = p;
+        break;
+      }
+    }
+    if (sourcePath)
+      missing.push({ ident, path: sourcePath });
+  }
+  if (missing.length === 0)
+    return content;
+  const seen = new Set;
+  const unique = missing.filter((entry) => {
+    if (seen.has(entry.ident))
+      return false;
+    seen.add(entry.ident);
+    return true;
+  });
+  const inserts = unique.map((entry) => `import * as ${entry.ident} from "${entry.path}";`).join(`
+`);
+  return `${inserts}
+${content}`;
+}, isReadableArtifact = (artifact) => artifact.path.endsWith(".js"), rewriteBuildOutputs = async (outputs, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return;
+  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
+    let original;
+    try {
+      original = await artifact.text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(artifact.path, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, rewriteBuildOutputsWith = async (outputs, resolveVendorPaths) => {
+  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
+    const vendorPaths = resolveVendorPaths(artifact);
+    if (Object.keys(vendorPaths).length === 0)
+      return;
+    let original;
+    try {
+      original = await artifact.text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(artifact.path, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, rewriteVendorDirectories = async (vendorDirs, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return;
+  const allFiles = [];
+  for (const dir of vendorDirs) {
+    try {
+      const entries = await readdir(dir);
+      for (const entry of entries) {
+        if (entry.endsWith(".js"))
+          allFiles.push(join2(dir, entry));
+      }
+    } catch {}
+  }
+  await Promise.all(allFiles.map(async (filePath) => {
+    let original;
+    try {
+      original = await Bun.file(filePath).text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    let next = rewriteImportsInContent(original, vendorPaths);
+    next = fixMissingReExportNamespacesInContent(next);
+    if (next === original)
+      return;
+    try {
+      await Bun.write(filePath, next);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, buildWithImportRewrite = async (pendingBuild, vendorPaths) => {
+  const result = await pendingBuild;
+  if (result.outputs.length > 0) {
+    await rewriteBuildOutputs(result.outputs, vendorPaths);
+  }
+  return result;
+};
+var init_rewriteImportsPlugin = __esm(() => {
+  init_nativeRewrite();
+});
+
+// src/core/angularServerModule.ts
+import { mkdir } from "fs/promises";
+import { dirname, join as join3, relative } from "path";
+var serverCacheRoot, compiledModuleCache, ANGULAR_SPECIFIER_RE, getCachedModulePath = (sourcePath) => {
+  const relativeSourcePath = relative(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
+  return join3(serverCacheRoot, `${normalizedSourcePath}.server.js`);
+}, collectVendorPaths = (code) => {
+  const vendorPaths = {};
+  if (!isProductionRuntime()) {
+    return vendorPaths;
+  }
+  const specifiers = new Set([...code.matchAll(ANGULAR_SPECIFIER_RE)].map((match) => match[1]));
+  specifiers.forEach((specifier) => {
+    if (!specifier)
+      return;
+    const resolved = resolveAngularRuntimePath(specifier);
+    if (resolved === specifier)
+      return;
+    vendorPaths[specifier] = resolved;
+  });
+  return vendorPaths;
+}, buildAngularServerModule = async (sourcePath) => {
+  const result = await Bun.build({
+    entrypoints: [sourcePath],
+    format: "esm",
+    packages: "external",
+    target: "bun",
+    throw: false
+  });
+  const entry = result.outputs.find((output) => output.kind === "entry-point");
+  if (!result.success || !entry) {
+    const message = result.logs.map((log) => String(log)).join(`
+`);
+    throw new Error(`Failed to compile Angular island server module for "${sourcePath}":
+${message}`);
+  }
+  const code = await entry.text();
+  const rewritten = rewriteImportsInContent(code, collectVendorPaths(code));
+  const modulePath = getCachedModulePath(sourcePath);
+  await mkdir(dirname(modulePath), { recursive: true });
+  await Bun.write(modulePath, rewritten);
+  return modulePath;
+}, compileAngularServerModule = (sourcePath) => {
+  const cached = compiledModuleCache.get(sourcePath);
+  if (cached) {
+    return cached;
+  }
+  const compiledModulePromise = buildAngularServerModule(sourcePath);
+  compiledModuleCache.set(sourcePath, compiledModulePromise);
+  return compiledModulePromise;
+};
+var init_angularServerModule = __esm(() => {
+  init_resolveAngularPackage();
+  init_rewriteImportsPlugin();
+  serverCacheRoot = join3(process.cwd(), ".absolutejs", "islands", "angular");
+  compiledModuleCache = new Map;
+  ANGULAR_SPECIFIER_RE = /["'](@angular\/[^"']+)["']/g;
 });
 
 // src/build/resolvePackageImport.ts
-import { resolve as resolve2, join as join2 } from "path";
+import { resolve as resolve3, join as join4 } from "path";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 var resolveExportPath = (entry, conditions) => {
   if (typeof entry === "string")
@@ -744,11 +1055,11 @@ var resolveExportPath = (entry, conditions) => {
   const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
   const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
   const exportKey = subpath ? `./${subpath}` : ".";
-  const currentPackageJsonPath = resolve2(process.cwd(), "package.json");
+  const currentPackageJsonPath = resolve3(process.cwd(), "package.json");
   const currentPackageJson = existsSync2(currentPackageJsonPath) ? JSON.parse(readFileSync2(currentPackageJsonPath, "utf-8")) : null;
   const currentPackageDir = currentPackageJson?.name === packageName ? process.cwd() : null;
-  const packageDir = currentPackageDir ?? resolve2(process.cwd(), "node_modules", packageName ?? "");
-  const packageJsonPath = join2(packageDir, "package.json");
+  const packageDir = currentPackageDir ?? resolve3(process.cwd(), "node_modules", packageName ?? "");
+  const packageJsonPath = join4(packageDir, "package.json");
   if (!existsSync2(packageJsonPath))
     return null;
   try {
@@ -763,12 +1074,12 @@ var resolveExportPath = (entry, conditions) => {
     if (!importPath)
       return null;
     if (currentPackageDir && importPath.startsWith("./dist/")) {
-      const sourceCandidate = resolve2(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
+      const sourceCandidate = resolve3(packageDir, importPath.replace(/^\.\/dist\//, "./src/"));
       if (existsSync2(sourceCandidate)) {
         return sourceCandidate;
       }
     }
-    const resolved = resolve2(packageDir, importPath);
+    const resolved = resolve3(packageDir, importPath);
     return existsSync2(resolved) ? resolved : null;
   } catch {
     return null;
@@ -944,12 +1255,12 @@ import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import {
-  dirname,
+  dirname as dirname2,
   extname,
   isAbsolute,
-  join as join3,
-  relative,
-  resolve as resolve3
+  join as join5,
+  relative as relative2,
+  resolve as resolve4
 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 var CSS_EXTENSION_PATTERN, STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, requireOptionalPeer, requireFromCwd, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less|styl(?:us)?)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less|styl(?:us)?)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
@@ -985,9 +1296,9 @@ ${message}`);
     return requireOptionalPeer(specifier);
   }
 }, normalizeLoadPaths = (filePath, paths = []) => [
-  dirname(filePath),
+  dirname2(filePath),
   process.cwd(),
-  ...paths.map((path) => resolve3(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]
@@ -995,7 +1306,7 @@ ${message}`);
   const cwd = process.cwd();
   if (tsconfigAliasCache?.cwd === cwd)
     return tsconfigAliasCache;
-  const tsconfigPath = resolve3(cwd, "tsconfig.json");
+  const tsconfigPath = resolve4(cwd, "tsconfig.json");
   const empty = { aliases: [], baseUrl: cwd, cwd };
   if (!existsSync3(tsconfigPath)) {
     tsconfigAliasCache = empty;
@@ -1004,7 +1315,7 @@ ${message}`);
   try {
     const parsed = JSON.parse(stripJsonComments(readFileSync3(tsconfigPath, "utf-8")));
     const compilerOptions = parsed.compilerOptions ?? {};
-    const baseUrl = resolve3(cwd, compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve4(cwd, compilerOptions.baseUrl ?? ".");
     tsconfigAliasCache = {
       aliases: normalizeAliasEntries(compilerOptions.paths),
       baseUrl,
@@ -1032,7 +1343,7 @@ ${message}`);
       continue;
     const wildcard = match[1] ?? "";
     for (const replacement of alias.replacements) {
-      targets.push(resolve3(baseUrl, replacement.replace("*", wildcard)));
+      targets.push(resolve4(baseUrl, replacement.replace("*", wildcard)));
     }
   }
   return targets;
@@ -1046,21 +1357,21 @@ ${message}`);
   const ext = extname(basePath);
   const paths = ext ? [basePath] : getLanguageExtensions(language).flatMap((extension) => [
     `${basePath}${extension}`,
-    join3(basePath, `index${extension}`)
+    join5(basePath, `index${extension}`)
   ]);
   if (language === "scss" || language === "sass") {
     return paths.flatMap((path) => {
-      const dir = dirname(path);
+      const dir = dirname2(path);
       const base = path.slice(dir.length + 1);
-      return [path, join3(dir, `_${base}`)];
+      return [path, join5(dir, `_${base}`)];
     });
   }
   return paths;
 }, resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
   const rawCandidates = [
     ...resolveAliasTargets(specifier, config),
-    isAbsolute(specifier) ? specifier : resolve3(fromDirectory, specifier),
-    ...loadPaths.map((path) => resolve3(path, specifier))
+    isAbsolute(specifier) ? specifier : resolve4(fromDirectory, specifier),
+    ...loadPaths.map((path) => resolve4(path, specifier))
   ];
   for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
     if (existsSync3(candidate))
@@ -1076,8 +1387,8 @@ ${message}`);
     path: url.slice(0, markerIndex)
   };
 }, rebaseCssUrls = (contents, sourceFile, entryFile) => {
-  const sourceDir = dirname(sourceFile);
-  const entryDir = dirname(entryFile);
+  const sourceDir = dirname2(sourceFile);
+  const entryDir = dirname2(entryFile);
   if (sourceDir === entryDir)
     return contents;
   return contents.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (match, quote, rawUrl) => {
@@ -1085,7 +1396,7 @@ ${message}`);
     if (!trimmedUrl || isExternalCssUrl(trimmedUrl))
       return match;
     const { marker, path } = splitCssUrl(trimmedUrl);
-    const rebased = relative(entryDir, resolve3(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})`;
@@ -1093,7 +1404,7 @@ ${message}`);
 }, 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))
     return match;
-  const resolved = resolveImportPath(specifier, dirname(sourceFile), loadPaths, language, config);
+  const resolved = resolveImportPath(specifier, dirname2(sourceFile), loadPaths, language, config);
   return resolved ? `${prefix}${quote}${resolved}${quote}` : match;
 }), preprocessLoadedStyle = (contents, sourceFile, entryFile, loadPaths = [], language, config) => {
   const rebased = rebaseCssUrls(contents, sourceFile, entryFile);
@@ -1123,7 +1434,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   }
   return mod;
 }, loadPostcssConfigFile = async (configPath) => {
-  const resolved = resolve3(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({
@@ -1183,9 +1494,9 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   return result.css;
 }, createSassImporter = (entryFile, loadPaths, language, config, deps) => ({
   canonicalize(specifier, options) {
-    const fromDirectory = options.containingUrl ? dirname(fileURLToPath(options.containingUrl)) : dirname(entryFile);
+    const fromDirectory = options.containingUrl ? dirname2(fileURLToPath(options.containingUrl)) : dirname2(entryFile);
     const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
-    return resolved ? new URL(pathToFileURL(resolve3(resolved)).href) : null;
+    return resolved ? new URL(pathToFileURL(resolve4(resolved)).href) : null;
   },
   load(canonicalUrl) {
     const filePath = fileURLToPath(canonicalUrl);
@@ -1202,9 +1513,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, resolve3(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, resolve3(currentDirectory), loadPaths, "less", config);
+      const resolved = resolveImportPath(filename, resolve4(currentDirectory), loadPaths, "less", config);
       if (!resolved) {
         throw new Error(`Unable to resolve Less import "${filename}"`);
       }
@@ -1241,29 +1552,29 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         const stylusDeps = renderer.deps?.();
         if (Array.isArray(stylusDeps)) {
           for (const dep of stylusDeps)
-            deps.add(resolve3(dep));
+            deps.add(resolve4(dep));
         }
       }
       resolveCss(css ?? "");
     });
   });
 }, styleDependencyGraph, styleOutputHashes, recordStyleDeps = (entry, deps) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   const stripped = new Set;
   for (const dep of deps) {
-    const resolved = resolve3(dep);
+    const resolved = resolve4(dep);
     if (resolved !== key)
       stripped.add(resolved);
   }
   styleDependencyGraph.set(key, stripped);
 }, addStyleImporter = (importerPath, stylePath) => {
-  const key = resolve3(importerPath);
-  const target = resolve3(stylePath);
+  const key = resolve4(importerPath);
+  const target = resolve4(stylePath);
   const deps = styleDependencyGraph.get(key) ?? new Set;
   deps.add(target);
   styleDependencyGraph.set(key, deps);
 }, findStyleEntriesImporting = (changedPath) => {
-  const target = resolve3(changedPath);
+  const target = resolve4(changedPath);
   const importers = [];
   for (const [entry, deps] of styleDependencyGraph) {
     if (deps.has(target))
@@ -1271,13 +1582,13 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   }
   return importers;
 }, recordStyleOutput = (entry, css) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   const hash = createHash("sha1").update(css).digest("hex");
   const previous = styleOutputHashes.get(key);
   styleOutputHashes.set(key, hash);
   return previous !== hash;
 }, forgetStyleEntry = (entry) => {
-  const key = resolve3(entry);
+  const key = resolve4(entry);
   styleDependencyGraph.delete(key);
   styleOutputHashes.delete(key);
 }, compileStyleSource = async (filePath, source, languageHint, config) => {
@@ -1303,7 +1614,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         loadPaths,
         style: "expanded",
         syntax: language === "sass" ? "indented" : "scss",
-        url: new URL(pathToFileURL(resolve3(filePath)).href)
+        url: new URL(pathToFileURL(resolve4(filePath)).href)
       });
       const css = await runPostcss(result.css, filePath, config);
       const loadedUrls = result.loadedUrls ?? [];
@@ -1311,7 +1622,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
         if (url.protocol !== "file:")
           continue;
         const dep = fileURLToPath(url);
-        if (resolve3(dep) === resolve3(filePath))
+        if (resolve4(dep) === resolve4(filePath))
           continue;
         deps.add(dep);
       }
@@ -1432,7 +1743,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     const start = match.index ?? 0;
     const end = start + match[0].length;
     parts.push(content.slice(cursor, start));
-    const fullPath = isAbsolute(importPath) ? importPath : resolve3(baseDir, importPath);
+    const fullPath = isAbsolute(importPath) ? importPath : resolve4(baseDir, importPath);
     if (visited.has(fullPath) || !existsSync3(fullPath)) {
       parts.push(visited.has(fullPath) ? "" : match[0]);
       cursor = end;
@@ -1441,7 +1752,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     const nextVisited = new Set(visited);
     nextVisited.add(fullPath);
     const imported = await readFile(fullPath, "utf-8");
-    parts.push(await resolveCssImportsAsync(imported, dirname(fullPath), nextVisited));
+    parts.push(await resolveCssImportsAsync(imported, dirname2(fullPath), nextVisited));
     cursor = end;
   }
   parts.push(content.slice(cursor));
@@ -1450,13 +1761,13 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   if (!isPreprocessableStylePath(filePath)) {
     const raw = await readFile(filePath, "utf-8");
     const processed = await runPostcss(raw, filePath, config);
-    return resolveCssImportsAsync(processed, dirname(filePath), new Set([filePath]));
+    return resolveCssImportsAsync(processed, dirname2(filePath), new Set([filePath]));
   }
   const compiled = await compileStyleSource(filePath, undefined, undefined, config);
-  return resolveCssImportsAsync(compiled, dirname(filePath), new Set([filePath]));
+  return resolveCssImportsAsync(compiled, dirname2(filePath), new Set([filePath]));
 }, resolveCssImportsSync = (content, baseDir, visited) => {
   return content.replace(CSS_IMPORT_PATTERN, (match, importPath) => {
-    const fullPath = isAbsolute(importPath) ? importPath : resolve3(baseDir, importPath);
+    const fullPath = isAbsolute(importPath) ? importPath : resolve4(baseDir, importPath);
     if (visited.has(fullPath))
       return "";
     if (!existsSync3(fullPath))
@@ -1464,7 +1775,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     const nextVisited = new Set(visited);
     nextVisited.add(fullPath);
     const imported = readFileSync3(fullPath, "utf-8");
-    return resolveCssImportsSync(imported, dirname(fullPath), nextVisited);
+    return resolveCssImportsSync(imported, dirname2(fullPath), nextVisited);
   });
 }, compileStyleFileIfNeededSync = (filePath, config) => {
   const rawContents = readFileSync3(filePath, "utf-8");
@@ -1490,18 +1801,18 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
       loadPaths,
       style: "expanded",
       syntax: language === "sass" ? "indented" : "scss",
-      url: new URL(pathToFileURL(resolve3(filePath)).href)
+      url: new URL(pathToFileURL(resolve4(filePath)).href)
     });
     const loadedUrls = result.loadedUrls ?? [];
     for (const url of loadedUrls) {
       if (url.protocol !== "file:")
         continue;
       const dep = fileURLToPath(url);
-      if (resolve3(dep) === resolve3(filePath))
+      if (resolve4(dep) === resolve4(filePath))
         continue;
       addStyleImporter(filePath, dep);
     }
-    return resolveCssImportsSync(result.css, dirname(filePath), new Set([filePath]));
+    return resolveCssImportsSync(result.css, dirname2(filePath), new Set([filePath]));
   }
   if (language === "less") {
     throw new Error(`Unable to compile ${filePath}: Less styleUrl preprocessing is async-only. Import the Less file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
@@ -1509,7 +1820,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   if (language === "stylus") {
     throw new Error(`Unable to compile ${filePath}: Stylus styleUrl preprocessing is async-only. Import the Stylus file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
   }
-  return resolveCssImportsSync(rawContents, dirname(filePath), new Set([filePath]));
+  return resolveCssImportsSync(rawContents, dirname2(filePath), new Set([filePath]));
 }, getCssOutputExtension = (filePath) => isPreprocessableStylePath(filePath) ? ".css" : extname(filePath);
 var init_stylePreprocessor = __esm(() => {
   CSS_EXTENSION_PATTERN = /\.css$/i;
@@ -1518,7 +1829,7 @@ var init_stylePreprocessor = __esm(() => {
   STYLE_LANGUAGE_PATTERN = /^(s[ac]ss|less|styl(?:us)?)$/i;
   importOptionalPeer = new Function("specifier", "return import(specifier)");
   requireOptionalPeer = new Function("specifier", "return require(specifier)");
-  requireFromCwd = createRequire(join3(process.cwd(), "package.json"));
+  requireFromCwd = createRequire(join5(process.cwd(), "package.json"));
   styleDependencyGraph = new Map;
   styleOutputHashes = new Map;
   stylePreprocessorPlugin = createStylePreprocessorPlugin();
@@ -1526,14 +1837,14 @@ var init_stylePreprocessor = __esm(() => {
 });
 
 // src/core/svelteServerModule.ts
-import { mkdir, readdir } from "fs/promises";
-import { basename, dirname as dirname2, extname as extname2, join as join4, relative as relative2, resolve as resolve4 } from "path";
-var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
-  const importPath = relative2(dirname2(from), target).replace(/\\/g, "/");
+import { mkdir as mkdir2, readdir as readdir2 } from "fs/promises";
+import { basename, dirname as dirname3, extname as extname2, join as join6, relative as relative3, resolve as resolve5 } from "path";
+var serverCacheRoot2, compiledModuleCache2, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
+  const importPath = relative3(dirname3(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
   for (const entry of entries) {
-    const entryPath = join4(dir, entry.name);
+    const entryPath = join6(dir, entry.name);
     if (entry.isDirectory())
       stack.push(entryPath);
     if (entry.isFile() && entry.name === targetFileName) {
@@ -1547,7 +1858,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   const nextStack = [];
   const dirEntries = await Promise.all(dirs.map(async (dir) => ({
     dir,
-    entries: await readdir(dir, {
+    entries: await readdir2(dir, {
       encoding: "utf-8",
       withFileTypes: true
     })
@@ -1563,11 +1874,11 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (cachedPath !== undefined) {
     return cachedPath;
   }
-  if (!sourcePath.includes(`${join4(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
+  if (!sourcePath.includes(`${join6(process.cwd(), "build")}${process.platform === "win32" ? "" : "/"}`) && !sourcePath.includes("/build/")) {
     originalSourcePathCache.set(sourcePath, sourcePath);
     return sourcePath;
   }
-  const resolvedSourcePath = await findSourceFileByBasename(join4(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
+  const resolvedSourcePath = await findSourceFileByBasename(join6(process.cwd(), "src"), normalizeBuiltSvelteFileName(sourcePath));
   const nextPath = resolvedSourcePath ?? sourcePath;
   originalSourcePathCache.set(sourcePath, nextPath);
   return nextPath;
@@ -1575,7 +1886,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const basePath = resolve4(dirname2(from), spec);
+  const basePath = resolve5(dirname3(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -1583,19 +1894,19 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     `${basePath}.mjs`,
     `${basePath}.cjs`,
     `${basePath}.json`,
-    join4(basePath, "index.ts"),
-    join4(basePath, "index.js"),
-    join4(basePath, "index.mjs"),
-    join4(basePath, "index.cjs"),
-    join4(basePath, "index.json")
+    join6(basePath, "index.ts"),
+    join6(basePath, "index.js"),
+    join6(basePath, "index.mjs"),
+    join6(basePath, "index.cjs"),
+    join6(basePath, "index.json")
   ];
   const existResults = await Promise.all(candidates.map((candidate) => Bun.file(candidate).exists()));
   const foundIndex = existResults.indexOf(true);
   return foundIndex >= 0 ? candidates[foundIndex] ?? null : null;
-}, getCachedModulePath = (sourcePath) => {
-  const relativeSourcePath = relative2(process.cwd(), sourcePath).replace(/\\/g, "/");
+}, getCachedModulePath2 = (sourcePath) => {
+  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join4(serverCacheRoot, `${normalizedSourcePath}.server.js`);
+  return join6(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
 }, resolveSvelteImport = async (spec, from) => {
   if (!spec.startsWith(".") && !spec.startsWith("/")) {
     const resolved = resolvePackageImport(spec);
@@ -1607,7 +1918,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const explicitPath = resolve4(dirname2(from), spec);
+  const explicitPath = resolve5(dirname3(from), spec);
   if (extname2(explicitPath) === ".svelte") {
     return explicitPath;
   }
@@ -1627,7 +1938,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   }
   await Bun.write(path, content);
 }, compileSvelteServerModule = async (sourcePath) => {
-  const cachedModulePath = compiledModuleCache.get(sourcePath);
+  const cachedModulePath = compiledModuleCache2.get(sourcePath);
   if (cachedModulePath) {
     return cachedModulePath;
   }
@@ -1666,7 +1977,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
       continue;
     if (resolvedChildModules[index])
       continue;
-    rewrittenModulePaths.set(spec, ensureRelativeImportPath(getCachedModulePath(sourcePath), resolvedModuleImport));
+    rewrittenModulePaths.set(spec, ensureRelativeImportPath(getCachedModulePath2(sourcePath), resolvedModuleImport));
   }
   for (const [spec, resolvedModuleImport] of rewrittenModulePaths) {
     transpiled = transpiled.replaceAll(spec, resolvedModuleImport);
@@ -1680,15 +1991,15 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
     generate: "server"
   }).js.code;
   for (const [spec, compiledChildPath] of childModulePaths) {
-    compiledCode = compiledCode.replaceAll(spec, ensureRelativeImportPath(getCachedModulePath(sourcePath), compiledChildPath));
+    compiledCode = compiledCode.replaceAll(spec, ensureRelativeImportPath(getCachedModulePath2(sourcePath), compiledChildPath));
   }
   for (const [spec, resolvedModuleImport] of rewrittenModulePaths) {
     compiledCode = compiledCode.replaceAll(spec, resolvedModuleImport);
   }
-  const compiledModulePath = getCachedModulePath(sourcePath);
-  await mkdir(dirname2(compiledModulePath), { recursive: true });
+  const compiledModulePath = getCachedModulePath2(sourcePath);
+  await mkdir2(dirname3(compiledModulePath), { recursive: true });
   await writeIfChanged(compiledModulePath, compiledCode);
-  compiledModuleCache.set(sourcePath, compiledModulePath);
+  compiledModuleCache2.set(sourcePath, compiledModulePath);
   return compiledModulePath;
 };
 var init_svelteServerModule = __esm(() => {
@@ -1696,8 +2007,8 @@ var init_svelteServerModule = __esm(() => {
   init_lowerIslandSyntax();
   init_lowerAwaitSlotSyntax();
   init_stylePreprocessor();
-  serverCacheRoot = join4(process.cwd(), ".absolutejs", "islands", "svelte");
-  compiledModuleCache = new Map;
+  serverCacheRoot2 = join6(process.cwd(), ".absolutejs", "islands", "svelte");
+  compiledModuleCache2 = new Map;
   originalSourcePathCache = new Map;
   transpiler = new Bun.Transpiler({
     loader: "ts",
@@ -1707,16 +2018,16 @@ var init_svelteServerModule = __esm(() => {
 
 // src/core/vueServerModule.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, realpathSync } from "fs";
-import { mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname3, join as join5, relative as relative3, resolve as resolve5 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname4, join as join7, relative as relative4, resolve as resolve6 } from "path";
 var {Transpiler } = globalThis.Bun;
-var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, transpiler2, ensureRelativeImportPath2 = (from, target) => {
-  const importPath = relative3(dirname3(from), target).replace(/\\/g, "/");
+var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot3, compiledModuleCache3, transpiler2, ensureRelativeImportPath2 = (from, target) => {
+  const importPath = relative4(dirname4(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
-}, getCachedModulePath2 = (sourcePath) => {
-  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
+}, getCachedModulePath3 = (sourcePath) => {
+  const relativeSourcePath = relative4(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join5(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
+  return join7(serverCacheRoot3, `${normalizedSourcePath}.server.js`);
 }, writeIfChanged2 = async (path, content) => {
   const targetFile = Bun.file(path);
   if (await targetFile.exists()) {
@@ -1743,7 +2054,7 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
 `) : nonVueLines.join(`
 `);
 }, extractRelativeVueImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => typeof importPath === "string" && importPath.startsWith(".") && importPath.endsWith(".vue")), compileVueServerModule = async (sourcePath) => {
-  const cachedModulePath = compiledModuleCache2.get(sourcePath);
+  const cachedModulePath = compiledModuleCache3.get(sourcePath);
   if (cachedModulePath)
     return cachedModulePath;
   const compiler = await import("@vue/compiler-sfc");
@@ -1776,7 +2087,7 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
   }).code : "const ssrRender = () => {};";
   const childImportPaths = extractRelativeVueImports(compiledScript.content);
   const compiledChildren = await Promise.all(childImportPaths.map(async (relativeImport) => ({
-    compiledPath: await compileVueServerModule(resolve5(dirname3(sourcePath), relativeImport)),
+    compiledPath: await compileVueServerModule(resolve6(dirname4(sourcePath), relativeImport)),
     spec: relativeImport
   })));
   const strippedScript = stripExports(compiledScript.content);
@@ -1788,20 +2099,20 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
     "export default script;"
   ].join(`
 `));
-  const compiledModulePath = getCachedModulePath2(sourcePath);
+  const compiledModulePath = getCachedModulePath3(sourcePath);
   let rewritten = assembled;
   for (const child of compiledChildren) {
     rewritten = rewritten.replaceAll(child.spec, ensureRelativeImportPath2(compiledModulePath, child.compiledPath));
   }
-  await mkdir2(dirname3(compiledModulePath), { recursive: true });
+  await mkdir3(dirname4(compiledModulePath), { recursive: true });
   await writeIfChanged2(compiledModulePath, rewritten);
-  compiledModuleCache2.set(sourcePath, compiledModulePath);
+  compiledModuleCache3.set(sourcePath, compiledModulePath);
   return compiledModulePath;
 };
 var init_vueServerModule = __esm(() => {
   init_constants();
-  serverCacheRoot2 = join5(process.cwd(), ".absolutejs", "islands", "vue");
-  compiledModuleCache2 = new Map;
+  serverCacheRoot3 = join7(process.cwd(), ".absolutejs", "islands", "vue");
+  compiledModuleCache3 = new Map;
   transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
 });
 
@@ -1896,8 +2207,17 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
     throw new Error("Resolved Vue island is not a valid Vue component.");
   }
   return resolvedComponent;
+}, loadAngularServerBuildComponent = async (buildReferencePath, exportName) => {
+  const serverModulePath = await compileAngularServerModule(buildReferencePath);
+  const loadedModule = await import(serverModulePath);
+  if (exportName && exportName !== "default" && exportName in loadedModule) {
+    return loadedModule[exportName];
+  }
+  return "default" in loadedModule ? loadedModule.default : loadedModule;
 }, resolveAngularServerIslandComponent = async (component) => {
-  const resolvedComponent = await resolveServerIslandComponent(component);
+  const buildReference = getIslandBuildReference(component);
+  const buildReferencePath = buildReference?.source ? resolveBuildReferencePath(buildReference.source, import.meta.url) : null;
+  const resolvedComponent = buildReferencePath ? await loadAngularServerBuildComponent(buildReferencePath, buildReference?.export) : await resolveServerIslandComponent(component);
   if (!isAngularServerIslandComponent(resolvedComponent)) {
     throw new Error("Resolved Angular island is not a valid Angular component.");
   }
@@ -1953,6 +2273,7 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
 };
 var init_renderIslandMarkup = __esm(() => {
   init_islandSsr();
+  init_angularServerModule();
   init_svelteServerModule();
   init_vueServerModule();
   init_islandMarkupAttributes();
@@ -2083,5 +2404,5 @@ export {
   createIslandStore
 };
 
-//# debugId=C47DC29833D65DA764756E2164756E21
+//# debugId=402D3FC3BBA2047F64756E2164756E21
 //# sourceMappingURL=index.js.map