@obsfx/trekker 0.1.7 → 0.1.9

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

@@ -0,0 +1,56 @@
+/**
+ * For server-side CSS imports, we need to ignore the actual module content but
+ * still trigger the hot-reloading diff mechanism. So here we put the content
+ * inside a comment.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _crypto = /*#__PURE__*/ _interop_require_default(require("crypto"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const NextServerCSSLoader = function(content) {
+    this.cacheable && this.cacheable();
+    const options = this.getOptions();
+    let isCSSModule = options.cssModules;
+    // Only add the checksum during development.
+    if (process.env.NODE_ENV !== 'production') {
+        // This check is only for backwards compatibility.
+        // TODO: Remove this in the next major version (next 14)
+        if (isCSSModule === undefined) {
+            this.emitWarning(Object.defineProperty(new Error("No 'cssModules' option was found for the next-flight-css-loader plugin."), "__NEXT_ERROR_CODE", {
+                value: "E8",
+                enumerable: false,
+                configurable: true
+            }));
+            isCSSModule = this.resourcePath.match(/\.module\.(css|sass|scss)$/) !== null;
+        }
+        const checksum = _crypto.default.createHash('sha1').update(typeof content === 'string' ? Buffer.from(content) : content).digest().toString('hex').substring(0, 12);
+        if (isCSSModule) {
+            return `\
+${content}
+module.exports.__checksum = ${JSON.stringify(checksum)}
+`;
+        }
+        // Server CSS imports are always available for HMR, so we attach
+        // `module.hot.accept()` to the generated module.
+        const hmrCode = 'if (module.hot) { module.hot.accept() }';
+        return `\
+export default ${JSON.stringify(checksum)}
+${hmrCode}
+`;
+    }
+    return content;
+};
+const _default = NextServerCSSLoader;
+
+//# sourceMappingURL=next-flight-css-loader.js.map

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

@@ -0,0 +1,33 @@
+// This file must be bundled in the app's client layer, it shouldn't be directly
+// imported by the server.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    callServer: null,
+    createServerReference: null,
+    findSourceMapURL: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    callServer: function() {
+        return _appcallserver.callServer;
+    },
+    createServerReference: function() {
+        return _client.createServerReference;
+    },
+    findSourceMapURL: function() {
+        return _appfindsourcemapurl.findSourceMapURL;
+    }
+});
+const _appcallserver = require("next/dist/client/app-call-server");
+const _appfindsourcemapurl = require("next/dist/client/app-find-source-map-url");
+const _client = require("react-server-dom-webpack/client");
+
+//# sourceMappingURL=action-client-wrapper.js.map

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

