@obsfx/trekker 0.1.7 → 0.1.8

package/webapp-dist/vendor/next/dist/build/templates/helpers.js

@@ -0,0 +1,36 @@
+/**
+ * Hoists a name from a module or promised module.
+ *
+ * @param module the module to hoist the name from
+ * @param name the name to hoist
+ * @returns the value on the module (or promised module)
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "hoist", {
+    enumerable: true,
+    get: function() {
+        return hoist;
+    }
+});
+function hoist(module, name) {
+    // If the name is available in the module, return it.
+    if (name in module) {
+        return module[name];
+    }
+    // If a property called `then` exists, assume it's a promise and
+    // return a promise that resolves to the name.
+    if ('then' in module && typeof module.then === 'function') {
+        return module.then((mod)=>hoist(mod, name));
+    }
+    // If we're trying to hoise the default export, and the module is a function,
+    // return the module itself.
+    if (typeof module === 'function' && name === 'default') {
+        return module;
+    }
+    // Otherwise, return undefined.
+    return undefined;
+}
+
+//# sourceMappingURL=helpers.js.map

package/webapp-dist/vendor/next/dist/build/templates/middleware.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _globals = require("../../server/web/globals");
+const _adapter = require("../../server/web/adapter");
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
+const _isnextroutererror = require("../../client/components/is-next-router-error");
+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 mod = {
+    ..._VAR_USERLAND
+};
+const page = 'VAR_DEFINITION_PAGE';
+const isProxy = page === '/proxy' || page === '/src/proxy';
+const handlerUserland = (isProxy ? mod.proxy : mod.middleware) || mod.default;
+class ProxyMissingExportError extends Error {
+    constructor(message){
+        super(message);
+        // Stack isn't useful here, remove it considering it spams logs during development.
+        this.stack = '';
+    }
+}
+// TODO: This spams logs during development. Find a better way to handle this.
+// Removing this will spam "fn is not a function" logs which is worse.
+if (typeof handlerUserland !== 'function') {
+    throw new ProxyMissingExportError(`The ${isProxy ? 'Proxy' : 'Middleware'} file "${page}" must export a function named \`${isProxy ? 'proxy' : 'middleware'}\` or a default function.`);
+}
+// Proxy will only sent out the FetchEvent to next server,
+// so load instrumentation module here and track the error inside proxy module.
+function errorHandledHandler(fn) {
+    return async (...args)=>{
+        try {
+            return await fn(...args);
+        } catch (err) {
+            // In development, error the navigation API usage in runtime,
+            // since it's not allowed to be used in proxy as it's outside of react component tree.
+            if (process.env.NODE_ENV !== 'production') {
+                if ((0, _isnextroutererror.isNextRouterError)(err)) {
+                    err.message = `Next.js navigation API is not allowed to be used in ${isProxy ? 'Proxy' : 'Middleware'}.`;
+                    throw err;
+                }
+            }
+            const req = args[0];
+            const url = new URL(req.url);
+            const resource = url.pathname + url.search;
+            await (0, _globals.edgeInstrumentationOnRequestError)(err, {
+                path: resource,
+                method: req.method,
+                headers: Object.fromEntries(req.headers.entries())
+            }, {
+                routerKind: 'Pages Router',
+                routePath: '/proxy',
+                routeType: 'proxy',
+                revalidateReason: undefined
+            });
+            throw err;
+        }
+    };
+}
+const handler = (opts)=>{
+    return (0, _adapter.adapter)({
+        ...opts,
+        page,
+        handler: errorHandledHandler(handlerUserland)
+    });
+};
+const _default = handler;
+
+//# sourceMappingURL=middleware.js.map

package/webapp-dist/vendor/next/dist/build/templates/pages-api.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    config: null,
+    default: null,
+    handler: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    config: function() {
+        return config;
+    },
+    // Re-export the handler (should be the default export).
+    default: function() {
+        return _default;
+    },
+    handler: function() {
+        return handler;
+    }
+});
+const _apiutils = require("../../server/api-utils");
+const _routekind = require("../../server/route-kind");
+const _modulecompiled = require("../../server/route-modules/pages-api/module.compiled");
+const _helpers = require("./helpers");
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
+const _tracer = require("../../server/lib/trace/tracer");
+const _constants = require("../../server/lib/trace/constants");
+const _requestmeta = require("../../server/request-meta");
+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 _default = (0, _helpers.hoist)(_VAR_USERLAND, 'default');
+const config = (0, _helpers.hoist)(_VAR_USERLAND, 'config');
+// Create and export the route module that will be consumed.
+const routeModule = new _modulecompiled.PagesAPIRouteModule({
+    definition: {
+        kind: _routekind.RouteKind.PAGES_API,
+        page: 'VAR_DEFINITION_PAGE',
+        pathname: 'VAR_DEFINITION_PATHNAME',
+        // The following aren't used in production.
+        bundlePath: '',
+        filename: ''
+    },
+    userland: _VAR_USERLAND,
+    distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
+    relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || ''
+});
+async function handler(req, res, ctx) {
+    if (routeModule.isDev) {
+        (0, _requestmeta.addRequestMeta)(req, 'devRequestTimingInternalsEnd', process.hrtime.bigint());
+    }
+    let srcPage = 'VAR_DEFINITION_PAGE';
+    // turbopack doesn't normalize `/index` in the page name
+    // so we need to to process dynamic routes properly
+    // TODO: fix turbopack providing differing value from webpack
+    if (process.env.TURBOPACK) {
+        srcPage = srcPage.replace(/\/index$/, '') || '/';
+    }
+    const prepareResult = await routeModule.prepare(req, res, {
+        srcPage
+    });
+    if (!prepareResult) {
+        res.statusCode = 400;
+        res.end('Bad Request');
+        ctx.waitUntil == null ? void 0 : ctx.waitUntil.call(ctx, Promise.resolve());
+        return;
+    }
+    const { query, params, prerenderManifest, routerServerContext } = prepareResult;
+    try {
+        const method = req.method || 'GET';
+        const tracer = (0, _tracer.getTracer)();
+        const activeSpan = tracer.getActiveScopeSpan();
+        const onRequestError = routeModule.instrumentationOnRequestError.bind(routeModule);
+        const invokeRouteModule = async (span)=>routeModule.render(req, res, {
+                query: {
+                    ...query,
+                    ...params
+                },
+                params,
+                allowedRevalidateHeaderKeys: process.env.__NEXT_ALLOWED_REVALIDATE_HEADERS,
+                multiZoneDraftMode: Boolean(process.env.__NEXT_MULTI_ZONE_DRAFT_MODE),
+                trustHostHeader: process.env.__NEXT_TRUST_HOST_HEADER,
+                // TODO: get this from from runtime env so manifest
+                // doesn't need to load
+                previewProps: prerenderManifest.preview,
+                propagateError: false,
+                dev: routeModule.isDev,
+                page: 'VAR_DEFINITION_PAGE',
+                internalRevalidate: routerServerContext == null ? void 0 : routerServerContext.revalidate,
+                onError: (...args)=>onRequestError(req, ...args)
+            }).finally(()=>{
+                if (!span) return;
+                span.setAttributes({
+                    'http.status_code': res.statusCode,
+                    'next.rsc': false
+                });
+                const rootSpanAttributes = tracer.getRootSpanAttributes();
+                // We were unable to get attributes, probably OTEL is not enabled
+                if (!rootSpanAttributes) {
+                    return;
+                }
+                if (rootSpanAttributes.get('next.span_type') !== _constants.BaseServerSpan.handleRequest) {
+                    console.warn(`Unexpected root span type '${rootSpanAttributes.get('next.span_type')}'. Please report this Next.js issue https://github.com/vercel/next.js`);
+                    return;
+                }
+                const route = rootSpanAttributes.get('next.route');
+                if (route) {
+                    const name = `${method} ${route}`;
+                    span.setAttributes({
+                        'next.route': route,
+                        'http.route': route,
+                        'next.span_name': name
+                    });
+                    span.updateName(name);
+                } else {
+                    span.updateName(`${method} ${srcPage}`);
+                }
+            });
+        // TODO: activeSpan code path is for when wrapped by
+        // next-server can be removed when this is no longer used
+        if (activeSpan) {
+            await invokeRouteModule(activeSpan);
+        } else {
+            await tracer.withPropagatedContext(req.headers, ()=>tracer.trace(_constants.BaseServerSpan.handleRequest, {
+                    spanName: `${method} ${srcPage}`,
+                    kind: _tracer.SpanKind.SERVER,
+                    attributes: {
+                        'http.method': method,
+                        'http.target': req.url
+                    }
+                }, invokeRouteModule));
+        }
+    } catch (err) {
+        // we re-throw in dev to show the error overlay
+        if (routeModule.isDev) {
+            throw err;
+        }
+        // this is technically an invariant as error handling
+        // should be done inside of api-resolver onError
+        (0, _apiutils.sendError)(res, 500, 'Internal Server Error');
+    } finally{
+        // We don't allow any waitUntil work in pages API routes currently
+        // so if callback is present return with resolved promise since no
+        // pending work
+        ctx.waitUntil == null ? void 0 : ctx.waitUntil.call(ctx, Promise.resolve());
+    }
+}
+
+//# sourceMappingURL=pages-api.js.map

package/webapp-dist/vendor/next/dist/build/templates/pages-edge-api.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+require("../../server/web/globals");
+const _adapter = require("../../server/web/adapter");
+const _incrementalcache = require("../../server/lib/incremental-cache");
+const _apiutils = require("../../server/api-utils");
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_default(require("VAR_USERLAND"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const page = 'VAR_DEFINITION_PAGE';
+if (typeof _VAR_USERLAND.default !== 'function') {
+    throw Object.defineProperty(new Error(`The Edge Function "pages${page}" must export a \`default\` function`), "__NEXT_ERROR_CODE", {
+        value: "E162",
+        enumerable: false,
+        configurable: true
+    });
+}
+const handler = (opts)=>{
+    return (0, _adapter.adapter)({
+        ...opts,
+        IncrementalCache: _incrementalcache.IncrementalCache,
+        page: 'VAR_DEFINITION_PATHNAME',
+        handler: (0, _apiutils.wrapApiHandler)(page, _VAR_USERLAND.default)
+    });
+};
+const _default = handler;
+
+//# sourceMappingURL=pages-edge-api.js.map

package/webapp-dist/vendor/next/dist/build/templates/pages.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    config: null,
+    default: null,
+    getServerSideProps: null,
+    getStaticPaths: null,
+    getStaticProps: null,
+    handler: null,
+    reportWebVitals: null,
+    routeModule: null,
+    unstable_getServerProps: null,
+    unstable_getServerSideProps: null,
+    unstable_getStaticParams: null,
+    unstable_getStaticPaths: null,
+    unstable_getStaticProps: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    config: function() {
+        return config;
+    },
+    // Re-export the component (should be the default export).
+    default: function() {
+        return _default;
+    },
+    getServerSideProps: function() {
+        return getServerSideProps;
+    },
+    getStaticPaths: function() {
+        return getStaticPaths;
+    },
+    getStaticProps: function() {
+        return getStaticProps;
+    },
+    handler: function() {
+        return handler;
+    },
+    reportWebVitals: function() {
+        return reportWebVitals;
+    },
+    routeModule: function() {
+        return routeModule;
+    },
+    unstable_getServerProps: function() {
+        return unstable_getServerProps;
+    },
+    unstable_getServerSideProps: function() {
+        return unstable_getServerSideProps;
+    },
+    unstable_getStaticParams: function() {
+        return unstable_getStaticParams;
+    },
+    unstable_getStaticPaths: function() {
+        return unstable_getStaticPaths;
+    },
+    unstable_getStaticProps: function() {
+        return unstable_getStaticProps;
+    }
+});
+const _modulecompiled = require("../../server/route-modules/pages/module.compiled");
+const _routekind = require("../../server/route-kind");
+const _helpers = require("./helpers");
+const _VAR_MODULE_DOCUMENT = /*#__PURE__*/ _interop_require_wildcard(require("VAR_MODULE_DOCUMENT"));
+const _VAR_MODULE_APP = /*#__PURE__*/ _interop_require_wildcard(require("VAR_MODULE_APP"));
+const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
+const _pageshandler = require("../../server/route-modules/pages/pages-handler");
+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 _default = (0, _helpers.hoist)(_VAR_USERLAND, 'default');
+const getStaticProps = (0, _helpers.hoist)(_VAR_USERLAND, 'getStaticProps');
+const getStaticPaths = (0, _helpers.hoist)(_VAR_USERLAND, 'getStaticPaths');
+const getServerSideProps = (0, _helpers.hoist)(_VAR_USERLAND, 'getServerSideProps');
+const config = (0, _helpers.hoist)(_VAR_USERLAND, 'config');
+const reportWebVitals = (0, _helpers.hoist)(_VAR_USERLAND, 'reportWebVitals');
+const unstable_getStaticProps = (0, _helpers.hoist)(_VAR_USERLAND, 'unstable_getStaticProps');
+const unstable_getStaticPaths = (0, _helpers.hoist)(_VAR_USERLAND, 'unstable_getStaticPaths');
+const unstable_getStaticParams = (0, _helpers.hoist)(_VAR_USERLAND, 'unstable_getStaticParams');
+const unstable_getServerProps = (0, _helpers.hoist)(_VAR_USERLAND, 'unstable_getServerProps');
+const unstable_getServerSideProps = (0, _helpers.hoist)(_VAR_USERLAND, 'unstable_getServerSideProps');
+const routeModule = new _modulecompiled.PagesRouteModule({
+    definition: {
+        kind: _routekind.RouteKind.PAGES,
+        page: 'VAR_DEFINITION_PAGE',
+        pathname: 'VAR_DEFINITION_PATHNAME',
+        // The following aren't used in production.
+        bundlePath: '',
+        filename: ''
+    },
+    distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
+    relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',
+    components: {
+        // default export might not exist when optimized for data only
+        App: _VAR_MODULE_APP.default,
+        Document: _VAR_MODULE_DOCUMENT.default
+    },
+    userland: _VAR_USERLAND
+});
+const handler = (0, _pageshandler.getHandler)({
+    srcPage: 'VAR_DEFINITION_PAGE',
+    config,
+    userland: _VAR_USERLAND,
+    routeModule,
+    getStaticPaths,
+    getStaticProps,
+    getServerSideProps
+});
+
+//# sourceMappingURL=pages.js.map

