@absolutejs/absolute 0.19.0-beta.315 → 0.19.0-beta.317

package/dist/angular/browser.js

@@ -29356,6 +29356,869 @@ var init_islandMarkupAttributes = __esm(() => {
   init_islands();
 });
 
+// src/angular/injectorPatch.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+var applyInjectorPatch = (chunkPath, content) => {
+  if (content.includes('Symbol.for("angular.currentInjector")')) {
+    return;
+  }
+  const original = [
+    "let _currentInjector = undefined;",
+    "function getCurrentInjector() {",
+    "  return _currentInjector;",
+    "}",
+    "function setCurrentInjector(injector) {",
+    "  const former = _currentInjector;",
+    "  _currentInjector = injector;",
+    "  return former;",
+    "}"
+  ].join(`
+`);
+  const replacement = [
+    'const _injSym = Symbol.for("angular.currentInjector");',
+    "if (!globalThis[_injSym]) globalThis[_injSym] = { v: undefined };",
+    "function getCurrentInjector() {",
+    "  return globalThis[_injSym].v;",
+    "}",
+    "function setCurrentInjector(injector) {",
+    "  const former = globalThis[_injSym].v;",
+    "  globalThis[_injSym].v = injector;",
+    "  return former;",
+    "}"
+  ].join(`
+`);
+  const patched = content.replace(original, replacement);
+  if (patched === content) {
+    return;
+  }
+  writeFileSync(chunkPath, patched, "utf-8");
+}, resolveAngularCoreDir = () => {
+  const fromProject = resolve(process.cwd(), "node_modules/@angular/core");
+  if (existsSync(join(fromProject, "package.json"))) {
+    return fromProject;
+  }
+  return dirname(__require.resolve("@angular/core/package.json"));
+}, patchAngularInjectorSingleton = () => {
+  try {
+    const coreDir = resolveAngularCoreDir();
+    const chunkPath = join(coreDir, "fesm2022", "_not_found-chunk.mjs");
+    const content = readFileSync(chunkPath, "utf-8");
+    applyInjectorPatch(chunkPath, content);
+  } catch {}
+};
+var init_injectorPatch = __esm(() => {
+  patchAngularInjectorSingleton();
+});
+
+// src/angular/resolveAngularPackage.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+var resolveAngularPackage = (specifier) => {
+  const fromProject = resolve2(process.cwd(), "node_modules", specifier);
+  if (existsSync2(fromProject)) {
+    return fromProject;
+  }
+  return specifier;
+};
+var init_resolveAngularPackage = () => {};
+
+// src/angular/angularPatch.ts
+var exports_angularPatch = {};
+__export(exports_angularPatch, {
+  applyPatches: () => applyPatches
+});
+var ensureHead = (doc) => {
+  if (!doc || doc.head || !doc.documentElement) {
+    return;
+  }
+  const head = doc.createElement("head");
+  doc.documentElement.insertBefore(head, doc.documentElement.firstChild);
+}, applyPatches = async () => {
+  const { \u{275}DominoAdapter } = await import(resolveAngularPackage("@angular/platform-server"));
+  if (!\u{275}DominoAdapter?.prototype) {
+    console.warn("[Angular Patch] \u0275DominoAdapter not found, skipping patches");
+    return false;
+  }
+  const proto = \u{275}DominoAdapter.prototype;
+  const origGetBaseHref = proto.getBaseHref;
+  proto.getBaseHref = function(doc) {
+    if (!doc || !doc.head || typeof doc.head.children === "undefined") {
+      return "";
+    }
+    return origGetBaseHref.call(this, doc);
+  };
+  const origCreateHtmlDocument = proto.createHtmlDocument;
+  proto.createHtmlDocument = function() {
+    const doc = origCreateHtmlDocument.call(this);
+    ensureHead(doc);
+    return doc;
+  };
+  const origGetDefaultDocument = proto.getDefaultDocument;
+  proto.getDefaultDocument = function() {
+    const doc = origGetDefaultDocument.call(this);
+    ensureHead(doc);
+    return doc;
+  };
+  return true;
+};
+var init_angularPatch = __esm(() => {
+  init_resolveAngularPackage();
+});
+
+// src/angular/angularDeps.ts
+var initDominoAdapter = (platformServer) => {
+  try {
+    const DominoAdapter = platformServer.\u{275}DominoAdapter;
+    DominoAdapter?.makeCurrent?.();
+  } catch (err) {
+    console.error("Failed to initialize DominoAdapter:", err);
+  }
+}, loadAngularDeps = async () => {
+  patchAngularInjectorSingleton();
+  await import(resolveAngularPackage("@angular/compiler"));
+  const { applyPatches: applyPatches2 } = await Promise.resolve().then(() => (init_angularPatch(), exports_angularPatch));
+  await applyPatches2();
+  const [platformBrowser, platformServer, common, core2] = await Promise.all([
+    import(resolveAngularPackage("@angular/platform-browser")),
+    import(resolveAngularPackage("@angular/platform-server")),
+    import(resolveAngularPackage("@angular/common")),
+    import(resolveAngularPackage("@angular/core"))
+  ]);
+  if (false) {}
+  initDominoAdapter(platformServer);
+  return {
+    APP_BASE_HREF: common.APP_BASE_HREF,
+    bootstrapApplication: platformBrowser.bootstrapApplication,
+    DomSanitizer: platformBrowser.DomSanitizer,
+    provideClientHydration: platformBrowser.provideClientHydration,
+    provideServerRendering: platformServer.provideServerRendering,
+    provideZonelessChangeDetection: core2.provideZonelessChangeDetection,
+    reflectComponentType: core2.reflectComponentType,
+    renderApplication: platformServer.renderApplication,
+    Sanitizer: core2.Sanitizer,
+    SecurityContext: core2.SecurityContext
+  };
+}, angularDeps = null, getAngularDeps = () => {
+  if (!angularDeps) {
+    angularDeps = loadAngularDeps();
+  }
+  return angularDeps;
+};
+var init_angularDeps = __esm(() => {
+  init_injectorPatch();
+  init_resolveAngularPackage();
+});
+
+// src/utils/stringModifiers.ts
+var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-"), toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), toPascal = (str) => {
+  if (!str.includes("-") && !str.includes("_")) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
+}, toScreamingSnake = (str) => str.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+
+// src/utils/registerClientScript.ts
+var scriptRegistry, requestCounter = 0, getRequestId = () => `req_${Date.now()}_${++requestCounter}`, ssrContextGetter = null, getSsrContextId = () => ssrContextGetter?.() || Object.getOwnPropertyDescriptor(globalThis, "__absolutejs_requestId")?.value, registerClientScript = (script, requestId) => {
+  const id = requestId || getSsrContextId() || getRequestId();
+  if (!scriptRegistry.has(id)) {
+    scriptRegistry.set(id, new Set);
+  }
+  scriptRegistry.get(id)?.add(script);
+  return id;
+}, setSsrContextGetter = (getter) => {
+  ssrContextGetter = getter;
+}, clearAllClientScripts = () => {
+  scriptRegistry.clear();
+}, generateClientScriptCode = (scripts) => {
+  if (scripts.length === 0) {
+    return "";
+  }
+  const scriptCode = scripts.map((script, index) => {
+    const funcString = script.toString();
+    const bodyMatch = funcString.match(/\{([\s\S]*)\}/);
+    if (!bodyMatch || !bodyMatch[1]) {
+      return "";
+    }
+    const body = bodyMatch[1].trim();
+    return `
+	(function() {
+		var executed = false;
+		function executeScript_${index}() {
+			if (executed) return;
+			executed = true;
+			${body}
+		}
+
+		if (document.readyState === 'complete' || document.readyState === 'interactive') {
+			executeScript_${index}();
+		} else {
+			document.addEventListener('DOMContentLoaded', executeScript_${index});
+		}
+
+		// Watch for hydration-added elements
+		var observer = new MutationObserver(function() {
+			executeScript_${index}();
+			if (executed) observer.disconnect();
+		});
+		if (!executed) {
+			observer.observe(document.body || document.documentElement, { childList: true, subtree: true });
+		}
+
+		// Single fallback timeout
+		setTimeout(function() {
+			executeScript_${index}();
+			observer.disconnect();
+		}, 1000);
+	})();`;
+  }).join(`
+`);
+  return `<script>
+(function() {
+${scriptCode}
+})();
+</script>`;
+}, getAndClearClientScripts = (requestId) => {
+  const id = requestId || ssrContextGetter?.();
+  if (!id)
+    return [];
+  const scripts = scriptRegistry.get(id);
+  if (!scripts) {
+    return [];
+  }
+  const scriptArray = Array.from(scripts);
+  scriptRegistry.delete(id);
+  return scriptArray;
+};
+var init_registerClientScript = __esm(() => {
+  scriptRegistry = new Map;
+  if (typeof globalThis !== "undefined") {
+    Object.assign(globalThis, { registerClientScript });
+  }
+});
+
+// src/angular/ssrRender.ts
+var routePropsCache, cacheRouteData = (pagePath, data) => {
+  const cacheKey = pagePath.split("?")[0] ?? pagePath;
+  routePropsCache.set(cacheKey, data);
+}, getCachedRouteData = (pagePath) => routePropsCache.get(pagePath), selectorCache, buildDeps = (ssrResult, baseDeps) => {
+  if (!ssrResult?.core) {
+    return baseDeps;
+  }
+  const { common, core: core2, platformBrowser, platformServer } = ssrResult;
+  return {
+    APP_BASE_HREF: common?.APP_BASE_HREF ?? baseDeps.APP_BASE_HREF,
+    bootstrapApplication: platformBrowser?.bootstrapApplication ?? baseDeps.bootstrapApplication,
+    DomSanitizer: platformBrowser?.DomSanitizer ?? baseDeps.DomSanitizer,
+    provideClientHydration: platformBrowser?.provideClientHydration ?? baseDeps.provideClientHydration,
+    provideServerRendering: platformServer?.provideServerRendering ?? baseDeps.provideServerRendering,
+    provideZonelessChangeDetection: core2.provideZonelessChangeDetection,
+    reflectComponentType: core2.reflectComponentType,
+    renderApplication: platformServer?.renderApplication ?? baseDeps.renderApplication,
+    Sanitizer: core2.Sanitizer,
+    SecurityContext: core2.SecurityContext
+  };
+}, buildProviders = (deps, sanitizer, maybeProps, tokenMap) => {
+  const providers = [
+    deps.provideServerRendering(),
+    deps.provideClientHydration(),
+    deps.provideZonelessChangeDetection(),
+    { provide: deps.APP_BASE_HREF, useValue: "/" },
+    {
+      provide: deps.DomSanitizer,
+      useValue: sanitizer
+    },
+    { provide: deps.Sanitizer, useValue: sanitizer }
+  ];
+  if (!maybeProps) {
+    return providers;
+  }
+  const propProviders = Object.entries(maybeProps).map(([propName, propValue]) => ({
+    token: tokenMap.get(toScreamingSnake(propName)),
+    value: propValue
+  })).filter((entry) => entry.token).map((entry) => ({ provide: entry.token, useValue: entry.value }));
+  return [...providers, ...propProviders];
+}, clearSelectorCache = () => selectorCache.clear(), isInjectionToken = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  return "ngMetadataName" in value && value.ngMetadataName === "InjectionToken";
+}, discoverTokens = (pageModule) => new Map(Object.entries(pageModule).filter(([, value]) => isInjectionToken(value))), loadSsrDeps = async (pagePath) => {
+  const ssrDepsPath = (pagePath.split("?")[0] ?? pagePath).replace(/\.js$/, ".ssr-deps.js");
+  try {
+    const ssrDeps = await import(ssrDepsPath);
+    const result = {
+      common: ssrDeps.__angularCommon,
+      core: ssrDeps.__angularCore,
+      platformBrowser: ssrDeps.__angularPlatformBrowser,
+      platformServer: ssrDeps.__angularPlatformServer
+    };
+    return result;
+  } catch {
+    return null;
+  }
+}, resolveSelector = (deps, pagePath, PageComponent) => {
+  const cached = selectorCache.get(pagePath);
+  if (cached) {
+    return cached;
+  }
+  const selector = deps.reflectComponentType(PageComponent)?.selector ?? "ng-app";
+  selectorCache.set(pagePath, selector);
+  return selector;
+}, injectBeforeClose = (html, snippet) => {
+  if (html.includes("</body>")) {
+    return html.replace("</body>", `${snippet}</body>`);
+  }
+  if (html.includes("</html>")) {
+    return html.replace("</html>", `${snippet}</html>`);
+  }
+  return html + snippet;
+}, injectSsrScripts = (html, requestId, indexPath, props) => {
+  let result = html;
+  const registeredScripts = getAndClearClientScripts(requestId);
+  if (registeredScripts.length > 0) {
+    result = injectBeforeClose(result, generateClientScriptCode(registeredScripts));
+  }
+  if (props) {
+    result = injectBeforeClose(result, `<script>window.__ABS_ANGULAR_PAGE_PROPS__ = ${JSON.stringify(props)};</script>`);
+  }
+  if (indexPath) {
+    result = injectBeforeClose(result, `<script type="module" src="${indexPath}"></script>`);
+  }
+  return result;
+}, withSuppressedAngularDevLogs = async (render) => {
+  const origLog = console.log;
+  console.log = (...args) => {
+    if (typeof args[0] === "string" && args[0].includes("development mode")) {
+      return;
+    }
+    origLog.apply(console, args);
+  };
+  try {
+    return await render();
+  } finally {
+    console.log = origLog;
+  }
+}, renderAngularApp = async (deps, PageComponent, providers, document) => {
+  const bootstrap = (context) => deps.bootstrapApplication(PageComponent, { providers }, context);
+  return withSuppressedAngularDevLogs(() => deps.renderApplication(bootstrap, {
+    document,
+    platformProviders: [],
+    url: "/"
+  }));
+};
+var init_ssrRender = __esm(() => {
+  init_registerClientScript();
+  routePropsCache = new Map;
+  selectorCache = new Map;
+});
+
+// src/angular/islands.ts
+var angularIslandSelector = "abs-angular-island", getAngularIslandSelector = (_islandId) => angularIslandSelector, getSelectorFromRenderedIsland = (rootElement) => {
+  const firstChild = rootElement.firstElementChild;
+  if (!(firstChild instanceof HTMLElement)) {
+    return null;
+  }
+  const selector = firstChild.tagName.toLowerCase();
+  return selector.length > 0 ? selector : null;
+}, getClientAngularComponentSelector = (component) => {
+  const maybeDef = Reflect.get(component, "\u0275cmp");
+  if (typeof maybeDef !== "object" || maybeDef === null) {
+    return null;
+  }
+  const maybeSelectors = Reflect.get(maybeDef, "selectors");
+  if (!Array.isArray(maybeSelectors)) {
+    return null;
+  }
+  const firstSelectorGroup = maybeSelectors[0];
+  if (!Array.isArray(firstSelectorGroup)) {
+    return null;
+  }
+  const selector = firstSelectorGroup[0];
+  return typeof selector === "string" && selector.length > 0 ? selector : null;
+}, angularIslandAppPromise = null, getAngularIslandApp = async () => {
+  if (!angularIslandAppPromise) {
+    angularIslandAppPromise = (async () => {
+      const { EnvironmentInjector, provideZonelessChangeDetection } = await import("@angular/core");
+      const { createApplication } = await import("@angular/platform-browser");
+      const app = await createApplication({
+        providers: [provideZonelessChangeDetection()]
+      });
+      const environmentInjector = app.injector.get(EnvironmentInjector);
+      return {
+        app,
+        environmentInjector
+      };
+    })();
+  }
+  return angularIslandAppPromise;
+}, wrapperMetadataCache, requestRenderCache, getRequestRenderCache = () => {
+  const requestId = getSsrContextId();
+  if (!requestId) {
+    return null;
+  }
+  const cached = requestRenderCache.get(requestId);
+  if (cached) {
+    return cached;
+  }
+  const renderCache = new Map;
+  requestRenderCache.set(requestId, renderCache);
+  return renderCache;
+}, getAngularIslandWrapperKey = (component, _islandId) => {
+  const componentName = typeof component.name === "string" && component.name.length > 0 ? component.name : "AngularIsland";
+  return `${componentName}:${angularIslandSelector}`;
+}, getIslandRenderCacheKey = (component, props) => {
+  const componentName = typeof component.name === "string" && component.name.length > 0 ? component.name : "AngularIsland";
+  return `${componentName}:${JSON.stringify(props)}`;
+}, createAngularIslandWrapper = async (component, islandId) => {
+  const wrapperKey = getAngularIslandWrapperKey(component, islandId);
+  const cached = wrapperMetadataCache.get(wrapperKey);
+  if (cached) {
+    return cached;
+  }
+  const metadataPromise = (async () => {
+    const { Component: Component4, InjectionToken, inject } = await import("@angular/core");
+    const { NgComponentOutlet } = await import("@angular/common");
+    const deps = await getAngularDeps();
+    const selector = getAngularIslandSelector(islandId);
+    const propsToken = new InjectionToken(`${wrapperKey}:props`);
+
+    class AngularIslandWrapperComponent {
+      component = component;
+      props = inject(propsToken);
+    }
+    return {
+      deps,
+      propsToken,
+      selector,
+      WrapperComponent: Component4({
+        imports: [NgComponentOutlet, component],
+        selector,
+        standalone: true,
+        template: '<ng-container *ngComponentOutlet="component; inputs: props"></ng-container>'
+      })(AngularIslandWrapperComponent)
+    };
+  })();
+  wrapperMetadataCache.set(wrapperKey, metadataPromise);
+  return metadataPromise;
+}, extractAngularIslandRoot = (html, selector) => {
+  const openTag = `<${selector}`;
+  const start = html.indexOf(openTag);
+  if (start < 0) {
+    throw new Error(`Could not find Angular island root "${selector}".`);
+  }
+  const endTag = `</${selector}>`;
+  const end = html.indexOf(endTag, start);
+  if (end < 0) {
+    throw new Error(`Could not close Angular island root "${selector}".`);
+  }
+  return html.slice(start, end + endTag.length);
+}, renderAngularIslandToHtml = async (component, props, islandId) => {
+  const requestCache = getRequestRenderCache();
+  const renderCacheKey = getIslandRenderCacheKey(component, props);
+  const cachedHtml = requestCache?.get(renderCacheKey);
+  if (cachedHtml) {
+    return cachedHtml;
+  }
+  const { deps, propsToken, selector, WrapperComponent } = await createAngularIslandWrapper(component, islandId);
+  const providers = [
+    deps.provideServerRendering(),
+    deps.provideZonelessChangeDetection(),
+    { provide: deps.APP_BASE_HREF, useValue: "/" },
+    { provide: propsToken, useValue: props }
+  ];
+  const document = `<!DOCTYPE html><html><body><${selector}></${selector}></body></html>`;
+  const html = await withSuppressedAngularDevLogs(() => deps.renderApplication((context) => deps.bootstrapApplication(WrapperComponent, { providers }, context), {
+    document,
+    platformProviders: [],
+    url: "/"
+  }));
+  const islandHtml = extractAngularIslandRoot(html, selector);
+  requestCache?.set(renderCacheKey, islandHtml);
+  return islandHtml;
+}, mountAngularIsland = async (component, element2, props, islandId) => {
+  await Promise.resolve().then(() => (init_compiler(), exports_compiler));
+  const { createComponent, inputBinding } = await import("@angular/core");
+  const selector = getAngularIslandSelector(islandId);
+  const { app, environmentInjector } = await getAngularIslandApp();
+  let rootElement = element2.querySelector(selector);
+  if (!(rootElement instanceof HTMLElement)) {
+    element2.innerHTML = `<${selector}></${selector}>`;
+    rootElement = element2.querySelector(selector);
+  }
+  if (!(rootElement instanceof HTMLElement))
+    return app;
+  const componentSelector = getClientAngularComponentSelector(component) ?? getSelectorFromRenderedIsland(rootElement);
+  if (!componentSelector)
+    return app;
+  let hostElement = rootElement.querySelector(componentSelector);
+  if (!(hostElement instanceof HTMLElement)) {
+    rootElement.innerHTML = `<${componentSelector}></${componentSelector}>`;
+    hostElement = rootElement.querySelector(componentSelector);
+  }
+  if (!(hostElement instanceof HTMLElement))
+    return app;
+  hostElement.innerHTML = "";
+  const bindings = Object.entries(props).map(([key, value]) => inputBinding(key, () => value));
+  const componentRef = createComponent(component, {
+    bindings,
+    environmentInjector,
+    hostElement
+  });
+  app.attachView(componentRef.hostView);
+  componentRef.changeDetectorRef.detectChanges();
+  window.__ABS_ANGULAR_ISLAND_APPS__ ??= [];
+  window.__ABS_ANGULAR_ISLAND_APPS__.push(app);
+  return app;
+};
+var init_islands2 = __esm(() => {
+  init_angularDeps();
+  init_ssrRender();
+  init_registerClientScript();
+  wrapperMetadataCache = new Map;
+  requestRenderCache = new Map;
+});
+
+// src/core/islandSsr.ts
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { render as renderSvelte } from "svelte/server";
+import { createSSRApp, h } from "vue";
+import { renderToString as renderVueToString } from "vue/server-renderer";
+var renderReactIslandToHtml = (component, props) => renderToStaticMarkup(createElement(component, props)), renderSvelteIslandToHtml = (component, props) => {
+  const { body } = renderSvelte(component, { props });
+  return body;
+}, renderVueIslandToHtml = (component, props) => {
+  const app = createSSRApp({
+    render: () => h(component, props)
+  });
+  return renderVueToString(app);
+};
+var init_islandSsr = __esm(() => {
+  init_islands2();
+});
+
+// src/constants.ts
+var ANGULAR_INIT_TIMEOUT_MS = 500, ANSI_ESCAPE_LENGTH = 3, ASCII_SPACE = 32, BASE_36_RADIX = 36, BUN_BUILD_WARNING_SUPPRESSION = "wildcard sideEffects are not supported yet", BODY_SLICE_LENGTH = 2000, BYTES_PER_KILOBYTE = 1024, CLI_ARGS_OFFSET = 3, CSS_ERROR_RESOLVE_DELAY_MS = 50, CSS_MAX_CHECK_ATTEMPTS = 10, CSS_MAX_PARSE_TIMEOUT_MS = 500, CSS_SHEET_READY_TIMEOUT_MS = 100, DEFAULT_CHUNK_SIZE = 16384, DEFAULT_DEBOUNCE_MS = 15, DEFAULT_PORT = 3000, DEV_SERVER_RESTART_DEBOUNCE_MS = 100, DOM_UPDATE_DELAY_MS = 50, FILE_PROTOCOL_PREFIX_LENGTH = 7, FOCUS_ID_PREFIX_LENGTH = 3, FOCUS_IDX_PREFIX_LENGTH = 4, FOCUS_NAME_PREFIX_LENGTH = 5, HMR_UPDATE_TIMEOUT_MS = 2000, HOOK_SIGNATURE_LENGTH = 12, HOURS_IN_DAY = 24, HOURS_IN_HALF_DAY = 12, MAX_ERROR_LENGTH = 200, MAX_RECONNECT_ATTEMPTS = 60, MILLISECONDS_IN_A_SECOND = 1000, MINUTES_IN_AN_HOUR = 60, SECONDS_IN_A_MINUTE = 60, MILLISECONDS_IN_A_MINUTE, MILLISECONDS_IN_A_DAY, OVERLAY_FADE_DURATION_MS = 150, PING_INTERVAL_MS = 30000, RAF_BATCH_COUNT = 3, RANDOM_ID_END_INDEX = 11, REBUILD_BATCH_DELAY_MS = 10, REBUILD_RELOAD_DELAY_MS = 200, RECONNECT_INITIAL_DELAY_MS = 500, RECONNECT_POLL_INTERVAL_MS = 300, SIGINT_EXIT_CODE = 130, SIGTERM_EXIT_CODE = 143, SVELTE_CSS_LOAD_TIMEOUT_MS = 500, TIME_PRECISION = 2, TWO_THIRDS, UNFOUND_INDEX = -1, WEBSOCKET_NORMAL_CLOSURE = 1000;
+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;
+  TWO_THIRDS = 2 / 3;
+});
+
+// src/svelte/lowerIslandSyntax.ts
+var ISLAND_TAG_RE, extractIslandAttribute = (attributeString, name) => {
+  const quotedMatch = attributeString.match(new RegExp(`\\b${name}\\s*=\\s*["']([^"']+)["']`));
+  if (quotedMatch?.[1]) {
+    return { expression: JSON.stringify(quotedMatch[1]), found: true };
+  }
+  const attributeIndex = attributeString.search(new RegExp(`\\b${name}\\s*=\\s*\\{`));
+  if (attributeIndex >= 0) {
+    const braceStart = attributeString.indexOf("{", attributeIndex);
+    if (braceStart >= 0) {
+      let depth = 0;
+      for (let index = braceStart;index < attributeString.length; index += 1) {
+        const char = attributeString[index];
+        if (char === "{") {
+          depth += 1;
+        }
+        if (char === "}") {
+          depth -= 1;
+          if (depth === 0) {
+            return {
+              expression: attributeString.slice(braceStart + 1, index).trim(),
+              found: true
+            };
+          }
+        }
+      }
+    }
+  }
+  return { expression: "", found: false };
+}, lowerSvelteIslandSyntax = (source, mode = "server") => {
+  if (!source.includes("<Island")) {
+    return { code: source, transformed: false };
+  }
+  let islandIndex = 0;
+  const transformedMarkup = source.replace(ISLAND_TAG_RE, (fullMatch, attributeString) => {
+    const framework = extractIslandAttribute(attributeString, "framework");
+    const component = extractIslandAttribute(attributeString, "component");
+    if (!framework.found || !component.found) {
+      return fullMatch;
+    }
+    const hydrate = extractIslandAttribute(attributeString, "hydrate");
+    const props = extractIslandAttribute(attributeString, "props");
+    const slotId = `absolute-svelte-island-${islandIndex.toString(BASE_36_RADIX)}`;
+    islandIndex += 1;
+    const resolveExpression = `await __absoluteResolveIslandHtml(${JSON.stringify(slotId)}, { component: ${component.expression}, framework: ${framework.expression}, hydrate: ${hydrate.found ? hydrate.expression : JSON.stringify("load")}, props: ${props.found ? props.expression : "{}"} })`;
+    return `<div data-absolute-island-slot="${slotId}" style="display: contents">{@html ${resolveExpression}}</div>`;
+  });
+  const importLine = 'import { resolveIslandHtml as __absoluteResolveIslandHtml } from "@absolutejs/absolute/svelte";';
+  if (transformedMarkup.includes("<script")) {
+    return {
+      code: transformedMarkup.replace(/<script(\s[^>]*)?>/, (match) => `${match}
+${importLine}
+`),
+      transformed: true
+    };
+  }
+  return {
+    code: `<script lang="ts">
+${importLine}
+</script>
+${transformedMarkup}`,
+    transformed: true
+  };
+};
+var init_lowerIslandSyntax = __esm(() => {
+  init_constants();
+  ISLAND_TAG_RE = /<Island\b([\s\S]*?)\/>/g;
+});
+
+// src/core/svelteServerModule.ts
+import { mkdir } from "fs/promises";
+import { dirname as dirname2, extname, join as join2, relative, resolve as resolve3 } from "path";
+var serverCacheRoot, compiledModuleCache, transpiler, ensureRelativeImportPath = (from, to) => {
+  const importPath = relative(dirname2(from), to).replace(/\\/g, "/");
+  return importPath.startsWith(".") ? importPath : `./${importPath}`;
+}, resolveRelativeModule = async (spec, from) => {
+  if (!spec.startsWith(".")) {
+    return null;
+  }
+  const basePath = resolve3(dirname2(from), spec);
+  const candidates = [
+    basePath,
+    `${basePath}.ts`,
+    `${basePath}.js`,
+    `${basePath}.mjs`,
+    `${basePath}.cjs`,
+    `${basePath}.json`,
+    join2(basePath, "index.ts"),
+    join2(basePath, "index.js"),
+    join2(basePath, "index.mjs"),
+    join2(basePath, "index.cjs"),
+    join2(basePath, "index.json")
+  ];
+  for (const candidate of candidates) {
+    if (await Bun.file(candidate).exists() === true) {
+      return candidate;
+    }
+  }
+  return null;
+}, getCachedModulePath = (sourcePath) => {
+  const relativeSourcePath = relative(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
+  return join2(serverCacheRoot, `${normalizedSourcePath}.server.js`);
+}, resolveSvelteImport = async (spec, from) => {
+  if (spec.startsWith("/")) {
+    return spec;
+  }
+  if (!spec.startsWith(".")) {
+    return null;
+  }
+  const explicitPath = resolve3(dirname2(from), spec);
+  if (extname(explicitPath) === ".svelte") {
+    return explicitPath;
+  }
+  const candidate = `${explicitPath}.svelte`;
+  if (await Bun.file(candidate).exists() === true) {
+    return candidate;
+  }
+  return null;
+}, writeIfChanged = async (path, content) => {
+  const targetFile = Bun.file(path);
+  const exists = await targetFile.exists();
+  if (exists) {
+    const currentContent = await targetFile.text();
+    if (currentContent === content) {
+      return;
+    }
+  }
+  await Bun.write(path, content);
+}, compileSvelteServerModule = async (sourcePath) => {
+  const cachedModulePath = compiledModuleCache.get(sourcePath);
+  if (cachedModulePath) {
+    return cachedModulePath;
+  }
+  const source = await Bun.file(sourcePath).text();
+  const { compile, preprocess } = await import("svelte/compiler");
+  const loweredSource = lowerSvelteIslandSyntax(source, "server");
+  const preprocessed = await preprocess(loweredSource.code, {});
+  const transpiled = sourcePath.endsWith(".ts") || sourcePath.endsWith(".svelte.ts") ? transpiler.transformSync(preprocessed.code) : preprocessed.code;
+  const childImportSpecs = Array.from(transpiled.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((value) => value !== undefined);
+  const resolvedChildModules = await Promise.all(childImportSpecs.map((spec) => resolveSvelteImport(spec, sourcePath)));
+  const resolvedModuleImports = await Promise.all(childImportSpecs.map((spec) => resolveRelativeModule(spec, sourcePath)));
+  const childModulePaths = new Map;
+  const rewrittenModulePaths = new Map;
+  for (let index = 0;index < childImportSpecs.length; index += 1) {
+    const spec = childImportSpecs[index];
+    const resolvedChild = resolvedChildModules[index];
+    if (!spec || !resolvedChild)
+      continue;
+    const compiledChildPath = await compileSvelteServerModule(resolvedChild);
+    childModulePaths.set(spec, compiledChildPath);
+  }
+  for (let index = 0;index < childImportSpecs.length; index += 1) {
+    const spec = childImportSpecs[index];
+    const resolvedModuleImport = resolvedModuleImports[index];
+    if (!spec || !resolvedModuleImport)
+      continue;
+    if (resolvedChildModules[index])
+      continue;
+    rewrittenModulePaths.set(spec, ensureRelativeImportPath(getCachedModulePath(sourcePath), resolvedModuleImport));
+  }
+  let compiledCode = compile(transpiled, {
+    css: "injected",
+    experimental: {
+      async: loweredSource.transformed
+    },
+    filename: sourcePath,
+    generate: "server"
+  }).js.code;
+  for (const [spec, compiledChildPath] of childModulePaths) {
+    compiledCode = compiledCode.replaceAll(spec, ensureRelativeImportPath(getCachedModulePath(sourcePath), compiledChildPath));
+  }
+  for (const [spec, resolvedModuleImport] of rewrittenModulePaths) {
+    compiledCode = compiledCode.replaceAll(spec, resolvedModuleImport);
+  }
+  const compiledModulePath = getCachedModulePath(sourcePath);
+  await mkdir(dirname2(compiledModulePath), { recursive: true });
+  await writeIfChanged(compiledModulePath, compiledCode);
+  compiledModuleCache.set(sourcePath, compiledModulePath);
+  return compiledModulePath;
+};
+var init_svelteServerModule = __esm(() => {
+  init_lowerIslandSyntax();
+  serverCacheRoot = join2(process.cwd(), ".absolutejs", "islands", "svelte");
+  compiledModuleCache = new Map;
+  transpiler = new Bun.Transpiler({
+    loader: "ts",
+    target: "browser"
+  });
+});
+
+// src/core/renderIslandMarkup.ts
+var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildComponentCache, nextIslandId = () => {
+  islandSequence += 1;
+  return `island-${islandSequence}`;
+}, isRecord2 = (value) => typeof value === "object" && value !== null, isReactServerIslandComponent = (value) => typeof value === "function", isSvelteServerIslandComponent = (value) => typeof value === "function", isVueServerIslandComponent = (value) => typeof value === "function" || isRecord2(value), isAngularServerIslandComponent = (value) => typeof value === "function", resolveBuildReferencePath = (source, registryPath) => source.startsWith("file://") ? new URL(source).pathname : source.startsWith(".") ? new URL(source, registryPath).pathname : source, loadServerBuildComponent = async (buildReferencePath) => {
+  const cachedBuildComponent = resolvedServerBuildComponentCache.get(buildReferencePath);
+  if (cachedBuildComponent) {
+    return cachedBuildComponent;
+  }
+  const loadPromise = (async () => {
+    const compiledModulePath = await compileSvelteServerModule(buildReferencePath);
+    const loadedModule = await import(compiledModulePath);
+    return "default" in loadedModule ? loadedModule.default : loadedModule;
+  })();
+  resolvedServerBuildComponentCache.set(buildReferencePath, loadPromise);
+  return loadPromise;
+}, loadServerImportComponent = async (resolvedComponent) => {
+  const resolvedModulePath = resolvedComponent.startsWith(".") ? new URL(resolvedComponent, import.meta.url).pathname : resolvedComponent;
+  const importTarget = resolvedModulePath.endsWith(".svelte") ? await compileSvelteServerModule(resolvedModulePath) : resolvedModulePath;
+  const loadedModule = await import(importTarget);
+  return "default" in loadedModule ? loadedModule.default : loadedModule;
+}, resolveServerIslandComponent = async (component) => {
+  const cachedResolvedComponent = resolvedServerComponentCache.get(component);
+  if (cachedResolvedComponent) {
+    return cachedResolvedComponent;
+  }
+  const resolutionPromise = (async () => {
+    const buildReference = getIslandBuildReference(component);
+    const buildReferencePath = buildReference?.source ? resolveBuildReferencePath(buildReference.source, import.meta.url) : null;
+    if (buildReferencePath?.endsWith(".svelte")) {
+      return loadServerBuildComponent(buildReferencePath);
+    }
+    const resolvedComponent = getIslandComponent(component);
+    if (typeof resolvedComponent !== "string") {
+      return resolvedComponent;
+    }
+    return loadServerImportComponent(resolvedComponent);
+  })();
+  resolvedServerComponentCache.set(component, resolutionPromise);
+  return resolutionPromise;
+}, resolveReactServerIslandComponent = async (component) => {
+  const resolvedComponent = await resolveServerIslandComponent(component);
+  if (!isReactServerIslandComponent(resolvedComponent)) {
+    throw new Error("Resolved React island is not a valid React component.");
+  }
+  return resolvedComponent;
+}, resolveSvelteServerIslandComponent = async (component) => {
+  const resolvedComponent = await resolveServerIslandComponent(component);
+  if (!isSvelteServerIslandComponent(resolvedComponent)) {
+    throw new Error("Resolved Svelte island is not a valid Svelte component.");
+  }
+  return resolvedComponent;
+}, resolveVueServerIslandComponent = async (component) => {
+  const resolvedComponent = await resolveServerIslandComponent(component);
+  if (!isVueServerIslandComponent(resolvedComponent)) {
+    throw new Error("Resolved Vue island is not a valid Vue component.");
+  }
+  return resolvedComponent;
+}, resolveAngularServerIslandComponent = async (component) => {
+  const resolvedComponent = await resolveServerIslandComponent(component);
+  if (!isAngularServerIslandComponent(resolvedComponent)) {
+    throw new Error("Resolved Angular island is not a valid Angular component.");
+  }
+  return resolvedComponent;
+}, renderIslandResult = async (registry, props) => {
+  const islandId = nextIslandId();
+  const attributes = getIslandMarkerAttributes(props);
+  if (props.framework === "react") {
+    const entry = registry.react?.[props.component];
+    if (!entry) {
+      throw new Error(`Island component "${props.component}" is not registered for framework "react".`);
+    }
+    const component = await resolveReactServerIslandComponent(entry);
+    const html = renderReactIslandToHtml(component, props.props);
+    return { attributes, html };
+  }
+  if (props.framework === "svelte") {
+    const entry = registry.svelte?.[props.component];
+    if (!entry) {
+      throw new Error(`Island component "${props.component}" is not registered for framework "svelte".`);
+    }
+    const component = await resolveSvelteServerIslandComponent(entry);
+    const html = renderSvelteIslandToHtml(component, props.props);
+    return { attributes, html };
+  }
+  if (props.framework === "vue") {
+    const entry = registry.vue?.[props.component];
+    if (!entry) {
+      throw new Error(`Island component "${props.component}" is not registered for framework "vue".`);
+    }
+    const component = await resolveVueServerIslandComponent(entry);
+    const html = await renderVueIslandToHtml(component, props.props);
+    return { attributes, html };
+  }
+  if (props.framework === "angular") {
+    const entry = registry.angular?.[props.component];
+    if (!entry) {
+      throw new Error(`Island component "${props.component}" is not registered for framework "angular".`);
+    }
+    const component = await resolveAngularServerIslandComponent(entry);
+    const html = await renderAngularIslandToHtml(component, props.props, islandId);
+    return {
+      attributes: {
+        ...getIslandMarkerAttributes(props, islandId)
+      },
+      html
+    };
+  }
+  throw new Error(`Framework "${props.framework}" is not implemented in this prototype.`);
+}, renderIslandMarkup = async (registry, props) => {
+  const result = await renderIslandResult(registry, props);
+  return `<div ${serializeIslandAttributes(result.attributes)}>${result.html}</div>`;
+};
+var init_renderIslandMarkup = __esm(() => {
+  init_islandSsr();
+  init_svelteServerModule();
+  init_islandMarkupAttributes();
+  init_islands();
+  resolvedServerComponentCache = new Map;
+  resolvedServerBuildComponentCache = new Map;
+});
+
 // node_modules/rxjs/dist/cjs/internal/util/isFunction.js
 var require_isFunction = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -30040,7 +30903,7 @@ var require_Observable = __commonJS((exports) => {
     Observable2.prototype.forEach = function(next, promiseCtor) {
       var _this = this;
       promiseCtor = getPromiseCtor(promiseCtor);
-      return new promiseCtor(function(resolve, reject) {
+      return new promiseCtor(function(resolve4, reject) {
         var subscriber = new Subscriber_1.SafeSubscriber({
           next: function(value) {
             try {
@@ -30051,7 +30914,7 @@ var require_Observable = __commonJS((exports) => {
             }
           },
           error: reject,
-          complete: resolve
+          complete: resolve4
         });
         _this.subscribe(subscriber);
       });
@@ -30073,14 +30936,14 @@ var require_Observable = __commonJS((exports) => {
     Observable2.prototype.toPromise = function(promiseCtor) {
       var _this = this;
       promiseCtor = getPromiseCtor(promiseCtor);
-      return new promiseCtor(function(resolve, reject) {
+      return new promiseCtor(function(resolve4, reject) {
         var value;
         _this.subscribe(function(x) {
           return value = x;
         }, function(err) {
           return reject(err);
         }, function() {
-          return resolve(value);
+          return resolve4(value);
         });
       });
     };
@@ -32108,11 +32971,11 @@ var require_isReadableStreamLike = __commonJS((exports) => {
 var require_innerFrom = __commonJS((exports) => {
   var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
     function adopt(value) {
-      return value instanceof P ? value : new P(function(resolve) {
-        resolve(value);
+      return value instanceof P ? value : new P(function(resolve4) {
+        resolve4(value);
       });
     }
-    return new (P || (P = Promise))(function(resolve, reject) {
+    return new (P || (P = Promise))(function(resolve4, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -32128,7 +32991,7 @@ var require_innerFrom = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve4(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -32218,14 +33081,14 @@ var require_innerFrom = __commonJS((exports) => {
     }, i);
     function verb(n) {
       i[n] = o[n] && function(v) {
-        return new Promise(function(resolve, reject) {
-          v = o[n](v), settle(resolve, reject, v.done, v.value);
+        return new Promise(function(resolve4, reject) {
+          v = o[n](v), settle(resolve4, reject, v.done, v.value);
         });
       };
     }
-    function settle(resolve, reject, d, v) {
+    function settle(resolve4, reject, d, v) {
       Promise.resolve(v).then(function(v2) {
-        resolve({ value: v2, done: d });
+        resolve4({ value: v2, done: d });
       }, reject);
     }
   };
@@ -32343,7 +33206,7 @@ var require_innerFrom = __commonJS((exports) => {
   exports.fromIterable = fromIterable;
   function fromAsyncIterable(asyncIterable) {
     return new Observable_1.Observable(function(subscriber) {
-      process(asyncIterable, subscriber).catch(function(err) {
+      process2(asyncIterable, subscriber).catch(function(err) {
         return subscriber.error(err);
       });
     });
@@ -32353,7 +33216,7 @@ var require_innerFrom = __commonJS((exports) => {
     return fromAsyncIterable(isReadableStreamLike_1.readableStreamLikeToAsyncGenerator(readableStream));
   }
   exports.fromReadableStreamLike = fromReadableStreamLike;
-  function process(asyncIterable, subscriber) {
+  function process2(asyncIterable, subscriber) {
     var asyncIterable_1, asyncIterable_1_1;
     var e_2, _a;
     return __awaiter(this, undefined, undefined, function() {
@@ -32801,7 +33664,7 @@ var require_lastValueFrom = __commonJS((exports) => {
   var EmptyError_1 = require_EmptyError();
   function lastValueFrom(source, config) {
     var hasConfig = typeof config === "object";
-    return new Promise(function(resolve, reject) {
+    return new Promise(function(resolve4, reject) {
       var _hasValue = false;
       var _value;
       source.subscribe({
@@ -32812,9 +33675,9 @@ var require_lastValueFrom = __commonJS((exports) => {
         error: reject,
         complete: function() {
           if (_hasValue) {
-            resolve(_value);
+            resolve4(_value);
           } else if (hasConfig) {
-            resolve(config.defaultValue);
+            resolve4(config.defaultValue);
           } else {
             reject(new EmptyError_1.EmptyError);
           }
@@ -32833,16 +33696,16 @@ var require_firstValueFrom = __commonJS((exports) => {
   var Subscriber_1 = require_Subscriber();
   function firstValueFrom(source, config) {
     var hasConfig = typeof config === "object";
-    return new Promise(function(resolve, reject) {
+    return new Promise(function(resolve4, reject) {
       var subscriber = new Subscriber_1.SafeSubscriber({
         next: function(value) {
-          resolve(value);
+          resolve4(value);
           subscriber.unsubscribe();
         },
         error: reject,
         complete: function() {
           if (hasConfig) {
-            resolve(config.defaultValue);
+            resolve4(config.defaultValue);
           } else {
             reject(new EmptyError_1.EmptyError);
           }
@@ -37089,7 +37952,7 @@ var require_window = __commonJS((exports) => {
   var OperatorSubscriber_1 = require_OperatorSubscriber();
   var noop_1 = require_noop();
   var innerFrom_1 = require_innerFrom();
-  function window(windowBoundaries) {
+  function window2(windowBoundaries) {
     return lift_1.operate(function(source, subscriber) {
       var windowSubject = new Subject_1.Subject;
       subscriber.next(windowSubject.asObservable());
@@ -37113,7 +37976,7 @@ var require_window = __commonJS((exports) => {
       };
     });
   }
-  exports.window = window;
+  exports.window = window2;
 });
 
 // node_modules/rxjs/dist/cjs/internal/operators/windowCount.js
@@ -37218,8 +38081,8 @@ var require_windowTime = __commonJS((exports) => {
       var windowRecords = [];
       var restartOnClose = false;
       var closeWindow = function(record) {
-        var { window, subs } = record;
-        window.complete();
+        var { window: window2, subs } = record;
+        window2.complete();
         subs.unsubscribe();
         arrRemove_1.arrRemove(windowRecords, record);
         restartOnClose && startWindow();
@@ -37252,8 +38115,8 @@ var require_windowTime = __commonJS((exports) => {
       };
       var terminate = function(cb) {
         loop(function(_a2) {
-          var window = _a2.window;
-          return cb(window);
+          var window2 = _a2.window;
+          return cb(window2);
         });
         cb(subscriber);
         subscriber.unsubscribe();
@@ -37315,12 +38178,12 @@ var require_windowToggle = __commonJS((exports) => {
         subscriber.error(err);
       };
       innerFrom_1.innerFrom(openings).subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function(openValue) {
-        var window = new Subject_1.Subject;
-        windows.push(window);
+        var window2 = new Subject_1.Subject;
+        windows.push(window2);
         var closingSubscription = new Subscription_1.Subscription;
         var closeWindow = function() {
-          arrRemove_1.arrRemove(windows, window);
-          window.complete();
+          arrRemove_1.arrRemove(windows, window2);
+          window2.complete();
           closingSubscription.unsubscribe();
         };
         var closingNotifier;
@@ -37330,7 +38193,7 @@ var require_windowToggle = __commonJS((exports) => {
           handleError(err);
           return;
         }
-        subscriber.next(window.asObservable());
+        subscriber.next(window2.asObservable());
         closingSubscription.add(closingNotifier.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, closeWindow, noop_1.noop, handleError)));
       }, noop_1.noop));
       source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function(value) {
@@ -37377,17 +38240,17 @@ var require_windowWhen = __commonJS((exports) => {
   var innerFrom_1 = require_innerFrom();
   function windowWhen(closingSelector) {
     return lift_1.operate(function(source, subscriber) {
-      var window;
+      var window2;
       var closingSubscriber;
       var handleError = function(err) {
-        window.error(err);
+        window2.error(err);
         subscriber.error(err);
       };
       var openWindow = function() {
         closingSubscriber === null || closingSubscriber === undefined || closingSubscriber.unsubscribe();
-        window === null || window === undefined || window.complete();
-        window = new Subject_1.Subject;
-        subscriber.next(window.asObservable());
+        window2 === null || window2 === undefined || window2.complete();
+        window2 = new Subject_1.Subject;
+        subscriber.next(window2.asObservable());
         var closingNotifier;
         try {
           closingNotifier = innerFrom_1.innerFrom(closingSelector());
@@ -37399,13 +38262,13 @@ var require_windowWhen = __commonJS((exports) => {
       };
       openWindow();
       source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function(value) {
-        return window.next(value);
+        return window2.next(value);
       }, function() {
-        window.complete();
+        window2.complete();
         subscriber.complete();
       }, handleError, function() {
         closingSubscriber === null || closingSubscriber === undefined || closingSubscriber.unsubscribe();
-        window = null;
+        window2 = null;
       }));
     });
   }
@@ -38340,6 +39203,11 @@ IslandComponent = __legacyDecorateClassTS([
   })
 ], IslandComponent);
 var Island = IslandComponent;
+// src/angular/createIsland.ts
+init_renderIslandMarkup();
+var createTypedIsland = (registry) => {
+  return (props) => renderIslandMarkup(registry, props);
+};
 // src/angular/island-state.service.ts
 var import_rxjs = __toESM(require_cjs(), 1);
 import { Injectable } from "@angular/core";
@@ -38450,9 +39318,10 @@ var renderIsland = async () => {
 };
 export {
   renderIsland,
+  createTypedIsland,
   IslandState,
   Island
 };
 
-//# debugId=6B7EAAC7963B51E564756E2164756E21
+//# debugId=E514B079E0178E1464756E2164756E21
 //# sourceMappingURL=browser.js.map