npm - @obsfx/trekker - Versions diffs - 0.1.7 → 0.1.9 - Mend

@obsfx/trekker 0.1.7 → 0.1.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1300) hide show

package/webapp-dist/vendor/next/dist/server/app-render/metadata-insertion/create-server-inserted-metadata.js ADDED Viewed

@@ -0,0 +1,28 @@
+/**
+ * For chromium based browsers (Chrome, Edge, etc.) and Safari,
+ * icons need to stay under <head> to be picked up by the browser.
+ *
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createServerInsertedMetadata", {
+    enumerable: true,
+    get: function() {
+        return createServerInsertedMetadata;
+    }
+});
+const REINSERT_ICON_SCRIPT = `\
+document.querySelectorAll('body link[rel="icon"], body link[rel="apple-touch-icon"]').forEach(el => document.head.appendChild(el))`;
+function createServerInsertedMetadata(nonce) {
+    let inserted = false;
+    return async function getServerInsertedMetadata() {
+        if (inserted) {
+            return '';
+        }
+        inserted = true;
+        return `<script ${nonce ? `nonce="${nonce}"` : ''}>${REINSERT_ICON_SCRIPT}</script>`;
+    };
+}
+//# sourceMappingURL=create-server-inserted-metadata.js.map

package/webapp-dist/vendor/next/dist/server/app-render/module-loading/track-dynamic-import.js ADDED Viewed

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "trackDynamicImport", {
+    enumerable: true,
+    get: function() {
+        return trackDynamicImport;
+    }
+});
+const _invarianterror = require("../../../shared/lib/invariant-error");
+const _isthenable = require("../../../shared/lib/is-thenable");
+const _trackmoduleloadingexternal = require("./track-module-loading.external");
+function trackDynamicImport(modulePromise) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError("Dynamic imports should not be instrumented in the edge runtime, because `cacheComponents` doesn't support it"), "__NEXT_ERROR_CODE", {
+            value: "E687",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    if (!(0, _isthenable.isThenable)(modulePromise)) {
+        // We're expecting `import()` to always return a promise. If it's not, something's very wrong.
+        throw Object.defineProperty(new _invarianterror.InvariantError('`trackDynamicImport` should always receive a promise. Something went wrong in the dynamic imports transform.'), "__NEXT_ERROR_CODE", {
+            value: "E677",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Even if we're inside a prerender and have `workUnitStore.cacheSignal`, we always track the promise globally.
+    // (i.e. via the global `moduleLoadingSignal` that `trackPendingImport` uses internally).
+    //
+    // We do this because the `import()` promise might be cached in userspace:
+    // (which is quite common for e.g. lazy initialization in libraries)
+    //
+    //   let promise;
+    //   function doDynamicImportOnce() {
+    //     if (!promise) {
+    //       promise = import("...");
+    //       // transformed into:
+    //       // promise = trackDynamicImport(import("..."));
+    //     }
+    //     return promise;
+    //   }
+    //
+    // If multiple prerenders (e.g. multiple pages) depend on `doDynamicImportOnce`,
+    // we have to wait for the import *in all of them*.
+    // If we only tracked it using `workUnitStore.cacheSignal.trackRead()`,
+    // then only the first prerender to call `doDynamicImportOnce` would wait --
+    // Subsequent prerenders would re-use the existing `promise`,
+    // and `trackDynamicImport` wouldn't be called again in their scope,
+    // so their respective CacheSignals wouldn't wait for the promise.
+    (0, _trackmoduleloadingexternal.trackPendingImport)(modulePromise);
+    return modulePromise;
+}
+//# sourceMappingURL=track-dynamic-import.js.map

package/webapp-dist/vendor/next/dist/server/app-render/module-loading/track-module-loading.external.js ADDED Viewed

@@ -0,0 +1,32 @@
+// NOTE: this is marked as shared/external because it's stateful
+// and the state needs to be shared between app-render (which waits for pending imports)
+// and helpers used in transformed page code (which register pending imports)
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    trackPendingChunkLoad: null,
+    trackPendingImport: null,
+    trackPendingModules: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    trackPendingChunkLoad: function() {
+        return _trackmoduleloadinginstance.trackPendingChunkLoad;
+    },
+    trackPendingImport: function() {
+        return _trackmoduleloadinginstance.trackPendingImport;
+    },
+    trackPendingModules: function() {
+        return _trackmoduleloadinginstance.trackPendingModules;
+    }
+});
+const _trackmoduleloadinginstance = require("./track-module-loading.instance");
+//# sourceMappingURL=track-module-loading.external.js.map

package/webapp-dist/vendor/next/dist/server/app-render/module-loading/track-module-loading.instance.js ADDED Viewed

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    trackPendingChunkLoad: null,
+    trackPendingImport: null,
+    trackPendingModules: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    trackPendingChunkLoad: function() {
+        return trackPendingChunkLoad;
+    },
+    trackPendingImport: function() {
+        return trackPendingImport;
+    },
+    trackPendingModules: function() {
+        return trackPendingModules;
+    }
+});
+const _cachesignal = require("../cache-signal");
+const _isthenable = require("../../../shared/lib/is-thenable");
+/**
+ * Tracks all in-flight async imports and chunk loads.
+ * Initialized lazily, because we don't want this to error in case it gets pulled into an edge runtime module.
+ */ let _moduleLoadingSignal;
+function getModuleLoadingSignal() {
+    if (!_moduleLoadingSignal) {
+        _moduleLoadingSignal = new _cachesignal.CacheSignal();
+    }
+    return _moduleLoadingSignal;
+}
+function trackPendingChunkLoad(promise) {
+    const moduleLoadingSignal = getModuleLoadingSignal();
+    moduleLoadingSignal.trackRead(promise);
+}
+function trackPendingImport(exportsOrPromise) {
+    const moduleLoadingSignal = getModuleLoadingSignal();
+    // requiring an async module returns a promise.
+    // if it's sync, there's nothing to track.
+    if ((0, _isthenable.isThenable)(exportsOrPromise)) {
+        // A client reference proxy might look like a promise, but we can only call `.then()` on it, not e.g. `.finally()`.
+        // Turn it into a real promise to avoid issues elsewhere.
+        const promise = Promise.resolve(exportsOrPromise);
+        moduleLoadingSignal.trackRead(promise);
+    }
+}
+function trackPendingModules(cacheSignal) {
+    const moduleLoadingSignal = getModuleLoadingSignal();
+    // We can't just use `cacheSignal.trackRead(moduleLoadingSignal.cacheReady())`,
+    // because we might start and finish multiple batches of module loads while waiting for caches,
+    // and `moduleLoadingSignal.cacheReady()` would resolve after the first batch.
+    // Instead, we'll keep notifying `cacheSignal` of each import/chunk-load.
+    const unsubscribe = moduleLoadingSignal.subscribeToReads(cacheSignal);
+    // Later, when `cacheSignal` is no longer waiting for any caches (or imports that we've notified it of),
+    // we can unsubscribe it.
+    cacheSignal.cacheReady().then(unsubscribe);
+}
+//# sourceMappingURL=track-module-loading.instance.js.map

