@taskmark/ui 0.2.1 → 0.2.2

package/dist/standalone/node_modules/next/dist/server/app-render/instant-validation/stream-utils.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    createNodeStreamFromChunks: null,
-    createNodeStreamWithLateRelease: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    createNodeStreamFromChunks: function() {
-        return createNodeStreamFromChunks;
-    },
-    createNodeStreamWithLateRelease: function() {
-        return createNodeStreamWithLateRelease;
-    }
-});
-const _invarianterror = require("../../../shared/lib/invariant-error");
-function createNodeStreamWithLateRelease(partialChunks, allChunks, releaseSignal) {
-    if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('createNodeStreamWithLateRelease cannot be used in the edge runtime'), "__NEXT_ERROR_CODE", {
-            value: "E993",
-            enumerable: false,
-            configurable: true
-        });
-    } else {
-        const { Readable } = require('node:stream');
-        let nextIndex = 0;
-        const readable = new Readable({
-            read () {
-                while(nextIndex < partialChunks.length){
-                    this.push(partialChunks[nextIndex]);
-                    nextIndex++;
-                }
-            }
-        });
-        releaseSignal.addEventListener('abort', ()=>{
-            // Flush any remaining chunks from the original set
-            while(nextIndex < partialChunks.length){
-                readable.push(partialChunks[nextIndex]);
-                nextIndex++;
-            }
-            // Flush all chunks since we're now aborted and can't schedule
-            // any new work but these chunks might unblock debugInfo
-            while(nextIndex < allChunks.length){
-                readable.push(allChunks[nextIndex]);
-                nextIndex++;
-            }
-            setImmediate(()=>{
-                readable.push(null);
-            });
-        }, {
-            once: true
-        });
-        return readable;
-    }
-}
-function createNodeStreamFromChunks(chunks, signal) {
-    if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('createNodeStreamFromChunks cannot be used in the edge runtime'), "__NEXT_ERROR_CODE", {
-            value: "E945",
-            enumerable: false,
-            configurable: true
-        });
-    } else {
-        const { Readable } = require('node:stream');
-        // If there's a signal, delay closing until it fires
-        if (signal) {
-            signal.addEventListener('abort', ()=>{
-                readable.push(null);
-            }, {
-                once: true
-            });
-        }
-        let nextIndex = 0;
-        const readable = new Readable({
-            read () {
-                while(nextIndex < chunks.length){
-                    this.push(chunks[nextIndex]);
-                    nextIndex++;
-                }
-                if (!signal) {
-                    this.push(null);
-                }
-            }
-        });
-        return readable;
-    }
-}
-
-//# sourceMappingURL=stream-utils.js.map

package/dist/standalone/node_modules/next/dist/server/app-render/interop-default.js

