@obsfx/trekker 0.1.7 → 0.1.8

package/webapp-dist/vendor/next/dist/build/segment-config/app/app-segment-config.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    AppSegmentConfigSchemaKeys: null,
+    parseAppSegmentConfig: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AppSegmentConfigSchemaKeys: function() {
+        return AppSegmentConfigSchemaKeys;
+    },
+    parseAppSegmentConfig: function() {
+        return parseAppSegmentConfig;
+    }
+});
+const _zod = require("next/dist/compiled/zod");
+const _zod1 = require("../../../shared/lib/zod");
+const CookieSchema = _zod.z.object({
+    name: _zod.z.string(),
+    value: _zod.z.string(),
+    httpOnly: _zod.z.boolean().optional(),
+    path: _zod.z.string().optional()
+}).strict();
+const RuntimeSampleSchema = _zod.z.object({
+    cookies: _zod.z.array(CookieSchema).optional(),
+    headers: _zod.z.array(_zod.z.tuple([
+        _zod.z.string(),
+        _zod.z.string()
+    ])).optional(),
+    params: _zod.z.record(_zod.z.union([
+        _zod.z.string(),
+        _zod.z.array(_zod.z.string())
+    ])).optional(),
+    searchParams: _zod.z.record(_zod.z.union([
+        _zod.z.string(),
+        _zod.z.array(_zod.z.string()),
+        _zod.z.undefined()
+    ])).optional()
+}).strict();
+const StaticPrefetchSchema = _zod.z.object({
+    mode: _zod.z.literal('static'),
+    from: _zod.z.array(_zod.z.string()).optional(),
+    expectUnableToVerify: _zod.z.boolean().optional()
+}).strict();
+const RuntimePrefetchSchema = _zod.z.object({
+    mode: _zod.z.literal('runtime'),
+    samples: _zod.z.array(RuntimeSampleSchema).min(1),
+    from: _zod.z.array(_zod.z.string()).optional(),
+    expectUnableToVerify: _zod.z.boolean().optional()
+}).strict();
+const PrefetchSchema = _zod.z.discriminatedUnion('mode', [
+    StaticPrefetchSchema,
+    RuntimePrefetchSchema
+]);
+/**
+ * The schema for configuration for a page.
+ */ const AppSegmentConfigSchema = _zod.z.object({
+    /**
+   * The number of seconds to revalidate the page or false to disable revalidation.
+   */ revalidate: _zod.z.union([
+        _zod.z.number().int().nonnegative(),
+        _zod.z.literal(false)
+    ]).optional(),
+    /**
+   * Whether the page supports dynamic parameters.
+   */ dynamicParams: _zod.z.boolean().optional(),
+    /**
+   * The dynamic behavior of the page.
+   */ dynamic: _zod.z.enum([
+        'auto',
+        'error',
+        'force-static',
+        'force-dynamic'
+    ]).optional(),
+    /**
+   * The caching behavior of the page.
+   */ fetchCache: _zod.z.enum([
+        'auto',
+        'default-cache',
+        'only-cache',
+        'force-cache',
+        'force-no-store',
+        'default-no-store',
+        'only-no-store'
+    ]).optional(),
+    /**
+   * How this segment should be prefetched.
+   */ unstable_prefetch: PrefetchSchema.optional(),
+    /**
+   * The preferred region for the page.
+   */ preferredRegion: _zod.z.union([
+        _zod.z.string(),
+        _zod.z.array(_zod.z.string())
+    ]).optional(),
+    /**
+   * The runtime to use for the page.
+   */ runtime: _zod.z.enum([
+        'edge',
+        'nodejs'
+    ]).optional(),
+    /**
+   * The maximum duration for the page in seconds.
+   */ maxDuration: _zod.z.number().int().nonnegative().optional()
+});
+function parseAppSegmentConfig(data, route) {
+    const parsed = AppSegmentConfigSchema.safeParse(data, {
+        errorMap: (issue, ctx)=>{
+            if (issue.path.length === 1) {
+                switch(issue.path[0]){
+                    case 'revalidate':
+                        {
+                            return {
+                                message: `Invalid revalidate value ${JSON.stringify(ctx.data)} on "${route}", must be a non-negative number or false`
+                            };
+                        }
+                    case 'unstable_prefetch':
+                        {
+                            return {
+                                // @TODO replace this link with a link to the docs when they are written
+                                message: `Invalid unstable_prefetch value ${JSON.stringify(ctx.data)} on "${route}", must be an object with a mode of "static" or "runtime". Read more at https://nextjs.org/docs/messages/invalid-prefetch-configuration`
+                            };
+                        }
+                    default:
+                }
+            }
+            return {
+                message: ctx.defaultError
+            };
+        }
+    });
+    if (!parsed.success) {
+        throw (0, _zod1.formatZodError)(`Invalid segment configuration options detected for "${route}". Read more at https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config`, parsed.error);
+    }
+    return parsed.data;
+}
+const AppSegmentConfigSchemaKeys = AppSegmentConfigSchema.keyof().options;
+
+//# sourceMappingURL=app-segment-config.js.map

