From 55a4f1fc869e41aca748c63d3018f0448b1606e0 Mon Sep 17 00:00:00 2001 From: pack Date: Sun, 9 Aug 2026 10:37:07 +0000 Subject: first commit --- node_modules/path-to-regexp/LICENSE | 21 ++ node_modules/path-to-regexp/Readme.md | 224 +++++++++++++++ node_modules/path-to-regexp/dist/index.d.ts | 147 ++++++++++ node_modules/path-to-regexp/dist/index.js | 431 ++++++++++++++++++++++++++++ node_modules/path-to-regexp/package.json | 64 +++++ 5 files changed, 887 insertions(+) create mode 100644 node_modules/path-to-regexp/LICENSE create mode 100644 node_modules/path-to-regexp/Readme.md create mode 100644 node_modules/path-to-regexp/dist/index.d.ts create mode 100644 node_modules/path-to-regexp/dist/index.js create mode 100644 node_modules/path-to-regexp/package.json (limited to 'node_modules/path-to-regexp') diff --git a/node_modules/path-to-regexp/LICENSE b/node_modules/path-to-regexp/LICENSE new file mode 100644 index 0000000..983fbe8 --- /dev/null +++ b/node_modules/path-to-regexp/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Blake Embrey (hello@blakeembrey.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. diff --git a/node_modules/path-to-regexp/Readme.md b/node_modules/path-to-regexp/Readme.md new file mode 100644 index 0000000..f33e392 --- /dev/null +++ b/node_modules/path-to-regexp/Readme.md @@ -0,0 +1,224 @@ +# Path-to-RegExp + +> Turn a path string such as `/user/:name` into a regular expression. + +[![NPM version][npm-image]][npm-url] +[![NPM downloads][downloads-image]][downloads-url] +[![Build status][build-image]][build-url] +[![Build coverage][coverage-image]][coverage-url] +[![License][license-image]][license-url] + +## Installation + +``` +npm install path-to-regexp --save +``` + +## Usage + +```js +const { + match, + pathToRegexp, + compile, + parse, + stringify, +} = require("path-to-regexp"); +``` + +### Parameters + +Parameters match arbitrary strings in a path by matching up to the end of the segment, or up to any proceeding tokens. They are defined by prefixing a colon to the parameter name (`:foo`). Parameter names can use any valid JavaScript identifier, or be double quoted to use other characters (`:"param-name"`). + +```js +const fn = match("/:foo/:bar"); + +fn("/test/route"); +//=> { path: '/test/route', params: { foo: 'test', bar: 'route' } } +``` + +### Wildcard + +Wildcard parameters match one or more characters across multiple segments. They are defined the same way as regular parameters, but are prefixed with an asterisk (`*foo`). + +```js +const fn = match("/*splat"); + +fn("/bar/baz"); +//=> { path: '/bar/baz', params: { splat: [ 'bar', 'baz' ] } } +``` + +### Optional + +Braces can be used to define parts of the path that are optional. + +```js +const fn = match("/users{/:id}/delete"); + +fn("/users/delete"); +//=> { path: '/users/delete', params: {} } + +fn("/users/123/delete"); +//=> { path: '/users/123/delete', params: { id: '123' } } +``` + +## Match + +The `match` function returns a function for matching strings against a path: + +- **path** String, `TokenData` object, or array of strings and `TokenData` objects. +- **options** _(optional)_ (Extends [pathToRegexp](#pathToRegexp) options) + - **decode** Function for decoding strings to params, or `false` to disable all processing. (default: `decodeURIComponent`) + +```js +const fn = match("/foo/:bar"); +``` + +**Please note:** `path-to-regexp` is intended for ordered data (e.g. paths, hosts). It can not handle arbitrarily ordered data (e.g. query strings, URL fragments, JSON, etc). + +## PathToRegexp + +The `pathToRegexp` function returns the `regexp` for matching strings against paths, and an array of `keys` for understanding the `RegExp#exec` matches. + +- **path** String, `TokenData` object, or array of strings and `TokenData` objects. +- **options** _(optional)_ (See [parse](#parse) for more options) + - **sensitive** Regexp will be case sensitive. (default: `false`) + - **end** Validate the match reaches the end of the string. (default: `true`) + - **delimiter** The default delimiter for segments, e.g. `[^/]` for `:named` parameters. (default: `'/'`) + - **trailing** Allows optional trailing delimiter to match. (default: `true`) + +```js +const { regexp, keys } = pathToRegexp("/foo/:bar"); + +regexp.exec("/foo/123"); //=> ["/foo/123", "123"] +``` + +## Compile ("Reverse" Path-To-RegExp) + +The `compile` function will return a function for transforming parameters into a valid path: + +- **path** A string or `TokenData` object. +- **options** (See [parse](#parse) for more options) + - **delimiter** The default delimiter for segments, e.g. `[^/]` for `:named` parameters. (default: `'/'`) + - **encode** Function for encoding input strings for output into the path, or `false` to disable entirely. (default: `encodeURIComponent`) + +```js +const toPath = compile("/user/:id"); + +toPath({ id: "name" }); //=> "/user/name" +toPath({ id: "café" }); //=> "/user/caf%C3%A9" + +const toPathRepeated = compile("/*segment"); + +toPathRepeated({ segment: ["foo"] }); //=> "/foo" +toPathRepeated({ segment: ["a", "b", "c"] }); //=> "/a/b/c" + +// When disabling `encode`, you need to make sure inputs are encoded correctly. No arrays are accepted. +const toPathRaw = compile("/user/:id", { encode: false }); + +toPathRaw({ id: "%3A%2F" }); //=> "/user/%3A%2F" +``` + +## Stringify + +Transform a `TokenData` object to a Path-to-RegExp string. + +- **data** A `TokenData` object. + +```js +const data = { + tokens: [ + { type: "text", value: "/" }, + { type: "param", name: "foo" }, + ], +}; + +const path = stringify(data); //=> "/:foo" +``` + +## Developers + +- If you are rewriting paths with match and compile, consider using `encode: false` and `decode: false` to keep raw paths passed around. +- To ensure matches work on paths containing characters usually encoded, such as emoji, consider using [encodeurl](https://github.com/pillarjs/encodeurl) for `encodePath`. + +### Parse + +The `parse` function accepts a string and returns `TokenData`, which can be used with `match` and `compile`. + +- **path** A string. +- **options** _(optional)_ + - **encodePath** A function for encoding input strings. (default: `x => x`, recommended: [`encodeurl`](https://github.com/pillarjs/encodeurl)) + +### Tokens + +`TokenData` has two properties: + +- **tokens** A sequence of tokens, currently of types `text`, `param`, `wildcard`, or `group`. +- **originalPath** The original path used with `parse`, shown in error messages to assist debugging. + +### Custom path + +In some applications you may not be able to use the `path-to-regexp` syntax, but you still want to use this library for `match` and `compile`. For example: + +```js +import { match } from "path-to-regexp"; + +const tokens = [ + { type: "text", value: "/" }, + { type: "param", name: "foo" }, +]; +const originalPath = "/[foo]"; // To help debug error messages. +const path = { tokens, originalPath }; +const fn = match(path); + +fn("/test"); //=> { path: '/test', params: { foo: 'test' } } +``` + +## Errors + +An effort has been made to ensure ambiguous paths from previous releases throw an error. This means you might be seeing an error when things worked before. + +### Missing parameter name + +Parameter names must be provided after `:` or `*`, for example `/*path`. They can be valid JavaScript identifiers (e.g. `:myName`) or JSON strings (`:"my-name"`). + +### Unexpected `?` or `+` + +In past releases, `?`, `*`, and `+` were used to denote optional or repeating parameters. As an alternative, try these: + +- For optional (`?`), use braces: `/file{.:ext}`. +- For one or more (`+`), use a wildcard: `/*path`. +- For zero or more (`*`), use both: `/files{/*path}`. + +### Unexpected `(`, `)`, `[`, `]`, etc. + +Previous versions of Path-to-RegExp used these for RegExp features. This version no longer supports them so they've been reserved to avoid ambiguity. To match these characters literally, escape them with a backslash, e.g. `"\\("`. + +### Unterminated quote + +Parameter names can be wrapped in double quote characters, and this error means you forgot to close the quote character. For example, `:"foo`. + +### Express <= 4.x + +Path-To-RegExp breaks compatibility with Express <= `4.x` in the following ways: + +- The wildcard `*` must have a name and matches the behavior of parameters `:`. +- The optional character `?` is no longer supported, use braces instead: `/:file{.:ext}`. +- Regexp characters are not supported. +- Some characters have been reserved to avoid confusion during upgrade (`()[]?+!`). +- Parameter names now support valid JavaScript identifiers, or quoted like `:"this"`. + +## License + +MIT + +[npm-image]: https://img.shields.io/npm/v/path-to-regexp +[npm-url]: https://npmjs.org/package/path-to-regexp +[downloads-image]: https://img.shields.io/npm/dm/path-to-regexp +[downloads-url]: https://npmjs.org/package/path-to-regexp +[build-image]: https://img.shields.io/github/actions/workflow/status/pillarjs/path-to-regexp/ci.yml?branch=master +[build-url]: https://github.com/pillarjs/path-to-regexp/actions/workflows/ci.yml?query=branch%3Amaster +[coverage-image]: https://img.shields.io/codecov/c/gh/pillarjs/path-to-regexp +[coverage-url]: https://codecov.io/gh/pillarjs/path-to-regexp +[license-image]: http://img.shields.io/npm/l/path-to-regexp.svg?style=flat +[license-url]: LICENSE.md diff --git a/node_modules/path-to-regexp/dist/index.d.ts b/node_modules/path-to-regexp/dist/index.d.ts new file mode 100644 index 0000000..c173a44 --- /dev/null +++ b/node_modules/path-to-regexp/dist/index.d.ts @@ -0,0 +1,147 @@ +/** + * Encode a string into another string. + */ +export type Encode = (value: string) => string; +/** + * Decode a string into another string. + */ +export type Decode = (value: string) => string; +export interface ParseOptions { + /** + * A function for encoding input strings. + */ + encodePath?: Encode; +} +export interface PathToRegexpOptions { + /** + * Matches the path completely without trailing characters. (default: `true`) + */ + end?: boolean; + /** + * Allows optional trailing delimiter to match. (default: `true`) + */ + trailing?: boolean; + /** + * Match will be case sensitive. (default: `false`) + */ + sensitive?: boolean; + /** + * The default delimiter for segments. (default: `'/'`) + */ + delimiter?: string; +} +export interface MatchOptions extends PathToRegexpOptions { + /** + * Function for decoding strings for params, or `false` to disable entirely. (default: `decodeURIComponent`) + */ + decode?: Decode | false; +} +export interface CompileOptions { + /** + * Function for encoding input strings for output into the path, or `false` to disable entirely. (default: `encodeURIComponent`) + */ + encode?: Encode | false; + /** + * The default delimiter for segments. (default: `'/'`) + */ + delimiter?: string; +} +/** + * Plain text. + */ +export interface Text { + type: "text"; + value: string; +} +/** + * A parameter designed to match arbitrary text within a segment. + */ +export interface Parameter { + type: "param"; + name: string; +} +/** + * A wildcard parameter designed to match multiple segments. + */ +export interface Wildcard { + type: "wildcard"; + name: string; +} +/** + * A set of possible tokens to expand when matching. + */ +export interface Group { + type: "group"; + tokens: Token[]; +} +/** + * A token that corresponds with a regexp capture. + */ +export type Key = Parameter | Wildcard; +/** + * A sequence of `path-to-regexp` keys that match capturing groups. + */ +export type Keys = Array; +/** + * A sequence of path match characters. + */ +export type Token = Text | Parameter | Wildcard | Group; +/** + * Tokenized path instance. + */ +export declare class TokenData { + readonly tokens: Token[]; + readonly originalPath?: string | undefined; + constructor(tokens: Token[], originalPath?: string | undefined); +} +/** + * ParseError is thrown when there is an error processing the path. + */ +export declare class PathError extends TypeError { + readonly originalPath: string | undefined; + constructor(message: string, originalPath: string | undefined); +} +/** + * Parse a string for the raw tokens. + */ +export declare function parse(str: string, options?: ParseOptions): TokenData; +/** + * Compile a string to a template function for the path. + */ +export declare function compile

(path: Path, options?: CompileOptions & ParseOptions): (params?: P) => string; +export type ParamData = Partial>; +export type PathFunction

= (data?: P) => string; +/** + * A match result contains data about the path match. + */ +export interface MatchResult

{ + path: string; + params: P; +} +/** + * A match is either `false` (no match) or a match result. + */ +export type Match

= false | MatchResult

; +/** + * The match function takes a string and returns whether it matched the path. + */ +export type MatchFunction

= (path: string) => Match

; +/** + * Supported path types. + */ +export type Path = string | TokenData; +/** + * Transform a path into a match function. + */ +export declare function match

(path: Path | Path[], options?: MatchOptions & ParseOptions): MatchFunction

; +/** + * Transform a path into a regular expression and capture keys. + */ +export declare function pathToRegexp(path: Path | Path[], options?: PathToRegexpOptions & ParseOptions): { + regexp: RegExp; + keys: Keys; +}; +/** + * Stringify token data into a path string. + */ +export declare function stringify(data: TokenData): string; diff --git a/node_modules/path-to-regexp/dist/index.js b/node_modules/path-to-regexp/dist/index.js new file mode 100644 index 0000000..97f36e8 --- /dev/null +++ b/node_modules/path-to-regexp/dist/index.js @@ -0,0 +1,431 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PathError = exports.TokenData = void 0; +exports.parse = parse; +exports.compile = compile; +exports.match = match; +exports.pathToRegexp = pathToRegexp; +exports.stringify = stringify; +const DEFAULT_DELIMITER = "/"; +const NOOP_VALUE = (value) => value; +const ID_START = /^[$_\p{ID_Start}]$/u; +const ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u; +const ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u; +/** + * Escape text for stringify to path. + */ +function escapeText(str) { + return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&"); +} +/** + * Escape a regular expression string. + */ +function escape(str) { + return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&"); +} +/** + * Tokenized path instance. + */ +class TokenData { + constructor(tokens, originalPath) { + this.tokens = tokens; + this.originalPath = originalPath; + } +} +exports.TokenData = TokenData; +/** + * ParseError is thrown when there is an error processing the path. + */ +class PathError extends TypeError { + constructor(message, originalPath) { + let text = message; + if (originalPath) + text += `: ${originalPath}`; + text += `; visit https://git.new/pathToRegexpError for info`; + super(text); + this.originalPath = originalPath; + } +} +exports.PathError = PathError; +/** + * Parse a string for the raw tokens. + */ +function parse(str, options = {}) { + const { encodePath = NOOP_VALUE } = options; + const chars = [...str]; + let index = 0; + function consumeUntil(end) { + const output = []; + let path = ""; + function writePath() { + if (!path) + return; + output.push({ + type: "text", + value: encodePath(path), + }); + path = ""; + } + while (index < chars.length) { + const value = chars[index++]; + if (value === end) { + writePath(); + return output; + } + if (value === "\\") { + if (index === chars.length) { + throw new PathError(`Unexpected end after \\ at index ${index}`, str); + } + path += chars[index++]; + continue; + } + if (value === ":" || value === "*") { + const type = value === ":" ? "param" : "wildcard"; + let name = ""; + if (ID_START.test(chars[index])) { + do { + name += chars[index++]; + } while (ID_CONTINUE.test(chars[index])); + } + else if (chars[index] === '"') { + let quoteStart = index; + while (index < chars.length) { + if (chars[++index] === '"') { + index++; + quoteStart = 0; + break; + } + // Increment over escape characters. + if (chars[index] === "\\") + index++; + name += chars[index]; + } + if (quoteStart) { + throw new PathError(`Unterminated quote at index ${quoteStart}`, str); + } + } + if (!name) { + throw new PathError(`Missing parameter name at index ${index}`, str); + } + writePath(); + output.push({ type, name }); + continue; + } + if (value === "{") { + writePath(); + output.push({ + type: "group", + tokens: consumeUntil("}"), + }); + continue; + } + if (value === "}" || + value === "(" || + value === ")" || + value === "[" || + value === "]" || + value === "+" || + value === "?" || + value === "!") { + throw new PathError(`Unexpected ${value} at index ${index - 1}`, str); + } + path += value; + } + if (end) { + throw new PathError(`Unexpected end at index ${index}, expected ${end}`, str); + } + writePath(); + return output; + } + return new TokenData(consumeUntil(""), str); +} +/** + * Compile a string to a template function for the path. + */ +function compile(path, options = {}) { + const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options; + const data = typeof path === "object" ? path : parse(path, options); + const fn = tokensToFunction(data.tokens, delimiter, encode); + return function path(params = {}) { + const missing = []; + const path = fn(params, missing); + if (missing.length) { + throw new TypeError(`Missing parameters: ${missing.join(", ")}`); + } + return path; + }; +} +function tokensToFunction(tokens, delimiter, encode) { + const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode)); + return (data, missing) => { + let result = ""; + for (const encoder of encoders) { + result += encoder(data, missing); + } + return result; + }; +} +/** + * Convert a single token into a path building function. + */ +function tokenToFunction(token, delimiter, encode) { + if (token.type === "text") + return () => token.value; + if (token.type === "group") { + const fn = tokensToFunction(token.tokens, delimiter, encode); + return (data, missing) => { + const len = missing.length; + const value = fn(data, missing); + if (missing.length === len) + return value; + missing.length = len; // Reset optional group. + return ""; + }; + } + const encodeValue = encode || NOOP_VALUE; + if (token.type === "wildcard" && encode !== false) { + return (data, missing) => { + const value = data[token.name]; + if (value == null) { + missing.push(token.name); + return ""; + } + if (!Array.isArray(value) || value.length === 0) { + throw new TypeError(`Expected "${token.name}" to be a non-empty array`); + } + let result = ""; + for (let i = 0; i < value.length; i++) { + if (typeof value[i] !== "string") { + throw new TypeError(`Expected "${token.name}/${i}" to be a string`); + } + if (i > 0) + result += delimiter; + result += encodeValue(value[i]); + } + return result; + }; + } + return (data, missing) => { + const value = data[token.name]; + if (value == null) { + missing.push(token.name); + return ""; + } + if (typeof value !== "string") { + throw new TypeError(`Expected "${token.name}" to be a string`); + } + return encodeValue(value); + }; +} +/** + * Transform a path into a match function. + */ +function match(path, options = {}) { + const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options; + const { regexp, keys } = pathToRegexp(path, options); + const decoders = keys.map((key) => { + if (decode === false) + return NOOP_VALUE; + if (key.type === "param") + return decode; + return (value) => value.split(delimiter).map(decode); + }); + return function match(input) { + const m = regexp.exec(input); + if (!m) + return false; + const path = m[0]; + const params = Object.create(null); + for (let i = 1; i < m.length; i++) { + if (m[i] === undefined) + continue; + const key = keys[i - 1]; + const decoder = decoders[i - 1]; + params[key.name] = decoder(m[i]); + } + return { path, params }; + }; +} +/** + * Transform a path into a regular expression and capture keys. + */ +function pathToRegexp(path, options = {}) { + const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true, } = options; + const keys = []; + let source = ""; + let combinations = 0; + function process(path) { + if (Array.isArray(path)) { + for (const p of path) + process(p); + return; + } + const data = typeof path === "object" ? path : parse(path, options); + flatten(data.tokens, 0, [], (tokens) => { + if (combinations >= 256) { + throw new PathError("Too many path combinations", data.originalPath); + } + if (combinations > 0) + source += "|"; + source += toRegExpSource(tokens, delimiter, keys, data.originalPath); + combinations++; + }); + } + process(path); + let pattern = `^(?:${source})`; + if (trailing) + pattern += "(?:" + escape(delimiter) + "$)?"; + pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)"; + return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys }; +} +/** + * Generate a flat list of sequence tokens from the given tokens. + */ +function flatten(tokens, index, result, callback) { + while (index < tokens.length) { + const token = tokens[index++]; + if (token.type === "group") { + const len = result.length; + flatten(token.tokens, 0, result, (seq) => flatten(tokens, index, seq, callback)); + result.length = len; + continue; + } + result.push(token); + } + callback(result); +} +/** + * Transform a flat sequence of tokens into a regular expression. + */ +function toRegExpSource(tokens, delimiter, keys, originalPath) { + let result = ""; + let backtrack = ""; + let wildcardBacktrack = ""; + let prevCaptureType = 0; + let hasSegmentCapture = 0; + let index = 0; + function hasInSegment(index, type) { + while (index < tokens.length) { + const token = tokens[index++]; + if (token.type === type) + return true; + if (token.type === "text") { + if (token.value.includes(delimiter)) + break; + } + } + return false; + } + function peekText(index) { + let result = ""; + while (index < tokens.length) { + const token = tokens[index++]; + if (token.type !== "text") + break; + result += token.value; + } + return result; + } + while (index < tokens.length) { + const token = tokens[index++]; + if (token.type === "text") { + result += escape(token.value); + backtrack += token.value; + if (prevCaptureType === 2) + wildcardBacktrack += token.value; + if (token.value.includes(delimiter)) + hasSegmentCapture = 0; + continue; + } + if (token.type === "param" || token.type === "wildcard") { + if (prevCaptureType && !backtrack) { + throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath); + } + if (token.type === "param") { + result += + hasSegmentCapture & 2 // Seen wildcard in segment. + ? `(${negate(delimiter, backtrack)}+)` + : hasInSegment(index, "wildcard") // See wildcard later in segment. + ? `(${negate(delimiter, peekText(index))}+)` + : hasSegmentCapture & 1 // Seen parameter in segment. + ? `(${negate(delimiter, backtrack)}+|${escape(backtrack)})` + : `(${negate(delimiter, "")}+)`; + hasSegmentCapture |= prevCaptureType = 1; + } + else { + result += + hasSegmentCapture & 2 // Seen wildcard in segment. + ? `(${negate(backtrack, "")}+)` + : wildcardBacktrack // No capture in segment, seen wildcard in path. + ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)` + : `([^]+)`; + wildcardBacktrack = ""; + hasSegmentCapture |= prevCaptureType = 2; + } + keys.push(token); + backtrack = ""; + continue; + } + throw new TypeError(`Unknown token type: ${token.type}`); + } + return result; +} +/** + * Block backtracking on previous text/delimiter. + */ +function negate(a, b) { + if (b.length > a.length) + return negate(b, a); // Longest string first. + if (a === b) + b = ""; // Cleaner regex strings, no duplication. + if (b.length > 1) + return `(?:(?!${escape(a)}|${escape(b)})[^])`; + if (a.length > 1) + return `(?:(?!${escape(a)})[^${escape(b)}])`; + return `[^${escape(a + b)}]`; +} +/** + * Stringify an array of tokens into a path string. + */ +function stringifyTokens(tokens, index) { + let value = ""; + while (index < tokens.length) { + const token = tokens[index++]; + if (token.type === "text") { + value += escapeText(token.value); + continue; + } + if (token.type === "group") { + value += "{" + stringifyTokens(token.tokens, 0) + "}"; + continue; + } + if (token.type === "param") { + value += ":" + stringifyName(token.name, tokens[index]); + continue; + } + if (token.type === "wildcard") { + value += "*" + stringifyName(token.name, tokens[index]); + continue; + } + throw new TypeError(`Unknown token type: ${token.type}`); + } + return value; +} +/** + * Stringify token data into a path string. + */ +function stringify(data) { + return stringifyTokens(data.tokens, 0); +} +/** + * Stringify a parameter name, escaping when it cannot be emitted directly. + */ +function stringifyName(name, next) { + if (!ID.test(name)) + return JSON.stringify(name); + if ((next === null || next === void 0 ? void 0 : next.type) === "text" && ID_CONTINUE.test(next.value[0])) { + return JSON.stringify(name); + } + return name; +} +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/node_modules/path-to-regexp/package.json b/node_modules/path-to-regexp/package.json new file mode 100644 index 0000000..44ca91d --- /dev/null +++ b/node_modules/path-to-regexp/package.json @@ -0,0 +1,64 @@ +{ + "name": "path-to-regexp", + "version": "8.4.2", + "description": "Express style path to RegExp utility", + "keywords": [ + "express", + "regexp", + "route", + "routing" + ], + "repository": { + "type": "git", + "url": "https://github.com/pillarjs/path-to-regexp.git" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + }, + "license": "MIT", + "exports": "./dist/index.js", + "main": "dist/index.js", + "typings": "dist/index.d.ts", + "files": [ + "dist/" + ], + "scripts": { + "bench": "vitest bench", + "build": "ts-scripts build", + "format": "ts-scripts format", + "lint": "ts-scripts lint", + "prepare": "ts-scripts install && npm run build", + "size": "size-limit", + "specs": "ts-scripts specs", + "test": "ts-scripts test && npm run size" + }, + "devDependencies": { + "@borderless/ts-scripts": "^0.15.0", + "@size-limit/preset-small-lib": "^11.1.2", + "@types/node": "^22.7.2", + "@types/semver": "^7.3.1", + "@vitest/coverage-v8": "^3.0.5", + "recheck": "^4.5.0", + "size-limit": "^11.1.2", + "typescript": "^5.7.3", + "vitest": "^3.0.5" + }, + "publishConfig": { + "access": "public" + }, + "size-limit": [ + { + "path": "dist/index.js", + "limit": "2 kB" + } + ], + "ts-scripts": { + "dist": [ + "dist" + ], + "project": [ + "tsconfig.build.json" + ] + } +} -- cgit v1.2.3