@b4run/inspector 0.8.28

package/.next/standalone/node_modules/.pnpm/next@16.3.0_@babel+core@7.29.7_@opentelemetry+api@1.9.1_@playwright+test@1.62.1_@types+_dbc857abffbbe11b366888a920df3956/node_modules/next/dist/server/app-render/async-local-storage.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    bindSnapshot: null,
+    createAsyncLocalStorage: null,
+    createSnapshot: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    bindSnapshot: function() {
+        return bindSnapshot;
+    },
+    createAsyncLocalStorage: function() {
+        return createAsyncLocalStorage;
+    },
+    createSnapshot: function() {
+        return createSnapshot;
+    }
+});
+const sharedAsyncLocalStorageNotAvailableError = Object.defineProperty(new Error('Invariant: AsyncLocalStorage accessed in runtime where it is not available'), "__NEXT_ERROR_CODE", {
+    value: "E504",
+    enumerable: false,
+    configurable: true
+});
+class FakeAsyncLocalStorage {
+    disable() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    getStore() {
+        // This fake implementation of AsyncLocalStorage always returns `undefined`.
+        return undefined;
+    }
+    run() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    exit() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    enterWith() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+    }
+    static bind(fn) {
+        return fn;
+    }
+}
+const maybeGlobalAsyncLocalStorage = typeof globalThis !== 'undefined' && globalThis.AsyncLocalStorage;
+function createAsyncLocalStorage() {
+    if (maybeGlobalAsyncLocalStorage) {
+        return new maybeGlobalAsyncLocalStorage();
+    }
+    return new FakeAsyncLocalStorage();
+}
+function bindSnapshot(// WARNING: Don't pass a named function to this argument! See: https://github.com/facebook/react/pull/34911
+fn) {
+    if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.bind(fn);
+    }
+    return FakeAsyncLocalStorage.bind(fn);
+}
+function createSnapshot() {
+    if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.snapshot();
+    }
+    return function(fn, ...args) {
+        return fn(...args);
+    };
+}
+
+//# sourceMappingURL=async-local-storage.js.map