@@ -1,17 +0,0 @@
-/**
- * Interop between "export default" and "module.exports".
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "interopDefault", {
-    enumerable: true,
-    get: function() {
-        return interopDefault;
-    }
-});
-function interopDefault(mod) {
-    return mod.default || mod;
-}
-
-//# sourceMappingURL=interop-default.js.map

package/dist/standalone/node_modules/next/dist/server/app-render/make-get-server-inserted-html.js

@@ -1,92 +0,0 @@
-/* eslint-disable @next/internal/no-ambiguous-jsx -- whole module is used in React Client */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "makeGetServerInsertedHTML", {
-    enumerable: true,
-    get: function() {
-        return makeGetServerInsertedHTML;
-    }
-});
-const _jsxruntime = require("react/jsx-runtime");
-const _react = /*#__PURE__*/ _interop_require_default(require("react"));
-const _httpaccessfallback = require("../../client/components/http-access-fallback/http-access-fallback");
-const _redirect = require("../../client/components/redirect");
-const _redirecterror = require("../../client/components/redirect-error");
-const _server = require("react-dom/server");
-const _nodewebstreamshelper = require("../stream-utils/node-web-streams-helper");
-const _redirectstatuscode = require("../../client/components/redirect-status-code");
-const _addpathprefix = require("../../shared/lib/router/utils/add-path-prefix");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function makeGetServerInsertedHTML({ polyfills, renderServerInsertedHTML, serverCapturedErrors, tracingMetadata, basePath }) {
-    let flushedErrorMetaTagsUntilIndex = 0;
-    // These only need to be rendered once, they'll be set to empty arrays once flushed.
-    let polyfillTags = polyfills.map((polyfill)=>{
-        return /*#__PURE__*/ (0, _jsxruntime.jsx)("script", {
-            ...polyfill
-        }, polyfill.src);
-    });
-    let traceMetaTags = (tracingMetadata || []).map(({ key, value }, index)=>/*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
-            name: key,
-            content: value
-        }, `next-trace-data-${index}`));
-    return async function getServerInsertedHTML() {
-        // Loop through all the errors that have been captured but not yet
-        // flushed.
-        const errorMetaTags = [];
-        while(flushedErrorMetaTagsUntilIndex < serverCapturedErrors.length){
-            const error = serverCapturedErrors[flushedErrorMetaTagsUntilIndex];
-            flushedErrorMetaTagsUntilIndex++;
-            if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(error)) {
-                errorMetaTags.push(/*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
-                    name: "robots",
-                    content: "noindex"
-                }, error.digest), process.env.NODE_ENV === 'development' ? /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
-                    name: "next-error",
-                    content: "not-found"
-                }, "next-error") : null);
-            } else if ((0, _redirecterror.isRedirectError)(error)) {
-                const redirectUrl = (0, _addpathprefix.addPathPrefix)((0, _redirect.getURLFromRedirectError)(error), basePath);
-                const statusCode = (0, _redirect.getRedirectStatusCodeFromError)(error);
-                const isPermanent = statusCode === _redirectstatuscode.RedirectStatusCode.PermanentRedirect ? true : false;
-                if (redirectUrl) {
-                    errorMetaTags.push(/*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
-                        id: "__next-page-redirect",
-                        httpEquiv: "refresh",
-                        content: `${isPermanent ? 0 : 1};url=${redirectUrl}`
-                    }, error.digest));
-                }
-            }
-        }
-        const serverInsertedHTML = renderServerInsertedHTML();
-        // Skip React rendering if we know the content is empty.
-        if (polyfillTags.length === 0 && traceMetaTags.length === 0 && errorMetaTags.length === 0 && Array.isArray(serverInsertedHTML) && serverInsertedHTML.length === 0) {
-            return '';
-        }
-        const stream = await (0, _server.renderToReadableStream)(/*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
-            children: [
-                polyfillTags,
-                serverInsertedHTML,
-                traceMetaTags,
-                errorMetaTags
-            ]
-        }), {
-            // Larger chunk because this isn't sent over the network.
-            // Let's set it to 1MB.
-            progressiveChunkSize: 1024 * 1024
-        });
-        // The polyfills and trace metadata have been flushed, so they don't need to be rendered again
-        polyfillTags = [];
-        traceMetaTags = [];
-        // There's no need to wait for the stream to be ready
-        // e.g. calling `await stream.allReady` because `streamToString` will
-        // wait and decode the stream progressively with better parallelism.
-        return (0, _nodewebstreamshelper.streamToString)(stream);
-    };
-}
-
-//# sourceMappingURL=make-get-server-inserted-html.js.map

package/dist/standalone/node_modules/next/dist/server/app-render/manifests-singleton.js

@@ -1,264 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    getClientReferenceManifest: null,
-    getServerActionsManifest: null,
-    getServerModuleMap: null,
-    selectWorkerForForwarding: null,
-    setManifestsSingleton: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getClientReferenceManifest: function() {
-        return getClientReferenceManifest;
-    },
-    getServerActionsManifest: function() {
-        return getServerActionsManifest;
-    },
-    getServerModuleMap: function() {
-        return getServerModuleMap;
-    },
-    selectWorkerForForwarding: function() {
-        return selectWorkerForForwarding;
-    },
-    setManifestsSingleton: function() {
-        return setManifestsSingleton;
-    }
-});
-const _invarianterror = require("../../shared/lib/invariant-error");
-const _apppaths = require("../../shared/lib/router/utils/app-paths");
-const _pathhasprefix = require("../../shared/lib/router/utils/path-has-prefix");
-const _removepathprefix = require("../../shared/lib/router/utils/remove-path-prefix");
-const _workasyncstorageexternal = require("./work-async-storage.external");
-// This is a global singleton that is, among other things, also used to
-// encode/decode bound args of server function closures. This can't be using a
-// AsyncLocalStorage as it might happen at the module level.
-const MANIFESTS_SINGLETON = Symbol.for('next.server.manifests');
-const globalThisWithManifests = globalThis;
-function createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute) {
-    const createMappingProxy = (prop)=>{
-        return new Proxy({}, {
-            get (_, id) {
-                const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-                if (workStore) {
-                    const currentManifest = clientReferenceManifestsPerRoute.get(workStore.route);
-                    if (currentManifest == null ? void 0 : currentManifest[prop][id]) {
-                        return currentManifest[prop][id];
-                    }
-                    // In development, we also check all other manifests to see if the
-                    // module exists there. This is to support a scenario where React's
-                    // I/O tracking (dev-only) creates a connection from one page to
-                    // another through an emitted async I/O node that references client
-                    // components from the other page, e.g. in owner props.
-                    // TODO: Maybe we need to add a `debugBundlerConfig` option to React
-                    // to avoid this workaround. The current workaround has the
-                    // disadvantage that one might accidentally or intentionally share
-                    // client references across pages (e.g. by storing them in a global
-                    // variable), which would then only be caught in production.
-                    if (process.env.NODE_ENV !== 'production') {
-                        for (const [route, manifest] of clientReferenceManifestsPerRoute){
-                            if (route === workStore.route) {
-                                continue;
-                            }
-                            const entry = manifest[prop][id];
-                            if (entry !== undefined) {
-                                return entry;
-                            }
-                        }
-                    }
-                } else {
-                    // If there's no work store defined, we can assume that a client
-                    // reference manifest is needed during module evaluation, e.g. to
-                    // create a server function using a higher-order function. This
-                    // might also use client components which need to be serialized by
-                    // Flight, and therefore client references need to be resolvable. In
-                    // that case we search all page manifests to find the module.
-                    for (const manifest of clientReferenceManifestsPerRoute.values()){
-                        const entry = manifest[prop][id];
-                        if (entry !== undefined) {
-                            return entry;
-                        }
-                    }
-                }
-                return undefined;
-            }
-        });
-    };
-    const mappingProxies = new Map();
-    return new Proxy({}, {
-        get (_, prop) {
-            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-            switch(prop){
-                case 'moduleLoading':
-                case 'entryCSSFiles':
-                case 'entryJSFiles':
-                    {
-                        if (!workStore) {
-                            throw Object.defineProperty(new _invarianterror.InvariantError(`Cannot access "${prop}" without a work store.`), "__NEXT_ERROR_CODE", {
-                                value: "E952",
-                                enumerable: false,
-                                configurable: true
-                            });
-                        }
-                        const currentManifest = clientReferenceManifestsPerRoute.get(workStore.route);
-                        if (!currentManifest) {
-                            throw Object.defineProperty(new _invarianterror.InvariantError(`The client reference manifest for route "${workStore.route}" does not exist.`), "__NEXT_ERROR_CODE", {
-                                value: "E951",
-                                enumerable: false,
-                                configurable: true
-                            });
-                        }
-                        return currentManifest[prop];
-                    }
-                case 'clientModules':
-                case 'rscModuleMapping':
-                case 'edgeRscModuleMapping':
-                case 'ssrModuleMapping':
-                case 'edgeSSRModuleMapping':
-                    {
-                        let proxy = mappingProxies.get(prop);
-                        if (!proxy) {
-                            proxy = createMappingProxy(prop);
-                            mappingProxies.set(prop, proxy);
-                        }
-                        return proxy;
-                    }
-                default:
-                    {
-                        throw Object.defineProperty(new _invarianterror.InvariantError(`This is a proxied client reference manifest. The property "${String(prop)}" is not handled.`), "__NEXT_ERROR_CODE", {
-                            value: "E953",
-                            enumerable: false,
-                            configurable: true
-                        });
-                    }
-            }
-        }
-    });
-}
-/**
- * This function creates a Flight-acceptable server module map proxy from our
- * Server Reference Manifest similar to our client module map. This is because
- * our manifest contains a lot of internal Next.js data that are relevant to the
- * runtime, workers, etc. that React doesn't need to know.
- */ function createServerModuleMap() {
-    return new Proxy({}, {
-        get: (_, id)=>{
-            var _getServerActionsManifest__id, _getServerActionsManifest_;
-            const workers = (_getServerActionsManifest_ = getServerActionsManifest()[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node']) == null ? void 0 : (_getServerActionsManifest__id = _getServerActionsManifest_[id]) == null ? void 0 : _getServerActionsManifest__id.workers;
-            if (!workers) {
-                return undefined;
-            }
-            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-            let workerEntry;
-            if (workStore) {
-                workerEntry = workers[normalizeWorkerPageName(workStore.page)];
-            } else {
-                // If there's no work store defined, we can assume that a server
-                // module map is needed during module evaluation, e.g. to create a
-                // server action using a higher-order function. Therefore it should be
-                // safe to return any entry from the manifest that matches the action
-                // ID. They all refer to the same module ID, which must also exist in
-                // the current page bundle. TODO: This is currently not guaranteed in
-                // Turbopack, and needs to be fixed.
-                workerEntry = Object.values(workers).at(0);
-            }
-            if (!workerEntry) {
-                return undefined;
-            }
-            const { moduleId, async } = workerEntry;
-            return {
-                id: moduleId,
-                name: id,
-                chunks: [],
-                async
-            };
-        }
-    });
-}
-/**
- * The flight entry loader keys actions by bundlePath. bundlePath corresponds
- * with the relative path (including 'app') to the page entrypoint.
- */ function normalizeWorkerPageName(pageName) {
-    if ((0, _pathhasprefix.pathHasPrefix)(pageName, 'app')) {
-        return pageName;
-    }
-    return 'app' + pageName;
-}
-/**
- * Converts a bundlePath (relative path to the entrypoint) to a routable page
- * name.
- */ function denormalizeWorkerPageName(bundlePath) {
-    return (0, _apppaths.normalizeAppPath)((0, _removepathprefix.removePathPrefix)(bundlePath, 'app'));
-}
-function selectWorkerForForwarding(actionId, pageName) {
-    var _serverActionsManifest__actionId;
-    const serverActionsManifest = getServerActionsManifest();
-    const workers = (_serverActionsManifest__actionId = serverActionsManifest[process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node'][actionId]) == null ? void 0 : _serverActionsManifest__actionId.workers;
-    // There are no workers to handle this action, nothing to forward to.
-    if (!workers) {
-        return;
-    }
-    // If there is an entry for the current page, we don't need to forward.
-    if (workers[normalizeWorkerPageName(pageName)]) {
-        return;
-    }
-    // Otherwise, grab the first worker that has a handler for this action id.
-    return denormalizeWorkerPageName(Object.keys(workers)[0]);
-}
-function setManifestsSingleton({ page, clientReferenceManifest, serverActionsManifest: rawServerActionsManifest }) {
-    const existingSingleton = globalThisWithManifests[MANIFESTS_SINGLETON];
-    const serverActionsManifest = {
-        encryptionKey: rawServerActionsManifest.encryptionKey,
-        // Use null-prototypes for the action objects to prevent prototype pollution
-        // from affecting action ID lookups.
-        node: Object.assign(Object.create(null), rawServerActionsManifest.node),
-        edge: Object.assign(Object.create(null), rawServerActionsManifest.edge)
-    };
-    if (existingSingleton) {
-        existingSingleton.clientReferenceManifestsPerRoute.set((0, _apppaths.normalizeAppPath)(page), clientReferenceManifest);
-        existingSingleton.serverActionsManifest = serverActionsManifest;
-    } else {
-        const clientReferenceManifestsPerRoute = new Map([
-            [
-                (0, _apppaths.normalizeAppPath)(page),
-                clientReferenceManifest
-            ]
-        ]);
-        const proxiedClientReferenceManifest = createProxiedClientReferenceManifest(clientReferenceManifestsPerRoute);
-        globalThisWithManifests[MANIFESTS_SINGLETON] = {
-            clientReferenceManifestsPerRoute,
-            proxiedClientReferenceManifest,
-            serverActionsManifest,
-            serverModuleMap: createServerModuleMap()
-        };
-    }
-}
-function getManifestsSingleton() {
-    const manifestSingleton = globalThisWithManifests[MANIFESTS_SINGLETON];
-    if (!manifestSingleton) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('The manifests singleton was not initialized.'), "__NEXT_ERROR_CODE", {
-            value: "E950",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    return manifestSingleton;
-}
-function getClientReferenceManifest() {
-    return getManifestsSingleton().proxiedClientReferenceManifest;
-}
-function getServerActionsManifest() {
-    return getManifestsSingleton().serverActionsManifest;
-}
-function getServerModuleMap() {
-    return getManifestsSingleton().serverModuleMap;
-}
-
-//# sourceMappingURL=manifests-singleton.js.map

package/dist/standalone/node_modules/next/dist/server/app-render/metadata-insertion/create-server-inserted-metadata.js

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

package/dist/standalone/node_modules/next/dist/server/app-render/module-loading/track-dynamic-import.js

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

package/dist/standalone/node_modules/next/dist/server/app-render/module-loading/track-module-loading.external.js

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

package/dist/standalone/node_modules/next/dist/server/app-render/module-loading/track-module-loading.instance.js

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