kindflow 0.1.0

package/web/standalone/apps/web/node_modules/next/dist/server/app-render/entry-base.js

@@ -0,0 +1,256 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ClientPageRoot: null,
+    ClientSegmentRoot: null,
+    Fragment: null,
+    HTTPAccessFallbackBoundary: null,
+    InstantValidation: null,
+    LayoutRouter: null,
+    LoadingBoundaryProvider: null,
+    Postpone: null,
+    RenderFromTemplateContext: null,
+    RootLayoutBoundary: null,
+    SegmentViewNode: null,
+    SegmentViewStateNode: null,
+    actionAsyncStorage: null,
+    captureOwnerStack: null,
+    collectPrefetchHints: null,
+    collectSegmentData: null,
+    createElement: null,
+    createMetadataComponents: null,
+    createPrerenderParamsForClientSegment: null,
+    createPrerenderSearchParamsForClientPage: null,
+    createServerParamsForServerSegment: null,
+    createServerSearchParamsForServerPage: null,
+    createTemporaryReferenceSet: null,
+    decodeAction: null,
+    decodeFormState: null,
+    decodeReply: null,
+    patchFetch: null,
+    preconnect: null,
+    preloadFont: null,
+    preloadStyle: null,
+    prerender: null,
+    renderToReadableStream: null,
+    serverHooks: null,
+    taintObjectReference: null,
+    workAsyncStorage: null,
+    workUnitAsyncStorage: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ClientPageRoot: function() {
+        return _clientpage.ClientPageRoot;
+    },
+    ClientSegmentRoot: function() {
+        return _clientsegment.ClientSegmentRoot;
+    },
+    Fragment: function() {
+        return _react.Fragment;
+    },
+    HTTPAccessFallbackBoundary: function() {
+        return _errorboundary.HTTPAccessFallbackBoundary;
+    },
+    InstantValidation: function() {
+        return InstantValidation;
+    },
+    LayoutRouter: function() {
+        return _layoutrouter.default;
+    },
+    LoadingBoundaryProvider: function() {
+        return _layoutrouter.LoadingBoundaryProvider;
+    },
+    Postpone: function() {
+        return _postpone.Postpone;
+    },
+    RenderFromTemplateContext: function() {
+        return _renderfromtemplatecontext.default;
+    },
+    RootLayoutBoundary: function() {
+        return _boundarycomponents.RootLayoutBoundary;
+    },
+    SegmentViewNode: function() {
+        return SegmentViewNode;
+    },
+    SegmentViewStateNode: function() {
+        return SegmentViewStateNode;
+    },
+    actionAsyncStorage: function() {
+        return _actionasyncstorageexternal.actionAsyncStorage;
+    },
+    captureOwnerStack: function() {
+        return _react.captureOwnerStack;
+    },
+    collectPrefetchHints: function() {
+        return _collectsegmentdata.collectPrefetchHints;
+    },
+    collectSegmentData: function() {
+        return _collectsegmentdata.collectSegmentData;
+    },
+    createElement: function() {
+        return _react.createElement;
+    },
+    createMetadataComponents: function() {
+        return _metadata.createMetadataComponents;
+    },
+    createPrerenderParamsForClientSegment: function() {
+        return _params.createPrerenderParamsForClientSegment;
+    },
+    createPrerenderSearchParamsForClientPage: function() {
+        return _searchparams.createPrerenderSearchParamsForClientPage;
+    },
+    createServerParamsForServerSegment: function() {
+        return _params.createServerParamsForServerSegment;
+    },
+    createServerSearchParamsForServerPage: function() {
+        return _searchparams.createServerSearchParamsForServerPage;
+    },
+    createTemporaryReferenceSet: function() {
+        return _server.createTemporaryReferenceSet;
+    },
+    decodeAction: function() {
+        return _server.decodeAction;
+    },
+    decodeFormState: function() {
+        return _server.decodeFormState;
+    },
+    decodeReply: function() {
+        return _server.decodeReply;
+    },
+    patchFetch: function() {
+        return patchFetch;
+    },
+    preconnect: function() {
+        return _preloads.preconnect;
+    },
+    preloadFont: function() {
+        return _preloads.preloadFont;
+    },
+    preloadStyle: function() {
+        return _preloads.preloadStyle;
+    },
+    prerender: function() {
+        return _static.prerender;
+    },
+    renderToReadableStream: function() {
+        return _server.renderToReadableStream;
+    },
+    serverHooks: function() {
+        return _hooksservercontext;
+    },
+    taintObjectReference: function() {
+        return _taint.taintObjectReference;
+    },
+    workAsyncStorage: function() {
+        return _workasyncstorageexternal.workAsyncStorage;
+    },
+    workUnitAsyncStorage: function() {
+        return _workunitasyncstorageexternal.workUnitAsyncStorage;
+    }
+});
+const _server = require("react-server-dom-webpack/server");
+const _static = require("react-server-dom-webpack/static");
+const _react = require("react");
+const _layoutrouter = /*#__PURE__*/ _interop_require_wildcard(require("../../client/components/layout-router"));
+const _renderfromtemplatecontext = /*#__PURE__*/ _interop_require_default(require("../../client/components/render-from-template-context"));
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
+const _actionasyncstorageexternal = require("../app-render/action-async-storage.external");
+const _clientpage = require("../../client/components/client-page");
+const _clientsegment = require("../../client/components/client-segment");
+const _searchparams = require("../request/search-params");
+const _params = require("../request/params");
+const _hooksservercontext = /*#__PURE__*/ _interop_require_wildcard(require("../../client/components/hooks-server-context"));
+const _errorboundary = require("../../client/components/http-access-fallback/error-boundary");
+const _metadata = require("../../lib/metadata/metadata");
+const _boundarycomponents = require("../../lib/framework/boundary-components");
+const _preloads = require("./rsc/preloads");
+const _postpone = require("./rsc/postpone");
+const _taint = require("./rsc/taint");
+const _collectsegmentdata = require("./collect-segment-data");
+const _patchfetch = require("../lib/patch-fetch");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const InstantValidation = ()=>{
+    if (process.env.NEXT_RUNTIME !== 'edge' && process.env.__NEXT_CACHE_COMPONENTS) {
+        return require('./instant-validation/instant-validation');
+    } else {
+        return undefined;
+    }
+};
+let SegmentViewNode = ()=>null;
+let SegmentViewStateNode = ()=>null;
+if (process.env.NODE_ENV === 'development') {
+    const mod = require('../../next-devtools/userspace/app/segment-explorer-node');
+    SegmentViewNode = mod.SegmentViewNode;
+    SegmentViewStateNode = mod.SegmentViewStateNode;
+}
+// hot-reloader modules are not bundled so we need to inject `__next__clear_chunk_cache__`
+// into globalThis from this file which is bundled.
+if (process.env.TURBOPACK) {
+    globalThis.__next__clear_chunk_cache__ = __turbopack_clear_chunk_cache__;
+} else {
+    // Webpack does not have chunks on the server
+    globalThis.__next__clear_chunk_cache__ = null;
+}
+function patchFetch() {
+    return (0, _patchfetch.patchFetch)({
+        workAsyncStorage: _workasyncstorageexternal.workAsyncStorage,
+        workUnitAsyncStorage: _workunitasyncstorageexternal.workUnitAsyncStorage
+    });
+}
+
+//# sourceMappingURL=entry-base.js.map