package/.next/standalone/node_modules/.pnpm/next@16.3.0_@babel+core@7.29.7_@opentelemetry+api@1.9.1_@playwright+test@1.62.1_@types+_dbc857abffbbe11b366888a920df3956/node_modules/next/dist/server/app-render/blocking-route-messages.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createDynamicBodyError: null,
+    createDynamicBodyErrorInNavigation: null,
+    createDynamicMetadataError: null,
+    createDynamicOrRuntimeBodyError: null,
+    createDynamicOrRuntimeMetadataError: null,
+    createDynamicOrRuntimeViewportError: null,
+    createDynamicViewportError: null,
+    createLinkBodyErrorInNavigation: null,
+    createLinkMetadataError: null,
+    createLinkViewportError: null,
+    createRuntimeBodyError: null,
+    createRuntimeBodyErrorInNavigation: null,
+    createRuntimeMetadataError: null,
+    createRuntimeViewportError: null,
+    logBuildDebugHint: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createDynamicBodyError: function() {
+        return createDynamicBodyError;
+    },
+    createDynamicBodyErrorInNavigation: function() {
+        return createDynamicBodyErrorInNavigation;
+    },
+    createDynamicMetadataError: function() {
+        return createDynamicMetadataError;
+    },
+    createDynamicOrRuntimeBodyError: function() {
+        return createDynamicOrRuntimeBodyError;
+    },
+    createDynamicOrRuntimeMetadataError: function() {
+        return createDynamicOrRuntimeMetadataError;
+    },
+    createDynamicOrRuntimeViewportError: function() {
+        return createDynamicOrRuntimeViewportError;
+    },
+    createDynamicViewportError: function() {
+        return createDynamicViewportError;
+    },
+    createLinkBodyErrorInNavigation: function() {
+        return createLinkBodyErrorInNavigation;
+    },
+    createLinkMetadataError: function() {
+        return createLinkMetadataError;
+    },
+    createLinkViewportError: function() {
+        return createLinkViewportError;
+    },
+    createRuntimeBodyError: function() {
+        return createRuntimeBodyError;
+    },
+    createRuntimeBodyErrorInNavigation: function() {
+        return createRuntimeBodyErrorInNavigation;
+    },
+    createRuntimeMetadataError: function() {
+        return createRuntimeMetadataError;
+    },
+    createRuntimeViewportError: function() {
+        return createRuntimeViewportError;
+    },
+    logBuildDebugHint: function() {
+        return logBuildDebugHint;
+    }
+});
+function createRuntimeBodyError(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered runtime data during prerendering.\n\n` + `\`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` accessed outside of \`<Suspense>\` prevents the route from being prerendered, blocking the page load and leading to a slower user experience.\n\n` + `Ways to fix this:\n` + `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` + `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-runtime`), "__NEXT_ERROR_CODE", {
+        value: "E1427",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createDynamicBodyError(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered uncached data during prerendering.\n\n` + `\`fetch(...)\` or \`connection()\` accessed outside of \`<Suspense>\` prevents the route from being prerendered, blocking the page load and leading to a slower user experience.\n\n` + `Ways to fix this:\n` + `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` + `  - [cache] Cache the data access with \`"use cache"\` (does not apply to \`connection()\`)\n` + `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-dynamic`), "__NEXT_ERROR_CODE", {
+        value: "E1440",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createRuntimeBodyErrorInNavigation(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered runtime data during prerendering or a navigation.\n\n` + `\`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` accessed outside of \`<Suspense>\` prevents the route from being prerendered or the navigation from being instant, leading to a slower user experience.\n\n` + `Ways to fix this:\n` + `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` + `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-runtime`), "__NEXT_ERROR_CODE", {
+        value: "E1430",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createLinkBodyErrorInNavigation(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered URL data during prerendering or a navigation.\n\n` + `\`params\` or \`searchParams\` accessed outside of \`<Suspense>\` may prevent the navigation from being instant, leading to a slower user experience.\n\n` + `Ways to fix this:\n` + `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` + `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` + `Learn more: https://nextjs.org/docs/messages/instant-shell-url-data`), "__NEXT_ERROR_CODE", {
+        value: "E1439",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createDynamicBodyErrorInNavigation(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered uncached data during prerendering or a navigation.\n\n` + `\`fetch(...)\` or \`connection()\` accessed outside of \`<Suspense>\` prevents the route from being prerendered or the navigation from being instant, leading to a slower user experience.\n\n` + `Ways to fix this:\n` + `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` + `  - [cache] Cache the data access with \`"use cache"\` (does not apply to \`connection()\`)\n` + `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-dynamic`), "__NEXT_ERROR_CODE", {
+        value: "E1437",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createDynamicOrRuntimeBodyError(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered uncached or runtime data during prerendering.\n\n` + `\`fetch(...)\`, \`cookies()\`, \`headers()\`, \`params\`, \`searchParams\`, or \`connection()\` accessed outside of \`<Suspense>\` prevents the route from being prerendered, blocking the page load and leading to a slower user experience.\n\n` + `Ways to fix this:\n` + `  - [stream] Provide a placeholder with \`<Suspense fallback={...}>\` around the data access\n` + `  - [cache] For uncached data (\`fetch\`, database calls): cache the access with \`"use cache"\` (does not apply to \`connection()\`)\n` + `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-dynamic`), "__NEXT_ERROR_CODE", {
+        value: "E1428",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createLinkMetadataError(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered URL data in \`generateMetadata()\`.\n\n` + `This route's metadata is blocked, but the rest of its content can be prefetched. \`params\` or \`searchParams\` accessed in \`generateMetadata()\` prevent it from being prefetched.\n\n` + `Ways to fix this:\n` + `  - [static] Use a static metadata export instead of \`generateMetadata()\`\n` + `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime`), "__NEXT_ERROR_CODE", {
+        value: "E1429",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createRuntimeMetadataError(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered runtime data in \`generateMetadata()\`.\n\n` + `This route's metadata is blocked, but the rest of its content can be prerendered. \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` accessed in \`generateMetadata()\` cause it to run dynamically.\n\n` + `Ways to fix this:\n` + `  - [static] Use a static metadata export instead of \`generateMetadata()\`\n` + `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime`), "__NEXT_ERROR_CODE", {
+        value: "E1423",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createDynamicMetadataError(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered uncached data in \`generateMetadata()\`.\n\n` + `This route's metadata is blocked, but the rest of its content can be prerendered. \`fetch(...)\` or \`connection()\` accessed in \`generateMetadata()\` cause it to run dynamically.\n\n` + `Ways to fix this:\n` + `  - [cache] Cache the metadata with \`"use cache"\` in \`generateMetadata()\` (does not apply to \`connection()\`)\n` + `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-metadata-dynamic`), "__NEXT_ERROR_CODE", {
+        value: "E1425",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createLinkViewportError(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered URL data in \`generateViewport()\`.\n\n` + `\`params\` or \`searchParams\` in \`generateViewport()\` prevents the page from being prerendered, leading to a slower user experience.\n\n` + `Ways to fix this:\n` + `  - [static] Use a static viewport export instead of \`generateViewport()\`\n` + `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime`), "__NEXT_ERROR_CODE", {
+        value: "E1431",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createRuntimeViewportError(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered runtime data in \`generateViewport()\`.\n\n` + `\`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` in \`generateViewport()\` prevents the page from being prerendered, leading to a slower user experience.\n\n` + `Ways to fix this:\n` + `  - [static] Use a static viewport export instead of \`generateViewport()\`\n` + `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime`), "__NEXT_ERROR_CODE", {
+        value: "E1424",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createDynamicViewportError(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered uncached data in \`generateViewport()\`.\n\n` + `\`fetch(...)\` or \`connection()\` in \`generateViewport()\` prevents the page from being prerendered, leading to a slower user experience.\n\n` + `Ways to fix this:\n` + `  - [cache] Cache the viewport data with \`"use cache"\` in \`generateViewport()\` (does not apply to \`connection()\`)\n` + `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-viewport-dynamic`), "__NEXT_ERROR_CODE", {
+        value: "E1438",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createDynamicOrRuntimeViewportError(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered uncached or runtime data in \`generateViewport()\`.\n\n` + `This prevents the page from being prerendered, leading to a slower user experience. Unlike metadata, viewport cannot be streamed behind \`<Suspense>\` because it affects the initial page load.\n\n` + `Ways to fix this:\n` + `  - [static] Use a static viewport export instead of \`generateViewport()\`\n` + `  - [cache] For uncached data (\`fetch\`, database calls): cache the viewport with \`"use cache"\` in \`generateViewport()\` (does not apply to \`connection()\`)\n` + `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-viewport-runtime`), "__NEXT_ERROR_CODE", {
+        value: "E1436",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createDynamicOrRuntimeMetadataError(route) {
+    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered uncached or runtime data in \`generateMetadata()\`.\n\n` + `This route's metadata is blocked, but the rest of its content can be prerendered.\n\n` + `Ways to fix this:\n` + `  - [static] Use a static metadata export instead of \`generateMetadata()\`\n` + `  - [cache] Cache the metadata with \`"use cache"\` in \`generateMetadata()\` (does not apply to \`connection()\`)\n` + `  - [dynamic] Render a marker component that calls \`await connection()\` inside \`<Suspense>\` on the page\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-metadata-runtime`), "__NEXT_ERROR_CODE", {
+        value: "E1426",
+        enumerable: false,
+        configurable: true
+    });
+}
+function logBuildDebugHint(route) {
+    if (process.env.NODE_ENV !== 'development') {
+        console.error(`To get a more detailed stack trace and pinpoint the issue, try one of the following:\n` + `  - Start the app in development mode by running \`next dev\`, then open "${route}" in your browser to investigate the error.\n` + `  - Rerun the production build with \`next build --debug-prerender\` to generate better stack traces.`);
+    } else if (!process.env.__NEXT_DEV_SERVER) {
+        console.error(`To debug the issue, start the app in development mode by running \`next dev\`, then open "${route}" in your browser to investigate the error.`);
+    }
+}
+
+//# sourceMappingURL=blocking-route-messages.js.map

package/.next/standalone/node_modules/.pnpm/next@16.3.0_@babel+core@7.29.7_@opentelemetry+api@1.9.1_@playwright+test@1.62.1_@types+_dbc857abffbbe11b366888a920df3956/node_modules/next/dist/server/app-render/cache-signal.js

@@ -0,0 +1,181 @@
+/**
+ * This class is used to detect when all cache reads for a given render are settled.
+ * We do this to allow for cache warming the prerender without having to continue rendering
+ * the remainder of the page. This feature is really only useful when the cacheComponents flag is on
+ * and should only be used in codepaths gated with this feature.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CacheSignal", {
+    enumerable: true,
+    get: function() {
+        return CacheSignal;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+class CacheSignal {
+    constructor(){
+        this.count = 0;
+        this.earlyListeners = [];
+        this.listeners = [];
+        this.tickPending = false;
+        this.pendingTimeoutCleanup = null;
+        this.subscribedSignals = null;
+        this.invokeListenersIfNoPendingReads = ()=>{
+            this.pendingTimeoutCleanup = null;
+            if (this.count === 0) {
+                for(let i = 0; i < this.listeners.length; i++){
+                    this.listeners[i]();
+                }
+                this.listeners.length = 0;
+            }
+        };
+        if (process.env.NEXT_RUNTIME === 'edge') {
+            // we rely on `process.nextTick`, which is not supported in edge
+            throw Object.defineProperty(new _invarianterror.InvariantError('CacheSignal cannot be used in the edge runtime, because `cacheComponents` does not support it.'), "__NEXT_ERROR_CODE", {
+                value: "E728",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    noMorePendingCaches() {
+        if (!this.tickPending) {
+            this.tickPending = true;
+            queueMicrotask(()=>process.nextTick(()=>{
+                    this.tickPending = false;
+                    if (this.count === 0) {
+                        for(let i = 0; i < this.earlyListeners.length; i++){
+                            this.earlyListeners[i]();
+                        }
+                        this.earlyListeners.length = 0;
+                    }
+                }));
+        }
+        // After a cache resolves, React will schedule new rendering work:
+        // - in a microtask (when prerendering)
+        // - in setImmediate (when rendering)
+        // To cover both of these, we have to make sure that we let immediates execute at least once after each cache resolved.
+        // We don't know when the pending timeout was scheduled (and if it's about to resolve),
+        // so by scheduling a new one, we can be sure that we'll go around the event loop at least once.
+        if (this.pendingTimeoutCleanup) {
+            // We cancel the timeout in beginRead, so this shouldn't ever be active here,
+            // but we still cancel it defensively.
+            this.pendingTimeoutCleanup();
+        }
+        this.pendingTimeoutCleanup = scheduleImmediateAndTimeoutWithCleanup(this.invokeListenersIfNoPendingReads);
+    }
+    /**
+   * This promise waits until there are no more in progress cache reads but no later.
+   * This allows for adding more cache reads after to delay cacheReady.
+   */ inputReady() {
+        return new Promise((resolve)=>{
+            this.earlyListeners.push(resolve);
+            if (this.count === 0) {
+                this.noMorePendingCaches();
+            }
+        });
+    }
+    /**
+   * If there are inflight cache reads this Promise can resolve in a microtask however
+   * if there are no inflight cache reads then we wait at least one task to allow initial
+   * cache reads to be initiated.
+   */ cacheReady() {
+        return new Promise((resolve)=>{
+            this.listeners.push(resolve);
+            if (this.count === 0) {
+                this.noMorePendingCaches();
+            }
+        });
+    }
+    beginRead() {
+        this.count++;
+        // There's a new pending cache, so if there's a `noMorePendingCaches` timeout running,
+        // we should cancel it.
+        if (this.pendingTimeoutCleanup) {
+            this.pendingTimeoutCleanup();
+            this.pendingTimeoutCleanup = null;
+        }
+        if (this.subscribedSignals !== null) {
+            for (const subscriber of this.subscribedSignals){
+                subscriber.beginRead();
+            }
+        }
+    }
+    endRead() {
+        if (this.count === 0) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('CacheSignal got more endRead() calls than beginRead() calls'), "__NEXT_ERROR_CODE", {
+                value: "E678",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        // If this is the last read we need to wait a task before we can claim the cache is settled.
+        // The cache read will likely ping a Server Component which can read from the cache again and this
+        // will play out in a microtask so we need to only resolve pending listeners if we're still at 0
+        // after at least one task.
+        // We only want one task scheduled at a time so when we hit count 1 we don't decrement the counter immediately.
+        // If intervening reads happen before the scheduled task runs they will never observe count 1 preventing reentrency
+        this.count--;
+        if (this.count === 0) {
+            this.noMorePendingCaches();
+        }
+        if (this.subscribedSignals !== null) {
+            for (const subscriber of this.subscribedSignals){
+                subscriber.endRead();
+            }
+        }
+    }
+    hasPendingReads() {
+        return this.count > 0;
+    }
+    trackRead(promise) {
+        this.beginRead();
+        // `promise.finally()` still rejects, so don't use it here to avoid unhandled rejections
+        const onFinally = this.endRead.bind(this);
+        promise.then(onFinally, onFinally);
+        return promise;
+    }
+    subscribeToReads(subscriber) {
+        if (subscriber === this) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('A CacheSignal cannot subscribe to itself'), "__NEXT_ERROR_CODE", {
+                value: "E679",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (this.subscribedSignals === null) {
+            this.subscribedSignals = new Set();
+        }
+        this.subscribedSignals.add(subscriber);
+        // we'll notify the subscriber of each endRead() on this signal,
+        // so we need to give it a corresponding beginRead() for each read we have in flight now.
+        for(let i = 0; i < this.count; i++){
+            subscriber.beginRead();
+        }
+        return this.unsubscribeFromReads.bind(this, subscriber);
+    }
+    unsubscribeFromReads(subscriber) {
+        if (!this.subscribedSignals) {
+            return;
+        }
+        this.subscribedSignals.delete(subscriber);
+    // we don't need to set the set back to `null` if it's empty --
+    // if other signals are subscribing to this one, it'll likely get more subscriptions later,
+    // so we'd have to allocate a fresh set again when that happens.
+    }
+}
+function scheduleImmediateAndTimeoutWithCleanup(cb) {
+    // If we decide to clean up the timeout, we want to remove
+    // either the immediate or the timeout, whichever is still pending.
+    let clearPending;
+    const immediate = setImmediate(()=>{
+        const timeout = setTimeout(cb, 0);
+        clearPending = clearTimeout.bind(null, timeout);
+    });
+    clearPending = clearImmediate.bind(null, immediate);
+    return ()=>clearPending();
+}
+
+//# sourceMappingURL=cache-signal.js.map