shieldcortex 4.2.2 → 4.2.4

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/app-render/work-unit-async-storage.external.js

@@ -1,252 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    getCacheSignal: null,
-    getDraftModeProviderForCacheScope: null,
-    getHmrRefreshHash: null,
-    getPrerenderResumeDataCache: null,
-    getRenderResumeDataCache: null,
-    getRuntimeStagePromise: null,
-    getServerComponentsHmrCache: null,
-    isHmrRefresh: null,
-    throwForMissingRequestStore: null,
-    throwInvariantForMissingStore: null,
-    workUnitAsyncStorage: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getCacheSignal: function() {
-        return getCacheSignal;
-    },
-    getDraftModeProviderForCacheScope: function() {
-        return getDraftModeProviderForCacheScope;
-    },
-    getHmrRefreshHash: function() {
-        return getHmrRefreshHash;
-    },
-    getPrerenderResumeDataCache: function() {
-        return getPrerenderResumeDataCache;
-    },
-    getRenderResumeDataCache: function() {
-        return getRenderResumeDataCache;
-    },
-    getRuntimeStagePromise: function() {
-        return getRuntimeStagePromise;
-    },
-    getServerComponentsHmrCache: function() {
-        return getServerComponentsHmrCache;
-    },
-    isHmrRefresh: function() {
-        return isHmrRefresh;
-    },
-    throwForMissingRequestStore: function() {
-        return throwForMissingRequestStore;
-    },
-    throwInvariantForMissingStore: function() {
-        return throwInvariantForMissingStore;
-    },
-    workUnitAsyncStorage: function() {
-        return _workunitasyncstorageinstance.workUnitAsyncStorageInstance;
-    }
-});
-const _workunitasyncstorageinstance = require("./work-unit-async-storage-instance");
-const _approuterheaders = require("../../client/components/app-router-headers");
-const _invarianterror = require("../../shared/lib/invariant-error");
-function throwForMissingRequestStore(callingExpression) {
-    throw Object.defineProperty(new Error(`\`${callingExpression}\` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
-        value: "E251",
-        enumerable: false,
-        configurable: true
-    });
-}
-function throwInvariantForMissingStore() {
-    throw Object.defineProperty(new _invarianterror.InvariantError('Expected workUnitAsyncStorage to have a store.'), "__NEXT_ERROR_CODE", {
-        value: "E696",
-        enumerable: false,
-        configurable: true
-    });
-}
-function getPrerenderResumeDataCache(workUnitStore) {
-    switch(workUnitStore.type){
-        case 'prerender':
-        case 'prerender-runtime':
-        case 'prerender-ppr':
-            return workUnitStore.prerenderResumeDataCache;
-        case 'prerender-client':
-            // TODO eliminate fetch caching in client scope and stop exposing this data
-            // cache during SSR.
-            return workUnitStore.prerenderResumeDataCache;
-        case 'request':
-            {
-                // In dev, we might fill caches even during a dynamic request.
-                if (workUnitStore.prerenderResumeDataCache) {
-                    return workUnitStore.prerenderResumeDataCache;
-                }
-            // fallthrough
-            }
-        case 'prerender-legacy':
-        case 'cache':
-        case 'private-cache':
-        case 'unstable-cache':
-            return null;
-        default:
-            return workUnitStore;
-    }
-}
-function getRenderResumeDataCache(workUnitStore) {
-    switch(workUnitStore.type){
-        case 'request':
-        case 'prerender':
-        case 'prerender-runtime':
-        case 'prerender-client':
-            if (workUnitStore.renderResumeDataCache) {
-                // If we are in a prerender, we might have a render resume data cache
-                // that is used to read from prefilled caches.
-                return workUnitStore.renderResumeDataCache;
-            }
-        // fallthrough
-        case 'prerender-ppr':
-            // Otherwise we return the mutable resume data cache here as an immutable
-            // version of the cache as it can also be used for reading.
-            return workUnitStore.prerenderResumeDataCache ?? null;
-        case 'cache':
-        case 'private-cache':
-        case 'unstable-cache':
-        case 'prerender-legacy':
-            return null;
-        default:
-            return workUnitStore;
-    }
-}
-function getHmrRefreshHash(workStore, workUnitStore) {
-    if (workStore.dev) {
-        switch(workUnitStore.type){
-            case 'cache':
-            case 'private-cache':
-            case 'prerender':
-            case 'prerender-runtime':
-                return workUnitStore.hmrRefreshHash;
-            case 'request':
-                var _workUnitStore_cookies_get;
-                return (_workUnitStore_cookies_get = workUnitStore.cookies.get(_approuterheaders.NEXT_HMR_REFRESH_HASH_COOKIE)) == null ? void 0 : _workUnitStore_cookies_get.value;
-            case 'prerender-client':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-            case 'unstable-cache':
-                break;
-            default:
-                workUnitStore;
-        }
-    }
-    return undefined;
-}
-function isHmrRefresh(workStore, workUnitStore) {
-    if (workStore.dev) {
-        switch(workUnitStore.type){
-            case 'cache':
-            case 'private-cache':
-            case 'request':
-                return workUnitStore.isHmrRefresh ?? false;
-            case 'prerender':
-            case 'prerender-client':
-            case 'prerender-runtime':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-            case 'unstable-cache':
-                break;
-            default:
-                workUnitStore;
-        }
-    }
-    return false;
-}
-function getServerComponentsHmrCache(workStore, workUnitStore) {
-    if (workStore.dev) {
-        switch(workUnitStore.type){
-            case 'cache':
-            case 'private-cache':
-            case 'request':
-                return workUnitStore.serverComponentsHmrCache;
-            case 'prerender':
-            case 'prerender-client':
-            case 'prerender-runtime':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-            case 'unstable-cache':
-                break;
-            default:
-                workUnitStore;
-        }
-    }
-    return undefined;
-}
-function getDraftModeProviderForCacheScope(workStore, workUnitStore) {
-    if (workStore.isDraftMode) {
-        switch(workUnitStore.type){
-            case 'cache':
-            case 'private-cache':
-            case 'unstable-cache':
-            case 'prerender-runtime':
-            case 'request':
-                return workUnitStore.draftMode;
-            case 'prerender':
-            case 'prerender-client':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-                break;
-            default:
-                workUnitStore;
-        }
-    }
-    return undefined;
-}
-function getCacheSignal(workUnitStore) {
-    switch(workUnitStore.type){
-        case 'prerender':
-        case 'prerender-client':
-        case 'prerender-runtime':
-            return workUnitStore.cacheSignal;
-        case 'request':
-            {
-                // In dev, we might fill caches even during a dynamic request.
-                if (workUnitStore.cacheSignal) {
-                    return workUnitStore.cacheSignal;
-                }
-            // fallthrough
-            }
-        case 'prerender-ppr':
-        case 'prerender-legacy':
-        case 'cache':
-        case 'private-cache':
-        case 'unstable-cache':
-            return null;
-        default:
-            return workUnitStore;
-    }
-}
-function getRuntimeStagePromise(workUnitStore) {
-    switch(workUnitStore.type){
-        case 'prerender-runtime':
-        case 'private-cache':
-            return workUnitStore.runtimeStagePromise;
-        case 'prerender':
-        case 'prerender-client':
-        case 'prerender-ppr':
-        case 'prerender-legacy':
-        case 'request':
-        case 'cache':
-        case 'unstable-cache':
-            return null;
-        default:
-            return workUnitStore;
-    }
-}
-
-//# sourceMappingURL=work-unit-async-storage.external.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/async-storage/draft-mode-provider.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "DraftModeProvider", {
-    enumerable: true,
-    get: function() {
-        return DraftModeProvider;
-    }
-});
-const _apiutils = require("../api-utils");
-class DraftModeProvider {
-    constructor(previewProps, req, cookies, mutableCookies){
-        var _cookies_get;
-        // The logic for draftMode() is very similar to tryGetPreviewData()
-        // but Draft Mode does not have any data associated with it.
-        const isOnDemandRevalidate = previewProps && (0, _apiutils.checkIsOnDemandRevalidate)(req, previewProps).isOnDemandRevalidate;
-        const cookieValue = (_cookies_get = cookies.get(_apiutils.COOKIE_NAME_PRERENDER_BYPASS)) == null ? void 0 : _cookies_get.value;
-        this._isEnabled = Boolean(!isOnDemandRevalidate && cookieValue && previewProps && (cookieValue === previewProps.previewModeId || // In dev mode, the cookie can be actual hash value preview id but the preview props can still be `development-id`.
-        process.env.NODE_ENV !== 'production' && previewProps.previewModeId === 'development-id'));
-        this._previewModeId = previewProps == null ? void 0 : previewProps.previewModeId;
-        this._mutableCookies = mutableCookies;
-    }
-    get isEnabled() {
-        return this._isEnabled;
-    }
-    enable() {
-        if (!this._previewModeId) {
-            throw Object.defineProperty(new Error('Invariant: previewProps missing previewModeId this should never happen'), "__NEXT_ERROR_CODE", {
-                value: "E93",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        this._mutableCookies.set({
-            name: _apiutils.COOKIE_NAME_PRERENDER_BYPASS,
-            value: this._previewModeId,
-            httpOnly: true,
-            sameSite: process.env.NODE_ENV !== 'development' ? 'none' : 'lax',
-            secure: process.env.NODE_ENV !== 'development',
-            path: '/'
-        });
-        this._isEnabled = true;
-    }
-    disable() {
-        // To delete a cookie, set `expires` to a date in the past:
-        // https://tools.ietf.org/html/rfc6265#section-4.1.1
-        // `Max-Age: 0` is not valid, thus ignored, and the cookie is persisted.
-        this._mutableCookies.set({
-            name: _apiutils.COOKIE_NAME_PRERENDER_BYPASS,
-            value: '',
-            httpOnly: true,
-            sameSite: process.env.NODE_ENV !== 'development' ? 'none' : 'lax',
-            secure: process.env.NODE_ENV !== 'development',
-            path: '/',
-            expires: new Date(0)
-        });
-        this._isEnabled = false;
-    }
-}
-
-//# sourceMappingURL=draft-mode-provider.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/async-storage/request-store.js

@@ -1,144 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    createRequestStoreForAPI: null,
-    createRequestStoreForRender: null,
-    synchronizeMutableCookies: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    createRequestStoreForAPI: function() {
-        return createRequestStoreForAPI;
-    },
-    createRequestStoreForRender: function() {
-        return createRequestStoreForRender;
-    },
-    synchronizeMutableCookies: function() {
-        return synchronizeMutableCookies;
-    }
-});
-const _approuterheaders = require("../../client/components/app-router-headers");
-const _headers = require("../web/spec-extension/adapters/headers");
-const _requestcookies = require("../web/spec-extension/adapters/request-cookies");
-const _cookies = require("../web/spec-extension/cookies");
-const _draftmodeprovider = require("./draft-mode-provider");
-const _utils = require("../web/utils");
-function getHeaders(headers) {
-    const cleaned = _headers.HeadersAdapter.from(headers);
-    for (const header of _approuterheaders.FLIGHT_HEADERS){
-        cleaned.delete(header);
-    }
-    return _headers.HeadersAdapter.seal(cleaned);
-}
-function getMutableCookies(headers, onUpdateCookies) {
-    const cookies = new _cookies.RequestCookies(_headers.HeadersAdapter.from(headers));
-    return _requestcookies.MutableRequestCookiesAdapter.wrap(cookies, onUpdateCookies);
-}
-/**
- * If middleware set cookies in this request (indicated by `x-middleware-set-cookie`),
- * then merge those into the existing cookie object, so that when `cookies()` is accessed
- * it's able to read the newly set cookies.
- */ function mergeMiddlewareCookies(req, existingCookies) {
-    if ('x-middleware-set-cookie' in req.headers && typeof req.headers['x-middleware-set-cookie'] === 'string') {
-        const setCookieValue = req.headers['x-middleware-set-cookie'];
-        const responseHeaders = new Headers();
-        for (const cookie of (0, _utils.splitCookiesString)(setCookieValue)){
-            responseHeaders.append('set-cookie', cookie);
-        }
-        const responseCookies = new _cookies.ResponseCookies(responseHeaders);
-        // Transfer cookies from ResponseCookies to RequestCookies
-        for (const cookie of responseCookies.getAll()){
-            existingCookies.set(cookie);
-        }
-    }
-}
-function createRequestStoreForRender(req, res, url, rootParams, implicitTags, onUpdateCookies, previewProps, isHmrRefresh, serverComponentsHmrCache, renderResumeDataCache, devFallbackParams) {
-    return createRequestStoreImpl(// Pages start in render phase by default
-    'render', req, res, url, rootParams, implicitTags, onUpdateCookies, renderResumeDataCache, previewProps, isHmrRefresh, serverComponentsHmrCache, devFallbackParams);
-}
-function createRequestStoreForAPI(req, url, implicitTags, onUpdateCookies, previewProps) {
-    return createRequestStoreImpl(// API routes start in action phase by default
-    'action', req, undefined, url, {}, implicitTags, onUpdateCookies, null, previewProps, false, undefined, null);
-}
-function createRequestStoreImpl(phase, req, res, url, rootParams, implicitTags, onUpdateCookies, renderResumeDataCache, previewProps, isHmrRefresh, serverComponentsHmrCache, devFallbackParams) {
-    function defaultOnUpdateCookies(cookies) {
-        if (res) {
-            res.setHeader('Set-Cookie', cookies);
-        }
-    }
-    const cache = {};
-    return {
-        type: 'request',
-        phase,
-        implicitTags,
-        // Rather than just using the whole `url` here, we pull the parts we want
-        // to ensure we don't use parts of the URL that we shouldn't. This also
-        // lets us avoid requiring an empty string for `search` in the type.
-        url: {
-            pathname: url.pathname,
-            search: url.search ?? ''
-        },
-        rootParams,
-        get headers () {
-            if (!cache.headers) {
-                // Seal the headers object that'll freeze out any methods that could
-                // mutate the underlying data.
-                cache.headers = getHeaders(req.headers);
-            }
-            return cache.headers;
-        },
-        get cookies () {
-            if (!cache.cookies) {
-                // if middleware is setting cookie(s), then include those in
-                // the initial cached cookies so they can be read in render
-                const requestCookies = new _cookies.RequestCookies(_headers.HeadersAdapter.from(req.headers));
-                mergeMiddlewareCookies(req, requestCookies);
-                // Seal the cookies object that'll freeze out any methods that could
-                // mutate the underlying data.
-                cache.cookies = _requestcookies.RequestCookiesAdapter.seal(requestCookies);
-            }
-            return cache.cookies;
-        },
-        set cookies (value){
-            cache.cookies = value;
-        },
-        get mutableCookies () {
-            if (!cache.mutableCookies) {
-                const mutableCookies = getMutableCookies(req.headers, onUpdateCookies || (res ? defaultOnUpdateCookies : undefined));
-                mergeMiddlewareCookies(req, mutableCookies);
-                cache.mutableCookies = mutableCookies;
-            }
-            return cache.mutableCookies;
-        },
-        get userspaceMutableCookies () {
-            if (!cache.userspaceMutableCookies) {
-                const userspaceMutableCookies = (0, _requestcookies.createCookiesWithMutableAccessCheck)(this);
-                cache.userspaceMutableCookies = userspaceMutableCookies;
-            }
-            return cache.userspaceMutableCookies;
-        },
-        get draftMode () {
-            if (!cache.draftMode) {
-                cache.draftMode = new _draftmodeprovider.DraftModeProvider(previewProps, req, this.cookies, this.mutableCookies);
-            }
-            return cache.draftMode;
-        },
-        renderResumeDataCache: renderResumeDataCache ?? null,
-        isHmrRefresh,
-        serverComponentsHmrCache: serverComponentsHmrCache || globalThis.__serverComponentsHmrCache,
-        devFallbackParams
-    };
-}
-function synchronizeMutableCookies(store) {
-    // TODO: does this need to update headers as well?
-    store.cookies = _requestcookies.RequestCookiesAdapter.seal((0, _requestcookies.responseCookiesToRequestCookies)(store.mutableCookies));
-}
-
-//# sourceMappingURL=request-store.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/async-storage/with-store.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-//# sourceMappingURL=with-store.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/async-storage/work-store.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "createWorkStore", {
-    enumerable: true,
-    get: function() {
-        return createWorkStore;
-    }
-});
-const _aftercontext = require("../after/after-context");
-const _apppaths = require("../../shared/lib/router/utils/app-paths");
-const _lazyresult = require("../lib/lazy-result");
-const _handlers = require("../use-cache/handlers");
-const _asynclocalstorage = require("../app-render/async-local-storage");
-function createWorkStore({ page, renderOpts, isPrefetchRequest, buildId, previouslyRevalidatedTags, nonce }) {
-    /**
-   * Rules of Static & Dynamic HTML:
-   *
-   *    1.) We must generate static HTML unless the caller explicitly opts
-   *        in to dynamic HTML support.
-   *
-   *    2.) If dynamic HTML support is requested, we must honor that request
-   *        or throw an error. It is the sole responsibility of the caller to
-   *        ensure they aren't e.g. requesting dynamic HTML for a static page.
-   *
-   *    3.) If the request is in draft mode, we must generate dynamic HTML.
-   *
-   *    4.) If the request is a server action, we must generate dynamic HTML.
-   *
-   * These rules help ensure that other existing features like request caching,
-   * coalescing, and ISR continue working as intended.
-   */ const isStaticGeneration = !renderOpts.shouldWaitOnAllReady && !renderOpts.supportsDynamicResponse && !renderOpts.isDraftMode && !renderOpts.isPossibleServerAction;
-    const isDevelopment = renderOpts.dev ?? false;
-    const shouldTrackFetchMetrics = isDevelopment || // The only times we want to track fetch metrics outside of development is
-    // when we are performing a static generation and we either are in debug
-    // mode, or tracking fetch metrics was specifically opted into.
-    isStaticGeneration && (!!process.env.NEXT_DEBUG_BUILD || process.env.NEXT_SSG_FETCH_METRICS === '1');
-    const store = {
-        isStaticGeneration,
-        page,
-        route: (0, _apppaths.normalizeAppPath)(page),
-        incrementalCache: // we fallback to a global incremental cache for edge-runtime locally
-        // so that it can access the fs cache without mocks
-        renderOpts.incrementalCache || globalThis.__incrementalCache,
-        cacheLifeProfiles: renderOpts.cacheLifeProfiles,
-        isBuildTimePrerendering: renderOpts.nextExport,
-        hasReadableErrorStacks: renderOpts.hasReadableErrorStacks,
-        fetchCache: renderOpts.fetchCache,
-        isOnDemandRevalidate: renderOpts.isOnDemandRevalidate,
-        isDraftMode: renderOpts.isDraftMode,
-        isPrefetchRequest,
-        buildId,
-        reactLoadableManifest: (renderOpts == null ? void 0 : renderOpts.reactLoadableManifest) || {},
-        assetPrefix: (renderOpts == null ? void 0 : renderOpts.assetPrefix) || '',
-        nonce,
-        afterContext: createAfterContext(renderOpts),
-        cacheComponentsEnabled: renderOpts.cacheComponents,
-        dev: isDevelopment,
-        previouslyRevalidatedTags,
-        refreshTagsByCacheKind: createRefreshTagsByCacheKind(),
-        runInCleanSnapshot: (0, _asynclocalstorage.createSnapshot)(),
-        shouldTrackFetchMetrics,
-        reactServerErrorsByDigest: new Map()
-    };
-    // TODO: remove this when we resolve accessing the store outside the execution context
-    renderOpts.store = store;
-    return store;
-}
-function createAfterContext(renderOpts) {
-    const { waitUntil, onClose, onAfterTaskError } = renderOpts;
-    return new _aftercontext.AfterContext({
-        waitUntil,
-        onClose,
-        onTaskError: onAfterTaskError
-    });
-}
-/**
- * Creates a map with lazy results that refresh tags for the respective cache
- * kind when they're awaited for the first time.
- */ function createRefreshTagsByCacheKind() {
-    const refreshTagsByCacheKind = new Map();
-    const cacheHandlers = (0, _handlers.getCacheHandlerEntries)();
-    if (cacheHandlers) {
-        for (const [kind, cacheHandler] of cacheHandlers){
-            if ('refreshTags' in cacheHandler) {
-                refreshTagsByCacheKind.set(kind, (0, _lazyresult.createLazyResult)(async ()=>cacheHandler.refreshTags()));
-            }
-        }
-    }
-    return refreshTagsByCacheKind;
-}
-
-//# sourceMappingURL=work-store.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/base-http/helpers.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    isNodeNextRequest: null,
-    isNodeNextResponse: null,
-    isWebNextRequest: null,
-    isWebNextResponse: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    isNodeNextRequest: function() {
-        return isNodeNextRequest;
-    },
-    isNodeNextResponse: function() {
-        return isNodeNextResponse;
-    },
-    isWebNextRequest: function() {
-        return isWebNextRequest;
-    },
-    isWebNextResponse: function() {
-        return isWebNextResponse;
-    }
-});
-const isWebNextRequest = (req)=>process.env.NEXT_RUNTIME === 'edge';
-const isWebNextResponse = (res)=>process.env.NEXT_RUNTIME === 'edge';
-const isNodeNextRequest = (req)=>process.env.NEXT_RUNTIME !== 'edge';
-const isNodeNextResponse = (res)=>process.env.NEXT_RUNTIME !== 'edge';
-
-//# sourceMappingURL=helpers.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/base-http/index.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    BaseNextRequest: null,
-    BaseNextResponse: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    BaseNextRequest: function() {
-        return BaseNextRequest;
-    },
-    BaseNextResponse: function() {
-        return BaseNextResponse;
-    }
-});
-const _redirectstatuscode = require("../../client/components/redirect-status-code");
-const _getcookieparser = require("../api-utils/get-cookie-parser");
-class BaseNextRequest {
-    constructor(method, url, body){
-        this.method = method;
-        this.url = url;
-        this.body = body;
-    }
-    // Utils implemented using the abstract methods above
-    get cookies() {
-        if (this._cookies) return this._cookies;
-        return this._cookies = (0, _getcookieparser.getCookieParser)(this.headers)();
-    }
-}
-class BaseNextResponse {
-    constructor(destination){
-        this.destination = destination;
-    }
-    // Utils implemented using the abstract methods above
-    redirect(destination, statusCode) {
-        this.setHeader('Location', destination);
-        this.statusCode = statusCode;
-        // Since IE11 doesn't support the 308 header add backwards
-        // compatibility using refresh header
-        if (statusCode === _redirectstatuscode.RedirectStatusCode.PermanentRedirect) {
-            this.setHeader('Refresh', `0;url=${destination}`);
-        }
-        return this;
-    }
-}
-
-//# sourceMappingURL=index.js.map