@obsfx/trekker 0.1.7 → 0.1.8

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-barrel-loader.js

@@ -0,0 +1,268 @@
+/**
+ * ## Barrel Optimizations
+ *
+ * This loader is used to optimize the imports of "barrel" files that have many
+ * re-exports. Currently, both Node.js and Webpack have to enter all of these
+ * submodules even if we only need a few of them.
+ *
+ * For example, say a file `foo.js` with the following contents:
+ *
+ *   export { a } from './a'
+ *   export { b } from './b'
+ *   export { c } from './c'
+ *   ...
+ *
+ * If the user imports `a` only, this loader will accept the `names` option to
+ * be `['a']`. Then, it request the "__barrel_transform__" SWC transform to load
+ * `foo.js` and receive the following output:
+ *
+ *   export const __next_private_export_map__ = '[["a","./a","a"],["b","./b","b"],["c","./c","c"],...]'
+ *
+ *   format: '["<imported identifier>", "<import path>", "<exported name>"]'
+ *   e.g.: import { a as b } from './module-a' => '["b", "./module-a", "a"]'
+ *
+ * The export map, generated by SWC, is a JSON that represents the exports of
+ * that module, their original file, and their original name (since you can do
+ * `export { a as b }`).
+ *
+ * Then, this loader can safely remove all the exports that are not needed and
+ * re-export the ones from `names`:
+ *
+ *   export { a } from './a'
+ *
+ * That's the basic situation and also the happy path.
+ *
+ *
+ *
+ * ## Wildcard Exports
+ *
+ * For wildcard exports (e.g. `export * from './a'`), it becomes a bit more complicated.
+ * Say `foo.js` with the following contents:
+ *
+ *   export * from './a'
+ *   export * from './b'
+ *   export * from './c'
+ *   ...
+ *
+ * If the user imports `bar` from it, SWC can never know which files are going to be
+ * exporting `bar`. So, we have to keep all the wildcard exports and do the same
+ * process recursively. This loader will return the following output:
+ *
+ *   export * from '__barrel_optimize__?names=bar&wildcard!=!./a'
+ *   export * from '__barrel_optimize__?names=bar&wildcard!=!./b'
+ *   export * from '__barrel_optimize__?names=bar&wildcard!=!./c'
+ *   ...
+ *
+ * The "!=!" tells Webpack to use the same loader to process './a', './b', and './c'.
+ * After the recursive process, the "inner loaders" will either return an empty string
+ * or:
+ *
+ *   export * from './target'
+ *
+ * Where `target` is the file that exports `bar`.
+ *
+ *
+ *
+ * ## Non-Barrel Files
+ *
+ * If the file is not a barrel, we can't apply any optimizations. That's because
+ * we can't easily remove things from the file. For example, say `foo.js` with:
+ *
+ *   const v = 1
+ *   export function b () {
+ *     return v
+ *   }
+ *
+ * If the user imports `b` only, we can't remove the `const v = 1` even though
+ * the file is side-effect free. In these caes, this loader will simply re-export
+ * `foo.js`:
+ *
+ *   export * from './foo'
+ *
+ * Besides these cases, this loader also carefully handles the module cache so
+ * SWC won't analyze the same file twice, and no instance of the same file will
+ * be accidentally created as different instances.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _swc = require("../../swc");
+const _installbindings = require("../../swc/install-bindings");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// This is a in-memory cache for the mapping of barrel exports. This only applies
+// to the packages that we optimize. It will never change (e.g. upgrading packages)
+// during the lifetime of the server so we can safely cache it.
+// There is also no need to collect the cache for the same reason.
+const barrelTransformMappingCache = new Map();
+async function getBarrelMapping(resourcePath, swcCacheDir, resolve, fs) {
+    if (barrelTransformMappingCache.has(resourcePath)) {
+        return barrelTransformMappingCache.get(resourcePath);
+    }
+    // This is a SWC transform specifically for `optimizeBarrelExports`. We don't
+    // care about other things but the export map only.
+    async function transpileSource(filename, source, isWildcard) {
+        const isTypeScript = filename.endsWith('.ts') || filename.endsWith('.tsx');
+        return new Promise((res)=>(0, _swc.transform)(source, {
+                filename,
+                inputSourceMap: undefined,
+                sourceFileName: filename,
+                optimizeBarrelExports: {
+                    wildcard: isWildcard
+                },
+                jsc: {
+                    parser: {
+                        syntax: isTypeScript ? 'typescript' : 'ecmascript',
+                        [isTypeScript ? 'tsx' : 'jsx']: true
+                    },
+                    experimental: {
+                        cacheRoot: swcCacheDir
+                    }
+                }
+            }).then((output)=>{
+                res(output.code);
+            }));
+    }
+    // Avoid circular `export *` dependencies
+    const visited = new Set();
+    async function getMatches(file, isWildcard, isClientEntry) {
+        if (visited.has(file)) {
+            return null;
+        }
+        visited.add(file);
+        const source = await new Promise((res, rej)=>{
+            fs.readFile(file, (err, data)=>{
+                if (err || data === undefined) {
+                    rej(err);
+                } else {
+                    res(data.toString());
+                }
+            });
+        });
+        const output = await transpileSource(file, source, isWildcard);
+        const matches = output.match(/^([^]*)export (const|var) __next_private_export_map__ = ('[^']+'|"[^"]+")/);
+        if (!matches) {
+            return null;
+        }
+        const matchedDirectives = output.match(/^([^]*)export (const|var) __next_private_directive_list__ = '([^']+)'/);
+        const directiveList = matchedDirectives ? JSON.parse(matchedDirectives[3]) : [];
+        // "use client" in barrel files has to be transferred to the target file.
+        isClientEntry = directiveList.includes('use client');
+        let exportList = JSON.parse(matches[3].slice(1, -1));
+        const wildcardExports = [
+            ...output.matchAll(/export \* from "([^"]+)"/g)
+        ].map((match)=>match[1]);
+        // In the wildcard case, if the value is exported from another file, we
+        // redirect to that file (decl[0]). Otherwise, export from the current
+        // file itself.
+        if (isWildcard) {
+            for (const decl of exportList){
+                decl[1] = file;
+                decl[2] = decl[0];
+            }
+        }
+        // This recursively handles the wildcard exports (e.g. `export * from './a'`)
+        if (wildcardExports.length) {
+            await Promise.all(wildcardExports.map(async (req)=>{
+                const targetPath = await resolve(_path.default.dirname(file), req.replace('__barrel_optimize__?names=__PLACEHOLDER__!=!', ''));
+                const targetMatches = await getMatches(targetPath, true, isClientEntry);
+                if (targetMatches) {
+                    // Merge the export list
+                    exportList = exportList.concat(targetMatches.exportList);
+                }
+            }));
+        }
+        return {
+            exportList,
+            wildcardExports,
+            isClientEntry
+        };
+    }
+    const res = await getMatches(resourcePath, false, false);
+    barrelTransformMappingCache.set(resourcePath, res);
+    return res;
+}
+const NextBarrelLoader = async function() {
+    this.async();
+    this.cacheable(true);
+    // Install bindings early so they are definitely available.
+    // When run by webpack in next this is already done with correct configuration so this is a no-op.
+    // In turbopack loaders are run in a subprocess so it may or may not be done.
+    await (0, _installbindings.installBindings)();
+    const { names, swcCacheDir } = this.getOptions();
+    // For barrel optimizations, we always prefer the "module" field over the
+    // "main" field because ESM handling is more robust with better tree-shaking.
+    const resolve = this.getResolve({
+        mainFields: [
+            'module',
+            'main'
+        ]
+    });
+    const mapping = await getBarrelMapping(this.resourcePath, swcCacheDir, resolve, this.fs);
+    // `resolve` adds all sub-paths to the dependency graph. However, we already
+    // cached the mapping and we assume them to not change. So, we can safely
+    // clear the dependencies here to avoid unnecessary watchers which turned out
+    // to be very expensive.
+    this.clearDependencies();
+    if (!mapping) {
+        // This file isn't a barrel and we can't apply any optimizations. Let's re-export everything.
+        // Since this loader accepts `names` and the request is keyed with `names`, we can't simply
+        // return the original source here. That will create these imports with different names as
+        // different modules instances.
+        this.callback(null, `export * from ${JSON.stringify(this.resourcePath)}`);
+        return;
+    }
+    const exportList = mapping.exportList;
+    const isClientEntry = mapping.isClientEntry;
+    const exportMap = new Map();
+    for (const [name, filePath, orig] of exportList){
+        exportMap.set(name, [
+            filePath,
+            orig
+        ]);
+    }
+    let output = '';
+    let missedNames = [];
+    for (const name of names){
+        // If the name matches
+        if (exportMap.has(name)) {
+            const decl = exportMap.get(name);
+            if (decl[1] === '*') {
+                output += `\nexport * as ${name} from ${JSON.stringify(decl[0])}`;
+            } else if (decl[1] === 'default') {
+                output += `\nexport { default as ${name} } from ${JSON.stringify(decl[0])}`;
+            } else if (decl[1] === name) {
+                output += `\nexport { ${name} } from ${JSON.stringify(decl[0])}`;
+            } else {
+                output += `\nexport { ${decl[1]} as ${name} } from ${JSON.stringify(decl[0])}`;
+            }
+        } else {
+            missedNames.push(name);
+        }
+    }
+    // These are from wildcard exports.
+    if (missedNames.length > 0) {
+        for (const req of mapping.wildcardExports){
+            output += `\nexport * from ${JSON.stringify(req.replace('__PLACEHOLDER__', missedNames.join(',') + '&wildcard'))}`;
+        }
+    }
+    // When it has `"use client"` inherited from its barrel files, we need to
+    // prefix it to this target file as well.
+    if (isClientEntry) {
+        output = `"use client";\n${output}`;
+    }
+    this.callback(null, output);
+};
+const _default = NextBarrelLoader;
+
+//# sourceMappingURL=next-barrel-loader.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-client-pages-loader.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _stringifyrequest = require("../stringify-request");
+// this parameter: https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters
+function nextClientPagesLoader() {
+    const pagesLoaderSpan = this.currentTraceSpan.traceChild('next-client-pages-loader');
+    return pagesLoaderSpan.traceFn(()=>{
+        const { absolutePagePath, page } = this.getOptions();
+        pagesLoaderSpan.setAttribute('absolutePagePath', absolutePagePath);
+        const stringifiedPageRequest = (0, _stringifyrequest.stringifyRequest)(this, absolutePagePath);
+        const stringifiedPage = JSON.stringify(page);
+        return `
+    (window.__NEXT_P = window.__NEXT_P || []).push([
+      ${stringifiedPage},
+      function () {
+        return require(${stringifiedPageRequest});
+      }
+    ]);
+    if(module.hot) {
+      module.hot.dispose(function () {
+        window.__NEXT_P.push([${stringifiedPage}])
+      });
+    }
+  `;
+    });
+}
+const _default = nextClientPagesLoader;
+
+//# sourceMappingURL=next-client-pages-loader.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-edge-app-route-loader/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _getmodulebuildinfo = require("../get-module-build-info");
+const _stringifyrequest = require("../../stringify-request");
+const _constants = require("../../../../lib/constants");
+const _loadentrypoint = require("../../../load-entrypoint");
+const _ismetadataroute = require("../../../../lib/metadata/is-metadata-route");
+const EdgeAppRouteLoader = async function() {
+    const { page, absolutePagePath, preferredRegion, appDirLoader: appDirLoaderBase64 = '', middlewareConfig: middlewareConfigBase64 = '', cacheHandlers: cacheHandlersStringified } = this.getOptions();
+    const appDirLoader = Buffer.from(appDirLoaderBase64, 'base64').toString();
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, 'base64').toString());
+    const cacheHandlers = JSON.parse(cacheHandlersStringified || '{}');
+    if (!cacheHandlers.default) {
+        cacheHandlers.default = require.resolve('../../../../server/lib/cache-handlers/default.external');
+    }
+    // Ensure we only run this loader for as a module.
+    if (!this._module) throw Object.defineProperty(new Error('This loader is only usable as a module'), "__NEXT_ERROR_CODE", {
+        value: "E433",
+        enumerable: false,
+        configurable: true
+    });
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    buildInfo.nextEdgeSSR = {
+        isServerComponent: !(0, _ismetadataroute.isMetadataRoute)(page),
+        page: page,
+        isAppDir: true
+    };
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    const stringifiedPagePath = (0, _stringifyrequest.stringifyRequest)(this, absolutePagePath);
+    const modulePath = `${appDirLoader}${stringifiedPagePath.substring(1, stringifiedPagePath.length - 1)}?${_constants.WEBPACK_RESOURCE_QUERIES.edgeSSREntry}`;
+    return await (0, _loadentrypoint.loadEntrypoint)('edge-app-route', {
+        VAR_USERLAND: modulePath,
+        VAR_PAGE: page
+    }, {});
+};
+const _default = EdgeAppRouteLoader;
+
+//# sourceMappingURL=index.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-edge-function-loader.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _getmodulebuildinfo = require("./get-module-build-info");
+const _stringifyrequest = require("../stringify-request");
+const nextEdgeFunctionLoader = function nextEdgeFunctionLoader() {
+    const { absolutePagePath, page, rootDir, preferredRegion, middlewareConfig: middlewareConfigBase64 } = this.getOptions();
+    const stringifiedPagePath = (0, _stringifyrequest.stringifyRequest)(this, absolutePagePath);
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, 'base64').toString());
+    buildInfo.route = {
+        page: page || '/',
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    buildInfo.nextEdgeApiFunction = {
+        page: page || '/'
+    };
+    buildInfo.rootDir = rootDir;
+    return `
+        import 'next/dist/esm/server/web/globals'
+        import { adapter } from 'next/dist/esm/server/web/adapter'
+        import { IncrementalCache } from 'next/dist/esm/server/lib/incremental-cache'
+        import { wrapApiHandler } from 'next/dist/esm/server/api-utils'
+
+        import handler from ${stringifiedPagePath}
+
+        if (typeof handler !== 'function') {
+          throw new Error('The Edge Function "pages${page}" must export a \`default\` function');
+        }
+
+        export default function nHandler (opts) {
+          return adapter({
+              ...opts,
+              IncrementalCache,
+              page: ${JSON.stringify(page)},
+              handler: wrapApiHandler(${JSON.stringify(page)}, handler),
+          })
+        }
+    `;
+};
+const _default = nextEdgeFunctionLoader;
+
+//# sourceMappingURL=next-edge-function-loader.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-edge-ssr-loader/index.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _getmodulebuildinfo = require("../get-module-build-info");
+const _constants = require("../../../../lib/constants");
+const _routekind = require("../../../../server/route-kind");
+const _normalizepagepath = require("../../../../shared/lib/page-path/normalize-page-path");
+const _loadentrypoint = require("../../../load-entrypoint");
+/*
+For pages SSR'd at the edge, we bundle them with the ESM version of Next in order to
+benefit from the better tree-shaking and thus, smaller bundle sizes.
+
+The absolute paths for _app, _error and _document, used in this loader, link to the regular CJS modules.
+They are generated in `createPagesMapping` where we don't have access to `isEdgeRuntime`,
+so we have to do it here. It's not that bad because it keeps all references to ESM modules magic in this place.
+*/ function swapDistFolderWithEsmDistFolder(path) {
+    return path.replace('next/dist/pages', 'next/dist/esm/pages');
+}
+function getRouteModuleOptions(page) {
+    const options = {
+        definition: {
+            kind: _routekind.RouteKind.PAGES,
+            page: (0, _normalizepagepath.normalizePagePath)(page),
+            pathname: page,
+            // The following aren't used in production.
+            bundlePath: '',
+            filename: ''
+        }
+    };
+    return options;
+}
+const edgeSSRLoader = async function edgeSSRLoader() {
+    const { page, absolutePagePath, absoluteAppPath, absoluteDocumentPath, absolute500Path, absoluteErrorPath, isServerComponent, appDirLoader: appDirLoaderBase64, pagesType, cacheHandler, cacheHandlers: cacheHandlersStringified, preferredRegion, middlewareConfig: middlewareConfigBase64 } = this.getOptions();
+    const cacheHandlers = JSON.parse(cacheHandlersStringified || '{}');
+    if (!cacheHandlers.default) {
+        cacheHandlers.default = require.resolve('../../../../server/lib/cache-handlers/default.external');
+    }
+    const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, 'base64').toString());
+    const appDirLoader = Buffer.from(appDirLoaderBase64 || '', 'base64').toString();
+    const isAppDir = pagesType === 'app';
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    buildInfo.nextEdgeSSR = {
+        isServerComponent,
+        page: page,
+        isAppDir
+    };
+    buildInfo.route = {
+        page,
+        absolutePagePath,
+        preferredRegion,
+        middlewareConfig
+    };
+    const pagePath = this.utils.contextify(this.context || this.rootContext, absolutePagePath);
+    const appPath = absoluteAppPath ? this.utils.contextify(this.context || this.rootContext, swapDistFolderWithEsmDistFolder(absoluteAppPath)) : '';
+    const errorPath = absoluteErrorPath ? this.utils.contextify(this.context || this.rootContext, swapDistFolderWithEsmDistFolder(absoluteErrorPath)) : '';
+    const documentPath = absoluteDocumentPath ? this.utils.contextify(this.context || this.rootContext, swapDistFolderWithEsmDistFolder(absoluteDocumentPath)) : '';
+    const userland500Path = absolute500Path ? this.utils.contextify(this.context || this.rootContext, swapDistFolderWithEsmDistFolder(absolute500Path)) : null;
+    const stringifiedPagePath = JSON.stringify(pagePath);
+    const pageModPath = `${appDirLoader}${stringifiedPagePath.substring(1, stringifiedPagePath.length - 1)}${isAppDir ? `?${_constants.WEBPACK_RESOURCE_QUERIES.edgeSSREntry}` : ''}`;
+    if (isAppDir) {
+        return await (0, _loadentrypoint.loadEntrypoint)('edge-ssr-app', {
+            VAR_USERLAND: pageModPath,
+            VAR_PAGE: page
+        }, {}, {
+            incrementalCacheHandler: cacheHandler ?? null
+        });
+    } else {
+        return await (0, _loadentrypoint.loadEntrypoint)('edge-ssr', {
+            VAR_USERLAND: pageModPath,
+            VAR_DEFINITION_PATHNAME: page,
+            VAR_MODULE_DOCUMENT: documentPath,
+            VAR_MODULE_APP: appPath,
+            VAR_MODULE_GLOBAL_ERROR: errorPath
+        }, {
+            pageRouteModuleOptions: JSON.stringify(getRouteModuleOptions(page)),
+            errorRouteModuleOptions: JSON.stringify(getRouteModuleOptions('/_error')),
+            user500RouteModuleOptions: JSON.stringify(getRouteModuleOptions('/500'))
+        }, {
+            userland500Page: userland500Path,
+            incrementalCacheHandler: cacheHandler ?? null
+        });
+    }
+};
+const _default = edgeSSRLoader;
+
+//# sourceMappingURL=index.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-error-browser-binary-loader.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return nextErrorBrowserBinaryLoader;
+    }
+});
+function nextErrorBrowserBinaryLoader() {
+    const { resourcePath, rootContext } = this;
+    const relativePath = resourcePath.slice(rootContext.length + 1);
+    throw Object.defineProperty(new Error(`Node.js binary module ./${relativePath} is not supported in the browser. Please only use the module on server side`), "__NEXT_ERROR_CODE", {
+        value: "E79",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=next-error-browser-binary-loader.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-flight-action-entry-loader.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+function nextFlightActionEntryLoader() {
+    const { actions } = this.getOptions();
+    const actionList = JSON.parse(actions);
+    const individualActions = actionList.map(([path, actionsFromModule])=>{
+        return actionsFromModule.map(({ id, exportedName })=>{
+            return [
+                id,
+                path,
+                exportedName
+            ];
+        });
+    }).flat();
+    return `
+${individualActions.map(([id, path, exportedName])=>{
+        // Re-export the same functions from the original module path as action IDs.
+        return `export { ${exportedName} as "${id}" } from ${JSON.stringify(path)}`;
+    }).join('\n')}
+`;
+}
+const _default = nextFlightActionEntryLoader;
+
+//# sourceMappingURL=next-flight-action-entry-loader.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-flight-client-entry-loader.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return transformSource;
+    }
+});
+const _constants = require("../../../shared/lib/constants");
+const _getmodulebuildinfo = require("./get-module-build-info");
+const _utils = require("./utils");
+function transformSource() {
+    let { modules, server } = this.getOptions();
+    const isServer = server === 'true';
+    if (!Array.isArray(modules)) {
+        modules = modules ? [
+            modules
+        ] : [];
+    }
+    const code = modules.map((x)=>JSON.parse(x))// Filter out CSS files in the SSR compilation
+    .filter(({ request })=>isServer ? !_utils.regexCSS.test(request) : true).map(({ request, ids })=>{
+        const importPath = JSON.stringify(request.startsWith(_constants.BARREL_OPTIMIZATION_PREFIX) ? request.replace(':', '!=!') : request);
+        // When we cannot determine the export names, we use eager mode to include the whole module.
+        // Otherwise, we use eager mode with webpackExports to only include the necessary exports.
+        // If we have '*' in the ids, we include all the imports
+        if (ids.length === 0 || ids.includes('*')) {
+            return `import(/* webpackMode: "eager" */ ${importPath});\n`;
+        } else {
+            return `import(/* webpackMode: "eager", webpackExports: ${JSON.stringify(ids)} */ ${importPath});\n`;
+        }
+    }).join(';\n');
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    buildInfo.rsc = {
+        type: _constants.RSC_MODULE_TYPES.client
+    };
+    if (process.env.BUILTIN_FLIGHT_CLIENT_ENTRY_PLUGIN) {
+        const rscModuleInformationJson = JSON.stringify(buildInfo.rsc);
+        return `/* __rspack_internal_rsc_module_information_do_not_use__ ${rscModuleInformationJson} */\n` + code;
+    }
+    return code;
+}
+
+//# sourceMappingURL=next-flight-client-entry-loader.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-flight-client-module-loader.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _getpagestaticinfo = require("../../analysis/get-page-static-info");
+const _getmodulebuildinfo = require("./get-module-build-info");
+const flightClientModuleLoader = function transformSource(source, sourceMap) {
+    // Avoid buffer to be consumed
+    if (typeof source !== 'string') {
+        throw Object.defineProperty(new Error('Expected source to have been transformed to a string.'), "__NEXT_ERROR_CODE", {
+            value: "E429",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    if (!this._module) {
+        return source;
+    }
+    // Assign the RSC meta information to buildInfo.
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
+    buildInfo.rsc = (0, _getpagestaticinfo.getRSCModuleInformation)(source, false);
+    let prefix = '';
+    if (process.env.BUILTIN_FLIGHT_CLIENT_ENTRY_PLUGIN) {
+        const rscModuleInformationJson = JSON.stringify(buildInfo.rsc);
+        prefix = `/* __rspack_internal_rsc_module_information_do_not_use__ ${rscModuleInformationJson} */\n`;
+        source = prefix + source;
+    }
+    // This is a server action entry module in the client layer. We need to
+    // create re-exports of "virtual modules" to expose the reference IDs to the
+    // client separately so they won't be always in the same one module which is
+    // not splittable. This server action module tree shaking is only applied in
+    // production mode. In development mode, we want to preserve the original
+    // modules (as transformed by SWC) to ensure that source mapping works.
+    if (buildInfo.rsc.actionIds && process.env.NODE_ENV === 'production') {
+        return prefix + Object.entries(buildInfo.rsc.actionIds).map(([id, name])=>{
+            return `export { ${name} } from 'next-flight-server-reference-proxy-loader?id=${id}&name=${name}!'`;
+        }).join('\n');
+    }
+    return this.callback(null, source, sourceMap);
+};
+const _default = flightClientModuleLoader;
+
+//# sourceMappingURL=next-flight-client-module-loader.js.map