package/webapp-dist/vendor/next/dist/server/app-render/parse-and-validate-flight-router-state.js ADDED Viewed

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseAndValidateFlightRouterState", {
+    enumerable: true,
+    get: function() {
+        return parseAndValidateFlightRouterState;
+    }
+});
+const _types = require("./types");
+const _superstruct = require("next/dist/compiled/superstruct");
+function parseAndValidateFlightRouterState(stateHeader) {
+    if (typeof stateHeader === 'undefined') {
+        return undefined;
+    }
+    if (Array.isArray(stateHeader)) {
+        throw Object.defineProperty(new Error('Multiple router state headers were sent. This is not allowed.'), "__NEXT_ERROR_CODE", {
+            value: "E418",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // We limit the size of the router state header to ~40kb. This is to prevent
+    // a malicious user from sending a very large header and slowing down the
+    // resolving of the router state.
+    // This is around 2,000 nested or parallel route segment states:
+    // '{"children":["",{}]}'.length === 20.
+    if (stateHeader.length > 20 * 2000) {
+        throw Object.defineProperty(new Error('The router state header was too large.'), "__NEXT_ERROR_CODE", {
+            value: "E142",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    try {
+        const state = JSON.parse(decodeURIComponent(stateHeader));
+        (0, _superstruct.assert)(state, _types.flightRouterStateSchema);
+        return state;
+    } catch  {
+        throw Object.defineProperty(new Error('The router state header was sent but could not be parsed.'), "__NEXT_ERROR_CODE", {
+            value: "E10",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+//# sourceMappingURL=parse-and-validate-flight-router-state.js.map

package/webapp-dist/vendor/next/dist/server/app-render/postponed-state.js ADDED Viewed

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    DynamicHTMLPreludeState: null,
+    DynamicState: null,
+    getDynamicDataPostponedState: null,
+    getDynamicHTMLPostponedState: null,
+    getPostponedFromState: null,
+    parsePostponedState: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DynamicHTMLPreludeState: function() {
+        return DynamicHTMLPreludeState;
+    },
+    DynamicState: function() {
+        return DynamicState;
+    },
+    getDynamicDataPostponedState: function() {
+        return getDynamicDataPostponedState;
+    },
+    getDynamicHTMLPostponedState: function() {
+        return getDynamicHTMLPostponedState;
+    },
+    getPostponedFromState: function() {
+        return getPostponedFromState;
+    },
+    parsePostponedState: function() {
+        return parsePostponedState;
+    }
+});
+const _getdynamicparam = require("../../shared/lib/router/utils/get-dynamic-param");
+const _resumedatacache = require("../resume-data-cache/resume-data-cache");
+var DynamicState = /*#__PURE__*/ function(DynamicState) {
+    /**
+   * The dynamic access occurred during the RSC render phase.
+   */ DynamicState[DynamicState["DATA"] = 1] = "DATA";
+    /**
+   * The dynamic access occurred during the HTML shell render phase.
+   */ DynamicState[DynamicState["HTML"] = 2] = "HTML";
+    return DynamicState;
+}({});
+var DynamicHTMLPreludeState = /*#__PURE__*/ function(DynamicHTMLPreludeState) {
+    DynamicHTMLPreludeState[DynamicHTMLPreludeState["Empty"] = 0] = "Empty";
+    DynamicHTMLPreludeState[DynamicHTMLPreludeState["Full"] = 1] = "Full";
+    return DynamicHTMLPreludeState;
+}({});
+async function getDynamicHTMLPostponedState(postponed, preludeState, fallbackRouteParams, resumeDataCache, isCacheComponentsEnabled) {
+    const data = [
+        preludeState,
+        postponed
+    ];
+    const dataString = JSON.stringify(data);
+    // If there are no fallback route params, we can just serialize the postponed
+    // state as is.
+    if (!fallbackRouteParams || fallbackRouteParams.size === 0) {
+        // Serialized as `<postponedString.length>:<postponedString><renderResumeDataCache>`
+        return `${dataString.length}:${dataString}${await (0, _resumedatacache.stringifyResumeDataCache)((0, _resumedatacache.createRenderResumeDataCache)(resumeDataCache), isCacheComponentsEnabled)}`;
+    }
+    const replacements = Array.from(fallbackRouteParams.entries());
+    const replacementsString = JSON.stringify(replacements);
+    // Serialized as `<replacements.length><replacements><data>`
+    const postponedString = `${replacementsString.length}${replacementsString}${dataString}`;
+    // Serialized as `<postponedString.length>:<postponedString><renderResumeDataCache>`
+    return `${postponedString.length}:${postponedString}${await (0, _resumedatacache.stringifyResumeDataCache)(resumeDataCache, isCacheComponentsEnabled)}`;
+}
+async function getDynamicDataPostponedState(resumeDataCache, isCacheComponentsEnabled) {
+    return `4:null${await (0, _resumedatacache.stringifyResumeDataCache)((0, _resumedatacache.createRenderResumeDataCache)(resumeDataCache), isCacheComponentsEnabled)}`;
+}
+function parsePostponedState(state, interpolatedParams) {
+    try {
+        var _state_match;
+        const postponedStringLengthMatch = (_state_match = state.match(/^([0-9]*):/)) == null ? void 0 : _state_match[1];
+        if (!postponedStringLengthMatch) {
+            throw Object.defineProperty(new Error(`Invariant: invalid postponed state ${state}`), "__NEXT_ERROR_CODE", {
+                value: "E314",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const postponedStringLength = parseInt(postponedStringLengthMatch);
+        // We add a `:` to the end of the length as the first character of the
+        // postponed string is the length of the replacement entries.
+        const postponedString = state.slice(postponedStringLengthMatch.length + 1, postponedStringLengthMatch.length + postponedStringLength + 1);
+        const renderResumeDataCache = (0, _resumedatacache.createRenderResumeDataCache)(state.slice(postponedStringLengthMatch.length + postponedStringLength + 1));
+        try {
+            if (postponedString === 'null') {
+                return {
+                    type: 1,
+                    renderResumeDataCache
+                };
+            }
+            if (/^[0-9]/.test(postponedString)) {
+                var _postponedString_match;
+                const match = (_postponedString_match = postponedString.match(/^([0-9]*)/)) == null ? void 0 : _postponedString_match[1];
+                if (!match) {
+                    throw Object.defineProperty(new Error(`Invariant: invalid postponed state ${JSON.stringify(postponedString)}`), "__NEXT_ERROR_CODE", {
+                        value: "E314",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                // This is the length of the replacements entries.
+                const length = parseInt(match);
+                const replacements = JSON.parse(postponedString.slice(match.length, // We then go to the end of the string.
+                match.length + length));
+                let postponed = postponedString.slice(match.length + length);
+                for (const [segmentKey, [searchValue, dynamicParamType]] of replacements){
+                    const { treeSegment: [, // This is the same value that'll be used in the postponed state
+                    // as it's part of the tree data. That's why we use it as the
+                    // replacement value.
+                    value] } = (0, _getdynamicparam.getDynamicParam)(interpolatedParams, segmentKey, dynamicParamType, null);
+                    postponed = postponed.replaceAll(searchValue, value);
+                }
+                return {
+                    type: 2,
+                    data: JSON.parse(postponed),
+                    renderResumeDataCache
+                };
+            }
+            return {
+                type: 2,
+                data: JSON.parse(postponedString),
+                renderResumeDataCache
+            };
+        } catch (err) {
+            console.error('Failed to parse postponed state', err);
+            return {
+                type: 1,
+                renderResumeDataCache
+            };
+        }
+    } catch (err) {
+        console.error('Failed to parse postponed state', err);
+        return {
+            type: 1,
+            renderResumeDataCache: (0, _resumedatacache.createPrerenderResumeDataCache)()
+        };
+    }
+}
+function getPostponedFromState(state) {
+    const [preludeState, postponed] = state.data;
+    return {
+        preludeState,
+        postponed
+    };
+}
+//# sourceMappingURL=postponed-state.js.map

package/webapp-dist/vendor/next/dist/server/app-render/prospective-render-utils.js ADDED Viewed

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    Phase: null,
+    printDebugThrownValueForProspectiveRender: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Phase: function() {
+        return Phase;
+    },
+    printDebugThrownValueForProspectiveRender: function() {
+        return printDebugThrownValueForProspectiveRender;
+    }
+});
+const _createerrorhandler = require("./create-error-handler");
+const _reactlargeshellerror = require("./react-large-shell-error");
+var Phase = /*#__PURE__*/ function(Phase) {
+    Phase["ProspectiveRender"] = "the prospective render";
+    Phase["SegmentCollection"] = "segment collection";
+    return Phase;
+}({});
+function printDebugThrownValueForProspectiveRender(thrownValue, route, phase) {
+    // We don't need to print well-known Next.js errors.
+    if ((0, _createerrorhandler.getDigestForWellKnownError)(thrownValue)) {
+        return;
+    }
+    if ((0, _reactlargeshellerror.isReactLargeShellError)(thrownValue)) {
+        // TODO: Aggregate
+        console.error(thrownValue);
+        return undefined;
+    }
+    let message;
+    if (typeof thrownValue === 'object' && thrownValue !== null && typeof thrownValue.message === 'string') {
+        message = thrownValue.message;
+        if (typeof thrownValue.stack === 'string') {
+            const originalErrorStack = thrownValue.stack;
+            const stackStart = originalErrorStack.indexOf('\n');
+            if (stackStart > -1) {
+                const error = Object.defineProperty(new Error(`Route ${route} errored during ${phase}. These errors are normally ignored and may not prevent the route from prerendering but are logged here because build debugging is enabled.
+Original Error: ${message}`), "__NEXT_ERROR_CODE", {
+                    value: "E949",
+                    enumerable: false,
+                    configurable: true
+                });
+                error.stack = 'Error: ' + error.message + originalErrorStack.slice(stackStart);
+                console.error(error);
+                return;
+            }
+        }
+    } else if (typeof thrownValue === 'string') {
+        message = thrownValue;
+    }
+    if (message) {
+        console.error(`Route ${route} errored during ${phase}. These errors are normally ignored and may not prevent the route from prerendering but are logged here because build debugging is enabled. No stack was provided.
+Original Message: ${message}`);
+        return;
+    }
+    console.error(`Route ${route} errored during ${phase}. These errors are normally ignored and may not prevent the route from prerendering but are logged here because build debugging is enabled. The thrown value is logged just following this message`);
+    console.error(thrownValue);
+    return;
+}
+//# sourceMappingURL=prospective-render-utils.js.map

package/webapp-dist/vendor/next/dist/server/app-render/react-large-shell-error.js ADDED Viewed

@@ -0,0 +1,17 @@
+// TODO: isWellKnownError -> isNextInternalError
+// isReactLargeShellError -> isWarning
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isReactLargeShellError", {
+    enumerable: true,
+    get: function() {
+        return isReactLargeShellError;
+    }
+});
+function isReactLargeShellError(error) {
+    return typeof error === 'object' && error !== null && 'message' in error && typeof error.message === 'string' && error.message.startsWith('This rendered a large document (>');
+}
+//# sourceMappingURL=react-large-shell-error.js.map

package/webapp-dist/vendor/next/dist/server/app-render/react-server.node.js ADDED Viewed

@@ -0,0 +1,39 @@
+// This file should be opted into the react-server layer
+// eslint-disable-next-line import/no-extraneous-dependencies
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createTemporaryReferenceSet: null,
+    decodeAction: null,
+    decodeFormState: null,
+    decodeReply: null,
+    decodeReplyFromBusboy: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createTemporaryReferenceSet: function() {
+        return _servernode.createTemporaryReferenceSet;
+    },
+    decodeAction: function() {
+        return _servernode.decodeAction;
+    },
+    decodeFormState: function() {
+        return _servernode.decodeFormState;
+    },
+    decodeReply: function() {
+        return _servernode.decodeReply;
+    },
+    decodeReplyFromBusboy: function() {
+        return _servernode.decodeReplyFromBusboy;
+    }
+});
+const _servernode = require("react-server-dom-webpack/server.node");
+//# sourceMappingURL=react-server.node.js.map

package/webapp-dist/vendor/next/dist/server/app-render/render-css-resource.js ADDED Viewed

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderCssResource", {
+    enumerable: true,
+    get: function() {
+        return renderCssResource;
+    }
+});
+const _encodeuripath = require("../../shared/lib/encode-uri-path");
+const _getassetquerystring = require("./get-asset-query-string");
+function renderCssResource(entryCssFiles, ctx, preloadCallbacks) {
+    const { componentMod: { createElement } } = ctx;
+    return entryCssFiles.map((entryCssFile, index)=>{
+        // `Precedence` is an opt-in signal for React to handle resource
+        // loading and deduplication, etc. It's also used as the key to sort
+        // resources so they will be injected in the correct order.
+        // During HMR, it's critical to use different `precedence` values
+        // for different stylesheets, so their order will be kept.
+        // https://github.com/facebook/react/pull/25060
+        const precedence = process.env.NODE_ENV === 'development' ? 'next_' + entryCssFile.path : 'next';
+        // In dev, Safari and Firefox will cache the resource during HMR:
+        // - https://github.com/vercel/next.js/issues/5860
+        // - https://bugs.webkit.org/show_bug.cgi?id=187726
+        // Because of this, we add a `?v=` query to bypass the cache during
+        // development. We need to also make sure that the number is always
+        // increasing.
+        const fullHref = `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(entryCssFile.path)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`;
+        if (entryCssFile.inlined && !ctx.parsedRequestHeaders.isRSCRequest) {
+            return createElement('style', {
+                key: index,
+                nonce: ctx.nonce,
+                precedence: precedence,
+                href: fullHref
+            }, entryCssFile.content);
+        }
+        preloadCallbacks == null ? void 0 : preloadCallbacks.push(()=>{
+            ctx.componentMod.preloadStyle(fullHref, ctx.renderOpts.crossOrigin, ctx.nonce);
+        });
+        return createElement('link', {
+            key: index,
+            rel: 'stylesheet',
+            href: fullHref,
+            precedence: precedence,
+            crossOrigin: ctx.renderOpts.crossOrigin,
+            nonce: ctx.nonce
+        });
+    });
+}
+//# sourceMappingURL=render-css-resource.js.map

package/webapp-dist/vendor/next/dist/server/app-render/required-scripts.js ADDED Viewed

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getRequiredScripts", {
+    enumerable: true,
+    get: function() {
+        return getRequiredScripts;
+    }
+});
+const _encodeuripath = require("../../shared/lib/encode-uri-path");
+const _reactdom = /*#__PURE__*/ _interop_require_default(require("react-dom"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getRequiredScripts(buildManifest, assetPrefix, crossOrigin, SRIManifest, qs, nonce, pagePath) {
+    var _buildManifest_rootMainFilesTree;
+    let preinitScripts;
+    let preinitScriptCommands = [];
+    const bootstrapScript = {
+        src: '',
+        crossOrigin
+    };
+    const files = (((_buildManifest_rootMainFilesTree = buildManifest.rootMainFilesTree) == null ? void 0 : _buildManifest_rootMainFilesTree[pagePath]) || buildManifest.rootMainFiles).map(_encodeuripath.encodeURIPath);
+    if (files.length === 0) {
+        throw Object.defineProperty(new Error('Invariant: missing bootstrap script. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
+            value: "E459",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    if (SRIManifest) {
+        bootstrapScript.src = `${assetPrefix}/_next/` + files[0] + qs;
+        bootstrapScript.integrity = SRIManifest[files[0]];
+        for(let i = 1; i < files.length; i++){
+            const src = `${assetPrefix}/_next/` + files[i] + qs;
+            const integrity = SRIManifest[files[i]];
+            preinitScriptCommands.push(src, integrity);
+        }
+        preinitScripts = ()=>{
+            // preinitScriptCommands is a double indexed array of src/integrity pairs
+            for(let i = 0; i < preinitScriptCommands.length; i += 2){
+                _reactdom.default.preinit(preinitScriptCommands[i], {
+                    as: 'script',
+                    integrity: preinitScriptCommands[i + 1],
+                    crossOrigin,
+                    nonce
+                });
+            }
+        };
+    } else {
+        bootstrapScript.src = `${assetPrefix}/_next/` + files[0] + qs;
+        for(let i = 1; i < files.length; i++){
+            const src = `${assetPrefix}/_next/` + files[i] + qs;
+            preinitScriptCommands.push(src);
+        }
+        preinitScripts = ()=>{
+            // preinitScriptCommands is a singled indexed array of src values
+            for(let i = 0; i < preinitScriptCommands.length; i++){
+                _reactdom.default.preinit(preinitScriptCommands[i], {
+                    as: 'script',
+                    nonce,
+                    crossOrigin
+                });
+            }
+        };
+    }
+    return [
+        preinitScripts,
+        bootstrapScript
+    ];
+}
+//# sourceMappingURL=required-scripts.js.map

package/webapp-dist/vendor/next/dist/server/app-render/rsc/postpone.js ADDED Viewed

@@ -0,0 +1,18 @@
+/*
+Files in the rsc directory are meant to be packaged as part of the RSC graph using next-app-loader.
+*/ // When postpone is available in canary React we can switch to importing it directly
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Postpone", {
+    enumerable: true,
+    get: function() {
+        return _dynamicrendering.Postpone;
+    }
+});
+const _dynamicrendering = require("../dynamic-rendering");
+//# sourceMappingURL=postpone.js.map