package/web/standalone/apps/web/node_modules/next/dist/server/app-render/flight-render-result.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlightRenderResult", {
+    enumerable: true,
+    get: function() {
+        return FlightRenderResult;
+    }
+});
+const _approuterheaders = require("../../client/components/app-router-headers");
+const _renderresult = /*#__PURE__*/ _interop_require_default(require("../render-result"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class FlightRenderResult extends _renderresult.default {
+    constructor(response, metadata = {}, waitUntil){
+        super(response, {
+            contentType: _approuterheaders.RSC_CONTENT_TYPE_HEADER,
+            metadata,
+            waitUntil
+        });
+    }
+}
+
+//# sourceMappingURL=flight-render-result.js.map

package/web/standalone/apps/web/node_modules/next/dist/server/app-render/get-asset-query-string.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getAssetQueryString", {
+    enumerable: true,
+    get: function() {
+        return getAssetQueryString;
+    }
+});
+const isDev = process.env.NODE_ENV === 'development';
+const isTurbopack = !!process.env.TURBOPACK;
+function getAssetQueryString(ctx, addTimestamp) {
+    let qs = '';
+    // In development we add the request timestamp to allow react to
+    // reload assets when a new RSC response is received.
+    // Turbopack handles HMR of assets itself and react doesn't need to reload them
+    // so this approach is not needed for Turbopack.
+    const shouldAddVersion = isDev && !isTurbopack && addTimestamp;
+    if (shouldAddVersion) {
+        qs += `?v=${ctx.requestTimestamp}`;
+    }
+    if (ctx.sharedContext.clientAssetToken) {
+        qs += `${shouldAddVersion ? '&' : '?'}dpl=${ctx.sharedContext.clientAssetToken}`;
+    }
+    return qs;
+}
+
+//# sourceMappingURL=get-asset-query-string.js.map

