remote-components 0.4.2 → 0.4.3

package/dist/chunk-HMB3SIVJ.cjs

@@ -0,0 +1,973 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return 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 _chunk7XXO2DLFcjs = require('./chunk-7XXO2DLF.cjs');
+
+
+var _chunkZ2SLBFQLcjs = require('./chunk-Z2SLBFQL.cjs');
+
+
+
+
+
+
+
+var _chunkBBXVML3Dcjs = require('./chunk-BBXVML3D.cjs');
+
+
+var _chunkKE7QPAQ4cjs = require('./chunk-KE7QPAQ4.cjs');
+
+// src/config/webpack/apply-shared-modules.ts
+var DEDUPLICATION_SKIPPED = "shared module deduplication skipped. The remote may load its own copy of shared dependencies.";
+function applySharedModules(bundle, resolve) {
+  _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+    "SharedModules",
+    `applySharedModules called for bundle: "${bundle}"`
+  );
+  _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+    "SharedModules",
+    `Shared modules to resolve: ${Object.keys(resolve)}`
+  );
+  const self = globalThis;
+  const scope = _chunk7XXO2DLFcjs.getScope.call(void 0, bundle);
+  const webpackBundle = _nullishCoalesce(_optionalChain([scope, 'optionalAccess', _ => _.webpackRequire]), () => ( _optionalChain([self, 'access', _2 => _2.__remote_webpack_require__, 'optionalAccess', _3 => _3[bundle]])));
+  if (webpackBundle) {
+    const modulePaths = Object.keys(
+      _nullishCoalesce(_nullishCoalesce(_optionalChain([self, 'access', _4 => _4.__remote_webpack_module_map__, 'optionalAccess', _5 => _5[bundle]]), () => ( webpackBundle.m)), () => ( {}))
+    );
+    _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+      "SharedModules",
+      `Available module paths for bundle "${bundle}": ${modulePaths}`
+    );
+    for (const [key, value] of Object.entries(resolve)) {
+      const exactIds = modulePaths.filter((p) => p === key);
+      const ids = exactIds.length > 0 ? exactIds : modulePaths.filter((p) => p.includes(key));
+      if (ids.length === 0) {
+        _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+          "SharedModules",
+          `No matching module path found for shared module "${key}"`
+        );
+      }
+      for (const id of ids) {
+        if (webpackBundle.m) {
+          const resolvedId = _optionalChain([self, 'access', _6 => _6.__remote_webpack_module_map__, 'optionalAccess', _7 => _7[bundle], 'optionalAccess', _8 => _8[id]]) ? `${self.__remote_webpack_module_map__[bundle][id]}` : id;
+          if (resolvedId !== id) {
+            _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+              "SharedModules",
+              `Mapped module id: "${id}" -> "${resolvedId}"`
+            );
+          }
+          webpackBundle.m[resolvedId] = (module) => {
+            module.exports = value;
+          };
+        } else {
+          _chunkBBXVML3Dcjs.logWarn.call(void 0, 
+            "SharedModules",
+            `webpackBundle.m is not available for bundle "${bundle}" \u2014 ${DEDUPLICATION_SKIPPED}`
+          );
+        }
+      }
+    }
+  } else {
+    _chunkBBXVML3Dcjs.logWarn.call(void 0, 
+      "SharedModules",
+      `No webpack require found for bundle "${bundle}" \u2014 ${DEDUPLICATION_SKIPPED}`
+    );
+    _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+      "SharedModules",
+      `Available bundles: ${Object.keys(_nullishCoalesce(self.__remote_webpack_require__, () => ( {})))}`
+    );
+  }
+}
+
+// src/runtime/turbopack/patterns.ts
+var MODULE_ID_PATTERN = '"[^"]+"|[0-9]+';
+function stripQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function extractGroup(re, input, group) {
+  const raw = _optionalChain([re, 'access', _9 => _9.exec, 'call', _10 => _10(input), 'optionalAccess', _11 => _11.groups, 'optionalAccess', _12 => _12[group]]);
+  return raw ? stripQuotes(raw) : void 0;
+}
+var REMOTE_SHARED_MARKER_RE = /(?:self|[a-z])\.TURBOPACK_REMOTE_SHARED/;
+var REMOTE_SHARED_ASSIGNMENT_RE = new RegExp(
+  `\\.TURBOPACK_REMOTE_SHARED\\s*=\\s*await (?:__turbopack_context__|[a-z])\\.A\\((?<sharedModuleId>${MODULE_ID_PATTERN})\\)`
+);
+var ASYNC_MODULE_LOADER_RE = new RegExp(
+  `(?:__turbopack_context__|[a-z])\\.A\\((?<asyncSharedModuleId>${MODULE_ID_PATTERN})\\)`
+);
+var ASYNC_MODULE_CALLBACK_RE = new RegExp(
+  `(?:parentImport|[a-z])\\((?<sharedModuleId>${MODULE_ID_PATTERN})\\)`
+);
+var TURBOPACK_GLOBAL_RE = /(?:globalThis|self)\s*(?:\.TURBOPACK|\[\s*["']TURBOPACK["']\s*\])/;
+
+// src/runtime/turbopack/chunk-loader.ts
+function loadChunkWithScope(scope, chunkId) {
+  _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+    "ChunkLoader",
+    `loadChunkWithScope: "${chunkId}" (scope: "${scope.scopedName}")`
+  );
+  const self = globalThis;
+  const ns = _chunkZ2SLBFQLcjs.getNamespace.call(void 0, );
+  const { bundle, path, prefix } = _chunk7XXO2DLFcjs.parseRemoteId.call(void 0, chunkId);
+  const remoteRuntime = _optionalChain([self, 'access', _13 => _13.__remote_webpack_require__, 'optionalAccess', _14 => _14[_nullishCoalesce(bundle, () => ( "default"))]]) ? _optionalChain([self, 'access', _15 => _15.__remote_webpack_require__, 'access', _16 => _16[_nullishCoalesce(bundle, () => ( "default"))], 'optionalAccess', _17 => _17.type]) || "webpack" : scope.runtime;
+  if (remoteRuntime === _chunk7XXO2DLFcjs.RUNTIME_WEBPACK) {
+    return Promise.resolve(void 0);
+  }
+  const rawPath = path ? _chunk7XXO2DLFcjs.collapseDoubleSlashes.call(void 0, `${prefix}${path}`) : "/";
+  const url = new URL(rawPath, scope.url).href;
+  if (url.endsWith(".css")) {
+    return;
+  }
+  if (ns.chunkCache[url]) {
+    _chunkBBXVML3Dcjs.logDebug.call(void 0, "ChunkLoader", `Cache hit for "${chunkId}" (url="${url}")`);
+    return ns.chunkCache[url];
+  }
+  const resolvedUrl = _nullishCoalesce(_optionalChain([scope, 'access', _18 => _18.resolveClientUrl, 'optionalCall', _19 => _19(url)]), () => ( url));
+  if (resolvedUrl !== url) {
+    _chunkBBXVML3Dcjs.logDebug.call(void 0, "ChunkLoader", `Proxied chunk URL: "${url}" \u2192 "${resolvedUrl}"`);
+  }
+  ns.chunkCache[url] = new Promise((resolve, reject) => {
+    fetch(resolvedUrl).then((res) => res.text()).then((code) => {
+      const hasTurbopack = TURBOPACK_GLOBAL_RE.test(code);
+      if (hasTurbopack) {
+        return handleTurbopackChunk(code, scope, url);
+      }
+    }).then(resolve).catch((error) => {
+      const isProxied = _chunkKE7QPAQ4cjs.isProxiedUrl.call(void 0, resolvedUrl);
+      if (isProxied) {
+        reject(_chunkBBXVML3Dcjs.failedProxiedAssetError.call(void 0, "chunk", url, resolvedUrl));
+      } else {
+        _chunkBBXVML3Dcjs.warnCrossOriginFetchError.call(void 0, "ChunkLoader", url);
+        reject(error);
+      }
+    });
+  });
+  return ns.chunkCache[url];
+}
+function createChunkDispatcher() {
+  return function __chunk_dispatcher__(chunkId, scriptBundle) {
+    _chunkBBXVML3Dcjs.logDebug.call(void 0, "ChunkDispatcher", `Dispatching chunk: "${chunkId}"`);
+    const { bundle } = _chunk7XXO2DLFcjs.parseRemoteId.call(void 0, chunkId);
+    const bundleName = bundle || scriptBundle || "default";
+    const scope = _chunk7XXO2DLFcjs.getScope.call(void 0, bundleName);
+    _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+      "ChunkDispatcher",
+      `Scope resolution: bundle="${bundleName}", scope=${_nullishCoalesce(_optionalChain([scope, 'optionalAccess', _20 => _20.scopedName]), () => ( "null"))}`
+    );
+    if (!scope) {
+      _chunkBBXVML3Dcjs.logWarn.call(void 0, "ChunkDispatcher", `No scope found for bundle "${bundleName}"`);
+      return Promise.resolve(void 0);
+    }
+    return loadChunkWithScope(scope, chunkId);
+  };
+}
+async function handleTurbopackChunk(code, scope, url) {
+  if (/importScripts\(\.\.\.self.TURBOPACK_NEXT_CHUNK_URLS/.test(code)) {
+    const preloadLinks = document.querySelectorAll(
+      `link[rel="preload"][href="${new URL(url).pathname}"]`
+    );
+    preloadLinks.forEach((preloadLink) => preloadLink.remove());
+    return;
+  }
+  const self = globalThis;
+  const { globalKey } = scope;
+  const transformedCode = code.replace(
+    /globalThis\[\s*["']TURBOPACK["']\s*\]/g,
+    `globalThis["TURBOPACK_${globalKey}"]`
+  ).replace(
+    /self\[\s*["']TURBOPACK["']\s*\]/g,
+    `self["TURBOPACK_${globalKey}"]`
+  ).replace(/globalThis\.TURBOPACK/g, `globalThis.TURBOPACK_${globalKey}`).replace(/self\.TURBOPACK(?!_)/g, `self.TURBOPACK_${globalKey}`).replace(
+    /TURBOPACK_WORKER_LOCATION/g,
+    `TURBOPACK_WORKER_LOCATION_${globalKey}`
+  ).replace(
+    /TURBOPACK_NEXT_CHUNK_URLS/g,
+    `TURBOPACK_NEXT_CHUNK_URLS_${globalKey}`
+  ).replace(/TURBOPACK_CHUNK_LISTS/g, `TURBOPACK_CHUNK_LISTS_${globalKey}`).replace(
+    /TURBOPACK_CHUNK_UPDATE_LISTENERS/g,
+    `TURBOPACK_CHUNK_UPDATE_LISTENERS_${globalKey}`
+  ).replace(/__next_require__/g, `__${globalKey}_next_require__`).replace(
+    /\/\/# sourceMappingURL=(?<name>.+)(?<optional>\._)?\.js\.map/g,
+    `//# sourceMappingURL=${new URL(".", new URL(url, scope.url)).href}$1$2.js.map`
+  );
+  if (!self[`TURBOPACK_${globalKey}`]) {
+    const wrapPush = (target) => {
+      const originalPush = target.push;
+      if (typeof originalPush !== "function")
+        return target;
+      target.push = (...items) => {
+        for (const item of items) {
+          if (Array.isArray(item)) {
+            for (const entry of item) {
+              scope.turbopackModules.push(entry);
+            }
+          } else {
+            scope.turbopackModules.push(item);
+          }
+        }
+        return originalPush.apply(target, items);
+      };
+      return target;
+    };
+    const globalProp = `TURBOPACK_${globalKey}`;
+    let currentValue = wrapPush([]);
+    Object.defineProperty(self, globalProp, {
+      get() {
+        return currentValue;
+      },
+      set(newValue) {
+        if (newValue && typeof newValue === "object") {
+          wrapPush(newValue);
+        }
+        currentValue = newValue;
+      },
+      configurable: true,
+      enumerable: true
+    });
+  }
+  await new Promise((scriptResolve, scriptReject) => {
+    const blob = new Blob([transformedCode], {
+      type: "application/javascript; charset=UTF-8"
+    });
+    const scriptUrl = URL.createObjectURL(blob);
+    const script = document.createElement("script");
+    script.setAttribute("data-turbopack-src", url);
+    script.src = scriptUrl;
+    script.async = true;
+    script.onload = () => {
+      URL.revokeObjectURL(scriptUrl);
+      scriptResolve(void 0);
+      script.remove();
+    };
+    script.onerror = () => {
+      URL.revokeObjectURL(scriptUrl);
+      scriptReject(
+        new (0, _chunkBBXVML3Dcjs.RemoteComponentsError)(
+          `Failed to load <script src="${script.src}"> for Remote Component. Check the URL is correct.`
+        )
+      );
+      script.remove();
+    };
+    document.head.appendChild(script);
+  });
+  const chunkLists = self[`TURBOPACK_${globalKey}_CHUNK_LISTS`];
+  const loadChunkPromises = [];
+  while (_optionalChain([chunkLists, 'optionalAccess', _21 => _21.length])) {
+    const { chunks } = _nullishCoalesce(chunkLists.shift(), () => ( { chunks: [] }));
+    if (chunks.length > 0) {
+      for (const id of chunks) {
+        const baseUrl = url.slice(0, url.indexOf("/_next"));
+        const chunkLoadResult = loadChunkWithScope(
+          scope,
+          _chunk7XXO2DLFcjs.formatRemoteId.call(void 0, scope, `${baseUrl}/_next/${id}`)
+        );
+        if (chunkLoadResult) {
+          loadChunkPromises.push(chunkLoadResult);
+        }
+      }
+    }
+  }
+  if (loadChunkPromises.length > 0) {
+    await Promise.all(loadChunkPromises);
+  }
+}
+
+// src/runtime/turbopack/module.ts
+function requireModule(scope, moduleId, fullId) {
+  const idStr = String(moduleId);
+  const sharedModule = getSharedModule(scope, moduleId);
+  if (sharedModule !== null) {
+    if (scope.moduleCache[idStr]) {
+      _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+        "TurbopackModule",
+        `Shared module "${idStr}" resolved from host and overrides a cached remote copy in "${scope.scopedName}"`
+      );
+    }
+    return sharedModule;
+  }
+  if (scope.moduleCache[idStr])
+    return scope.moduleCache[idStr];
+  return handleTurbopackModule(
+    scope,
+    idStr,
+    _nullishCoalesce(fullId, () => ( _chunk7XXO2DLFcjs.formatRemoteId.call(void 0, scope, idStr)))
+  );
+}
+function handleTurbopackModule(scope, moduleId, id) {
+  if (scope.moduleCache[moduleId]) {
+    return scope.moduleCache[moduleId];
+  }
+  const modules = getTurbopackModules(scope);
+  if (!modules) {
+    _chunkBBXVML3Dcjs.logError.call(void 0, 
+      "TurbopackModule",
+      `TURBOPACK_${scope.globalKey} is undefined (scope: "${scope.scopedName}")`
+    );
+  }
+  const moduleInit = findModuleInit(modules, moduleId);
+  const exports = {};
+  const moduleExports = {
+    exports,
+    hot: createNoopHotModule()
+  };
+  if (typeof moduleInit !== "function") {
+    throw new Error(
+      `Module ${id} not found in bundle ${scope.name} with id ${moduleId}`
+    );
+  }
+  scope.moduleCache[moduleId] = moduleExports.exports;
+  moduleInit(
+    createTurbopackContext(
+      scope,
+      exports,
+      moduleExports,
+      modules,
+      moduleInit,
+      id
+    ),
+    moduleExports,
+    exports
+  );
+  if (scope.moduleCache[moduleId] !== moduleExports.exports) {
+    scope.moduleCache[moduleId] = moduleExports.exports;
+  }
+  return moduleExports.exports;
+}
+function findModuleInit(modules, moduleId) {
+  if (!modules || typeof modules !== "object")
+    return;
+  if (!Array.isArray(modules)) {
+    const key = moduleId in modules ? moduleId : Object.keys(modules).find((k) => k.startsWith(moduleId));
+    return key !== void 0 ? modules[key] : void 0;
+  }
+  const flat = modules.flat();
+  let idx = flat.findIndex((e) => String(e) === String(moduleId));
+  if (idx < 0) {
+    idx = flat.findIndex(
+      (e) => typeof e === "string" && e.startsWith(moduleId)
+    );
+  }
+  if (idx >= 0) {
+    return flat.slice(idx + 1).find((e) => typeof e === "function");
+  }
+  for (const entry of flat) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const obj = entry;
+    if (moduleId in obj)
+      return obj[moduleId];
+    const prefixKey = Object.keys(obj).find((k) => k.startsWith(moduleId));
+    if (prefixKey)
+      return obj[prefixKey];
+  }
+  return void 0;
+}
+function createTurbopackContext(scope, exports, moduleExports, modules, moduleInit, id) {
+  const scopedRequire = (moduleId) => requireModule(scope, moduleId, _chunk7XXO2DLFcjs.formatRemoteId.call(void 0, scope, String(moduleId)));
+  return {
+    // HMR not implemented for Remote Components
+    k: {
+      register() {
+      },
+      registerExports() {
+      },
+      signature() {
+        return (fn) => fn;
+      }
+    },
+    // ESM exports setup
+    s(bindings, esmId) {
+      let mod = exports;
+      if (typeof esmId === "string" || typeof esmId === "number") {
+        if (!scope.moduleCache[esmId]) {
+          scope.moduleCache[esmId] = {};
+        }
+        mod = scope.moduleCache[esmId];
+      }
+      Object.defineProperty(mod, "__esModule", { value: true });
+      if (Array.isArray(bindings)) {
+        let i = 0;
+        while (i < bindings.length) {
+          const propName = bindings[i++];
+          const tagOrFunc = bindings[i++];
+          if (typeof tagOrFunc === "number") {
+            Object.defineProperty(mod, propName, {
+              value: bindings[i++],
+              enumerable: true,
+              writable: false
+            });
+          } else {
+            const getterFn = tagOrFunc;
+            if (typeof bindings[i] === "function") {
+              const setterFn = bindings[i++];
+              Object.defineProperty(mod, propName, {
+                get: getterFn,
+                set: setterFn,
+                enumerable: true
+              });
+            } else {
+              Object.defineProperty(mod, propName, {
+                get: getterFn,
+                enumerable: true
+              });
+            }
+          }
+        }
+      }
+    },
+    // import — resolves directly via scope, no global dispatch
+    i(importId) {
+      let mod;
+      if (typeof importId === "string") {
+        const { exportSource, exportName } = _nullishCoalesce(_optionalChain([/\s+<export (?<exportSource>.*?) as (?<exportName>.*?)>$/, 'access', _22 => _22.exec, 'call', _23 => _23(
+          importId
+        ), 'optionalAccess', _24 => _24.groups]), () => ( {}));
+        const normalizedId = importId.replace(
+          /\s+<export(?<specifier>.*)>$/,
+          ""
+        );
+        mod = scopedRequire(normalizedId);
+        if (mod && exportSource && exportName && (exportSource === "*" || typeof mod[exportSource] !== "undefined") && typeof mod[exportName] === "undefined") {
+          if (exportSource === "*") {
+            mod[exportName] = mod;
+          } else {
+            mod[exportName] = mod[exportSource];
+          }
+        }
+      } else {
+        mod = scopedRequire(importId);
+      }
+      if (typeof mod !== "object" || mod === null) {
+        mod = { default: mod };
+      } else if (!("default" in mod) && // ES module namespace objects have a null prototype, so calling
+      // mod.toString() directly throws. Use Object.prototype.toString
+      // to safely detect them.
+      Object.prototype.toString.call(mod) !== "[object Module]") {
+        try {
+          mod.default = mod;
+        } catch (e2) {
+        }
+      }
+      return mod;
+    },
+    // require — resolves directly via scope
+    r(requireId) {
+      return scopedRequire(requireId);
+    },
+    // value exports
+    v(value) {
+      if (typeof value === "function") {
+        exports.default = value((vid) => scopedRequire(vid));
+      } else {
+        moduleExports.exports = value;
+      }
+    },
+    // async module initializer
+    async a(mod) {
+      let result;
+      await mod(
+        () => {
+        },
+        (value) => result = value
+      );
+      exports.default = result;
+    },
+    // async module loader — resolves directly via scope
+    async A(Aid) {
+      const mod = scopedRequire(Aid);
+      return mod.default((parentId) => scopedRequire(parentId));
+    },
+    // dynamic import tracking — no-op for remote components
+    j() {
+    },
+    // chunk loader — loads directly via scope, no global dispatch
+    l(url) {
+      const flatModules = Array.isArray(modules) ? modules : [];
+      const moduleInitIndex = flatModules.indexOf(moduleInit);
+      if (moduleInitIndex !== -1) {
+        const scriptIndex = flatModules.slice(0, moduleInitIndex).findLastIndex((bundleEntry) => bundleEntry instanceof Element);
+        if (scriptIndex !== -1) {
+          const script = flatModules[scriptIndex];
+          const scriptSrc = script.getAttribute("data-turbopack-src") || "";
+          const nextIndex = scriptSrc.indexOf("/_next");
+          const baseUrl = nextIndex !== -1 ? scriptSrc.slice(0, nextIndex) : "";
+          const chunkUrl = `${baseUrl}/_next/${url}`;
+          return loadChunkWithScope(scope, _chunk7XXO2DLFcjs.formatRemoteId.call(void 0, scope, chunkUrl));
+        }
+      }
+      throw new Error(
+        `Failed to load Turbopack chunk "${url}" for module "${id}". Check the URL is correct.`
+      );
+    },
+    // globalThis substitute shared across all modules in this scope
+    g: scope.moduleGlobal,
+    m: moduleExports,
+    e: exports
+  };
+}
+function createNoopHotModule() {
+  return {
+    active: true,
+    data: {},
+    accept() {
+    },
+    dispose() {
+    },
+    invalidate() {
+    }
+  };
+}
+
+// src/runtime/turbopack/shared-modules.ts
+var DEDUPLICATION_WARNING = "This module will not be deduplicated \u2014 the remote may load its own copy, which can cause duplicate instance errors (e.g. invalid hook calls if React is loaded twice).";
+var INLINE_REMOTE_SHARED_RE = /["']?__remote_shared_module_(?<specifier>[^"':]+)["']?\s*:\s*\(\)\s*=>\s*(?:__turbopack_context__|[a-z])\.A\((?<asyncSharedModuleId>"[^"]+"|[0-9]+)\)/g;
+function getTurbopackModules(scope) {
+  if (scope.turbopackModules.length > 0) {
+    return scope.turbopackModules;
+  }
+  const self = globalThis;
+  const raw = self[`TURBOPACK_${scope.globalKey}`];
+  if (!raw)
+    return void 0;
+  if (Array.isArray(raw)) {
+    return raw.flat();
+  }
+  return Object.entries(raw).flat();
+}
+async function initializeSharedModules(scope, hostShared = {}, remoteShared = {}) {
+  const allModules = getTurbopackModules(scope);
+  _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+    "SharedModules",
+    `initializeSharedModules: scope="${scope.scopedName}", allModules=${allModules ? allModules.length : "null"}, hostShared=[${Object.keys(hostShared).join(", ")}], remoteShared=${JSON.stringify(remoteShared)}`
+  );
+  let sharedModuleInitializer = null;
+  if (allModules) {
+    const sharedModuleInitializerIndex = allModules.findIndex((idOrFunc) => {
+      if (typeof idOrFunc !== "function") {
+        return false;
+      }
+      const funcCode = idOrFunc.toString();
+      return REMOTE_SHARED_MARKER_RE.test(funcCode);
+    });
+    if (sharedModuleInitializerIndex > 0) {
+      const sharedModuleInitializerCode = allModules[sharedModuleInitializerIndex].toString();
+      const sharedModuleInitializerId = allModules[sharedModuleInitializerIndex - 1];
+      const sharedModuleId = extractGroup(
+        REMOTE_SHARED_ASSIGNMENT_RE,
+        sharedModuleInitializerCode,
+        "sharedModuleId"
+      );
+      if (sharedModuleId) {
+        const { default: sharedModuleInitializerInstance } = handleTurbopackModule(
+          scope,
+          sharedModuleId,
+          _chunk7XXO2DLFcjs.formatRemoteId.call(void 0, scope, String(sharedModuleInitializerId))
+        );
+        sharedModuleInitializer = sharedModuleInitializerInstance;
+      }
+    }
+    if (sharedModuleInitializer) {
+      const { shared } = await sharedModuleInitializer;
+      const sharedModuleIds = extractSharedModuleIds(shared, scope);
+      _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+        "SharedModules",
+        `Resolved shared modules for scope="${scope.scopedName}": ${JSON.stringify(sharedModuleIds)}`
+      );
+      return installSharedModules(
+        scope,
+        hostShared,
+        sharedModuleIds,
+        (id, module) => `Host shared module "${module}" not found for ID ${id}. ${DEDUPLICATION_WARNING}`
+      );
+    }
+    const inlineSharedModuleIds = extractInlineSharedModuleIds(
+      allModules,
+      scope
+    );
+    if (Object.keys(inlineSharedModuleIds).length > 0) {
+      _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+        "SharedModules",
+        `Resolved inline shared modules for scope="${scope.scopedName}": ${JSON.stringify(inlineSharedModuleIds)}`
+      );
+      return installSharedModules(
+        scope,
+        hostShared,
+        inlineSharedModuleIds,
+        (id, module) => `Host shared module "${module}" not found for inline ID ${id}. ${DEDUPLICATION_WARNING}`
+      );
+    }
+    _chunkBBXVML3Dcjs.logWarn.call(void 0, 
+      "SharedModules",
+      `No shared module initializer found in bundle for scope="${scope.scopedName}" \u2014 falling back to remoteShared mapping`
+    );
+  } else {
+    _chunkBBXVML3Dcjs.logWarn.call(void 0, 
+      "SharedModules",
+      `No TURBOPACK modules found for scope="${scope.scopedName}" (TURBOPACK_${scope.globalKey} is empty)`
+    );
+  }
+  const normalizedRemoteShared = Object.fromEntries(
+    Object.entries(remoteShared).map(([id, module]) => [
+      id.replace("[app-ssr]", "[app-client]"),
+      module
+    ])
+  );
+  return installSharedModules(
+    scope,
+    hostShared,
+    normalizedRemoteShared,
+    (_id, module) => `Shared module "${module}" not found for "${scope.name}". ${DEDUPLICATION_WARNING}`
+  );
+}
+function extractSharedModuleIds(shared, scope) {
+  return Object.entries(shared).filter(([, value]) => typeof value === "function").reduce((acc, [key, value]) => {
+    const asyncSharedModuleId = extractGroup(
+      ASYNC_MODULE_LOADER_RE,
+      value.toString(),
+      "asyncSharedModuleId"
+    );
+    if (asyncSharedModuleId) {
+      const asyncSharedModule = findModuleInit(
+        getTurbopackModules(scope),
+        asyncSharedModuleId
+      );
+      if (asyncSharedModule) {
+        const sharedModuleId = extractGroup(
+          ASYNC_MODULE_CALLBACK_RE,
+          asyncSharedModule.toString(),
+          "sharedModuleId"
+        );
+        acc[_nullishCoalesce(sharedModuleId, () => ( asyncSharedModuleId))] = key.replace(
+          "__remote_shared_module_",
+          ""
+        );
+      }
+    }
+    return acc;
+  }, {});
+}
+function extractInlineSharedModuleIds(allModules, scope) {
+  const sharedModuleIds = {};
+  for (const idOrFunc of allModules) {
+    if (typeof idOrFunc !== "function")
+      continue;
+    const funcCode = idOrFunc.toString();
+    if (!funcCode.includes("__remote_shared_module_"))
+      continue;
+    INLINE_REMOTE_SHARED_RE.lastIndex = 0;
+    for (const match of funcCode.matchAll(INLINE_REMOTE_SHARED_RE)) {
+      const specifier = _optionalChain([match, 'access', _25 => _25.groups, 'optionalAccess', _26 => _26.specifier]);
+      const asyncSharedModuleId = stripQuotes2(
+        _optionalChain([match, 'access', _27 => _27.groups, 'optionalAccess', _28 => _28.asyncSharedModuleId])
+      );
+      if (!specifier || !asyncSharedModuleId)
+        continue;
+      const asyncSharedModule = findModuleInit(
+        getTurbopackModules(scope),
+        asyncSharedModuleId
+      );
+      if (!asyncSharedModule)
+        continue;
+      const sharedModuleId = extractGroup(
+        ASYNC_MODULE_CALLBACK_RE,
+        asyncSharedModule.toString(),
+        "sharedModuleId"
+      );
+      sharedModuleIds[_nullishCoalesce(sharedModuleId, () => ( asyncSharedModuleId))] = specifier;
+    }
+  }
+  return sharedModuleIds;
+}
+function stripQuotes2(value) {
+  if (_optionalChain([value, 'optionalAccess', _29 => _29.startsWith, 'call', _30 => _30('"')]) && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function installSharedModules(scope, hostShared, sharedModuleIds, missingMessage) {
+  const plan = _chunk7XXO2DLFcjs.createSharedModulePlan.call(void 0, {
+    bundle: scope.name,
+    hostShared,
+    remoteShared: sharedModuleIds,
+    scope: `remote:${scope.scopedName}`,
+    callerTag: "SharedModules"
+  });
+  for (const entry of plan.entries) {
+    if (entry.status === "resolved") {
+      delete scope.moduleCache[entry.id];
+    }
+  }
+  return _chunk7XXO2DLFcjs.installSharedModulePlan.call(void 0, {
+    plan,
+    target: scope.sharedModules,
+    callerTag: "SharedModules",
+    onMissing: (entry) => {
+      _chunkBBXVML3Dcjs.logError.call(void 0, "SharedModules", missingMessage(entry.id, entry.specifier));
+    }
+  }).then((results) => {
+    for (const entry of plan.entries) {
+      if (entry.status === "resolved") {
+        delete scope.moduleCache[entry.id];
+      }
+    }
+    return results;
+  });
+}
+function getSharedModule(scope, id) {
+  const idStr = String(id);
+  if (scope.sharedModules[idStr] !== void 0) {
+    return scope.sharedModules[idStr];
+  }
+  for (const [key, value] of Object.entries(scope.sharedModules)) {
+    if (typeof value !== "undefined" && idStr !== key && matchesSharedModuleKey(idStr, key)) {
+      return value;
+    }
+  }
+  return null;
+}
+function matchesSharedModuleKey(id, key) {
+  if (id.endsWith(key))
+    return true;
+  if (!key.includes("/") && !key.endsWith(".js"))
+    return false;
+  const index = id.lastIndexOf(key);
+  if (index < 0)
+    return false;
+  const afterKey = id.slice(index + key.length);
+  return /^\s+(?:\[[^\]]+\]\s*)?(?:\([^)]*\))?$/.test(afterKey);
+}
+
+// src/config/webpack/next-client-pages-loader.ts
+function nextClientPagesLoader(bundle, route, styleContainer = document.head) {
+  const self = globalThis;
+  const ns = _chunkZ2SLBFQLcjs.getNamespace.call(void 0, );
+  ns.pageComponentCache ??= {};
+  const cacheKey = `${bundle}:${route}`;
+  const remoteRequire = _optionalChain([self, 'access', _31 => _31.__remote_webpack_require__, 'optionalAccess', _32 => _32[bundle]]);
+  const turbopackScope = _optionalChain([remoteRequire, 'optionalAccess', _33 => _33.type]) === "turbopack" ? _chunk7XXO2DLFcjs.getScope.call(void 0, bundle) : void 0;
+  const applyBundleCss = () => {
+    const elements = _nullishCoalesce(ns.cssCache[bundle], () => ( []));
+    if (styleContainer) {
+      for (const el of elements) {
+        styleContainer.appendChild(el.cloneNode(true));
+      }
+    } else {
+      for (const el of elements) {
+        document.head.appendChild(el);
+      }
+    }
+  };
+  const cachedEntry = ns.pageComponentCache[cacheKey];
+  if (cachedEntry) {
+    applyBundleCss();
+    return cachedEntry;
+  }
+  const nextCssOriginal = document.querySelector(
+    `[id="__next_css__DO_NOT_USE__"]:not([data-bundle="${bundle}"][data-route="${route}"])`
+  );
+  const nextCssOriginalParent = _nullishCoalesce(_optionalChain([nextCssOriginal, 'optionalAccess', _34 => _34.parentNode]), () => ( null));
+  const nextCssOriginalNextSibling = _nullishCoalesce(_optionalChain([nextCssOriginal, 'optionalAccess', _35 => _35.nextSibling]), () => ( null));
+  if (nextCssOriginal) {
+    _optionalChain([nextCssOriginalParent, 'optionalAccess', _36 => _36.removeChild, 'call', _37 => _37(nextCssOriginal)]);
+  }
+  const nextCss = document.createElement("noscript");
+  nextCss.id = "__next_css__DO_NOT_USE__";
+  nextCss.setAttribute("data-bundle", bundle);
+  nextCss.setAttribute("data-route", route);
+  const nextCssEnd = document.createElement("noscript");
+  nextCssEnd.id = "__next_css__DO_NOT_USE_END__";
+  nextCssEnd.setAttribute("data-bundle", bundle);
+  nextCssEnd.setAttribute("data-route", route);
+  document.head.appendChild(nextCssEnd);
+  document.head.appendChild(nextCss);
+  const componentLoaderChunk = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce((turbopackScope ? findTurbopackPagesLoaderId(turbopackScope, route) : void 0), () => ( Object.keys(_nullishCoalesce(_optionalChain([remoteRequire, 'optionalAccess', _38 => _38.m]), () => ( {}))).find(
+    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=${encodeURIComponent(route)}!`)
+  ))), () => ( Object.keys(_nullishCoalesce(_optionalChain([remoteRequire, 'optionalAccess', _39 => _39.m]), () => ( {}))).find(
+    (key) => key.includes("/next/dist/client/page-loader.js")
+  ))), () => ( _optionalChain([self, 'access', _40 => _40.__remote_webpack_module_map__, 'optionalAccess', _41 => _41[bundle], 'optionalAccess', _42 => _42[_nullishCoalesce(_nullishCoalesce(Object.keys(_nullishCoalesce(self.__remote_webpack_module_map__[bundle], () => ( {}))).find(
+    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=${encodeURIComponent(route)}!`)
+  ), () => ( Object.keys(_nullishCoalesce(self.__remote_webpack_module_map__[bundle], () => ( {}))).find(
+    (key) => key.includes("/next/dist/client/page-loader.js")
+  ))), () => ( ""))]]))), () => ( -1));
+  const appLoaderChunk = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce((turbopackScope ? findTurbopackPagesLoaderId(turbopackScope, "/_app") : void 0), () => ( Object.keys(_nullishCoalesce(_optionalChain([remoteRequire, 'optionalAccess', _43 => _43.m]), () => ( {}))).find(
+    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=%2F_app`)
+  ))), () => ( Object.keys(_nullishCoalesce(_optionalChain([remoteRequire, 'optionalAccess', _44 => _44.m]), () => ( {}))).find(
+    (key) => key.includes("/next/dist/client/page-loader.js")
+  ))), () => ( _optionalChain([self, 'access', _45 => _45.__remote_webpack_module_map__, 'optionalAccess', _46 => _46[bundle], 'optionalAccess', _47 => _47[_nullishCoalesce(_nullishCoalesce(Object.keys(_nullishCoalesce(self.__remote_webpack_module_map__[bundle], () => ( {}))).find(
+    (key) => key.includes("/webpack/loaders/next-client-pages-loader.js") && key.includes(`page=%2F_app`)
+  ), () => ( Object.keys(_nullishCoalesce(self.__remote_webpack_module_map__[bundle], () => ( {}))).find(
+    (key) => key.includes("/next/dist/client/page-loader.js")
+  ))), () => ( ""))]]))), () => ( -1));
+  if (!isLoaderId(componentLoaderChunk) || !isLoaderId(appLoaderChunk)) {
+    throw new (0, _chunkBBXVML3Dcjs.RemoteComponentsError)(
+      `Next.js client pages loader not found in bundle "${bundle}".`
+    );
+  }
+  const __NEXT_P_ORIGINAL = self.__NEXT_P;
+  const selfOriginal = self;
+  delete selfOriginal.__NEXT_P;
+  try {
+    loadPagesLoaderModule(bundle, componentLoaderChunk, turbopackScope);
+    if (isLoaderId(appLoaderChunk)) {
+      loadPagesLoaderModule(bundle, appLoaderChunk, turbopackScope);
+    }
+    if (self.__NEXT_P) {
+      _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+        "ComponentLoader",
+        `Next.js Pages loader registry for "${route}" in "${bundle}": ${self.__NEXT_P.map((entry) => _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _48 => _48[0]]), () => ( "<empty>"))).join(", ")}`
+      );
+      const componentEntry = _nullishCoalesce(self.__NEXT_P.find(
+        (entry) => _optionalChain([entry, 'optionalAccess', _49 => _49[0]]) === route
+      ), () => ( self.__NEXT_P[0]));
+      const appEntry = _nullishCoalesce(self.__NEXT_P.find((entry) => _optionalChain([entry, 'optionalAccess', _50 => _50[0]]) === "/_app"), () => ( self.__NEXT_P[2]));
+      const [, componentLoader] = _nullishCoalesce(componentEntry, () => ( [
+        void 0,
+        () => ({ default: null })
+      ]));
+      const [, appLoader] = _nullishCoalesce(appEntry, () => ( [
+        void 0,
+        () => ({
+          default: null
+        })
+      ]));
+      const { default: Component = null } = componentLoader();
+      const { default: App = null } = appLoader();
+      const cssCache = ns.cssCache;
+      if (!cssCache[bundle]) {
+        const cssRE = /\.s?css$/;
+        Object.keys(_nullishCoalesce(_optionalChain([self, 'access', _51 => _51.__remote_webpack_require__, 'optionalAccess', _52 => _52[bundle], 'optionalAccess', _53 => _53.m]), () => ( {}))).filter((id) => cssRE.test(id)).forEach((id) => {
+          _optionalChain([self, 'access', _54 => _54.__remote_webpack_require__, 'optionalAccess', _55 => _55[bundle], 'optionalCall', _56 => _56(id)]);
+        });
+        Object.keys(_nullishCoalesce(_optionalChain([self, 'access', _57 => _57.__remote_webpack_module_map__, 'optionalAccess', _58 => _58[bundle]]), () => ( {}))).filter((path) => cssRE.test(path)).forEach((path) => {
+          const id = _optionalChain([self, 'access', _59 => _59.__remote_webpack_module_map__, 'optionalAccess', _60 => _60[bundle], 'optionalAccess', _61 => _61[path]]);
+          if (id) {
+            _optionalChain([self, 'access', _62 => _62.__remote_webpack_require__, 'optionalAccess', _63 => _63[bundle], 'optionalCall', _64 => _64(id)]);
+          }
+        });
+        const elements = [];
+        let node = nextCss.previousSibling;
+        while (node && node !== nextCssEnd) {
+          elements.push(node);
+          node.remove();
+          node = nextCss.previousSibling;
+        }
+        cssCache[bundle] = elements;
+      }
+      applyBundleCss();
+      const result = { Component, App };
+      ns.pageComponentCache[cacheKey] = result;
+      return result;
+    }
+    _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+      "ComponentLoader",
+      `Next.js Pages loaders for route "${route}" in "${bundle}" did not populate __NEXT_P`
+    );
+    return { Component: null, App: null };
+  } finally {
+    if (typeof __NEXT_P_ORIGINAL === "undefined") {
+      delete self.__NEXT_P;
+    } else {
+      self.__NEXT_P = __NEXT_P_ORIGINAL;
+    }
+    if (nextCssOriginal && nextCssOriginalParent) {
+      const restoreBefore = _optionalChain([nextCssOriginalNextSibling, 'optionalAccess', _65 => _65.parentNode]) === nextCssOriginalParent ? nextCssOriginalNextSibling : null;
+      nextCssOriginalParent.insertBefore(nextCssOriginal, restoreBefore);
+    }
+    nextCss.remove();
+    nextCssEnd.remove();
+  }
+}
+function isLoaderId(id) {
+  return typeof id === "string" && id.length > 0 || typeof id === "number" && id !== -1;
+}
+function loadPagesLoaderModule(bundle, id, turbopackScope) {
+  const self = globalThis;
+  if (turbopackScope) {
+    delete turbopackScope.moduleCache[String(id)];
+    requireModule(turbopackScope, id);
+    return;
+  }
+  const remoteRequire = _optionalChain([self, 'access', _66 => _66.__remote_webpack_require__, 'optionalAccess', _67 => _67[bundle]]);
+  if (_optionalChain([remoteRequire, 'optionalAccess', _68 => _68.c])) {
+    delete remoteRequire.c[id];
+  }
+  _optionalChain([remoteRequire, 'optionalCall', _69 => _69(id)]);
+}
+function findTurbopackPagesLoaderId(scope, route) {
+  const modules = getTurbopackModules(scope);
+  if (!modules)
+    return void 0;
+  const routeLiteral = JSON.stringify(route);
+  const singleQuotedRouteLiteral = `'${route.replaceAll("'", "\\'")}'`;
+  const flat = modules.flat();
+  for (let index = 0; index < flat.length; index++) {
+    const entry = flat[index];
+    if (typeof entry === "function") {
+      const code = entry.toString();
+      if (code.includes("__NEXT_P") && (code.includes(routeLiteral) || code.includes(singleQuotedRouteLiteral))) {
+        const id = findPreviousModuleId(flat, index);
+        if (isLoaderId(id) && isTurbopackPagesLoaderId(id)) {
+          _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+            "SharedModules",
+            `Resolved Turbopack Pages loader for route "${route}" in "${scope.scopedName}" as "${id}"`
+          );
+          return id;
+        }
+      }
+      continue;
+    }
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      continue;
+    if (typeof Element !== "undefined" && entry instanceof Element)
+      continue;
+    for (const [id, moduleInit] of Object.entries(
+      entry
+    )) {
+      if (typeof moduleInit !== "function")
+        continue;
+      const code = moduleInit.toString();
+      if (code.includes("__NEXT_P") && (code.includes(routeLiteral) || code.includes(singleQuotedRouteLiteral)) && isTurbopackPagesLoaderId(id)) {
+        _chunkBBXVML3Dcjs.logDebug.call(void 0, 
+          "SharedModules",
+          `Resolved Turbopack Pages loader for route "${route}" in "${scope.scopedName}" as "${id}"`
+        );
+        return id;
+      }
+    }
+  }
+  return void 0;
+}
+function isTurbopackPagesLoaderId(id) {
+  if (typeof id === "number")
+    return true;
+  return id.includes("[next]/entry/page-loader.ts") || id.includes("/next/dist/client/page-loader.js");
+}
+function findPreviousModuleId(entries, factoryIndex) {
+  for (let index = factoryIndex - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (isLoaderId(entry))
+      return entry;
+    if (typeof entry === "function")
+      return void 0;
+  }
+  return void 0;
+}
+
+
+
+
+
+
+
+
+exports.applySharedModules = applySharedModules; exports.loadChunkWithScope = loadChunkWithScope; exports.createChunkDispatcher = createChunkDispatcher; exports.initializeSharedModules = initializeSharedModules; exports.requireModule = requireModule; exports.nextClientPagesLoader = nextClientPagesLoader;
+//# sourceMappingURL=chunk-HMB3SIVJ.cjs.map