@codelionapps/unharness 0.0.0-stage → 0.1.0

package/dashboard/.next/standalone/node_modules/next/dist/lib/recursive-readdir.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "recursiveReadDir", {
+    enumerable: true,
+    get: function() {
+        return recursiveReadDir;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function recursiveReadDir(rootDirectory, options = {}) {
+    // Grab our options.
+    const { pathnameFilter, ignoreFilter, ignorePartFilter, sortPathnames = true, relativePathnames = true } = options;
+    // The list of pathnames to return.
+    const pathnames = [];
+    /**
+   * Coerces the pathname to be relative if requested.
+   */ const coerce = relativePathnames ? (pathname)=>pathname.replace(rootDirectory, '') : (pathname)=>pathname;
+    // The queue of directories to scan.
+    let directories = [
+        rootDirectory
+    ];
+    while(directories.length > 0){
+        // Load all the files in each directory at the same time.
+        const results = await Promise.all(directories.map(async (directory)=>{
+            const result = {
+                directories: [],
+                pathnames: [],
+                links: []
+            };
+            try {
+                const dir = await _promises.default.readdir(directory, {
+                    withFileTypes: true
+                });
+                for (const file of dir){
+                    // If enabled, ignore the file if it matches the ignore filter.
+                    if (ignorePartFilter && ignorePartFilter(file.name)) {
+                        continue;
+                    }
+                    // Handle each file.
+                    const absolutePathname = _path.default.join(directory, file.name);
+                    // If enabled, ignore the file if it matches the ignore filter.
+                    if (ignoreFilter && ignoreFilter(absolutePathname)) {
+                        continue;
+                    }
+                    // If the file is a directory, then add it to the list of directories,
+                    // they'll be scanned on a later pass.
+                    if (file.isDirectory()) {
+                        result.directories.push(absolutePathname);
+                    } else if (file.isSymbolicLink()) {
+                        result.links.push(absolutePathname);
+                    } else if (!pathnameFilter || pathnameFilter(absolutePathname)) {
+                        result.pathnames.push(coerce(absolutePathname));
+                    }
+                }
+            } catch (err) {
+                // This can only happen when the underlying directory was removed. If
+                // anything other than this error occurs, re-throw it.
+                // if (err.code !== 'ENOENT') throw err
+                if (err.code !== 'ENOENT' || directory === rootDirectory) throw err;
+                // The error occurred, so abandon reading this directory.
+                return null;
+            }
+            return result;
+        }));
+        // Empty the directories, we'll fill it later if some of the files are
+        // directories.
+        directories = [];
+        // Keep track of any symbolic links we find, we'll resolve them later.
+        const links = [];
+        // For each result of directory scans...
+        for (const result of results){
+            // If the directory was removed, then skip it.
+            if (!result) continue;
+            // Add any directories to the list of directories to scan.
+            directories.push(...result.directories);
+            // Add any symbolic links to the list of symbolic links to resolve.
+            links.push(...result.links);
+            // Add any file pathnames to the list of pathnames.
+            pathnames.push(...result.pathnames);
+        }
+        // Resolve all the symbolic links we found if any.
+        if (links.length > 0) {
+            const resolved = await Promise.all(links.map(async (absolutePathname)=>{
+                try {
+                    return await _promises.default.stat(absolutePathname);
+                } catch (err) {
+                    // This can only happen when the underlying link was removed. If
+                    // anything other than this error occurs, re-throw it.
+                    if (err.code !== 'ENOENT') throw err;
+                    // The error occurred, so abandon reading this directory.
+                    return null;
+                }
+            }));
+            for(let i = 0; i < links.length; i++){
+                const stats = resolved[i];
+                // If the link was removed, then skip it.
+                if (!stats) continue;
+                // We would have already ignored the file if it matched the ignore
+                // filter, so we don't need to check it again.
+                const absolutePathname = links[i];
+                if (stats.isDirectory()) {
+                    directories.push(absolutePathname);
+                } else if (!pathnameFilter || pathnameFilter(absolutePathname)) {
+                    pathnames.push(coerce(absolutePathname));
+                }
+            }
+        }
+    }
+    // Sort the pathnames in place if requested.
+    if (sortPathnames) {
+        pathnames.sort();
+    }
+    return pathnames;
+}
+
+//# sourceMappingURL=recursive-readdir.js.map

package/dashboard/.next/standalone/node_modules/next/dist/lib/redirect-status.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    allowedStatusCodes: null,
+    getRedirectStatus: null,
+    modifyRouteRegex: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    allowedStatusCodes: function() {
+        return allowedStatusCodes;
+    },
+    getRedirectStatus: function() {
+        return getRedirectStatus;
+    },
+    modifyRouteRegex: function() {
+        return modifyRouteRegex;
+    }
+});
+const _redirectstatuscode = require("../client/components/redirect-status-code");
+const allowedStatusCodes = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+function getRedirectStatus(route) {
+    return route.statusCode || (route.permanent ? _redirectstatuscode.RedirectStatusCode.PermanentRedirect : _redirectstatuscode.RedirectStatusCode.TemporaryRedirect);
+}
+function modifyRouteRegex(regex, restrictedPaths) {
+    if (restrictedPaths) {
+        regex = regex.replace(/\^/, `^(?!${restrictedPaths.map((path)=>path.replace(/\//g, '\\/')).join('|')})`);
+    }
+    regex = regex.replace(/\$$/, '(?:\\/)?$');
+    return regex;
+}
+
+//# sourceMappingURL=redirect-status.js.map