package/web/standalone/apps/web/node_modules/next/dist/server/app-render/get-css-inlined-link-tags.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getLinkAndScriptTags", {
+    enumerable: true,
+    get: function() {
+        return getLinkAndScriptTags;
+    }
+});
+const _manifestssingleton = require("./manifests-singleton");
+function getLinkAndScriptTags(filePath, injectedCSS, injectedScripts, collectNewImports) {
+    const filePathWithoutExt = filePath.replace(/\.[^.]+$/, '');
+    const cssChunks = new Set();
+    const jsChunks = new Set();
+    const { entryCSSFiles, entryJSFiles } = (0, _manifestssingleton.getClientReferenceManifest)();
+    const cssFiles = entryCSSFiles[filePathWithoutExt];
+    const jsFiles = entryJSFiles == null ? void 0 : entryJSFiles[filePathWithoutExt];
+    if (cssFiles) {
+        for (const css of cssFiles){
+            if (!injectedCSS.has(css.path)) {
+                if (collectNewImports) {
+                    injectedCSS.add(css.path);
+                }
+                cssChunks.add(css);
+            }
+        }
+    }
+    if (jsFiles) {
+        for (const file of jsFiles){
+            if (!injectedScripts.has(file)) {
+                if (collectNewImports) {
+                    injectedScripts.add(file);
+                }
+                jsChunks.add(file);
+            }
+        }
+    }
+    return {
+        styles: [
+            ...cssChunks
+        ],
+        scripts: [
+            ...jsChunks
+        ]
+    };
+}
+
+//# sourceMappingURL=get-css-inlined-link-tags.js.map

package/web/standalone/apps/web/node_modules/next/dist/server/app-render/get-layer-assets.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getLayerAssets", {
+    enumerable: true,
+    get: function() {
+        return getLayerAssets;
+    }
+});
+const _getcssinlinedlinktags = require("./get-css-inlined-link-tags");
+const _getpreloadablefonts = require("./get-preloadable-fonts");
+const _getassetquerystring = require("./get-asset-query-string");
+const _encodeuripath = require("../../shared/lib/encode-uri-path");
+const _rendercssresource = require("./render-css-resource");
+function getLayerAssets({ ctx, layoutOrPagePath, injectedCSS: injectedCSSWithCurrentLayout, injectedJS: injectedJSWithCurrentLayout, injectedFontPreloadTags: injectedFontPreloadTagsWithCurrentLayout, preloadCallbacks }) {
+    const { componentMod: { createElement } } = ctx;
+    const { styles: styleTags, scripts: scriptTags } = layoutOrPagePath ? (0, _getcssinlinedlinktags.getLinkAndScriptTags)(layoutOrPagePath, injectedCSSWithCurrentLayout, injectedJSWithCurrentLayout, true) : {
+        styles: [],
+        scripts: []
+    };
+    const preloadedFontFiles = layoutOrPagePath ? (0, _getpreloadablefonts.getPreloadableFonts)(ctx.renderOpts.nextFontManifest, layoutOrPagePath, injectedFontPreloadTagsWithCurrentLayout) : null;
+    if (preloadedFontFiles) {
+        if (preloadedFontFiles.length) {
+            for(let i = 0; i < preloadedFontFiles.length; i++){
+                const fontFilename = preloadedFontFiles[i];
+                const ext = /\.(woff|woff2|eot|ttf|otf)$/.exec(fontFilename)[1];
+                const type = `font/${ext}`;
+                const href = `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(fontFilename)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`;
+                preloadCallbacks.push(()=>{
+                    ctx.componentMod.preloadFont(href, type, ctx.renderOpts.crossOrigin, ctx.nonce);
+                });
+            }
+        } else {
+            try {
+                let url = new URL(ctx.assetPrefix);
+                preloadCallbacks.push(()=>{
+                    ctx.componentMod.preconnect(url.origin, 'anonymous', ctx.nonce);
+                });
+            } catch (error) {
+                // assetPrefix must not be a fully qualified domain name. We assume
+                // we should preconnect to same origin instead
+                preloadCallbacks.push(()=>{
+                    ctx.componentMod.preconnect('/', 'anonymous', ctx.nonce);
+                });
+            }
+        }
+    }
+    const styles = (0, _rendercssresource.renderCssResource)(styleTags, ctx, preloadCallbacks);
+    const scripts = scriptTags ? scriptTags.map((href, index)=>{
+        const fullSrc = `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(href)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`;
+        return createElement('script', {
+            src: fullSrc,
+            async: true,
+            key: `script-${index}`,
+            nonce: ctx.nonce
+        });
+    }) : [];
+    return styles.length || scripts.length ? [
+        ...styles,
+        ...scripts
+    ] : null;
+}
+
+//# sourceMappingURL=get-layer-assets.js.map

