@codelionapps/unharness 0.0.0-stage → 0.1.0

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/router/utils/sorted-routes.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getSortedRouteObjects: null,
+    getSortedRoutes: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getSortedRouteObjects: function() {
+        return getSortedRouteObjects;
+    },
+    getSortedRoutes: function() {
+        return getSortedRoutes;
+    }
+});
+class UrlNode {
+    insert(urlPath) {
+        this._insert(urlPath.split('/').filter(Boolean), [], false);
+    }
+    smoosh() {
+        return this._smoosh();
+    }
+    _smoosh(prefix = '/') {
+        const childrenPaths = [
+            ...this.children.keys()
+        ].sort();
+        if (this.slugName !== null) {
+            childrenPaths.splice(childrenPaths.indexOf('[]'), 1);
+        }
+        if (this.restSlugName !== null) {
+            childrenPaths.splice(childrenPaths.indexOf('[...]'), 1);
+        }
+        if (this.optionalRestSlugName !== null) {
+            childrenPaths.splice(childrenPaths.indexOf('[[...]]'), 1);
+        }
+        const routes = childrenPaths.map((c)=>this.children.get(c)._smoosh(`${prefix}${c}/`)).reduce((prev, curr)=>[
+                ...prev,
+                ...curr
+            ], []);
+        if (this.slugName !== null) {
+            routes.push(...this.children.get('[]')._smoosh(`${prefix}[${this.slugName}]/`));
+        }
+        if (!this.placeholder) {
+            const r = prefix === '/' ? '/' : prefix.slice(0, -1);
+            if (this.optionalRestSlugName != null) {
+                throw new Error(`You cannot define a route with the same specificity as a optional catch-all route ("${r}" and "${r}[[...${this.optionalRestSlugName}]]").`);
+            }
+            routes.unshift(r);
+        }
+        if (this.restSlugName !== null) {
+            routes.push(...this.children.get('[...]')._smoosh(`${prefix}[...${this.restSlugName}]/`));
+        }
+        if (this.optionalRestSlugName !== null) {
+            routes.push(...this.children.get('[[...]]')._smoosh(`${prefix}[[...${this.optionalRestSlugName}]]/`));
+        }
+        return routes;
+    }
+    _insert(urlPaths, slugNames, isCatchAll) {
+        if (urlPaths.length === 0) {
+            this.placeholder = false;
+            return;
+        }
+        if (isCatchAll) {
+            throw new Error(`Catch-all must be the last part of the URL.`);
+        }
+        // The next segment in the urlPaths list
+        let nextSegment = urlPaths[0];
+        // Check if the segment matches `[something]`
+        if (nextSegment.startsWith('[') && nextSegment.endsWith(']')) {
+            // Strip `[` and `]`, leaving only `something`
+            let segmentName = nextSegment.slice(1, -1);
+            let isOptional = false;
+            if (segmentName.startsWith('[') && segmentName.endsWith(']')) {
+                // Strip optional `[` and `]`, leaving only `something`
+                segmentName = segmentName.slice(1, -1);
+                isOptional = true;
+            }
+            if (segmentName.startsWith('…')) {
+                throw new Error(`Detected a three-dot character ('…') at ('${segmentName}'). Did you mean ('...')?`);
+            }
+            if (segmentName.startsWith('...')) {
+                // Strip `...`, leaving only `something`
+                segmentName = segmentName.substring(3);
+                isCatchAll = true;
+            }
+            if (segmentName.startsWith('[') || segmentName.endsWith(']')) {
+                throw new Error(`Segment names may not start or end with extra brackets ('${segmentName}').`);
+            }
+            if (segmentName.startsWith('.')) {
+                throw new Error(`Segment names may not start with erroneous periods ('${segmentName}').`);
+            }
+            function handleSlug(previousSlug, nextSlug) {
+                if (previousSlug !== null) {
+                    // If the specific segment already has a slug but the slug is not `something`
+                    // This prevents collisions like:
+                    // pages/[post]/index.js
+                    // pages/[id]/index.js
+                    // Because currently multiple dynamic params on the same segment level are not supported
+                    if (previousSlug !== nextSlug) {
+                        // TODO: This error seems to be confusing for users, needs an error link, the description can be based on above comment.
+                        throw new Error(`You cannot use different slug names for the same dynamic path ('${previousSlug}' !== '${nextSlug}').`);
+                    }
+                }
+                slugNames.forEach((slug)=>{
+                    if (slug === nextSlug) {
+                        throw new Error(`You cannot have the same slug name "${nextSlug}" repeat within a single dynamic path`);
+                    }
+                    if (slug.replace(/\W/g, '') === nextSegment.replace(/\W/g, '')) {
+                        throw new Error(`You cannot have the slug names "${slug}" and "${nextSlug}" differ only by non-word symbols within a single dynamic path`);
+                    }
+                });
+                slugNames.push(nextSlug);
+            }
+            if (isCatchAll) {
+                if (isOptional) {
+                    if (this.restSlugName != null) {
+                        throw new Error(`You cannot use both an required and optional catch-all route at the same level ("[...${this.restSlugName}]" and "${urlPaths[0]}" ).`);
+                    }
+                    handleSlug(this.optionalRestSlugName, segmentName);
+                    // slugName is kept as it can only be one particular slugName
+                    this.optionalRestSlugName = segmentName;
+                    // nextSegment is overwritten to [[...]] so that it can later be sorted specifically
+                    nextSegment = '[[...]]';
+                } else {
+                    if (this.optionalRestSlugName != null) {
+                        throw new Error(`You cannot use both an optional and required catch-all route at the same level ("[[...${this.optionalRestSlugName}]]" and "${urlPaths[0]}").`);
+                    }
+                    handleSlug(this.restSlugName, segmentName);
+                    // slugName is kept as it can only be one particular slugName
+                    this.restSlugName = segmentName;
+                    // nextSegment is overwritten to [...] so that it can later be sorted specifically
+                    nextSegment = '[...]';
+                }
+            } else {
+                if (isOptional) {
+                    throw new Error(`Optional route parameters are not yet supported ("${urlPaths[0]}").`);
+                }
+                handleSlug(this.slugName, segmentName);
+                // slugName is kept as it can only be one particular slugName
+                this.slugName = segmentName;
+                // nextSegment is overwritten to [] so that it can later be sorted specifically
+                nextSegment = '[]';
+            }
+        }
+        // If this UrlNode doesn't have the nextSegment yet we create a new child UrlNode
+        if (!this.children.has(nextSegment)) {
+            this.children.set(nextSegment, new UrlNode());
+        }
+        this.children.get(nextSegment)._insert(urlPaths.slice(1), slugNames, isCatchAll);
+    }
+    constructor(){
+        this.placeholder = true;
+        this.children = new Map();
+        this.slugName = null;
+        this.restSlugName = null;
+        this.optionalRestSlugName = null;
+    }
+}
+function getSortedRoutes(normalizedPages) {
+    // First the UrlNode is created, and every UrlNode can have only 1 dynamic segment
+    // Eg you can't have pages/[post]/abc.js and pages/[hello]/something-else.js
+    // Only 1 dynamic segment per nesting level
+    // So in the case that is test/e2e/dynamic-routing it'll be this:
+    // pages/[post]/comments.js
+    // pages/blog/[post]/comment/[id].js
+    // Both are fine because `pages/[post]` and `pages/blog` are on the same level
+    // So in this case `UrlNode` created here has `this.slugName === 'post'`
+    // And since your PR passed through `slugName` as an array basically it'd including it in too many possibilities
+    // Instead what has to be passed through is the upwards path's dynamic names
+    const root = new UrlNode();
+    // Here the `root` gets injected multiple paths, and insert will break them up into sublevels
+    normalizedPages.forEach((pagePath)=>root.insert(pagePath));
+    // Smoosh will then sort those sublevels up to the point where you get the correct route definition priority
+    return root.smoosh();
+}
+function getSortedRouteObjects(objects, getter) {
+    // We're assuming here that all the pathnames are unique, that way we can
+    // sort the list and use the index as the key.
+    const indexes = {};
+    const pathnames = [];
+    for(let i = 0; i < objects.length; i++){
+        const pathname = getter(objects[i]);
+        indexes[pathname] = i;
+        pathnames[i] = pathname;
+    }
+    // Sort the pathnames.
+    const sorted = getSortedRoutes(pathnames);
+    // Map the sorted pathnames back to the original objects using the new sorted
+    // index.
+    return sorted.map((pathname)=>objects[indexes[pathname]]);
+}
+
+//# sourceMappingURL=sorted-routes.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/router-context.shared-runtime.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RouterContext", {
+    enumerable: true,
+    get: function() {
+        return RouterContext;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const RouterContext = _react.default.createContext(null);
+if (process.env.NODE_ENV !== 'production') {
+    RouterContext.displayName = 'RouterContext';
+}
+
+//# sourceMappingURL=router-context.shared-runtime.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/rsc-transport.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createSkippedSegmentData: null,
+    readFulfilledValue: null,
+    segmentToTransportSegment: null,
+    transportNodeToFlightRouterState: null,
+    transportSegmentToSegment: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createSkippedSegmentData: function() {
+        return createSkippedSegmentData;
+    },
+    readFulfilledValue: function() {
+        return readFulfilledValue;
+    },
+    segmentToTransportSegment: function() {
+        return segmentToTransportSegment;
+    },
+    transportNodeToFlightRouterState: function() {
+        return transportNodeToFlightRouterState;
+    },
+    transportSegmentToSegment: function() {
+        return transportSegmentToSegment;
+    }
+});
+const _segment = require("./segment");
+function createSkippedSegmentData() {
+    return {
+        r: null,
+        p: true,
+        v: null
+    };
+}
+function readFulfilledValue(valueFromServer, unresolvedValue, rejectedValue = unresolvedValue) {
+    const thenable = valueFromServer;
+    // Force Flight to unwrap a received-but-not-yet-settled row.
+    thenable.then(noop, noop);
+    switch(thenable.status){
+        case 'fulfilled':
+            return thenable.value;
+        case 'rejected':
+            return rejectedValue;
+        // No status yet: the row is still pending, or absent from this decode.
+        case undefined:
+        default:
+            return unresolvedValue;
+    }
+}
+const noop = ()=>{};
+function segmentToTransportSegment(segment) {
+    if (typeof segment === 'string') {
+        return segment;
+    }
+    return {
+        n: segment[0],
+        t: segment[2],
+        k: segment[1],
+        s: segment[3]
+    };
+}
+function transportSegmentToSegment(transportSegment) {
+    if (typeof transportSegment === 'string') {
+        return transportSegment;
+    }
+    return [
+        transportSegment.n,
+        // `k` may be null when the client is expected to parse the param value
+        // from the URL (per-segment prefetch responses). Callers that need the
+        // real value resolve it from the rendered pathname instead of using this
+        // function (see resolveTransportSegment in decode-server-response); the
+        // remaining callers are value-insensitive (segment request keys, which
+        // never include param values) or only see concrete keys.
+        transportSegment.k ?? '',
+        transportSegment.t,
+        transportSegment.s
+    ];
+}
+function transportNodeToFlightRouterState(node, renderedSearch) {
+    const parallelRoutes = {};
+    const children = node.c;
+    if (children !== undefined) {
+        for (const [parallelRouteKey, childNode] of children){
+            parallelRoutes[parallelRouteKey] = transportNodeToFlightRouterState(childNode, renderedSearch);
+        }
+    }
+    const flightRouterState = [
+        transportSegmentToSegment(node.s),
+        parallelRoutes
+    ];
+    if (node.h !== undefined) {
+        flightRouterState[4] = node.h;
+    }
+    if (flightRouterState[0] === _segment.PAGE_SEGMENT_KEY) {
+        flightRouterState[5] = renderedSearch;
+    }
+    return flightRouterState;
+}
+
+//# sourceMappingURL=rsc-transport.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/segment-cache/segment-value-encoding.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    HEAD_REQUEST_KEY: null,
+    ROOT_SEGMENT_REQUEST_KEY: null,
+    appendSegmentRequestKeyPart: null,
+    convertSegmentPathToStaticExportFilename: null,
+    createSegmentRequestKeyPart: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    HEAD_REQUEST_KEY: function() {
+        return HEAD_REQUEST_KEY;
+    },
+    ROOT_SEGMENT_REQUEST_KEY: function() {
+        return ROOT_SEGMENT_REQUEST_KEY;
+    },
+    appendSegmentRequestKeyPart: function() {
+        return appendSegmentRequestKeyPart;
+    },
+    convertSegmentPathToStaticExportFilename: function() {
+        return convertSegmentPathToStaticExportFilename;
+    },
+    createSegmentRequestKeyPart: function() {
+        return createSegmentRequestKeyPart;
+    }
+});
+const ROOT_SEGMENT_REQUEST_KEY = '';
+const HEAD_REQUEST_KEY = '/_head';
+function createSegmentRequestKeyPart(segment) {
+    if (typeof segment === 'string') {
+        const safeName = // TODO: FlightRouterState encodes Not Found routes as "/_not-found".
+        // But params typically don't include the leading slash. We should use
+        // a different encoding to avoid this special case.
+        segment === '/_not-found' ? '_not-found' : encodeToFilesystemAndURLSafeString(segment);
+        // Since this is not a dynamic segment, it's fully encoded. It does not
+        // need to be "hydrated" with a param value.
+        return safeName;
+    }
+    const name = segment[0];
+    const paramType = segment[2];
+    const safeName = encodeToFilesystemAndURLSafeString(name);
+    const encodedName = '$' + paramType + '$' + safeName;
+    return encodedName;
+}
+function appendSegmentRequestKeyPart(parentRequestKey, parallelRouteKey, childRequestKeyPart) {
+    // Aside from being filesystem safe, segment keys are also designed so that
+    // each segment and parallel route creates its own subdirectory. Roughly in
+    // the same shape as the source app directory. This is mostly just for easier
+    // debugging (you can open up the build folder and navigate the output); if
+    // we wanted to do we could just use a flat structure.
+    // Omit the parallel route key for children, since this is the most
+    // common case. Saves some bytes (and it's what the app directory does).
+    const slotKey = parallelRouteKey === 'children' ? childRequestKeyPart : `@${encodeToFilesystemAndURLSafeString(parallelRouteKey)}/${childRequestKeyPart}`;
+    return parentRequestKey + '/' + slotKey;
+}
+// Define a regex pattern to match the most common characters found in a route
+// param. It excludes anything that might not be cross-platform filesystem
+// compatible, like |. It does not need to be precise because the fallback is to
+// just base64url-encode the whole parameter, which is fine; we just don't do it
+// by default for compactness, and for easier debugging.
+const simpleParamValueRegex = /^[a-zA-Z0-9\-_@]+$/;
+function encodeToFilesystemAndURLSafeString(value) {
+    if (simpleParamValueRegex.test(value)) {
+        return value;
+    }
+    // If there are any unsafe characters, base64url-encode the entire value.
+    // We also add a ! prefix so it doesn't collide with the simple case.
+    const base64url = btoa(value).replace(/\+/g, '-') // Replace '+' with '-'
+    .replace(/\//g, '_') // Replace '/' with '_'
+    .replace(/=+$/, '') // Remove trailing '='
+    ;
+    return '!' + base64url;
+}
+function convertSegmentPathToStaticExportFilename(segmentPath) {
+    return `__next${segmentPath.replace(/\//g, '.')}.txt`;
+}
+
+//# sourceMappingURL=segment-value-encoding.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/segment-cache/vary-params-decoding.js

@@ -0,0 +1,87 @@
+/**
+ * Vary Params Decoding
+ *
+ * This module is shared between server and client.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    SEARCH_PARAMS_VARY_ID: null,
+    createVaryParams: null,
+    decodeVaryParams: null,
+    readVaryParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    SEARCH_PARAMS_VARY_ID: function() {
+        return SEARCH_PARAMS_VARY_ID;
+    },
+    createVaryParams: function() {
+        return createVaryParams;
+    },
+    decodeVaryParams: function() {
+        return decodeVaryParams;
+    },
+    readVaryParams: function() {
+        return readVaryParams;
+    }
+});
+const _rsctransport = require("../rsc-transport");
+const SEARCH_PARAMS_VARY_ID = 0;
+/**
+ * Synchronously drains a vary params `AsyncIterable`, adding each yielded name
+ * to `target`.
+ *
+ * By the time this runs (on the client, or in collectSegmentData), the Flight
+ * stream has been fully buffered, so every yielded value is already
+ * materialized and can be read without awaiting: each iterator result is a
+ * Flight chunk whose settled state `readFulfilledValue` reads off the
+ * thenable's status.
+ *
+ * We add "every param yielded up to the point the stream suspends": a
+ * normally-closed iterable drains fully, while one left hanging (a sync-I/O
+ * abort, or a `close()` whose row hasn't flushed yet) drains to the prefix
+ * already in the stream. Both are correct — a segment's param accesses are all
+ * flushed as they happen during its render, so the prefix is exactly the set
+ * the response depends on. We therefore never need the terminating `done` row
+ * to be present; it's only stream hygiene.
+ */ function drainVaryParams(iterable, target) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    while(true){
+        const step = (0, _rsctransport.readFulfilledValue)(iterator.next(), undefined);
+        if (step === undefined || step.done) {
+            // Either the stream suspended here — everything yielded before this
+            // point has already been added — or the iterable finished cleanly.
+            return;
+        }
+        target.add(step.value);
+    }
+}
+function decodeVaryParams(iterable, rootIterable) {
+    if (iterable === null || iterable === undefined || rootIterable === null || rootIterable === undefined) {
+        return null;
+    }
+    const total = new Set();
+    drainVaryParams(iterable, total);
+    drainVaryParams(rootIterable, total);
+    return createVaryParams(total);
+}
+function createVaryParams(total) {
+    // TODO: Don't need to use a native promise. Just inline a thenable that
+    // immediately calls its listener.
+    const settled = Promise.resolve(total);
+    settled.status = 'fulfilled';
+    settled.value = total;
+    return settled;
+}
+function readVaryParams(varyParams) {
+    return (0, _rsctransport.readFulfilledValue)(varyParams, null);
+}
+
+//# sourceMappingURL=vary-params-decoding.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/segment.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    DEFAULT_SEGMENT_KEY: null,
+    NOT_FOUND_SEGMENT_KEY: null,
+    PAGE_SEGMENT_KEY: null,
+    computeSelectedLayoutSegment: null,
+    getSegmentValue: null,
+    getSelectedLayoutSegmentPath: null,
+    isGroupSegment: null,
+    isParallelRouteSegment: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DEFAULT_SEGMENT_KEY: function() {
+        return DEFAULT_SEGMENT_KEY;
+    },
+    NOT_FOUND_SEGMENT_KEY: function() {
+        return NOT_FOUND_SEGMENT_KEY;
+    },
+    PAGE_SEGMENT_KEY: function() {
+        return PAGE_SEGMENT_KEY;
+    },
+    computeSelectedLayoutSegment: function() {
+        return computeSelectedLayoutSegment;
+    },
+    getSegmentValue: function() {
+        return getSegmentValue;
+    },
+    getSelectedLayoutSegmentPath: function() {
+        return getSelectedLayoutSegmentPath;
+    },
+    isGroupSegment: function() {
+        return isGroupSegment;
+    },
+    isParallelRouteSegment: function() {
+        return isParallelRouteSegment;
+    }
+});
+function getSegmentValue(segment) {
+    return Array.isArray(segment) ? segment[1] : segment;
+}
+function isGroupSegment(segment) {
+    // Use array[0] for performant purpose
+    return segment[0] === '(' && segment.endsWith(')');
+}
+function isParallelRouteSegment(segment) {
+    return segment.startsWith('@') && segment !== '@children';
+}
+function computeSelectedLayoutSegment(segments, parallelRouteKey) {
+    if (!segments || segments.length === 0) {
+        return null;
+    }
+    // For 'children', use first segment; for other parallel routes, use last segment
+    const rawSegment = parallelRouteKey === 'children' ? segments[0] : segments[segments.length - 1];
+    // If the default slot is showing, return null since it's not technically "selected" (it's a fallback)
+    // Returning an internal value like `__DEFAULT__` would be confusing
+    return rawSegment === DEFAULT_SEGMENT_KEY ? null : rawSegment;
+}
+function getSelectedLayoutSegmentPath(tree, parallelRouteKey, first = true, segmentPath = []) {
+    let node;
+    if (first) {
+        // Use the provided parallel route key on the first parallel route
+        node = tree[1][parallelRouteKey];
+    } else {
+        // After first parallel route prefer children, if there's no children pick the first parallel route.
+        const parallelRoutes = tree[1];
+        node = parallelRoutes.children ?? Object.values(parallelRoutes)[0];
+    }
+    if (!node) return segmentPath;
+    const segment = node[0];
+    let segmentValue = getSegmentValue(segment);
+    if (!segmentValue || segmentValue === PAGE_SEGMENT_KEY) {
+        return segmentPath;
+    }
+    segmentPath.push(segmentValue);
+    return getSelectedLayoutSegmentPath(node, parallelRouteKey, false, segmentPath);
+}
+const PAGE_SEGMENT_KEY = '__PAGE__';
+const DEFAULT_SEGMENT_KEY = '__DEFAULT__';
+const NOT_FOUND_SEGMENT_KEY = '/_not-found';
+
+//# sourceMappingURL=segment.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/server-inserted-html.shared-runtime.js

@@ -0,0 +1,35 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ServerInsertedHTMLContext: null,
+    useServerInsertedHTML: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ServerInsertedHTMLContext: function() {
+        return ServerInsertedHTMLContext;
+    },
+    useServerInsertedHTML: function() {
+        return useServerInsertedHTML;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const ServerInsertedHTMLContext = /*#__PURE__*/ _react.default.createContext(null);
+function useServerInsertedHTML(callback) {
+    const addInsertedServerHTMLCallback = (0, _react.useContext)(ServerInsertedHTMLContext);
+    // Should have no effects on client where there's no flush effects provider
+    if (addInsertedServerHTMLCallback) {
+        addInsertedServerHTMLCallback(callback);
+    }
+}
+
+//# sourceMappingURL=server-inserted-html.shared-runtime.js.map