package/dashboard/.next/standalone/node_modules/next/dist/lib/require-instrumentation-client.js

@@ -0,0 +1,32 @@
+/**
+ * This module imports the configured client instrumentation modules.
+ *
+ * The `private-next-instrumentation-client` module is automatically aliased to
+ * either the user's instrumentation module or a generated module array.
+ */ "use strict";
+if (process.env.NODE_ENV === 'development') {
+    const measureName = 'Client Instrumentation Hook';
+    const startTime = performance.now();
+    // eslint-disable-next-line @next/internal/typechecked-require -- Not a module.
+    const instrumentationClient = require('private-next-instrumentation-client');
+    module.exports = Array.isArray(instrumentationClient) ? instrumentationClient : [
+        instrumentationClient
+    ];
+    const endTime = performance.now();
+    const duration = endTime - startTime;
+    // Using 16ms threshold as it represents one frame (1000ms/60fps)
+    // This helps identify if the instrumentation hook initialization
+    // could potentially cause frame drops during development.
+    const THRESHOLD = 16;
+    if (duration > THRESHOLD) {
+        console.log(`[${measureName}] Slow execution detected: ${duration.toFixed(0)}ms (Note: Code download overhead is not included in this measurement)`);
+    }
+} else {
+    // eslint-disable-next-line @next/internal/typechecked-require -- Not a module.
+    const instrumentationClient = require('private-next-instrumentation-client');
+    module.exports = Array.isArray(instrumentationClient) ? instrumentationClient : [
+        instrumentationClient
+    ];
+}
+
+//# sourceMappingURL=require-instrumentation-client.js.map