@@ -0,0 +1,27 @@
+// This function ensures that all the exported values are valid server actions,
+// during the runtime. By definition all actions are required to be async
+// functions, but here we can only check that they are functions.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ensureServerEntryExports", {
+    enumerable: true,
+    get: function() {
+        return ensureServerEntryExports;
+    }
+});
+function ensureServerEntryExports(actions) {
+    for(let i = 0; i < actions.length; i++){
+        const action = actions[i];
+        if (typeof action !== 'function') {
+            throw Object.defineProperty(new Error(`A "use server" file can only export async functions, found ${typeof action}.\nRead more: https://nextjs.org/docs/messages/invalid-use-server-value`), "__NEXT_ERROR_CODE", {
+                value: "E352",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+}
+
+//# sourceMappingURL=action-validate.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-flight-loader/cache-wrapper.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cache", {
+    enumerable: true,
+    get: function() {
+        return _usecachewrapper.cache;
+    }
+});
+const _usecachewrapper = require("../../../../server/use-cache/use-cache-wrapper");
+
+//# sourceMappingURL=cache-wrapper.js.map

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

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    getAssumedSourceType: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return transformSource;
+    },
+    getAssumedSourceType: function() {
+        return getAssumedSourceType;
+    }
+});
+const _webpack = require("next/dist/compiled/webpack/webpack");
+const _constants = require("../../../../lib/constants");
+const _constants1 = require("../../../../shared/lib/constants");
+const _warnonce = require("../../../../shared/lib/utils/warn-once");
+const _getpagestaticinfo = require("../../../analysis/get-page-static-info");
+const _utils = require("../../utils");
+const _getmodulebuildinfo = require("../get-module-build-info");
+const noopHeadPath = require.resolve('next/dist/client/components/noop-head');
+// For edge runtime it will be aliased to esm version by webpack
+const MODULE_PROXY_PATH = 'next/dist/build/webpack/loaders/next-flight-loader/module-proxy';
+function getAssumedSourceType(mod, sourceType) {
+    var _buildInfo_rsc, _buildInfo_rsc1;
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(mod);
+    const detectedClientEntryType = buildInfo == null ? void 0 : (_buildInfo_rsc = buildInfo.rsc) == null ? void 0 : _buildInfo_rsc.clientEntryType;
+    const clientRefs = (buildInfo == null ? void 0 : (_buildInfo_rsc1 = buildInfo.rsc) == null ? void 0 : _buildInfo_rsc1.clientRefs) || [];
+    // It's tricky to detect the type of a client boundary, but we should always
+    // use the `module` type when we can, to support `export *` and `export from`
+    // syntax in other modules that import this client boundary.
+    if (sourceType === 'auto') {
+        if (detectedClientEntryType === 'auto') {
+            if (clientRefs.length === 0) {
+                // If there's zero export detected in the client boundary, and it's the
+                // `auto` type, we can safely assume it's a CJS module because it doesn't
+                // have ESM exports.
+                return 'commonjs';
+            } else if (!clientRefs.includes('*')) {
+                // Otherwise, we assume it's an ESM module.
+                return 'module';
+            }
+        } else if (detectedClientEntryType === 'cjs') {
+            return 'commonjs';
+        }
+    }
+    return sourceType;
+}
+function transformSource(source, sourceMap) {
+    var _module_matchResource, _buildInfo_rsc, _buildInfo_rsc1;
+    // 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
+        });
+    }
+    const module1 = this._module;
+    // Assign the RSC meta information to buildInfo.
+    // Exclude next internal files which are not marked as client files
+    const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(module1);
+    buildInfo.rsc = (0, _getpagestaticinfo.getRSCModuleInformation)(source, true);
+    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;
+    }
+    prefix += `// This file is generated by the Webpack next-flight-loader.\n`;
+    // Resource key is the unique identifier for the resource. When RSC renders
+    // a client module, that key is used to identify that module across all compiler
+    // layers.
+    //
+    // Usually it's the module's file path + the export name (e.g. `foo.js#bar`).
+    // But with Barrel Optimizations, one file can be splitted into multiple modules,
+    // so when you import `foo.js#bar` and `foo.js#baz`, they are actually different
+    // "foo.js" being created by the Barrel Loader (one only exports `bar`, the other
+    // only exports `baz`).
+    //
+    // Because of that, we must add another query param to the resource key to
+    // differentiate them.
+    let resourceKey = this.resourcePath;
+    if ((_module_matchResource = module1.matchResource) == null ? void 0 : _module_matchResource.startsWith(_constants1.BARREL_OPTIMIZATION_PREFIX)) {
+        resourceKey = (0, _utils.formatBarrelOptimizedResource)(resourceKey, module1.matchResource);
+    }
+    // A client boundary.
+    if (((_buildInfo_rsc = buildInfo.rsc) == null ? void 0 : _buildInfo_rsc.type) === _constants1.RSC_MODULE_TYPES.client) {
+        const assumedSourceType = getAssumedSourceType(module1, sourceTypeFromModule(module1));
+        const clientRefs = buildInfo.rsc.clientRefs;
+        const stringifiedResourceKey = JSON.stringify(resourceKey);
+        if (assumedSourceType === 'module') {
+            if (clientRefs.length === 0) {
+                return this.callback(null, 'export {}');
+            }
+            if (clientRefs.includes('*')) {
+                this.callback(Object.defineProperty(new Error(`It's currently unsupported to use "export *" in a client boundary. Please use named exports instead.`), "__NEXT_ERROR_CODE", {
+                    value: "E46",
+                    enumerable: false,
+                    configurable: true
+                }));
+                return;
+            }
+            let esmSource = prefix + `\
+import { registerClientReference } from "react-server-dom-webpack/server";
+`;
+            for (const ref of clientRefs){
+                if (ref === 'default') {
+                    esmSource += `export default registerClientReference(
+function() { throw new Error(${JSON.stringify(`Attempted to call the default \
+export of ${stringifiedResourceKey} from the server, but it's on the client. \
+It's not possible to invoke a client function from the server, it can only be \
+rendered as a Component or passed to props of a Client Component.`)}); },
+${stringifiedResourceKey},
+"default",
+);\n`;
+                } else {
+                    esmSource += `export const ${ref} = registerClientReference(
+function() { throw new Error(${JSON.stringify(`Attempted to call ${ref}() from \
+the server but ${ref} is on the client. It's not possible to invoke a client \
+function from the server, it can only be rendered as a Component or passed to \
+props of a Client Component.`)}); },
+${stringifiedResourceKey},
+${JSON.stringify(ref)},
+);`;
+                }
+            }
+            const compilation = this._compilation;
+            const originalSourceURL = process.env.NEXT_RSPACK ? `webpack://_N_E/${this.utils.contextify(this.context || this.rootContext, this.resourcePath)}/__nextjs-internal-proxy.mjs` : _webpack.ModuleFilenameHelpers.createFilename(module1, {
+                moduleFilenameTemplate: 'webpack://[namespace]/[resource-path]/__nextjs-internal-proxy.mjs',
+                namespace: '_N_E'
+            }, {
+                requestShortener: compilation.requestShortener,
+                chunkGraph: compilation.chunkGraph,
+                hashFunction: compilation.outputOptions.hashFunction
+            });
+            return this.callback(null, esmSource, {
+                version: 3,
+                sources: [
+                    originalSourceURL
+                ],
+                // minimal, parseable mappings
+                mappings: 'AAAA',
+                sourcesContent: [
+                    esmSource
+                ]
+            });
+        } else if (assumedSourceType === 'commonjs') {
+            let cjsSource = prefix + `\
+const { createProxy } = require("${MODULE_PROXY_PATH}")
+
+module.exports = createProxy(${stringifiedResourceKey})
+`;
+            const compilation = this._compilation;
+            const originalSourceURL = process.env.NEXT_RSPACK ? `webpack://_N_E/${this.utils.contextify(this.context || this.rootContext, this.resourcePath)}/__nextjs-internal-proxy.cjs` : _webpack.ModuleFilenameHelpers.createFilename(module1, {
+                moduleFilenameTemplate: 'webpack://[namespace]/[resource-path]/__nextjs-internal-proxy.cjs',
+                namespace: '_N_E'
+            }, {
+                requestShortener: compilation.requestShortener,
+                chunkGraph: compilation.chunkGraph,
+                hashFunction: compilation.outputOptions.hashFunction
+            });
+            return this.callback(null, cjsSource, {
+                version: 3,
+                sources: [
+                    originalSourceURL
+                ],
+                // minimal, parseable mappings
+                mappings: 'AAAA',
+                sourcesContent: [
+                    cjsSource
+                ]
+            });
+        }
+    }
+    if (((_buildInfo_rsc1 = buildInfo.rsc) == null ? void 0 : _buildInfo_rsc1.type) !== _constants1.RSC_MODULE_TYPES.client) {
+        if (noopHeadPath === this.resourcePath) {
+            (0, _warnonce.warnOnce)(`Warning: You're using \`next/head\` inside the \`app\` directory, please migrate to the Metadata API. See https://nextjs.org/docs/app/building-your-application/upgrading/app-router-migration#step-3-migrating-nexthead for more details.`);
+        }
+    }
+    const replacedSource = source.replace(_constants.RSC_MOD_REF_PROXY_ALIAS, MODULE_PROXY_PATH);
+    this.callback(null, replacedSource, sourceMap);
+}
+function sourceTypeFromModule(module1) {
+    const moduleType = module1.type;
+    switch(moduleType){
+        case 'javascript/auto':
+            return 'auto';
+        case 'javascript/dynamic':
+            return 'script';
+        case 'javascript/esm':
+            return 'module';
+        default:
+            throw Object.defineProperty(new Error('Unexpected module type ' + moduleType), "__NEXT_ERROR_CODE", {
+                value: "E651",
+                enumerable: false,
+                configurable: true
+            });
+    }
+}
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,14 @@
+/* eslint-disable import/no-extraneous-dependencies */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createProxy", {
+    enumerable: true,
+    get: function() {
+        return createProxy;
+    }
+});
+const _server = require("react-server-dom-webpack/server");
+const createProxy = _server.createClientModuleProxy;
+
+//# sourceMappingURL=module-proxy.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-flight-loader/server-reference.js

