remote-components 0.3.4 → 0.3.6

package/dist/chunk-ER73O65F.cjs

@@ -0,0 +1,703 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk6IUP26UKcjs = require('./chunk-6IUP26UK.cjs');
+
+
+
+var _chunkF44NODUScjs = require('./chunk-F44NODUS.cjs');
+
+
+
+var _chunkXCFYWSLDcjs = require('./chunk-XCFYWSLD.cjs');
+
+
+var _chunkCREXMFMFcjs = require('./chunk-CREXMFMF.cjs');
+
+
+
+
+
+
+
+
+
+
+
+var _chunkR4QFK5TNcjs = require('./chunk-R4QFK5TN.cjs');
+
+
+
+
+
+
+var _chunkRUWR74XQcjs = require('./chunk-RUWR74XQ.cjs');
+
+
+var _chunkTCFLEBQMcjs = require('./chunk-TCFLEBQM.cjs');
+
+// src/host/server/fetch-with-hooks.ts
+async function fetchWithWarning(url, init) {
+  try {
+    return await fetch(url, init);
+  } catch (error) {
+    _chunkRUWR74XQcjs.warnCrossOriginFetchError.call(void 0, "FetchRemoteComponent", url);
+    throw error;
+  }
+}
+async function fetchWithHooks(url, additionalInit, options = {}) {
+  const {
+    onRequest,
+    onResponse,
+    abortController = new AbortController()
+  } = options;
+  const signal = abortController.signal;
+  const hookOptions = {
+    signal,
+    abort: (reason) => abortController.abort(reason)
+  };
+  const init = {
+    method: "GET",
+    headers: _chunkTCFLEBQMcjs.remoteFetchHeaders.call(void 0, ),
+    signal,
+    ...additionalInit
+  };
+  const res = await _asyncNullishCoalesce(await _optionalChain([onRequest, 'optionalCall', _ => _(url, init, hookOptions)]), async () => ( await fetchWithWarning(url, init)));
+  return await _asyncNullishCoalesce(await _optionalChain([onResponse, 'optionalCall', _2 => _2(url, res, hookOptions)]), async () => ( res));
+}
+
+// src/host/server/get-client-or-server-url.ts
+function getClientOrServerUrl(src, serverFallback) {
+  const fallback = typeof location !== "undefined" ? location.href : serverFallback;
+  if (!src) {
+    return new URL(fallback);
+  }
+  return typeof src === "string" ? new URL(src, fallback) : src;
+}
+
+// src/host/shared/lifecycle.ts
+function makeReactEmitter(callbacks) {
+  return {
+    beforeLoad(src) {
+      _optionalChain([callbacks, 'access', _3 => _3.onBeforeLoad, 'optionalCall', _4 => _4(src)]);
+    },
+    load(src) {
+      _optionalChain([callbacks, 'access', _5 => _5.onLoad, 'optionalCall', _6 => _6(src)]);
+    },
+    error(error, _src) {
+      _optionalChain([callbacks, 'access', _7 => _7.onError, 'optionalCall', _8 => _8(error)]);
+    },
+    change(info) {
+      _optionalChain([callbacks, 'access', _9 => _9.onChange, 'optionalCall', _10 => _10(info)]);
+    }
+  };
+}
+function makeEventEmitter(element) {
+  function dispatch(type, detail) {
+    const event = new Event(type, { bubbles: true, composed: true });
+    if (detail) {
+      Object.assign(event, detail);
+    }
+    element.dispatchEvent(event);
+  }
+  return {
+    beforeLoad(src) {
+      dispatch("beforeload", { src });
+    },
+    load(src) {
+      dispatch("load", { src });
+    },
+    error(error, src) {
+      dispatch("error", src != null ? { error, src } : { error });
+    },
+    change(info) {
+      dispatch("change", info);
+    }
+  };
+}
+
+// src/runtime/rsc.ts
+var _webstreamspolyfill = require('web-streams-polyfill');
+function fixPayload(payload) {
+  if (Array.isArray(payload)) {
+    if (payload[0] === "$") {
+      fixPayload(payload[3]);
+      if (payload.length === 4) {
+        payload.push(null, null, 1);
+      }
+    } else {
+      for (const item of payload) {
+        fixPayload(item);
+      }
+    }
+  } else if (typeof payload === "object" && payload !== null) {
+    for (const key in payload) {
+      fixPayload(payload[key]);
+    }
+  }
+}
+function buildRSCChunks(rscName, data) {
+  const chunks = [];
+  for (const chunk of data) {
+    for (const line of chunk.split("\n")) {
+      const match = /\.push\("(?<rsc>.*)"\);$/.exec(line);
+      if (_optionalChain([match, 'optionalAccess', _11 => _11.groups, 'optionalAccess', _12 => _12.rsc])) {
+        chunks.push(JSON.parse(`"${match.groups.rsc}"`));
+      }
+    }
+  }
+  return chunks;
+}
+function createRSCStream(rscName, data) {
+  return new (0, _webstreamspolyfill.ReadableStream)({
+    type: "bytes",
+    start(controller) {
+      const encoder = new TextEncoder();
+      const self = globalThis;
+      if (data.length > 0) {
+        const parsed = buildRSCChunks(rscName, data);
+        if (parsed.length > 0) {
+          self[rscName] = _nullishCoalesce(self[rscName], () => ( []));
+          self[rscName].push(...parsed);
+        }
+      }
+      const allChunks = (_nullishCoalesce(self[rscName], () => ( [`0:[null]
+`]))).join("");
+      self[rscName] = null;
+      allChunks.split("\n").forEach((chunk) => {
+        if (chunk.length > 0) {
+          const { before, id, prefix, payload } = _nullishCoalesce(_optionalChain([/^(?<before>[^:]*?)?(?<id>[0-9a-zA-Z]+):(?<prefix>[A-Z])?(?<payload>\[.*\])/, 'access', _13 => _13.exec, 'call', _14 => _14(
+            chunk
+          ), 'optionalAccess', _15 => _15.groups]), () => ( {}));
+          if (payload) {
+            const jsonPayload = JSON.parse(payload);
+            fixPayload(jsonPayload);
+            const reconstruct = `${_nullishCoalesce(before, () => ( ""))}${id}:${_nullishCoalesce(prefix, () => ( ""))}${JSON.stringify(jsonPayload)}`;
+            controller.enqueue(encoder.encode(`${reconstruct}
+`));
+          } else {
+            controller.enqueue(encoder.encode(`${chunk}
+`));
+          }
+        } else {
+          controller.enqueue(encoder.encode(`${chunk}
+`));
+        }
+      });
+      controller.close();
+    }
+  });
+}
+
+// src/runtime/html/html-spec.ts
+var ORIGIN_REWRITE_TAGS = [
+  "img",
+  "source",
+  "video",
+  "audio",
+  "track",
+  "iframe",
+  "embed",
+  "script",
+  "link"
+];
+var ID_SUFFIX_RSC = "_rsc";
+var ID_SUFFIX_SSR = "_ssr";
+var ID_SUFFIX_SHARED = "_shared";
+var DATA_BUNDLE = "data-bundle";
+var DATA_ROUTE = "data-route";
+var DATA_RUNTIME = "data-runtime";
+var DATA_TYPE = "data-type";
+var DATA_SRC = "data-src";
+var DATA_REMOTE_COMPONENTS_SHARED = "data-remote-components-shared";
+var TAG_REMOTE_COMPONENT = "remote-component";
+var NEXT_DATA_ID = "__NEXT_DATA__";
+var REMOTE_NEXT_DATA_ID = "__REMOTE_NEXT_DATA__";
+var NEXT_CONTAINER_ID = "__next";
+
+// src/runtime/html/rewrite-srcset.ts
+function rewriteSrcset(srcset, base, resolve) {
+  return srcset.split(",").map((entry) => {
+    const [url, descriptor] = entry.trim().split(/\s+/);
+    if (!url)
+      return entry;
+    const absoluteUrl = new URL(url, base).href;
+    const resolvedUrl = resolve ? resolve(absoluteUrl) : absoluteUrl;
+    return descriptor ? `${resolvedUrl} ${descriptor}` : resolvedUrl;
+  }).join(", ");
+}
+
+// src/runtime/html/apply-origin.ts
+function applyOriginToNodes(doc, url, resolveClientUrl) {
+  if (url.origin !== location.origin) {
+    const nodes = doc.querySelectorAll(
+      ORIGIN_REWRITE_TAGS.map(
+        (type) => `${type}[src],${type}[srcset],${type}[href],${type}[imagesrcset]`
+      ).join(",")
+    );
+    nodes.forEach((node) => {
+      if (node.hasAttribute("src") && /^[./]+\/?/.test(_nullishCoalesce(node.getAttribute("src"), () => ( "")))) {
+        const absoluteSrc = new URL(_nullishCoalesce(node.getAttribute("src"), () => ( "/")), url).href;
+        const isScript = node.tagName.toLowerCase() === "script";
+        node.src = isScript ? absoluteSrc : _nullishCoalesce(_optionalChain([resolveClientUrl, 'optionalCall', _16 => _16(absoluteSrc)]), () => ( absoluteSrc));
+      }
+      if (node.hasAttribute("href") && /^[./]+\/?/.test(_nullishCoalesce(node.getAttribute("href"), () => ( "")))) {
+        const absoluteHref = new URL(_nullishCoalesce(node.getAttribute("href"), () => ( "/")), url).href;
+        node.setAttribute(
+          "href",
+          _nullishCoalesce(_optionalChain([resolveClientUrl, 'optionalCall', _17 => _17(absoluteHref)]), () => ( absoluteHref))
+        );
+      }
+      if (node.hasAttribute("srcset")) {
+        const raw = node.getAttribute("srcset");
+        if (raw) {
+          const resolve = resolveClientUrl ? (abs) => _nullishCoalesce(resolveClientUrl(abs), () => ( abs)) : void 0;
+          node.setAttribute("srcset", rewriteSrcset(raw, url, resolve));
+        }
+      }
+      if (node.hasAttribute("imagesrcset")) {
+        const raw = node.getAttribute("imagesrcset");
+        if (raw) {
+          const resolve = resolveClientUrl ? (abs) => _nullishCoalesce(resolveClientUrl(abs), () => ( abs)) : void 0;
+          node.setAttribute("imagesrcset", rewriteSrcset(raw, url, resolve));
+        }
+      }
+    });
+  }
+}
+
+// src/runtime/metadata.ts
+var VALID_RUNTIMES = /* @__PURE__ */ new Set(["webpack", "turbopack", "script"]);
+var VALID_TYPES = /* @__PURE__ */ new Set([
+  "nextjs",
+  "remote-component",
+  "unknown"
+]);
+function isRuntime(value) {
+  return VALID_RUNTIMES.has(value);
+}
+function isComponentType(value) {
+  return VALID_TYPES.has(value);
+}
+function toRuntime(value) {
+  return value && isRuntime(value) ? value : "webpack";
+}
+function toComponentType(value) {
+  return value && isComponentType(value) ? value : "unknown";
+}
+function buildMetadata(attrs, url) {
+  const id = attrs.id || _chunkR4QFK5TNcjs.DEFAULT_COMPONENT_NAME;
+  const bundle = attrs.bundle || process.env.NEXT_PUBLIC_MFE_CURRENT_APPLICATION || _chunkR4QFK5TNcjs.DEFAULT_BUNDLE_NAME;
+  return {
+    name: attrs.name || id.replace(/_ssr$/, ""),
+    bundle,
+    route: attrs.route || url.pathname || _chunkR4QFK5TNcjs.DEFAULT_ROUTE,
+    runtime: toRuntime(attrs.runtime),
+    id,
+    type: toComponentType(attrs.type)
+  };
+}
+
+// src/runtime/html/parse-remote-html.ts
+function validateSingleComponent(doc, name, url) {
+  if (doc.querySelectorAll(`div[${DATA_BUNDLE}][${DATA_ROUTE}]`).length > 1 && !doc.querySelector(
+    `div[${DATA_BUNDLE}][${DATA_ROUTE}][id^="${name}"]`
+  ) || doc.querySelectorAll(`${TAG_REMOTE_COMPONENT}:not([src])`).length > 1 && !doc.querySelector(`${TAG_REMOTE_COMPONENT}[name="${name}"]`)) {
+    throw _chunkRUWR74XQcjs.multipleRemoteComponentsError.call(void 0, url);
+  }
+}
+function findComponentElement(doc, name) {
+  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(doc.querySelector(`div[${DATA_BUNDLE}][${DATA_ROUTE}][id^="${name}"]`), () => ( doc.querySelector(`div[${DATA_BUNDLE}][${DATA_ROUTE}]`))), () => ( doc.querySelector(`div#${NEXT_CONTAINER_ID}`))), () => ( doc.querySelector(`${TAG_REMOTE_COMPONENT}[name="${name}"]:not([src])`))), () => ( doc.querySelector(`${TAG_REMOTE_COMPONENT}:not([src])`)));
+}
+function parseNextData(doc) {
+  return JSON.parse(
+    _nullishCoalesce(_optionalChain([(_nullishCoalesce(doc.querySelector(`#${NEXT_DATA_ID}`), () => ( doc.querySelector(`#${REMOTE_NEXT_DATA_ID}`)))), 'optionalAccess', _18 => _18.textContent]), () => ( "null"))
+  );
+}
+function resolveComponentName(component, nextData, fallbackName) {
+  const isRemoteComponent = _optionalChain([component, 'optionalAccess', _19 => _19.tagName, 'access', _20 => _20.toLowerCase, 'call', _21 => _21()]) === TAG_REMOTE_COMPONENT;
+  const name = _optionalChain([component, 'optionalAccess', _22 => _22.getAttribute, 'call', _23 => _23("id"), 'optionalAccess', _24 => _24.replace, 'call', _25 => _25(new RegExp(`${ID_SUFFIX_SSR}$`), "")]) || isRemoteComponent && _optionalChain([component, 'optionalAccess', _26 => _26.getAttribute, 'call', _27 => _27("name")]) || (nextData ? "__next" : fallbackName);
+  return { name, isRemoteComponent };
+}
+function extractRemoteShared(doc, name, nextData) {
+  const remoteSharedEl = doc.querySelector(
+    `#${name}${ID_SUFFIX_SHARED}[${DATA_REMOTE_COMPONENTS_SHARED}]`
+  );
+  const remoteShared = _nullishCoalesce(_optionalChain([nextData, 'optionalAccess', _28 => _28.props, 'access', _29 => _29.__REMOTE_COMPONENT__, 'optionalAccess', _30 => _30.shared]), () => ( (_nullishCoalesce(JSON.parse(_nullishCoalesce(_optionalChain([remoteSharedEl, 'optionalAccess', _31 => _31.textContent]), () => ( "{}"))), () => ( {})))));
+  _optionalChain([remoteSharedEl, 'optionalAccess', _32 => _32.remove, 'call', _33 => _33()]);
+  return remoteShared;
+}
+function validateComponentFound(component, rsc, nextData, isRemoteComponent, url, name) {
+  if (!component || !(rsc || nextData || isRemoteComponent)) {
+    throw new (0, _chunkRUWR74XQcjs.RemoteComponentsError)(
+      `Remote Component not found on ${url}.${name !== _chunkR4QFK5TNcjs.DEFAULT_COMPONENT_NAME ? ` The name for the <RemoteComponent> is "${name}". Check <RemoteComponent> usage.` : ""} Did you forget to wrap the content in <RemoteComponent>?`
+    );
+  }
+}
+function extractLinks(doc, component) {
+  return Array.from(doc.querySelectorAll("link[href]")).filter(
+    (link) => !component.contains(link)
+  );
+}
+function extractScripts(doc, component, isRemoteComponent) {
+  return Array.from(
+    (isRemoteComponent ? component : doc).querySelectorAll(
+      `script[src],script[${DATA_SRC}]`
+    )
+  );
+}
+function parseRemoteComponentDocument(doc, name, url) {
+  validateSingleComponent(doc, name, url.href);
+  const component = findComponentElement(doc, name);
+  const nextData = parseNextData(doc);
+  const { name: resolvedName, isRemoteComponent } = resolveComponentName(
+    component,
+    nextData,
+    name
+  );
+  const rsc = doc.querySelector(`#${resolvedName}${ID_SUFFIX_RSC}`);
+  const metadata = buildMetadata(
+    {
+      name: resolvedName,
+      bundle: _optionalChain([component, 'optionalAccess', _34 => _34.getAttribute, 'call', _35 => _35(DATA_BUNDLE)]) || _optionalChain([nextData, 'optionalAccess', _36 => _36.props, 'access', _37 => _37.__REMOTE_COMPONENT__, 'optionalAccess', _38 => _38.bundle]),
+      route: _nullishCoalesce(_optionalChain([component, 'optionalAccess', _39 => _39.getAttribute, 'call', _40 => _40(DATA_ROUTE)]), () => ( _optionalChain([nextData, 'optionalAccess', _41 => _41.page]))),
+      runtime: _nullishCoalesce(_nullishCoalesce(_optionalChain([component, 'optionalAccess', _42 => _42.getAttribute, 'call', _43 => _43(DATA_RUNTIME)]), () => ( _optionalChain([nextData, 'optionalAccess', _44 => _44.props, 'access', _45 => _45.__REMOTE_COMPONENT__, 'optionalAccess', _46 => _46.runtime]))), () => ( _chunkR4QFK5TNcjs.RUNTIME_SCRIPT)),
+      id: _optionalChain([component, 'optionalAccess', _47 => _47.getAttribute, 'call', _48 => _48("id")]),
+      type: _optionalChain([component, 'optionalAccess', _49 => _49.getAttribute, 'call', _50 => _50(DATA_TYPE)])
+    },
+    url
+  );
+  const remoteShared = extractRemoteShared(doc, resolvedName, nextData);
+  validateComponentFound(
+    component,
+    rsc,
+    nextData,
+    isRemoteComponent,
+    url.href,
+    resolvedName
+  );
+  const links = extractLinks(doc, component);
+  const scripts = extractScripts(doc, component, isRemoteComponent);
+  return {
+    component,
+    name: resolvedName,
+    isRemoteComponent,
+    metadata,
+    nextData,
+    rsc,
+    remoteShared,
+    links,
+    scripts
+  };
+}
+
+// src/runtime/loaders/component-loader.ts
+var _react = require('react'); var React = _interopRequireWildcard(_react);
+var _jsxdevruntime = require('react/jsx-dev-runtime'); var JSXDevRuntime = _interopRequireWildcard(_jsxdevruntime);
+var _jsxruntime = require('react/jsx-runtime'); var JSXRuntime = _interopRequireWildcard(_jsxruntime);
+var _reactdom = require('react-dom'); var ReactDOM = _interopRequireWildcard(_reactdom);
+var _client = require('react-dom/client'); var ReactDOMClient = _interopRequireWildcard(_client);
+
+// src/runtime/rsc-imports.ts
+async function importRSCClientBrowser() {
+  try {
+    return await Promise.resolve().then(() => _interopRequireWildcard(require("next/dist/compiled/react-server-dom-webpack/client.browser")));
+  } catch (e) {
+    const mod = await Promise.resolve().then(() => _interopRequireWildcard(require("react-server-dom-webpack/client.browser")));
+    return _nullishCoalesce(mod.default, () => ( mod));
+  }
+}
+
+// src/runtime/loaders/component-loader.ts
+async function loadRemoteComponent({
+  url,
+  name,
+  rscName,
+  bundle,
+  route = "/",
+  runtime = "webpack",
+  data,
+  nextData,
+  scripts = [],
+  shared = Promise.resolve({}),
+  remoteShared = {},
+  container,
+  resolveClientUrl
+}) {
+  try {
+    if (runtime === "webpack") {
+      const self = globalThis;
+      if (!self.__DISABLE_WEBPACK_EXEC__) {
+        self.__DISABLE_WEBPACK_EXEC__ = {};
+      }
+      self.__DISABLE_WEBPACK_EXEC__[bundle] = true;
+      await _chunk6IUP26UKcjs.loadScripts.call(void 0, scripts, resolveClientUrl);
+    }
+    const hostShared = await shared;
+    _chunkRUWR74XQcjs.logDebug.call(void 0, 
+      "ComponentLoader",
+      `loadRemoteComponent: bundle="${bundle}", name="${name}"`
+    );
+    _chunkRUWR74XQcjs.logDebug.call(void 0, 
+      "ComponentLoader",
+      `Host shared modules available: ${Object.keys(hostShared)}`
+    );
+    _chunkRUWR74XQcjs.logDebug.call(void 0, 
+      "ComponentLoader",
+      `Remote shared modules requested: ${JSON.stringify(remoteShared)}`
+    );
+    const scope = await _chunkF44NODUScjs.setupRemoteScope.call(void 0, 
+      runtime,
+      scripts,
+      url,
+      bundle,
+      resolveClientUrl
+    );
+    if (runtime === "turbopack") {
+      await _chunkF44NODUScjs.initializeSharedModules.call(void 0, 
+        scope,
+        _chunkR4QFK5TNcjs.buildCoreShared.call(void 0, hostShared),
+        remoteShared
+      );
+    }
+    if (bundle) {
+      const resolve = await _chunkR4QFK5TNcjs.buildWebpackResolve.call(void 0, 
+        hostShared,
+        remoteShared,
+        bundle,
+        {
+          "/react/index.js": React,
+          "/react/jsx-dev-runtime.js": JSXDevRuntime,
+          "/react/jsx-runtime.js": JSXRuntime,
+          "/react-dom/index.js": ReactDOM,
+          "/react-dom/client.js": ReactDOMClient
+        },
+        "ComponentLoader"
+      );
+      _chunkXCFYWSLDcjs.applySharedModules.call(void 0, bundle, resolve);
+    } else {
+      _chunkRUWR74XQcjs.logWarn.call(void 0, 
+        "ComponentLoader",
+        "No bundle specified, skipping shared module setup"
+      );
+    }
+    const scopedData = data.map(
+      (chunk) => chunk.replaceAll(`[${bundle}]`, `[${scope.scopedName}]`)
+    );
+    if (scopedData.length > 0) {
+      return await loadRSCComponent(_nullishCoalesce(rscName, () => ( name)), scopedData);
+    } else if (nextData) {
+      return loadNextPagesComponent(bundle, route, nextData, name, container);
+    }
+    return loadRSCComponent(_nullishCoalesce(rscName, () => ( name)), [`0:[null]
+`]);
+  } catch (error) {
+    return {
+      component: null,
+      error: new (0, _chunkRUWR74XQcjs.RemoteComponentsError)(
+        `Failed to load remote component "${name}".`,
+        {
+          cause: error instanceof Error ? error : new Error(String(error))
+        }
+      )
+    };
+  }
+}
+async function loadRSCComponent(rscName, data) {
+  const { createFromReadableStream } = await importRSCClientBrowser();
+  if (typeof createFromReadableStream !== "function") {
+    throw new (0, _chunkRUWR74XQcjs.RemoteComponentsError)(
+      'Failed to import "react-server-dom-webpack". Is Next.js installed correctly?'
+    );
+  }
+  const stream = createRSCStream(rscName, data);
+  const component = createFromReadableStream(stream);
+  return { component };
+}
+function loadNextPagesComponent(bundle, route, nextData, name, container) {
+  const { Component, App } = _chunkXCFYWSLDcjs.nextClientPagesLoader.call(void 0, bundle, route, container);
+  if (!Component) {
+    throw new (0, _chunkRUWR74XQcjs.RemoteComponentsError)(
+      `Remote Component "${name}" is trying to load the component for route "${route}" but it is not available.`
+    );
+  }
+  const component = App ? React.createElement(App, { Component, ...nextData.props }) : React.createElement(Component, nextData.props);
+  return { component };
+}
+
+// src/host/shared/pipeline.ts
+function preparePipeline(input) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(input.html, "text/html");
+  const parsed = parseRemoteComponentDocument(doc, input.name, input.url);
+  const remoteShared = _nullishCoalesce(input.remoteShared, () => ( parsed.remoteShared));
+  if ("__remote_components_missing_shared__" in remoteShared) {
+    throw new (0, _chunkRUWR74XQcjs.RemoteComponentsError)(
+      remoteShared.__remote_components_missing_shared__
+    );
+  }
+  applyOriginToNodes(doc, input.url, input.resolveClientUrl);
+  const scriptDescriptors = buildScriptDescriptors(parsed.scripts, input.url);
+  return { doc, parsed, scriptDescriptors };
+}
+async function loadPrepared(input) {
+  const { prepared, url, signal, resolveClientUrl, container, rscName } = input;
+  const { doc, parsed, scriptDescriptors } = prepared;
+  if (signal.aborted) {
+    return { status: "aborted" };
+  }
+  const userShared = await input.shared;
+  if (signal.aborted) {
+    return { status: "aborted" };
+  }
+  if (parsed.isRemoteComponent) {
+    return loadStaticPath({
+      parsed,
+      doc,
+      url,
+      resolveClientUrl
+    });
+  }
+  return loadDynamicPath({
+    parsed,
+    doc,
+    url,
+    scriptDescriptors,
+    shared: userShared,
+    resolveClientUrl,
+    container,
+    rscName
+  });
+}
+function buildScriptDescriptors(scripts, url) {
+  return scripts.map((script) => {
+    const scriptSrc = script.getAttribute("data-src") || script.getAttribute("src") || script.src;
+    const { prefix, id: path } = _nullishCoalesce(_optionalChain([_chunkR4QFK5TNcjs.REMOTE_COMPONENT_REGEX, 'access', _51 => _51.exec, 'call', _52 => _52(scriptSrc), 'optionalAccess', _53 => _53.groups]), () => ( {
+      prefix: void 0,
+      id: scriptSrc
+    }));
+    return {
+      src: new URL(_chunkR4QFK5TNcjs.collapseDoubleSlashes.call(void 0, `${_nullishCoalesce(prefix, () => ( ""))}${path}`), url).href
+    };
+  });
+}
+async function loadStaticPath(input) {
+  const { parsed, doc, url, resolveClientUrl } = input;
+  const scripts = Array.from(
+    parsed.component.querySelectorAll("script")
+  );
+  const { mount, unmount } = await _chunkCREXMFMFcjs.loadStaticRemoteComponent.call(void 0, 
+    scripts,
+    url,
+    resolveClientUrl
+  );
+  return {
+    status: "static",
+    mount,
+    unmount,
+    metadata: parsed.metadata,
+    parsed,
+    doc
+  };
+}
+async function loadDynamicPath(input) {
+  const {
+    parsed,
+    doc,
+    url,
+    scriptDescriptors,
+    shared,
+    resolveClientUrl,
+    container
+  } = input;
+  const rscName = _nullishCoalesce(input.rscName, () => ( (parsed.rsc ? `__remote_component_rsc_${_chunkR4QFK5TNcjs.escapeString.call(void 0, url.href)}_${_chunkR4QFK5TNcjs.escapeString.call(void 0, parsed.name)}` : void 0)));
+  const rscData = parsed.rsc ? (parsed.rsc.textContent || "").split("\n").filter(Boolean) : [];
+  const result = await loadRemoteComponent({
+    url,
+    name: parsed.name,
+    rscName,
+    bundle: parsed.metadata.bundle,
+    route: parsed.metadata.route,
+    runtime: parsed.metadata.runtime,
+    data: rscData,
+    nextData: parsed.nextData,
+    scripts: scriptDescriptors,
+    shared: _chunkR4QFK5TNcjs.buildHostShared.call(void 0, shared, resolveClientUrl),
+    remoteShared: parsed.remoteShared,
+    container,
+    resolveClientUrl
+  });
+  if (result.error) {
+    return { status: "error", error: result.error };
+  }
+  return {
+    status: "loaded",
+    component: result.component,
+    metadata: parsed.metadata,
+    parsed,
+    doc
+  };
+}
+
+// src/host/shared/state.ts
+function createHostState() {
+  return {
+    stage: "idle",
+    prevSrc: void 0,
+    prevUrl: void 0,
+    prevName: void 0,
+    prevIsRemoteComponent: false,
+    abortController: void 0
+  };
+}
+
+// src/host/utils/resolve-name-from-src.ts
+function resolveNameFromSrc(src, defaultName) {
+  if (!src) {
+    return defaultName;
+  }
+  const hash = typeof src === "string" ? src : src.hash;
+  const hashIndex = hash.indexOf("#");
+  if (hashIndex < 0) {
+    return defaultName;
+  }
+  const name = hash.slice(hashIndex + 1);
+  return name || defaultName;
+}
+
+// src/runtime/url/resolve-client-url.ts
+function withRemoteSrc(resolveClientUrl, remoteSrc) {
+  const remoteOrigin = parseOrigin(remoteSrc);
+  return (url) => {
+    const urlOrigin = parseOrigin(url);
+    if (remoteOrigin && urlOrigin && urlOrigin !== remoteOrigin) {
+      return void 0;
+    }
+    return resolveClientUrl(remoteSrc, url);
+  };
+}
+function parseOrigin(url) {
+  try {
+    return new URL(url).origin;
+  } catch (e2) {
+    return void 0;
+  }
+}
+
+// src/runtime/url/default-resolve-client-url.ts
+function bindResolveClientUrl(prop, remoteSrc) {
+  return prop ? withRemoteSrc(prop, remoteSrc) : void 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+exports.fetchWithHooks = fetchWithHooks; exports.getClientOrServerUrl = getClientOrServerUrl; exports.makeReactEmitter = makeReactEmitter; exports.makeEventEmitter = makeEventEmitter; exports.createRSCStream = createRSCStream; exports.preparePipeline = preparePipeline; exports.loadPrepared = loadPrepared; exports.createHostState = createHostState; exports.resolveNameFromSrc = resolveNameFromSrc; exports.bindResolveClientUrl = bindResolveClientUrl;
+//# sourceMappingURL=chunk-ER73O65F.cjs.map