package/dashboard/.next/standalone/node_modules/next/dist/lib/resolve-build-paths.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    parseBuildPathsInput: null,
+    resolveBuildPaths: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    parseBuildPathsInput: function() {
+        return parseBuildPathsInput;
+    },
+    resolveBuildPaths: function() {
+        return resolveBuildPaths;
+    }
+});
+const _util = require("util");
+const _glob = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/glob"));
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _iserror = /*#__PURE__*/ _interop_require_default(require("./is-error"));
+const _findpagefile = require("../server/lib/find-page-file");
+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 glob = (0, _util.promisify)(_glob.default);
+/**
+ * Escapes Next.js dynamic route bracket expressions so glob treats them as
+ * literal directory names rather than character classes.
+ *
+ * e.g., "app/blog/[slug]/** /page.tsx" → "app/blog/\[slug\]/** /page.tsx"
+ */ function escapeBrackets(pattern) {
+    // Match Next.js dynamic route patterns: [name], [...name], [[...name]]
+    return pattern.replace(/\[\[?\.\.\.[^\]]+\]?\]|\[[^\]]+\]/g, (match)=>match.replace(/\[/g, '\\[').replace(/\]/g, '\\]'));
+}
+async function resolveBuildPaths(patterns, projectDir, pageExtensions) {
+    const appPaths = new Set();
+    const pagePaths = new Set();
+    const validFileMatcher = (0, _findpagefile.createValidFileMatcher)(pageExtensions, undefined);
+    // Detect whether the project keeps its routes under `src/` so we can accept
+    // patterns written with or without that prefix (e.g. both `app/foo/page.tsx`
+    // and `src/app/foo/page.tsx`).
+    const useSrcApp = _fs.default.existsSync(_path.default.join(projectDir, 'src', 'app'));
+    const useSrcPages = _fs.default.existsSync(_path.default.join(projectDir, 'src', 'pages'));
+    const includePatterns = [];
+    const excludePatterns = [];
+    for (const pattern of patterns){
+        const trimmed = pattern.trim();
+        if (!trimmed) continue;
+        if (trimmed.startsWith('!')) {
+            excludePatterns.push(escapeBrackets(addSrcPrefixIfNeeded(trimmed.slice(1), useSrcApp, useSrcPages)));
+        } else {
+            includePatterns.push(escapeBrackets(addSrcPrefixIfNeeded(trimmed, useSrcApp, useSrcPages)));
+        }
+    }
+    // Default to matching all files when only negation patterns are provided.
+    if (includePatterns.length === 0 && excludePatterns.length > 0) {
+        includePatterns.push('**');
+    }
+    // Combine patterns using brace expansion: {pattern1,pattern2}
+    const combinedPattern = includePatterns.length === 1 ? includePatterns[0] : `{${includePatterns.join(',')}}`;
+    try {
+        const matches = await glob(combinedPattern, {
+            cwd: projectDir,
+            ignore: excludePatterns
+        });
+        if (matches.length === 0) {
+            _log.warn(`Pattern "${patterns.join(',')}" did not match any files`);
+        }
+        for (const file of matches){
+            if (!_fs.default.statSync(_path.default.join(projectDir, file)).isDirectory()) {
+                categorizeAndAddPath(file, appPaths, pagePaths, validFileMatcher);
+            }
+        }
+    } catch (error) {
+        throw new Error(`Failed to resolve pattern "${patterns.join(',')}": ${(0, _iserror.default)(error) ? error.message : String(error)}`);
+    }
+    return {
+        appPaths: Array.from(appPaths).sort(),
+        pagePaths: Array.from(pagePaths).sort()
+    };
+}
+/**
+ * When the project keeps its `app/` or `pages/` directory under `src/`, prepend
+ * `src/` to bare patterns so the glob actually matches files on disk. Patterns
+ * that already include the `src/` prefix are returned unchanged.
+ */ function addSrcPrefixIfNeeded(pattern, useSrcApp, useSrcPages) {
+    const normalized = pattern.replace(/\\/g, '/');
+    if (useSrcApp && /^app\//.test(normalized)) {
+        return 'src/' + normalized;
+    }
+    if (useSrcPages && /^pages\//.test(normalized)) {
+        return 'src/' + normalized;
+    }
+    return pattern;
+}
+/**
+ * Categorizes a file path to either app or pages router based on its prefix.
+ * For app router, only route-defining files are included.
+ *
+ * Accepts both top-level (`app/...`, `pages/...`) and src-prefixed
+ * (`src/app/...`, `src/pages/...`) project structures.
+ *
+ * Examples:
+ * - "app/page.tsx" → appPaths.add("/page.tsx")
+ * - "src/app/page.tsx" → appPaths.add("/page.tsx")
+ * - "app/layout.tsx" → skipped (not a route file)
+ * - "pages/index.tsx" → pagePaths.add("/index.tsx")
+ */ function categorizeAndAddPath(filePath, appPaths, pagePaths, validFileMatcher) {
+    let normalized = filePath.replace(/\\/g, '/');
+    if (normalized.startsWith('src/')) {
+        normalized = normalized.slice(4);
+    }
+    if (normalized.startsWith('app/')) {
+        const appRelativePath = '/' + normalized.slice(4);
+        if (validFileMatcher.isAppRouterPage(appRelativePath)) {
+            appPaths.add(appRelativePath);
+        }
+    } else if (normalized.startsWith('pages/')) {
+        pagePaths.add('/' + normalized.slice(6));
+    }
+}
+function parseBuildPathsInput(input) {
+    // Comma-separated values
+    return input.split(',').map((p)=>p.trim()).filter((p)=>p.length > 0);
+}
+
+//# sourceMappingURL=resolve-build-paths.js.map