package/web/standalone/apps/web/node_modules/next/dist/server/app-render/get-preloadable-fonts.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPreloadableFonts", {
+    enumerable: true,
+    get: function() {
+        return getPreloadableFonts;
+    }
+});
+function getPreloadableFonts(nextFontManifest, filePath, injectedFontPreloadTags) {
+    if (!nextFontManifest || !filePath) {
+        return null;
+    }
+    const filepathWithoutExtension = filePath.replace(/\.[^.]+$/, '');
+    const fontFiles = new Set();
+    let foundFontUsage = false;
+    const preloadedFontFiles = nextFontManifest.app[filepathWithoutExtension];
+    if (preloadedFontFiles) {
+        foundFontUsage = true;
+        for (const fontFile of preloadedFontFiles){
+            if (!injectedFontPreloadTags.has(fontFile)) {
+                fontFiles.add(fontFile);
+                injectedFontPreloadTags.add(fontFile);
+            }
+        }
+    }
+    if (fontFiles.size) {
+        return [
+            ...fontFiles
+        ].sort();
+    } else if (foundFontUsage && injectedFontPreloadTags.size === 0) {
+        return [];
+    } else {
+        return null;
+    }
+}
+
+//# sourceMappingURL=get-preloadable-fonts.js.map

package/web/standalone/apps/web/node_modules/next/dist/server/app-render/get-script-nonce-from-header.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getScriptNonceFromHeader", {
+    enumerable: true,
+    get: function() {
+        return getScriptNonceFromHeader;
+    }
+});
+const _htmlescape = require("../htmlescape");
+function getScriptNonceFromHeader(cspHeaderValue) {
+    var _directive_split_slice_map_find;
+    const directives = cspHeaderValue// Directives are split by ';'.
+    .split(';').map((directive)=>directive.trim());
+    // First try to find the directive for the 'script-src', otherwise try to
+    // fallback to the 'default-src'.
+    const directive = directives.find((dir)=>dir.startsWith('script-src')) || directives.find((dir)=>dir.startsWith('default-src'));
+    // If no directive could be found, then we're done.
+    if (!directive) {
+        return;
+    }
+    // Extract the nonce from the directive
+    const nonce = (_directive_split_slice_map_find = directive.split(' ')// Remove the 'strict-src'/'default-src' string, this can't be the nonce.
+    .slice(1).map((source)=>source.trim())// Find the first source with the 'nonce-' prefix.
+    .find((source)=>source.startsWith("'nonce-") && source.length > 8 && source.endsWith("'"))) == null ? void 0 : _directive_split_slice_map_find.slice(7, -1);
+    // If we could't find the nonce, then we're done.
+    if (!nonce) {
+        return;
+    }
+    // Don't accept the nonce value if it contains HTML escape characters.
+    // Technically, the spec requires a base64'd value, but this is just an
+    // extra layer.
+    if (_htmlescape.ESCAPE_REGEX.test(nonce)) {
+        throw Object.defineProperty(new Error('Nonce value from Content-Security-Policy contained HTML escape characters.\nLearn more: https://nextjs.org/docs/messages/nonce-contained-invalid-characters'), "__NEXT_ERROR_CODE", {
+            value: "E440",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return nonce;
+}
+
+//# sourceMappingURL=get-script-nonce-from-header.js.map

package/web/standalone/apps/web/node_modules/next/dist/server/app-render/get-short-dynamic-param-type.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "dynamicParamTypes", {
+    enumerable: true,
+    get: function() {
+        return dynamicParamTypes;
+    }
+});
+const dynamicParamTypes = {
+    catchall: 'c',
+    'catchall-intercepted-(..)(..)': 'ci(..)(..)',
+    'catchall-intercepted-(.)': 'ci(.)',
+    'catchall-intercepted-(..)': 'ci(..)',
+    'catchall-intercepted-(...)': 'ci(...)',
+    'optional-catchall': 'oc',
+    dynamic: 'd',
+    'dynamic-intercepted-(..)(..)': 'di(..)(..)',
+    'dynamic-intercepted-(.)': 'di(.)',
+    'dynamic-intercepted-(..)': 'di(..)',
+    'dynamic-intercepted-(...)': 'di(...)'
+};
+
+//# sourceMappingURL=get-short-dynamic-param-type.js.map

package/web/standalone/apps/web/node_modules/next/dist/server/app-render/has-loading-component-in-tree.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "hasLoadingComponentInTree", {
+    enumerable: true,
+    get: function() {
+        return hasLoadingComponentInTree;
+    }
+});
+function hasLoadingComponentInTree(tree) {
+    const [, parallelRoutes, { loading }] = tree;
+    if (loading) {
+        return true;
+    }
+    return Object.values(parallelRoutes).some((parallelRoute)=>hasLoadingComponentInTree(parallelRoute));
+}
+
+//# sourceMappingURL=has-loading-component-in-tree.js.map

package/web/standalone/apps/web/node_modules/next/dist/server/app-render/instant-validation/boundary-constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "INSTANT_VALIDATION_BOUNDARY_NAME", {
+    enumerable: true,
+    get: function() {
+        return INSTANT_VALIDATION_BOUNDARY_NAME;
+    }
+});
+const INSTANT_VALIDATION_BOUNDARY_NAME = '__next_instant_validation_boundary__';
+
+//# sourceMappingURL=boundary-constants.js.map

