@fusionkit/cli 0.1.1 → 0.1.3

package/scope/node_modules/next/dist/lib/picocolors.js

@@ -0,0 +1,177 @@
+// ISC License
+// Copyright (c) 2021 Alexey Raspopov, Kostiantyn Denysov, Anton Verinov
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+//
+// https://github.com/alexeyraspopov/picocolors/blob/b6261487e7b81aaab2440e397a356732cad9e342/picocolors.js#L1
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    bgBlack: null,
+    bgBlue: null,
+    bgCyan: null,
+    bgGreen: null,
+    bgMagenta: null,
+    bgRed: null,
+    bgWhite: null,
+    bgYellow: null,
+    black: null,
+    blue: null,
+    bold: null,
+    cyan: null,
+    dim: null,
+    gray: null,
+    green: null,
+    hidden: null,
+    inverse: null,
+    italic: null,
+    magenta: null,
+    purple: null,
+    red: null,
+    reset: null,
+    strikethrough: null,
+    underline: null,
+    white: null,
+    yellow: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    bgBlack: function() {
+        return bgBlack;
+    },
+    bgBlue: function() {
+        return bgBlue;
+    },
+    bgCyan: function() {
+        return bgCyan;
+    },
+    bgGreen: function() {
+        return bgGreen;
+    },
+    bgMagenta: function() {
+        return bgMagenta;
+    },
+    bgRed: function() {
+        return bgRed;
+    },
+    bgWhite: function() {
+        return bgWhite;
+    },
+    bgYellow: function() {
+        return bgYellow;
+    },
+    black: function() {
+        return black;
+    },
+    blue: function() {
+        return blue;
+    },
+    bold: function() {
+        return bold;
+    },
+    cyan: function() {
+        return cyan;
+    },
+    dim: function() {
+        return dim;
+    },
+    gray: function() {
+        return gray;
+    },
+    green: function() {
+        return green;
+    },
+    hidden: function() {
+        return hidden;
+    },
+    inverse: function() {
+        return inverse;
+    },
+    italic: function() {
+        return italic;
+    },
+    magenta: function() {
+        return magenta;
+    },
+    purple: function() {
+        return purple;
+    },
+    red: function() {
+        return red;
+    },
+    reset: function() {
+        return reset;
+    },
+    strikethrough: function() {
+        return strikethrough;
+    },
+    underline: function() {
+        return underline;
+    },
+    white: function() {
+        return white;
+    },
+    yellow: function() {
+        return yellow;
+    }
+});
+var _globalThis;
+const { env, stdout } = ((_globalThis = globalThis) == null ? void 0 : _globalThis.process) ?? {};
+const enabled = env && !env.NO_COLOR && (env.FORCE_COLOR || (stdout == null ? void 0 : stdout.isTTY) && !env.CI && env.TERM !== 'dumb');
+const replaceClose = (str, close, replace, index)=>{
+    const start = str.substring(0, index) + replace;
+    const end = str.substring(index + close.length);
+    const nextIndex = end.indexOf(close);
+    return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
+};
+const formatter = (open, close, replace = open)=>{
+    if (!enabled) return String;
+    return (input)=>{
+        const string = '' + input;
+        const index = string.indexOf(close, open.length);
+        return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+};
+const reset = enabled ? (s)=>`\x1b[0m${s}\x1b[0m` : String;
+const bold = formatter('\x1b[1m', '\x1b[22m', '\x1b[22m\x1b[1m');
+const dim = formatter('\x1b[2m', '\x1b[22m', '\x1b[22m\x1b[2m');
+const italic = formatter('\x1b[3m', '\x1b[23m');
+const underline = formatter('\x1b[4m', '\x1b[24m');
+const inverse = formatter('\x1b[7m', '\x1b[27m');
+const hidden = formatter('\x1b[8m', '\x1b[28m');
+const strikethrough = formatter('\x1b[9m', '\x1b[29m');
+const black = formatter('\x1b[30m', '\x1b[39m');
+const red = formatter('\x1b[31m', '\x1b[39m');
+const green = formatter('\x1b[32m', '\x1b[39m');
+const yellow = formatter('\x1b[33m', '\x1b[39m');
+const blue = formatter('\x1b[34m', '\x1b[39m');
+const magenta = formatter('\x1b[35m', '\x1b[39m');
+const purple = formatter('\x1b[38;2;173;127;168m', '\x1b[39m');
+const cyan = formatter('\x1b[36m', '\x1b[39m');
+const white = formatter('\x1b[37m', '\x1b[39m');
+const gray = formatter('\x1b[90m', '\x1b[39m');
+const bgBlack = formatter('\x1b[40m', '\x1b[49m');
+const bgRed = formatter('\x1b[41m', '\x1b[49m');
+const bgGreen = formatter('\x1b[42m', '\x1b[49m');
+const bgYellow = formatter('\x1b[43m', '\x1b[49m');
+const bgBlue = formatter('\x1b[44m', '\x1b[49m');
+const bgMagenta = formatter('\x1b[45m', '\x1b[49m');
+const bgCyan = formatter('\x1b[46m', '\x1b[49m');
+const bgWhite = formatter('\x1b[47m', '\x1b[49m');
+
+//# sourceMappingURL=picocolors.js.map

package/scope/node_modules/next/dist/lib/pretty-bytes.js

@@ -0,0 +1,74 @@
+/*
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return prettyBytes;
+    }
+});
+const UNITS = [
+    'B',
+    'kB',
+    'MB',
+    'GB',
+    'TB',
+    'PB',
+    'EB',
+    'ZB',
+    'YB'
+];
+/*
+Formats the given number using `Number#toLocaleString`.
+- If locale is a string, the value is expected to be a locale-key (for example: `de`).
+- If locale is true, the system default locale is used for translation.
+- If no value for locale is specified, the number is returned unmodified.
+*/ const toLocaleString = (number, locale)=>{
+    let result = number;
+    if (typeof locale === 'string') {
+        result = number.toLocaleString(locale);
+    } else if (locale === true) {
+        result = number.toLocaleString();
+    }
+    return result;
+};
+function prettyBytes(number, options) {
+    if (!Number.isFinite(number)) {
+        throw Object.defineProperty(new TypeError(`Expected a finite number, got ${typeof number}: ${number}`), "__NEXT_ERROR_CODE", {
+            value: "E572",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    options = Object.assign({}, options);
+    if (options.signed && number === 0) {
+        return ' 0 B';
+    }
+    const isNegative = number < 0;
+    const prefix = isNegative ? '-' : options.signed ? '+' : '';
+    if (isNegative) {
+        number = -number;
+    }
+    if (number < 1) {
+        const numberString = toLocaleString(number, options.locale);
+        return prefix + numberString + ' B';
+    }
+    const exponent = Math.min(Math.floor(Math.log10(number) / 3), UNITS.length - 1);
+    number = Number((number / Math.pow(1000, exponent)).toPrecision(3));
+    const numberString = toLocaleString(number, options.locale);
+    const unit = UNITS[exponent];
+    return prefix + numberString + ' ' + unit;
+}
+
+//# sourceMappingURL=pretty-bytes.js.map

package/scope/node_modules/next/dist/lib/realpath.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "realpathSync", {
+    enumerable: true,
+    get: function() {
+        return realpathSync;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const isWindows = process.platform === 'win32';
+const realpathSync = isWindows ? _fs.default.realpathSync : _fs.default.realpathSync.native;
+
+//# sourceMappingURL=realpath.js.map

package/scope/node_modules/next/dist/lib/recursive-delete.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "recursiveDelete", {
+    enumerable: true,
+    get: function() {
+        return recursiveDelete;
+    }
+});
+const _fs = require("fs");
+const _path = require("path");
+const _iserror = /*#__PURE__*/ _interop_require_default(require("./is-error"));
+const _wait = require("./wait");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const unlinkPath = async (p, isDir = false, t = 1)=>{
+    try {
+        if (isDir) {
+            await _fs.promises.rmdir(p);
+        } else {
+            await _fs.promises.unlink(p);
+        }
+    } catch (e) {
+        const code = (0, _iserror.default)(e) && e.code;
+        if ((code === 'EBUSY' || code === 'ENOTEMPTY' || code === 'EPERM' || code === 'EMFILE') && t < 3) {
+            await (0, _wait.wait)(t * 100);
+            return unlinkPath(p, isDir, t++);
+        }
+        if (code === 'ENOENT') {
+            return;
+        }
+        throw e;
+    }
+};
+async function recursiveDelete(/** Directory to delete the contents of */ dir, /** Exclude based on relative file path */ exclude, /** Ensures that parameter dir exists, this is not passed recursively */ previousPath = '') {
+    let result;
+    try {
+        result = await _fs.promises.readdir(dir, {
+            withFileTypes: true
+        });
+    } catch (e) {
+        if ((0, _iserror.default)(e) && e.code === 'ENOENT') {
+            return;
+        }
+        throw e;
+    }
+    await Promise.all(result.map(async (part)=>{
+        const absolutePath = (0, _path.join)(dir, part.name);
+        // readdir does not follow symbolic links
+        // if part is a symbolic link, follow it using stat
+        let isDirectory = part.isDirectory();
+        const isSymlink = part.isSymbolicLink();
+        if (isSymlink) {
+            const linkPath = await _fs.promises.readlink(absolutePath);
+            try {
+                const stats = await _fs.promises.stat((0, _path.isAbsolute)(linkPath) ? linkPath : (0, _path.join)((0, _path.dirname)(absolutePath), linkPath));
+                isDirectory = stats.isDirectory();
+            } catch  {}
+        }
+        const pp = (0, _path.join)(previousPath, part.name);
+        const isNotExcluded = !exclude || !exclude.test(pp);
+        if (isNotExcluded) {
+            if (!isSymlink && isDirectory) {
+                await recursiveDelete(absolutePath, exclude, pp);
+            }
+            return unlinkPath(absolutePath, !isSymlink && isDirectory);
+        }
+    }));
+}
+
+//# sourceMappingURL=recursive-delete.js.map

package/scope/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/scope/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/scope/node_modules/next/dist/lib/resolve-from.js

@@ -0,0 +1,65 @@
+// 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 Object.defineProperty(new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDirectory}\``), "__NEXT_ERROR_CODE", {
+            value: "E537",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    if (typeof moduleId !== 'string') {
+        throw Object.defineProperty(new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``), "__NEXT_ERROR_CODE", {
+            value: "E565",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    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/scope/node_modules/next/dist/lib/route-pattern-normalizer.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    hasAdjacentParameterIssues: null,
+    normalizeAdjacentParameters: null,
+    normalizeTokensForRegexp: null,
+    stripParameterSeparators: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    hasAdjacentParameterIssues: function() {
+        return hasAdjacentParameterIssues;
+    },
+    normalizeAdjacentParameters: function() {
+        return normalizeAdjacentParameters;
+    },
+    normalizeTokensForRegexp: function() {
+        return normalizeTokensForRegexp;
+    },
+    stripParameterSeparators: function() {
+        return stripParameterSeparators;
+    }
+});
+/**
+ * Route pattern normalization utilities for path-to-regexp compatibility.
+ *
+ * path-to-regexp 6.3.0+ introduced stricter validation that rejects certain
+ * patterns commonly used in Next.js interception routes. This module provides
+ * normalization functions to make Next.js route patterns compatible with the
+ * updated library while preserving all functionality.
+ */ /**
+ * Internal separator used to normalize adjacent parameter patterns.
+ * This unique marker is inserted between adjacent parameters and stripped out
+ * during parameter extraction to avoid conflicts with real URL content.
+ */ 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 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