package/dashboard/.next/standalone/node_modules/next/dist/lib/resolve-from.js

@@ -0,0 +1,57 @@
+// source: https://github.com/sindresorhus/resolve-from
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveFrom", {
+    enumerable: true,
+    get: function() {
+        return resolveFrom;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _iserror = /*#__PURE__*/ _interop_require_default(require("./is-error"));
+const _realpath = require("./realpath");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const Module = require('module');
+const resolveFrom = (fromDirectory, moduleId, silent)=>{
+    if (typeof fromDirectory !== 'string') {
+        throw new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDirectory}\``);
+    }
+    if (typeof moduleId !== 'string') {
+        throw new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``);
+    }
+    try {
+        fromDirectory = (0, _realpath.realpathSync)(fromDirectory);
+    } catch (error) {
+        if ((0, _iserror.default)(error) && error.code === 'ENOENT') {
+            fromDirectory = _path.default.resolve(fromDirectory);
+        } else if (silent) {
+            return;
+        } else {
+            throw error;
+        }
+    }
+    const fromFile = _path.default.join(fromDirectory, 'noop.js');
+    const resolveFileName = ()=>// @ts-expect-error
+        Module._resolveFilename(moduleId, {
+            id: fromFile,
+            filename: fromFile,
+            paths: // @ts-expect-error
+            Module._nodeModulePaths(fromDirectory)
+        });
+    if (silent) {
+        try {
+            return resolveFileName();
+        } catch (error) {
+            return;
+        }
+    }
+    return resolveFileName();
+};
+
+//# sourceMappingURL=resolve-from.js.map

package/dashboard/.next/standalone/node_modules/next/dist/lib/route-pattern-normalizer.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    PARAM_SEPARATOR: null,
+    hasAdjacentParameterIssues: null,
+    normalizeAdjacentParameters: null,
+    normalizeTokensForRegexp: null,
+    stripNormalizedSeparators: null,
+    stripParameterSeparators: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PARAM_SEPARATOR: function() {
+        return PARAM_SEPARATOR;
+    },
+    hasAdjacentParameterIssues: function() {
+        return hasAdjacentParameterIssues;
+    },
+    normalizeAdjacentParameters: function() {
+        return normalizeAdjacentParameters;
+    },
+    normalizeTokensForRegexp: function() {
+        return normalizeTokensForRegexp;
+    },
+    stripNormalizedSeparators: function() {
+        return stripNormalizedSeparators;
+    },
+    stripParameterSeparators: function() {
+        return stripParameterSeparators;
+    }
+});
+const PARAM_SEPARATOR = '_NEXTSEP_';
+function hasAdjacentParameterIssues(route) {
+    if (typeof route !== 'string') return false;
+    // Check for interception route markers followed immediately by parameters
+    // Pattern: /(.):param, /(..):param, /(...):param, /(.)(.):param etc.
+    // These patterns cause "Must have text between two parameters" errors
+    if (/\/\(\.{1,3}\):[^/\s]+/.test(route)) {
+        return true;
+    }
+    // Check for basic adjacent parameters without separators
+    // Pattern: :param1:param2 (but not :param* or other URL patterns)
+    if (/:[a-zA-Z_][a-zA-Z0-9_]*:[a-zA-Z_][a-zA-Z0-9_]*/.test(route)) {
+        return true;
+    }
+    return false;
+}
+function normalizeAdjacentParameters(route) {
+    let normalized = route;
+    // Handle interception route patterns: (.):param -> (.)_NEXTSEP_:param
+    normalized = normalized.replace(/(\([^)]*\)):([^/\s]+)/g, `$1${PARAM_SEPARATOR}:$2`);
+    // Handle other adjacent parameter patterns: :param1:param2 -> :param1_NEXTSEP_:param2
+    normalized = normalized.replace(/:([^:/\s)]+)(?=:)/g, `:$1${PARAM_SEPARATOR}`);
+    return normalized;
+}
+function normalizeTokensForRegexp(tokens) {
+    return tokens.map((token)=>{
+        // Token union type: Token = string | TokenObject
+        // Literal path segments are strings, parameters/wildcards are objects
+        if (typeof token === 'object' && token !== null && // Not all token objects have 'modifier' property (e.g., simple text tokens)
+        'modifier' in token && // Only repeating modifiers (* or +) cause the validation error
+        // Other modifiers like '?' (optional) are fine
+        (token.modifier === '*' || token.modifier === '+') && // Token objects can have different shapes depending on route pattern
+        'prefix' in token && 'suffix' in token && // Both prefix and suffix must be empty strings
+        // This is what causes the validation error in path-to-regexp
+        token.prefix === '' && token.suffix === '') {
+            // Add minimal prefix to satisfy path-to-regexp validation
+            // We use '/' as it's the most common path delimiter and won't break route matching
+            // The prefix gets used in regex generation but doesn't affect parameter extraction
+            return {
+                ...token,
+                prefix: '/'
+            };
+        }
+        return token;
+    });
+}
+function stripNormalizedSeparators(pathname) {
+    // Remove separator after interception route markers
+    // Pattern: (.)_NEXTSEP_ -> (.), (..)_NEXTSEP_ -> (..), etc.
+    // The separator appears after the closing paren of interception markers
+    return pathname.replace(new RegExp(`\\)${PARAM_SEPARATOR}`, 'g'), ')');
+}
+function stripParameterSeparators(params) {
+    const cleaned = {};
+    for (const [key, value] of Object.entries(params)){
+        if (typeof value === 'string') {
+            // Remove the separator if it appears at the start of parameter values
+            cleaned[key] = value.replace(new RegExp(`^${PARAM_SEPARATOR}`), '');
+        } else if (Array.isArray(value)) {
+            // Handle array parameters (from repeated route segments)
+            cleaned[key] = value.map((item)=>typeof item === 'string' ? item.replace(new RegExp(`^${PARAM_SEPARATOR}`), '') : item);
+        } else {
+            cleaned[key] = value;
+        }
+    }
+    return cleaned;
+}
+
+//# sourceMappingURL=route-pattern-normalizer.js.map