package/webapp-dist/vendor/next/dist/build/turbopack-analyze/index.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    turbopackAnalyze: null,
+    waitForShutdown: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    turbopackAnalyze: function() {
+        return turbopackAnalyze;
+    },
+    waitForShutdown: function() {
+        return waitForShutdown;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _turbopackwarning = require("../../lib/turbopack-warning");
+const _utils = require("../../shared/lib/turbopack/utils");
+const _swc = require("../swc");
+const _ciinfo = require("../../server/ci-info");
+const _compilationevents = require("../../shared/lib/turbopack/compilation-events");
+const _utils1 = require("../utils");
+const _normalizepath = require("../../lib/normalize-path");
+const _constants = require("../../shared/lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function turbopackAnalyze(analyzeContext) {
+    var _config_experimental, _config_turbopack, _config_turbopack1, _config_experimental1;
+    await (0, _turbopackwarning.validateTurboNextConfig)({
+        dir: analyzeContext.dir,
+        configPhase: _constants.PHASE_PRODUCTION_BUILD
+    });
+    const { config, dir, distDir, noMangling } = analyzeContext;
+    const currentNodeJsVersion = process.versions.node;
+    const startTime = process.hrtime();
+    const bindings = await (0, _swc.loadBindings)(config == null ? void 0 : (_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useWasmBinary);
+    const dev = false;
+    const supportedBrowsers = (0, _utils1.getSupportedBrowsers)(dir, dev);
+    const persistentCaching = (0, _utils.isFileSystemCacheEnabledForBuild)(config);
+    const rootPath = ((_config_turbopack = config.turbopack) == null ? void 0 : _config_turbopack.root) || config.outputFileTracingRoot || dir;
+    const project = await bindings.turbo.createProject({
+        rootPath: ((_config_turbopack1 = config.turbopack) == null ? void 0 : _config_turbopack1.root) || config.outputFileTracingRoot || dir,
+        projectPath: (0, _normalizepath.normalizePath)(_path.default.relative(rootPath, dir) || '.'),
+        distDir,
+        nextConfig: config,
+        watch: {
+            enable: false
+        },
+        dev,
+        env: process.env,
+        defineEnv: (0, _swc.createDefineEnv)({
+            isTurbopack: true,
+            config,
+            dev,
+            distDir,
+            projectPath: dir,
+            fetchCacheKeyPrefix: config.experimental.fetchCacheKeyPrefix,
+            hasRewrites: false,
+            // Implemented separately in Turbopack, doesn't have to be passed here.
+            middlewareMatchers: undefined,
+            rewrites: {
+                beforeFiles: [],
+                afterFiles: [],
+                fallback: []
+            }
+        }),
+        buildId: 'analyze-build',
+        encryptionKey: '',
+        previewProps: {
+            previewModeId: '',
+            previewModeEncryptionKey: '',
+            previewModeSigningKey: ''
+        },
+        browserslistQuery: supportedBrowsers.join(', '),
+        noMangling,
+        writeRoutesHashesManifest: false,
+        currentNodeJsVersion
+    }, {
+        persistentCaching,
+        memoryLimit: (_config_experimental1 = config.experimental) == null ? void 0 : _config_experimental1.turbopackMemoryLimit,
+        dependencyTracking: persistentCaching,
+        isCi: _ciinfo.isCI,
+        isShortSession: true
+    });
+    try {
+        (0, _compilationevents.backgroundLogCompilationEvents)(project);
+        await project.writeAnalyzeData(analyzeContext.appDirOnly);
+        const shutdownPromise = project.shutdown();
+        const time = process.hrtime(startTime);
+        return {
+            duration: time[0] + time[1] / 1e9,
+            shutdownPromise
+        };
+    } catch (err) {
+        await project.shutdown();
+        throw err;
+    }
+}
+let shutdownPromise;
+async function waitForShutdown() {
+    if (shutdownPromise) {
+        await shutdownPromise;
+    }
+}
+
+//# sourceMappingURL=index.js.map