@@ -0,0 +1,13 @@
+/* eslint-disable import/no-extraneous-dependencies */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerServerReference", {
+    enumerable: true,
+    get: function() {
+        return _server.registerServerReference;
+    }
+});
+const _server = require("react-server-dom-webpack/server");
+
+//# sourceMappingURL=server-reference.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-flight-loader/track-dynamic-import.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "trackDynamicImport", {
+    enumerable: true,
+    get: function() {
+        return _trackdynamicimport.trackDynamicImport;
+    }
+});
+const _trackdynamicimport = require("../../../../server/app-render/module-loading/track-dynamic-import");
+
+//# sourceMappingURL=track-dynamic-import.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-flight-server-reference-proxy-loader.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+// This is a virtual proxy loader that takes a Server Reference ID and a name,
+// creates a module that just re-exports the reference as that name.
+const flightServerReferenceProxyLoader = function transformSource() {
+    const { id, name } = this.getOptions();
+    // Both the import and the `createServerReference` call are marked as side
+    // effect free:
+    // - private-next-rsc-action-client-wrapper is matched as `sideEffects: false` in
+    //   the Webpack loader
+    // - createServerReference is marked as /*#__PURE__*/
+    //
+    // Because of that, Webpack is able to concatenate the modules and inline the
+    // reference IDs recursively directly into the module that uses them.
+    return `\
+import { createServerReference, callServer, findSourceMapURL } from 'private-next-rsc-action-client-wrapper'
+export ${name === 'default' ? 'default' : `const ${name} =`} /*#__PURE__*/createServerReference(${JSON.stringify(id)}, callServer, undefined, findSourceMapURL, ${JSON.stringify(name)})`;
+};
+const _default = flightServerReferenceProxyLoader;
+
+//# sourceMappingURL=next-flight-server-reference-proxy-loader.js.map

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return nextFontLoader;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _picocolors = require("../../../../lib/picocolors");
+const _loaderutils3 = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/loader-utils3"));
+const _postcssnextfont = /*#__PURE__*/ _interop_require_default(require("./postcss-next-font"));
+const _util = require("util");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function nextFontLoader() {
+    const nextFontLoaderSpan = this.currentTraceSpan.traceChild('next-font-loader');
+    return nextFontLoaderSpan.traceAsyncFn(async ()=>{
+        const callback = this.async();
+        /**
+     * The next-swc plugin next-transform-font turns font function calls into CSS imports.
+     * At the end of the import, it adds the call arguments and some additional data as a resourceQuery.
+     * e.g:
+     * const inter = Inter({ subset: ['latin'] })
+     * ->
+     * import inter from 'next/font/google/target.css?{"import":"Inter","subsets":["latin"]}'
+     *
+     * Here we parse the resourceQuery to get the font function name, call arguments, and the path to the file that called the font function.
+     */ const { path: relativeFilePathFromRoot, import: functionName, arguments: data, variableName } = JSON.parse(this.resourceQuery.slice(1));
+        // Throw error if @next/font is used in _document.js
+        if (/pages[\\/]_document\./.test(relativeFilePathFromRoot)) {
+            const err = Object.defineProperty(new Error(`${(0, _picocolors.bold)('Cannot')} be used within ${(0, _picocolors.cyan)('pages/_document.js')}.`), "__NEXT_ERROR_CODE", {
+                value: "E135",
+                enumerable: false,
+                configurable: true
+            });
+            err.name = 'NextFontError';
+            if (process.env.NEXT_RSPACK) {
+                // Rspack uses miette for error formatting, which automatically includes stack
+                // traces in the error message. To avoid showing redundant stack information
+                // in the final error output, we clear the stack property.
+                err.stack = undefined;
+            }
+            callback(err);
+            return;
+        }
+        const { isDev, isServer, assetPrefix, fontLoaderPath, postcss: getPostcss } = this.getOptions();
+        if (assetPrefix && !/^\/|https?:\/\//.test(assetPrefix)) {
+            const err = Object.defineProperty(new Error('assetPrefix must start with a leading slash or be an absolute URL(http:// or https://)'), "__NEXT_ERROR_CODE", {
+                value: "E72",
+                enumerable: false,
+                configurable: true
+            });
+            err.name = 'NextFontError';
+            callback(err);
+            return;
+        }
+        /**
+     * Emit font files to .next/static/media as [hash].[ext].
+     *
+     * If the font should be preloaded, add .p to the filename: [hash].p.[ext]
+     * NextFontManifestPlugin adds these files to the next/font manifest.
+     *
+     * If the font is using a size-adjust fallback font, add -s to the filename: [hash]-s.[ext]
+     * NextFontManifestPlugin uses this to see if fallback fonts are being used.
+     * This is used to collect stats on fallback fonts usage by the Google Aurora team.
+     */ const emitFontFile = (content, ext, preload, isUsingSizeAdjust)=>{
+            const opts = {
+                context: this.rootContext,
+                content
+            };
+            const interpolatedName = _loaderutils3.default.interpolateName(this, `static/media/[hash]${isUsingSizeAdjust ? '-s' : ''}${preload ? '.p' : ''}.${ext}`, opts);
+            const outputPath = `${assetPrefix}/_next/${interpolatedName}`;
+            // Only the client emits the font file
+            if (!isServer) {
+                this.emitFile(interpolatedName, content, null);
+            }
+            // But both the server and client must get the resulting path
+            return outputPath;
+        };
+        try {
+            // Import the font loader function from either next/font/local or next/font/google
+            // The font loader function emits font files and returns @font-faces and fallback font metrics
+            const fontLoader = require(fontLoaderPath).default;
+            let { css, fallbackFonts, adjustFontFallback, weight, style, variable } = await nextFontLoaderSpan.traceChild('font-loader').traceAsyncFn(()=>fontLoader({
+                    functionName,
+                    variableName,
+                    data,
+                    emitFontFile,
+                    resolve: (src)=>(0, _util.promisify)(this.resolve)(_path.default.dirname(_path.default.join(this.rootContext, relativeFilePathFromRoot)), src.startsWith('.') ? src : `./${src}`),
+                    isDev,
+                    isServer,
+                    loaderContext: this
+                }));
+            const { postcss } = await getPostcss();
+            // Exports will be exported as is from css-loader instead of a CSS module export
+            const exports1 = [];
+            // Generate a hash from the CSS content. Used to generate classnames
+            const fontFamilyHash = _loaderutils3.default.getHashDigest(Buffer.from(css), 'sha1', 'hex', 6);
+            // Add CSS classes, exports and make the font-family locally scoped by turning it unguessable
+            const result = await nextFontLoaderSpan.traceChild('postcss').traceAsyncFn(()=>postcss((0, _postcssnextfont.default)({
+                    exports: exports1,
+                    fallbackFonts,
+                    weight,
+                    style,
+                    adjustFontFallback,
+                    variable
+                })).process(css, {
+                    from: undefined
+                }));
+            const ast = {
+                type: 'postcss',
+                version: result.processor.version,
+                root: result.root
+            };
+            // Return the resulting CSS and send the postcss ast, font exports and the hash to the css-loader in the meta argument.
+            callback(null, result.css, null, {
+                exports: exports1,
+                ast,
+                fontFamilyHash
+            });
+        } catch (err) {
+            callback(err);
+        }
+    });
+}
+
+//# sourceMappingURL=index.js.map