package/dashboard/.next/standalone/node_modules/next/dist/lib/scheduler.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    atLeastOneTask: null,
+    scheduleImmediate: null,
+    scheduleOnNextTick: null,
+    waitAtLeastOneReactRenderTask: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    atLeastOneTask: function() {
+        return atLeastOneTask;
+    },
+    scheduleImmediate: function() {
+        return scheduleImmediate;
+    },
+    scheduleOnNextTick: function() {
+        return scheduleOnNextTick;
+    },
+    waitAtLeastOneReactRenderTask: function() {
+        return waitAtLeastOneReactRenderTask;
+    }
+});
+const scheduleOnNextTick = (cb)=>{
+    // We use Promise.resolve().then() here so that the operation is scheduled at
+    // the end of the promise job queue, we then add it to the next process tick
+    // to ensure it's evaluated afterwards.
+    //
+    // This was inspired by the implementation of the DataLoader interface: https://github.com/graphql/dataloader/blob/d336bd15282664e0be4b4a657cb796f09bafbc6b/src/index.js#L213-L255
+    //
+    Promise.resolve().then(()=>{
+        if (process.env.NEXT_RUNTIME === 'edge') {
+            setTimeout(cb, 0);
+        } else {
+            process.nextTick(cb);
+        }
+    });
+};
+const scheduleImmediate = (cb)=>{
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        setTimeout(cb, 0);
+    } else {
+        setImmediate(cb);
+    }
+};
+function atLeastOneTask() {
+    return new Promise((resolve)=>scheduleImmediate(resolve));
+}
+function waitAtLeastOneReactRenderTask() {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        return new Promise((r)=>setTimeout(r, 0));
+    } else {
+        return new Promise((r)=>setImmediate(r));
+    }
+}
+
+//# sourceMappingURL=scheduler.js.map

package/dashboard/.next/standalone/node_modules/next/dist/lib/semver-noop.js

@@ -0,0 +1,18 @@
+// DO NOT MODIFY THIS FILE DIRECTLY
+// It's for aliasing the `semver` package to be a noop for the `jsonwebtoken` package.
+// We're trying to minimize the size of the worker bundle.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "satisfies", {
+    enumerable: true,
+    get: function() {
+        return satisfies;
+    }
+});
+function satisfies() {
+    return true;
+}
+
+//# sourceMappingURL=semver-noop.js.map