package/web/standalone/apps/web/node_modules/next/dist/server/app-render/instant-validation/boundary-impl.js

@@ -0,0 +1,103 @@
+/* eslint-disable @next/internal/no-ambiguous-jsx -- React Client */ // Do not put a "use client" directive here. Import this module via the shim in
+// `packages/next/src/client/components/instant-validation/boundary.tsx` instead.
+// 'use client'
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    InstantValidationBoundaryContext: null,
+    PlaceValidationBoundaryBelowThisLevel: null,
+    RenderValidationBoundaryAtThisLevel: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    InstantValidationBoundaryContext: function() {
+        return InstantValidationBoundaryContext;
+    },
+    PlaceValidationBoundaryBelowThisLevel: function() {
+        return PlaceValidationBoundaryBelowThisLevel;
+    },
+    RenderValidationBoundaryAtThisLevel: function() {
+        return RenderValidationBoundaryAtThisLevel;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = require("react");
+const _boundaryconstants = require("./boundary-constants");
+const _invarianterror = require("../../../shared/lib/invariant-error");
+const _workunitasyncstorageexternal = require("../work-unit-async-storage.external");
+if (typeof window !== 'undefined') {
+    throw Object.defineProperty(new _invarianterror.InvariantError('Instant validation boundaries should never appear in browser bundles.'), "__NEXT_ERROR_CODE", {
+        value: "E1117",
+        enumerable: false,
+        configurable: true
+    });
+}
+function getValidationBoundaryTracking() {
+    const store = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (!store) return null;
+    switch(store.type){
+        case 'validation-client':
+            return store.boundaryState;
+        case 'prerender':
+        case 'prerender-client':
+        case 'prerender-ppr':
+        case 'prerender-legacy':
+        case 'prerender-runtime':
+        case 'request':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'generate-static-params':
+            break;
+        default:
+            store;
+    }
+    return null;
+}
+// We use a namespace object to allow us to recover the name of the function
+// at runtime even when production bundling/minification is used.
+const NameSpace = {
+    [_boundaryconstants.INSTANT_VALIDATION_BOUNDARY_NAME]: function({ id, children }) {
+        // Track which boundaries we actually managed to render.
+        const state = getValidationBoundaryTracking();
+        if (state === null) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('Missing boundary tracking state'), "__NEXT_ERROR_CODE", {
+                value: "E1060",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        state.renderedIds.add(id);
+        return children;
+    }
+};
+const InstantValidationBoundaryContext = /*#__PURE__*/ (0, _react.createContext)(null);
+function PlaceValidationBoundaryBelowThisLevel({ id, children }) {
+    return(// OuterLayoutRouter will see this and render a `RenderValidationBoundaryAtThisLevel`.
+    /*#__PURE__*/ (0, _jsxruntime.jsx)(InstantValidationBoundaryContext, {
+        value: id,
+        children: children
+    }));
+}
+function RenderValidationBoundaryAtThisLevel({ id, children }) {
+    // We got a boundaryId from the context. Clear the context so that the children don't render another boundary.
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(InstantValidationBoundary, {
+        id: id,
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(InstantValidationBoundaryContext, {
+            value: null,
+            children: children
+        })
+    });
+}
+const InstantValidationBoundary = // We use slice(0) to trick the bundler into not inlining/minifying the function
+// so it retains the name inferred from the namespace object
+NameSpace[_boundaryconstants.INSTANT_VALIDATION_BOUNDARY_NAME.slice(0)];
+
+//# sourceMappingURL=boundary-impl.js.map