package/webapp-dist/vendor/next/dist/build/segment-config/app/app-segments.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "collectSegments", {
+    enumerable: true,
+    get: function() {
+        return collectSegments;
+    }
+});
+const _appsegmentconfig = require("./app-segment-config");
+const _invarianterror = require("../../../shared/lib/invariant-error");
+const _checks = require("../../../server/route-modules/checks");
+const _clientandserverreferences = require("../../../lib/client-and-server-references");
+const _getsegmentparam = require("../../../shared/lib/router/utils/get-segment-param");
+const _appdirmodule = require("../../../server/lib/app-dir-module");
+/**
+ * Parses the app config and attaches it to the segment.
+ */ function attach(segment, userland, route) {
+    // If the userland is not an object, then we can't do anything with it.
+    if (typeof userland !== 'object' || userland === null) {
+        return;
+    }
+    // Try to parse the application configuration.
+    const config = (0, _appsegmentconfig.parseAppSegmentConfig)(userland, route);
+    // If there was any keys on the config, then attach it to the segment.
+    if (Object.keys(config).length > 0) {
+        segment.config = config;
+    }
+    if ('generateStaticParams' in userland && typeof userland.generateStaticParams === 'function') {
+        var _segment_config;
+        segment.generateStaticParams = userland.generateStaticParams;
+        // Validate that `generateStaticParams` makes sense in this context.
+        if (((_segment_config = segment.config) == null ? void 0 : _segment_config.runtime) === 'edge') {
+            throw Object.defineProperty(new Error('Edge runtime is not supported with `generateStaticParams`.'), "__NEXT_ERROR_CODE", {
+                value: "E502",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+}
+/**
+ * Walks the loader tree and collects the generate parameters for each segment.
+ *
+ * @param routeModule the app page route module
+ * @returns the segments for the app page route module
+ */ async function collectAppPageSegments(routeModule) {
+    // We keep track of unique segments, since with parallel routes, it's possible
+    // to see the same segment multiple times.
+    const segments = [];
+    // Queue will store loader trees.
+    const queue = [
+        routeModule.userland.loaderTree
+    ];
+    while(queue.length > 0){
+        const loaderTree = queue.shift();
+        const [name, parallelRoutes] = loaderTree;
+        // Process current node
+        const { mod: userland, filePath } = await (0, _appdirmodule.getLayoutOrPageModule)(loaderTree);
+        const isClientComponent = userland && (0, _clientandserverreferences.isClientReference)(userland);
+        const param = (0, _getsegmentparam.getSegmentParam)(name);
+        const segment = {
+            name,
+            paramName: param == null ? void 0 : param.paramName,
+            paramType: param == null ? void 0 : param.paramType,
+            filePath,
+            config: undefined,
+            generateStaticParams: undefined
+        };
+        // Only server components can have app segment configurations
+        if (!isClientComponent) {
+            attach(segment, userland, routeModule.definition.pathname);
+        }
+        // If this segment doesn't already exist, then add it to the segments array.
+        // The list of segments is short so we just use a list traversal to check
+        // for duplicates and spare us needing to maintain the string key.
+        if (segments.every((s)=>s.name !== segment.name || s.paramName !== segment.paramName || s.paramType !== segment.paramType || s.filePath !== segment.filePath)) {
+            segments.push(segment);
+        }
+        // Add all parallel routes to the queue
+        for (const parallelRoute of Object.values(parallelRoutes)){
+            queue.push(parallelRoute);
+        }
+    }
+    return segments;
+}
+/**
+ * Collects the segments for a given app route module.
+ *
+ * @param routeModule the app route module
+ * @returns the segments for the app route module
+ */ function collectAppRouteSegments(routeModule) {
+    // Get the pathname parts, slice off the first element (which is empty).
+    const parts = routeModule.definition.pathname.split('/').slice(1);
+    if (parts.length === 0) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected at least one segment'), "__NEXT_ERROR_CODE", {
+            value: "E580",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Generate all the segments.
+    const segments = parts.map((name)=>{
+        const param = (0, _getsegmentparam.getSegmentParam)(name);
+        return {
+            name,
+            paramName: param == null ? void 0 : param.paramName,
+            paramType: param == null ? void 0 : param.paramType,
+            filePath: undefined,
+            config: undefined,
+            generateStaticParams: undefined
+        };
+    });
+    // We know we have at least one, we verified this above. We should get the
+    // last segment which represents the root route module.
+    const segment = segments[segments.length - 1];
+    segment.filePath = routeModule.definition.filename;
+    // Extract the segment config from the userland module.
+    attach(segment, routeModule.userland, routeModule.definition.pathname);
+    return segments;
+}
+function collectSegments(routeModule) {
+    if ((0, _checks.isAppRouteRouteModule)(routeModule)) {
+        return collectAppRouteSegments(routeModule);
+    }
+    if ((0, _checks.isAppPageRouteModule)(routeModule)) {
+        return collectAppPageSegments(routeModule);
+    }
+    throw Object.defineProperty(new _invarianterror.InvariantError('Expected a route module to be one of app route or page'), "__NEXT_ERROR_CODE", {
+        value: "E568",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=app-segments.js.map

package/webapp-dist/vendor/next/dist/build/segment-config/app/collect-root-param-keys.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "collectRootParamKeys", {
+    enumerable: true,
+    get: function() {
+        return collectRootParamKeys;
+    }
+});
+const _getsegmentparam = require("../../../shared/lib/router/utils/get-segment-param");
+const _checks = require("../../../server/route-modules/checks");
+const _invarianterror = require("../../../shared/lib/invariant-error");
+function collectAppPageRootParamKeys(routeModule) {
+    let rootParams = [];
+    let current = routeModule.userland.loaderTree;
+    while(current){
+        var _getSegmentParam;
+        const [name, parallelRoutes, modules] = current;
+        // If this is a dynamic segment, then we collect the param.
+        const paramName = (_getSegmentParam = (0, _getsegmentparam.getSegmentParam)(name)) == null ? void 0 : _getSegmentParam.paramName;
+        if (paramName) {
+            rootParams.push(paramName);
+        }
+        // If this has a layout module, then we've found the root layout because
+        // we return once we found the first layout.
+        if (typeof modules.layout !== 'undefined') {
+            return rootParams;
+        }
+        // This didn't include a root layout, so we need to continue. We don't need
+        // to collect from other parallel routes because we can't have a parallel
+        // route above a root layout.
+        current = parallelRoutes.children;
+    }
+    // If we didn't find a root layout, then we don't have any params.
+    return [];
+}
+function collectRootParamKeys(routeModule) {
+    if ((0, _checks.isAppRouteRouteModule)(routeModule)) {
+        return [];
+    }
+    if ((0, _checks.isAppPageRouteModule)(routeModule)) {
+        return collectAppPageRootParamKeys(routeModule);
+    }
+    throw Object.defineProperty(new _invarianterror.InvariantError('Expected a route module to be one of app route or page'), "__NEXT_ERROR_CODE", {
+        value: "E568",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=collect-root-param-keys.js.map

package/webapp-dist/vendor/next/dist/build/segment-config/middleware/middleware-config.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    MiddlewareConfigInputSchema: null,
+    MiddlewareConfigInputSchemaKeys: null,
+    SourceSchema: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MiddlewareConfigInputSchema: function() {
+        return MiddlewareConfigInputSchema;
+    },
+    MiddlewareConfigInputSchemaKeys: function() {
+        return MiddlewareConfigInputSchemaKeys;
+    },
+    SourceSchema: function() {
+        return SourceSchema;
+    }
+});
+const _picomatch = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/picomatch"));
+const _zod = require("next/dist/compiled/zod");
+const _trytoparsepath = require("../../../lib/try-to-parse-path");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const RouteHasSchema = _zod.z.discriminatedUnion('type', [
+    _zod.z.object({
+        type: _zod.z.enum([
+            'header',
+            'query',
+            'cookie'
+        ]),
+        key: _zod.z.string({
+            required_error: 'key is required when type is header, query or cookie'
+        }),
+        value: _zod.z.string({
+            invalid_type_error: 'value must be a string'
+        }).optional()
+    }).strict(),
+    _zod.z.object({
+        type: _zod.z.literal('host'),
+        value: _zod.z.string({
+            required_error: 'host must have a value'
+        })
+    }).strict()
+]);
+const SourceSchema = _zod.z.string({
+    required_error: 'source is required'
+}).max(4096, 'exceeds max built length of 4096 for route').superRefine((val, ctx)=>{
+    if (!val.startsWith('/')) {
+        return ctx.addIssue({
+            code: _zod.z.ZodIssueCode.custom,
+            message: `source must start with /`
+        });
+    }
+    const { error, regexStr } = (0, _trytoparsepath.tryToParsePath)(val);
+    if (error || !regexStr) {
+        ctx.addIssue({
+            code: _zod.z.ZodIssueCode.custom,
+            message: `Invalid source '${val}': ${error.message}`
+        });
+    }
+});
+const MiddlewareMatcherInputSchema = _zod.z.object({
+    locale: _zod.z.union([
+        _zod.z.literal(false),
+        _zod.z.undefined()
+    ]).optional(),
+    has: _zod.z.array(RouteHasSchema).optional(),
+    missing: _zod.z.array(RouteHasSchema).optional(),
+    source: SourceSchema
+}).strict();
+const MiddlewareConfigMatcherInputSchema = _zod.z.union([
+    SourceSchema,
+    _zod.z.array(_zod.z.union([
+        SourceSchema,
+        MiddlewareMatcherInputSchema
+    ], {
+        invalid_type_error: 'must be an array of strings or middleware matchers'
+    }))
+]);
+const GlobSchema = _zod.z.string().superRefine((val, ctx)=>{
+    try {
+        (0, _picomatch.default)(val);
+    } catch (err) {
+        ctx.addIssue({
+            code: _zod.z.ZodIssueCode.custom,
+            message: `Invalid glob pattern '${val}': ${err.message}`
+        });
+    }
+});
+const MiddlewareConfigInputSchema = _zod.z.object({
+    /**
+   * The matcher for the middleware.
+   */ matcher: MiddlewareConfigMatcherInputSchema.optional(),
+    /**
+   * The regions that the middleware should run in.
+   */ regions: _zod.z.union([
+        _zod.z.string(),
+        _zod.z.array(_zod.z.string())
+    ]).optional(),
+    /**
+   * A glob, or an array of globs, ignoring dynamic code evaluation for specific
+   * files. The globs are relative to your application root folder.
+   */ unstable_allowDynamic: _zod.z.union([
+        GlobSchema,
+        _zod.z.array(GlobSchema)
+    ]).optional()
+});
+const MiddlewareConfigInputSchemaKeys = MiddlewareConfigInputSchema.keyof().options;
+
+//# sourceMappingURL=middleware-config.js.map

package/webapp-dist/vendor/next/dist/build/segment-config/pages/pages-segment-config.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    PagesSegmentConfigSchemaKeys: null,
+    parsePagesSegmentConfig: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PagesSegmentConfigSchemaKeys: function() {
+        return PagesSegmentConfigSchemaKeys;
+    },
+    parsePagesSegmentConfig: function() {
+        return parsePagesSegmentConfig;
+    }
+});
+const _zod = require("next/dist/compiled/zod");
+const _zod1 = require("../../../shared/lib/zod");
+/**
+ * The schema for the page segment config.
+ */ const PagesSegmentConfigSchema = _zod.z.object({
+    /**
+   * The runtime to use for the page.
+   */ runtime: _zod.z.enum([
+        'edge',
+        'experimental-edge',
+        'nodejs'
+    ]).optional(),
+    /**
+   * The maximum duration for the page render.
+   */ maxDuration: _zod.z.number().optional(),
+    /**
+   * The exported config object for the page.
+   */ config: _zod.z.object({
+        /**
+       * The runtime to use for the page.
+       */ runtime: _zod.z.enum([
+            'edge',
+            'experimental-edge',
+            'nodejs'
+        ]).optional(),
+        /**
+       * The maximum duration for the page render.
+       */ maxDuration: _zod.z.number().optional()
+    }).optional()
+});
+function parsePagesSegmentConfig(data, route) {
+    const parsed = PagesSegmentConfigSchema.safeParse(data, {});
+    if (!parsed.success) {
+        throw (0, _zod1.formatZodError)(`Invalid segment configuration options detected for "${route}". Read more at https://nextjs.org/docs/messages/invalid-page-config`, parsed.error);
+    }
+    return parsed.data;
+}
+const PagesSegmentConfigSchemaKeys = PagesSegmentConfigSchema.keyof().options;
+
+//# sourceMappingURL=pages-segment-config.js.map

package/webapp-dist/vendor/next/dist/build/sort-by-page-exts.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "sortByPageExts", {
+    enumerable: true,
+    get: function() {
+        return sortByPageExts;
+    }
+});
+const _posix = require("path/posix");
+function sortByPageExts(pageExtensions) {
+    return (a, b)=>{
+        // prioritize entries according to pageExtensions order
+        // for consistency as fs order can differ across systems
+        // NOTE: this is reversed so preferred comes last and
+        // overrides prior
+        const aExt = (0, _posix.extname)(a);
+        const bExt = (0, _posix.extname)(b);
+        const aNoExt = a.substring(0, a.length - aExt.length);
+        const bNoExt = b.substring(0, b.length - bExt.length);
+        if (aNoExt !== bNoExt) return 0;
+        // find extension index (skip '.' as pageExtensions doesn't have it)
+        const aExtIndex = pageExtensions.indexOf(aExt.substring(1));
+        const bExtIndex = pageExtensions.indexOf(bExt.substring(1));
+        return bExtIndex - aExtIndex;
+    };
+}
+
+//# sourceMappingURL=sort-by-page-exts.js.map

package/webapp-dist/vendor/next/dist/build/spinner.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return createSpinner;
+    }
+});
+const _ora = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/ora"));
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log"));
+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 dotsSpinner = {
+    frames: [
+        '.',
+        '..',
+        '...'
+    ],
+    interval: 200
+};
+function createSpinner(text, options = {}, logFn = console.log) {
+    let spinner;
+    let prefixText = `${_log.prefixes.info} ${text} `;
+    if (process.stdout.isTTY) {
+        spinner = (0, _ora.default)({
+            text: undefined,
+            prefixText,
+            spinner: dotsSpinner,
+            stream: process.stdout,
+            ...options
+        }).start();
+        // Add capturing of console.log/warn/error to allow pausing
+        // the spinner before logging and then restarting spinner after
+        const origLog = console.log;
+        const origWarn = console.warn;
+        const origError = console.error;
+        const origStop = spinner.stop.bind(spinner);
+        const origStopAndPersist = spinner.stopAndPersist.bind(spinner);
+        const logHandle = (method, args)=>{
+            // Enter a new line before logging new message, to avoid
+            // the new message shows up right after the spinner in the same line.
+            const isInProgress = spinner == null ? void 0 : spinner.isSpinning;
+            if (spinner && isInProgress) {
+                // Reset the current running spinner to empty line by `\r`
+                spinner.prefixText = '\r';
+                spinner.text = '\r';
+                spinner.clear();
+                origStop();
+            }
+            method(...args);
+            if (spinner && isInProgress) {
+                spinner.start();
+            }
+        };
+        console.log = (...args)=>logHandle(origLog, args);
+        console.warn = (...args)=>logHandle(origWarn, args);
+        console.error = (...args)=>logHandle(origError, args);
+        const resetLog = ()=>{
+            console.log = origLog;
+            console.warn = origWarn;
+            console.error = origError;
+        };
+        spinner.setText = (newText)=>{
+            text = newText;
+            prefixText = `${_log.prefixes.info} ${newText} `;
+            spinner.prefixText = prefixText;
+            return spinner;
+        };
+        spinner.stop = ()=>{
+            origStop();
+            resetLog();
+            return spinner;
+        };
+        spinner.stopAndPersist = ()=>{
+            // Add \r at beginning to reset the current line of loading status text
+            const suffixText = `\r${_log.prefixes.event} ${text} `;
+            if (spinner) {
+                spinner.text = suffixText;
+            } else {
+                logFn(suffixText);
+            }
+            origStopAndPersist();
+            resetLog();
+            return spinner;
+        };
+    } else if (prefixText || text) {
+        logFn(prefixText ? prefixText + '...' : text);
+    }
+    return spinner;
+}
+
+//# sourceMappingURL=spinner.js.map