twh_eastasia/vue-pure-admin
1
0
Fork 0
mirror of https://github.com/pure-admin/vue-pure-admin.git synced 2025-11-21 14:13:36 +08:00
Code Issues Packages Projects Releases Wiki Activity

chore：更换到主分支

Browse Source
This commit is contained in:
张益铭
2021-03-01 15:26:05 +08:00
parent 9064b372e8
commit 6a5f1810f9
3530 changed files with 59613 additions and 479452 deletions
Download Patch File Download Diff File Expand all files Collapse all files

227
node_modules/path-to-regexp/History.md generated vendored
View File

@@ -1,158 +1,171 @@
1.7.0 / 2016-11-08
==================
# Moved to [GitHub Releases](https://github.com/pillarjs/path-to-regexp/releases)
* Allow a `delimiter` option to be passed in with `tokensToRegExp` which will be used for "non-ending" token match situations
## 3.0.0 / 2019-01-13
1.6.0 / 2016-10-03
==================
- Always use prefix character as delimiter token, allowing any character to be a delimiter (e.g. `/:att1-:att2-:att3-:att4-:att5`)
- Remove `partial` support, prefer escaping the prefix delimiter explicitly (e.g. `\\/(apple-)?icon-:res(\\d+).png`)
* Populate `RegExp.keys` when using the `tokensToRegExp` method (making it consistent with the main export)
* Allow a `delimiter` option to be passed in with `parse`
* Updated TypeScript definition with `Keys` and `Options` updated
## 2.4.0 / 2018-08-26
1.5.3 / 2016-06-15
==================
- Support `start` option to disable anchoring from beginning of the string
* Add `\\` to the ignore character group to avoid backtracking on mismatched parens
## 2.3.0 / 2018-08-20
1.5.2 / 2016-06-15
==================
- Use `delimiter` when processing repeated matching groups (e.g. `foo/bar` has no prefix, but has a delimiter)
* Escape `\\` in string segments of regexp
## 2.2.1 / 2018-04-24
1.5.1 / 2016-06-08
==================
- Allow empty string with `end: false` to match both relative and absolute paths
* Add `index.d.ts` to NPM package
## 2.2.0 / 2018-03-06
1.5.0 / 2016-05-20
==================
- Pass `token` as second argument to `encode` option (e.g. `encode(value, token)`)
* Handle partial token segments (better)
* Allow compile to handle asterisk token segments
## 2.1.0 / 2017-10-20
1.4.0 / 2016-05-18
==================
- Handle non-ending paths where the final character is a delimiter
- E.g. `/foo/` before required either `/foo/` or `/foo//` to match in non-ending mode
* Handle RegExp unions in path matching groups
## 2.0.0 / 2017-08-23
1.3.0 / 2016-05-08
==================
- New option! Ability to set `endsWith` to match paths like `/test?query=string` up to the query string
- New option! Set `delimiters` for specific characters to be treated as parameter prefixes (e.g. `/:test`)
- Remove `isarray` dependency
- Explicitly handle trailing delimiters instead of trimming them (e.g. `/test/` is now treated as `/test/` instead of `/test` when matching)
- Remove overloaded `keys` argument that accepted `options`
- Remove `keys` list attached to the `RegExp` output
- Remove asterisk functionality (it's a real pain to properly encode)
- Change `tokensToFunction` (e.g. `compile`) to accept an `encode` function for pretty encoding (e.g. pass your own implementation)
* Clarify README language and named parameter token support
* Support advanced Closure Compiler with type annotations
* Add pretty paths options to compiled function output
* Add TypeScript definition to project
* Improved prefix handling with non-complete segment parameters (E.g. `/:foo?-bar`)
## 1.7.0 / 2016-11-08
1.2.1 / 2015-08-17
==================
- Allow a `delimiter` option to be passed in with `tokensToRegExp` which will be used for "non-ending" token match situations
* Encode values before validation with path compilation function
* More examples of using compilation in README
## 1.6.0 / 2016-10-03
1.2.0 / 2015-05-20
==================
- Populate `RegExp.keys` when using the `tokensToRegExp` method (making it consistent with the main export)
- Allow a `delimiter` option to be passed in with `parse`
- Updated TypeScript definition with `Keys` and `Options` updated
* Add support for matching an asterisk (`*`) as an unnamed match everything group (`(.*)`)
## 1.5.3 / 2016-06-15
1.1.1 / 2015-05-11
==================
- Add `\\` to the ignore character group to avoid backtracking on mismatched parens
* Expose methods for working with path tokens
## 1.5.2 / 2016-06-15
1.1.0 / 2015-05-09
==================
- Escape `\\` in string segments of regexp
* Expose the parser implementation to consumers
* Implement a compiler function to generate valid strings
* Huge refactor of tests to be more DRY and cover new parse and compile functions
* Use chai in tests
* Add .editorconfig
## 1.5.1 / 2016-06-08
1.0.3 / 2015-01-17
==================
- Add `index.d.ts` to NPM package
* Optimised function runtime
* Added `files` to `package.json`
## 1.5.0 / 2016-05-20
1.0.2 / 2014-12-17
==================
- Handle partial token segments (better)
- Allow compile to handle asterisk token segments
* Use `Array.isArray` shim
* Remove ES5 incompatible code
* Fixed repository path
* Added new readme badges
## 1.4.0 / 2016-05-18
1.0.1 / 2014-08-27
==================
- Handle RegExp unions in path matching groups
* Ensure installation works correctly on 0.8
## 1.3.0 / 2016-05-08
1.0.0 / 2014-08-17
==================
- Clarify README language and named parameter token support
- Support advanced Closure Compiler with type annotations
- Add pretty paths options to compiled function output
- Add TypeScript definition to project
- Improved prefix handling with non-complete segment parameters (E.g. `/:foo?-bar`)
* No more API changes
## 1.2.1 / 2015-08-17
0.2.5 / 2014-08-07
==================
- Encode values before validation with path compilation function
- More examples of using compilation in README
* Allow keys parameter to be omitted
## 1.2.0 / 2015-05-20
0.2.4 / 2014-08-02
==================
- Add support for matching an asterisk (`*`) as an unnamed match everything group (`(.*)`)
* Code coverage badge
* Updated readme
* Attach keys to the generated regexp
## 1.1.1 / 2015-05-11
0.2.3 / 2014-07-09
==================
- Expose methods for working with path tokens
* Add MIT license
## 1.1.0 / 2015-05-09
0.2.2 / 2014-07-06
==================
- Expose the parser implementation to consumers
- Implement a compiler function to generate valid strings
- Huge refactor of tests to be more DRY and cover new parse and compile functions
- Use chai in tests
- Add .editorconfig
* A passed in trailing slash in non-strict mode will become optional
* In non-end mode, the optional trailing slash will only match at the end
## 1.0.3 / 2015-01-17
0.2.1 / 2014-06-11
==================
- Optimised function runtime
- Added `files` to `package.json`
* Fixed a major capturing group regexp regression
## 1.0.2 / 2014-12-17
0.2.0 / 2014-06-09
==================
- Use `Array.isArray` shim
- Remove ES5 incompatible code
- Fixed repository path
- Added new readme badges
* Improved support for arrays
* Improved support for regexps
* Better support for non-ending strict mode matches with a trailing slash
* Travis CI support
* Block using regexp special characters in the path
* Removed support for the asterisk to match all
* New support for parameter suffixes - `*`, `+` and `?`
* Updated readme
* Provide delimiter information with keys array
## 1.0.1 / 2014-08-27
0.1.2 / 2014-03-10
==================
- Ensure installation works correctly on 0.8
* Move testing dependencies to `devDependencies`
## 1.0.0 / 2014-08-17
0.1.1 / 2014-03-10
==================
- No more API changes
* Match entire substring with `options.end`
* Properly handle ending and non-ending matches
## 0.2.5 / 2014-08-07
0.1.0 / 2014-03-06
==================
- Allow keys parameter to be omitted
* Add `options.end`
## 0.2.4 / 2014-08-02
0.0.2 / 2013-02-10
==================
- Code coverage badge
- Updated readme
- Attach keys to the generated regexp
* Update to match current express
* Add .license property to component.json
## 0.2.3 / 2014-07-09
- Add MIT license
## 0.2.2 / 2014-07-06
- A passed in trailing slash in non-strict mode will become optional
- In non-end mode, the optional trailing slash will only match at the end
## 0.2.1 / 2014-06-11
- Fixed a major capturing group regexp regression
## 0.2.0 / 2014-06-09
- Improved support for arrays
- Improved support for regexps
- Better support for non-ending strict mode matches with a trailing slash
- Travis CI support
- Block using regexp special characters in the path
- Removed support for the asterisk to match all
- New support for parameter suffixes - `*`, `+` and `?`
- Updated readme
- Provide delimiter information with keys array
## 0.1.2 / 2014-03-10
- Move testing dependencies to `devDependencies`
## 0.1.1 / 2014-03-10
- Match entire substring with `options.end`
- Properly handle ending and non-ending matches
## 0.1.0 / 2014-03-06
- Add `options.end`
## 0.0.2 / 2013-02-10
- Update to match current express
- Add .license property to component.json

304
node_modules/path-to-regexp/Readme.md generated vendored
View File

@@ -1,6 +1,6 @@
# Path-to-RegExp
> Turn an Express-style path string such as `/user/:name` into a regular expression.
> Turn a path string such as `/user/:name` into a regular expression.
[![NPM version][npm-image]][npm-url]
[![Build status][travis-image]][travis-url]
@@ -18,222 +18,300 @@ npm install path-to-regexp --save
## Usage
```javascript
var pathToRegexp = require('path-to-regexp')
const { pathToRegexp, match, parse, compile } = require("path-to-regexp");
// pathToRegexp(path, keys, options)
// pathToRegexp.parse(path)
// pathToRegexp.compile(path)
// pathToRegexp(path, keys?, options?)
// match(path)
// parse(path)
// compile(path)
```
- **path** An Express-style string, an array of strings, or a regular expression.
- **keys** An array to be populated with the keys found in the path.
- **path** A string, array of strings, or a regular expression.
- **keys** An array to populate with keys found in the path.
- **options**
- **sensitive** When `true` the route will be case sensitive. (default: `false`)
- **strict** When `false` the trailing slash is optional. (default: `false`)
- **end** When `false` the path will match at the beginning. (default: `true`)
- **delimiter** Set the default delimiter for repeat parameters. (default: `'/'`)
- **sensitive** When `true` the regexp will be case sensitive. (default: `false`)
- **strict** When `true` the regexp won't allow an optional trailing delimiter to match. (default: `false`)
- **end** When `true` the regexp will match to the end of the string. (default: `true`)
- **start** When `true` the regexp will match from the beginning of the string. (default: `true`)
- **delimiter** The default delimiter for segments, e.g. `[^/#?]` for `:named` patterns. (default: `'/#?'`)
- **endsWith** Optional character, or list of characters, to treat as "end" characters.
- **encode** A function to encode strings before inserting into `RegExp`. (default: `x => x`)
- **prefixes** List of characters to automatically consider prefixes when parsing. (default: `./`)
```javascript
var keys = []
var re = pathToRegexp('/foo/:bar', keys)
// re = /^\/foo\/([^\/]+?)\/?$/i
// keys = [{ name: 'bar', prefix: '/', delimiter: '/', optional: false, repeat: false, pattern: '[^\\/]+?' }]
const keys = [];
const regexp = pathToRegexp("/foo/:bar", keys);
// regexp = /^\/foo(?:\/([^\/#\?]+?))[\/#\?]?$/i
// keys = [{ name: 'bar', prefix: '/', suffix: '', pattern: '[^\\/#\\?]+?', modifier: '' }]
```
**Please note:** The `RegExp` returned by `path-to-regexp` is intended for use with pathnames or hostnames. It can not handle the query strings or fragments of a URL.
**Please note:** The `RegExp` returned by `path-to-regexp` is intended for ordered data (e.g. pathnames, hostnames). It can not handle arbitrarily ordered data (e.g. query strings, URL fragments, JSON, etc). When using paths that contain query strings, you need to escape the question mark (`?`) to ensure it does not flag the parameter as [optional](#optional).
### Parameters
The path string can be used to define parameters and populate the keys.
The path argument is used to define parameters and populate keys.
#### Named Parameters
Named parameters are defined by prefixing a colon to the parameter name (`:foo`). By default, the parameter will match until the following path segment.
Named parameters are defined by prefixing a colon to the parameter name (`:foo`).
```js
var re = pathToRegexp('/:foo/:bar', keys)
const regexp = pathToRegexp("/:foo/:bar");
// keys = [{ name: 'foo', prefix: '/', ... }, { name: 'bar', prefix: '/', ... }]
re.exec('/test/route')
//=> ['/test/route', 'test', 'route']
regexp.exec("/test/route");
//=> [ '/test/route', 'test', 'route', index: 0, input: '/test/route', groups: undefined ]
```
**Please note:** Named parameters must be made up of "word characters" (`[A-Za-z0-9_]`).
**Please note:** Parameter names must use "word characters" (`[A-Za-z0-9_]`).
##### Custom Matching Parameters
Parameters can have a custom regexp, which overrides the default match (`[^/]+`). For example, you can match digits or names in a path:
```js
var re = pathToRegexp('/(apple-)?icon-:res(\\d+).png', keys)
// keys = [{ name: 0, prefix: '/', ... }, { name: 'res', prefix: '', ... }]
const regexpNumbers = pathToRegexp("/icon-:foo(\\d+).png");
// keys = [{ name: 'foo', ... }]
re.exec('/icon-76.png')
//=> ['/icon-76.png', undefined, '76']
regexpNumbers.exec("/icon-123.png");
//=> ['/icon-123.png', '123']
regexpNumbers.exec("/icon-abc.png");
//=> null
const regexpWord = pathToRegexp("/(user|u)");
// keys = [{ name: 0, ... }]
regexpWord.exec("/u");
//=> ['/u', 'u']
regexpWord.exec("/users");
//=> null
```
#### Modified Parameters
**Tip:** Backslashes need to be escaped with another backslash in JavaScript strings.
##### Custom Prefix and Suffix
Parameters can be wrapped in `{}` to create custom prefixes or suffixes for your segment:
```js
const regexp = pathToRegexp("/:attr1?{-:attr2}?{-:attr3}?");
regexp.exec("/test");
// => ['/test', 'test', undefined, undefined]
regexp.exec("/test-test");
// => ['/test', 'test', 'test', undefined]
```
#### Unnamed Parameters
It is possible to write an unnamed parameter that only consists of a regexp. It works the same the named parameter, except it will be numerically indexed:
```js
const regexp = pathToRegexp("/:foo/(.*)");
// keys = [{ name: 'foo', ... }, { name: 0, ... }]
regexp.exec("/test/route");
//=> [ '/test/route', 'test', 'route', index: 0, input: '/test/route', groups: undefined ]
```
#### Modifiers
Modifiers must be placed after the parameter (e.g. `/:foo?`, `/(test)?`, `/:foo(test)?`, or `{-:foo(test)}?`).
##### Optional
Parameters can be suffixed with a question mark (`?`) to make the parameter optional. This will also make the prefix optional.
Parameters can be suffixed with a question mark (`?`) to make the parameter optional.
```js
var re = pathToRegexp('/:foo/:bar?', keys)
// keys = [{ name: 'foo', ... }, { name: 'bar', delimiter: '/', optional: true, repeat: false }]
const regexp = pathToRegexp("/:foo/:bar?");
// keys = [{ name: 'foo', ... }, { name: 'bar', prefix: '/', modifier: '?' }]
re.exec('/test')
//=> ['/test', 'test', undefined]
regexp.exec("/test");
//=> [ '/test', 'test', undefined, index: 0, input: '/test', groups: undefined ]
re.exec('/test/route')
//=> ['/test', 'test', 'route']
regexp.exec("/test/route");
//=> [ '/test/route', 'test', 'route', index: 0, input: '/test/route', groups: undefined ]
```
**Tip:** The prefix is also optional, escape the prefix `\/` to make it required.
When dealing with query strings, escape the question mark (`?`) so it doesn't mark the parameter as optional. Handling unordered data is outside the scope of this library.
```js
const regexp = pathToRegexp("/search/:tableName\\?useIndex=true&term=amazing");
regexp.exec("/search/people?useIndex=true&term=amazing");
//=> [ '/search/people?useIndex=true&term=amazing', 'people', index: 0, input: '/search/people?useIndex=true&term=amazing', groups: undefined ]
// This library does not handle query strings in different orders
regexp.exec("/search/people?term=amazing&useIndex=true");
//=> null
```
##### Zero or more
Parameters can be suffixed with an asterisk (`*`) to denote a zero or more parameter matches. The prefix is taken into account for each match.
Parameters can be suffixed with an asterisk (`*`) to denote a zero or more parameter matches.
```js
var re = pathToRegexp('/:foo*', keys)
// keys = [{ name: 'foo', delimiter: '/', optional: true, repeat: true }]
const regexp = pathToRegexp("/:foo*");
// keys = [{ name: 'foo', prefix: '/', modifier: '*' }]
re.exec('/')
//=> ['/', undefined]
regexp.exec("/");
//=> [ '/', undefined, index: 0, input: '/', groups: undefined ]
re.exec('/bar/baz')
//=> ['/bar/baz', 'bar/baz']
regexp.exec("/bar/baz");
//=> [ '/bar/baz', 'bar/baz', index: 0, input: '/bar/baz', groups: undefined ]
```
##### One or more
Parameters can be suffixed with a plus sign (`+`) to denote a one or more parameter matches. The prefix is taken into account for each match.
Parameters can be suffixed with a plus sign (`+`) to denote a one or more parameter matches.
```js
var re = pathToRegexp('/:foo+', keys)
// keys = [{ name: 'foo', delimiter: '/', optional: false, repeat: true }]
const regexp = pathToRegexp("/:foo+");
// keys = [{ name: 'foo', prefix: '/', modifier: '+' }]
re.exec('/')
regexp.exec("/");
//=> null
re.exec('/bar/baz')
//=> ['/bar/baz', 'bar/baz']
regexp.exec("/bar/baz");
//=> [ '/bar/baz','bar/baz', index: 0, input: '/bar/baz', groups: undefined ]
```
#### Custom Match Parameters
### Match
All parameters can be provided a custom regexp, which overrides the default (`[^\/]+`).
The `match` function will return a function for transforming paths into parameters:
```js
var re = pathToRegexp('/:foo(\\d+)', keys)
// keys = [{ name: 'foo', ... }]
// Make sure you consistently `decode` segments.
const match = match("/user/:id", { decode: decodeURIComponent });
re.exec('/123')
//=> ['/123', '123']
re.exec('/abc')
//=> null
match("/user/123"); //=> { path: '/user/123', index: 0, params: { id: '123' } }
match("/invalid"); //=> false
match("/user/caf%C3%A9"); //=> { path: '/user/caf%C3%A9', index: 0, params: { id: 'café' } }
```
**Please note:** Backslashes need to be escaped with another backslash in strings.
#### Process Pathname
#### Unnamed Parameters
It is possible to write an unnamed parameter that only consists of a matching group. It works the same as a named parameter, except it will be numerically indexed.
You should make sure variations of the same path match the expected `path`. Here's one possible solution using `encode`:
```js
var re = pathToRegexp('/:foo/(.*)', keys)
// keys = [{ name: 'foo', ... }, { name: 0, ... }]
const match = match("/café", { encode: encodeURI, decode: decodeURIComponent });
re.exec('/test/route')
//=> ['/test/route', 'test', 'route']
match("/user/caf%C3%A9"); //=> { path: '/user/caf%C3%A9', index: 0, params: { id: 'café' } }
```
#### Asterisk
**Note:** [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) automatically encodes pathnames for you.
An asterisk can be used for matching everything. It is equivalent to an unnamed matching group of `(.*)`.
##### Alternative Using Normalize
Sometimes you won't have an already normalized pathname. You can normalize it yourself before processing:
```js
var re = pathToRegexp('/foo/*', keys)
// keys = [{ name: '0', ... }]
/**
* Normalize a pathname for matching, replaces multiple slashes with a single
* slash and normalizes unicode characters to "NFC". When using this method,
* `decode` should be an identity function so you don't decode strings twice.
*/
function normalizePathname(pathname: string) {
return (
decodeURI(pathname)
// Replaces repeated slashes in the URL.
.replace(/\/+/g, "/")
// Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize
// Note: Missing native IE support, may want to skip this step.
.normalize()
);
}
re.exec('/foo/bar/baz')
//=> ['/foo/bar/baz', 'bar/baz']
// Two possible ways of writing `/café`:
const re = pathToRegexp("/caf\u00E9");
const input = encodeURI("/cafe\u0301");
re.test(input); //=> false
re.test(normalizePathname(input)); //=> true
```
### Parse
The parse function is exposed via `pathToRegexp.parse`. This will return an array of strings and keys.
The `parse` function will return a list of strings and keys from a path string:
```js
var tokens = pathToRegexp.parse('/route/:foo/(.*)')
const tokens = parse("/route/:foo/(.*)");
console.log(tokens[0])
console.log(tokens[0]);
//=> "/route"
console.log(tokens[1])
//=> { name: 'foo', prefix: '/', delimiter: '/', optional: false, repeat: false, pattern: '[^\\/]+?' }
console.log(tokens[1]);
//=> { name: 'foo', prefix: '/', suffix: '', pattern: '[^\\/#\\?]+?', modifier: '' }
console.log(tokens[2])
//=> { name: 0, prefix: '/', delimiter: '/', optional: false, repeat: false, pattern: '.*' }
console.log(tokens[2]);
//=> { name: 0, prefix: '/', suffix: '', pattern: '.*', modifier: '' }
```
**Note:** This method only works with Express-style strings.
**Note:** This method only works with strings.
### Compile ("Reverse" Path-To-RegExp)
Path-To-RegExp exposes a compile function for transforming an Express-style path into a valid path.
The `compile` function will return a function for transforming parameters into a valid path:
```js
var toPath = pathToRegexp.compile('/user/:id')
// Make sure you encode your path segments consistently.
const toPath = compile("/user/:id", { encode: encodeURIComponent });
toPath({ id: 123 }) //=> "/user/123"
toPath({ id: 'café' }) //=> "/user/caf%C3%A9"
toPath({ id: '/' }) //=> "/user/%2F"
toPath({ id: 123 }); //=> "/user/123"
toPath({ id: "café" }); //=> "/user/caf%C3%A9"
toPath({ id: "/" }); //=> "/user/%2F"
toPath({ id: ':' }) //=> "/user/%3A"
toPath({ id: ':' }, { pretty: true }) //=> "/user/:"
toPath({ id: ":/" }); //=> "/user/%3A%2F"
var toPathRepeated = pathToRegexp.compile('/:segment+')
// Without `encode`, you need to make sure inputs are encoded correctly.
const toPathRaw = compile("/user/:id");
toPathRepeated({ segment: 'foo' }) //=> "/foo"
toPathRepeated({ segment: ['a', 'b', 'c'] }) //=> "/a/b/c"
toPathRaw({ id: "%3A%2F" }); //=> "/user/%3A%2F"
toPathRaw({ id: ":/" }, { validate: false }); //=> "/user/:/"
var toPathRegexp = pathToRegexp.compile('/user/:id(\\d+)')
const toPathRepeated = compile("/:segment+");
toPathRegexp({ id: 123 }) //=> "/user/123"
toPathRegexp({ id: '123' }) //=> "/user/123"
toPathRegexp({ id: 'abc' }) //=> Throws `TypeError`.
toPathRepeated({ segment: "foo" }); //=> "/foo"
toPathRepeated({ segment: ["a", "b", "c"] }); //=> "/a/b/c"
const toPathRegexp = compile("/user/:id(\\d+)");
toPathRegexp({ id: 123 }); //=> "/user/123"
toPathRegexp({ id: "123" }); //=> "/user/123"
toPathRegexp({ id: "abc" }); //=> Throws `TypeError`.
toPathRegexp({ id: "abc" }, { validate: false }); //=> "/user/abc"
```
**Note:** The generated function will throw on invalid input. It will do all necessary checks to ensure the generated path is valid. This method only works with strings.
**Note:** The generated function will throw on invalid input.
### Working with Tokens
Path-To-RegExp exposes the two functions used internally that accept an array of tokens.
Path-To-RegExp exposes the two functions used internally that accept an array of tokens:
* `pathToRegexp.tokensToRegExp(tokens, options)` Transform an array of tokens into a matching regular expression.
* `pathToRegexp.tokensToFunction(tokens)` Transform an array of tokens into a path generator function.
- `tokensToRegexp(tokens, keys?, options?)` Transform an array of tokens into a matching regular expression.
- `tokensToFunction(tokens)` Transform an array of tokens into a path generator function.
#### Token Information
* `name` The name of the token (`string` for named or `number` for index)
* `prefix` The prefix character for the segment (`/` or `.`)
* `delimiter` The delimiter for the segment (same as prefix or `/`)
* `optional` Indicates the token is optional (`boolean`)
* `repeat` Indicates the token is repeated (`boolean`)
* `partial` Indicates this token is a partial path segment (`boolean`)
* `pattern` The RegExp used to match this token (`string`)
* `asterisk` Indicates the token is an `*` match (`boolean`)
- `name` The name of the token (`string` for named or `number` for unnamed index)
- `prefix` The prefix string for the segment (e.g. `"/"`)
- `suffix` The suffix string for the segment (e.g. `""`)
- `pattern` The RegExp used to match this token (`string`)
- `modifier` The modifier character used for the segment (e.g. `?`)
## Compatibility with Express <= 4.x
Path-To-RegExp breaks compatibility with Express <= `4.x`:
* No longer a direct conversion to a RegExp with sugar on top - it's a path matcher with named and unnamed matching groups
* It's unlikely you previously abused this feature, it's rare and you could always use a RegExp instead
* All matching RegExp special characters can be used in a matching group. E.g. `/:user(.*)`
* Other RegExp features are not support - no nested matching groups, non-capturing groups or look aheads
* Parameters have suffixes that augment meaning - `*`, `+` and `?`. E.g. `/:user*`
## TypeScript
Includes a [`.d.ts`](index.d.ts) file for TypeScript users.
- RegExp special characters can only be used in a parameter
- Express.js 4.x supported `RegExp` special characters regardless of position - this is considered a bug
- Parameters have suffixes that augment meaning - `*`, `+` and `?`. E.g. `/:user*`
- No wildcard asterisk (`*`) - use parameters instead (`(.*)` or `:splat*`)
## Live Demo

84
node_modules/path-to-regexp/index.d.ts generated vendored
View File

@@ -1,84 +0,0 @@
declare function pathToRegexp (path: pathToRegexp.Path, options?: pathToRegexp.RegExpOptions & pathToRegexp.ParseOptions): pathToRegexp.PathRegExp;
declare function pathToRegexp (path: pathToRegexp.Path, keys?: pathToRegexp.Key[], options?: pathToRegexp.RegExpOptions & pathToRegexp.ParseOptions): pathToRegexp.PathRegExp;
declare namespace pathToRegexp {
export interface PathRegExp extends RegExp {
// An array to be populated with the keys found in the path.
keys: Key[];
}
export interface RegExpOptions {
/**
* When `true` the route will be case sensitive. (default: `false`)
*/
sensitive?: boolean;
/**
* When `false` the trailing slash is optional. (default: `false`)
*/
strict?: boolean;
/**
* When `false` the path will match at the beginning. (default: `true`)
*/
end?: boolean;
/**
* Sets the final character for non-ending optimistic matches. (default: `/`)
*/
delimiter?: string;
}
export interface ParseOptions {
/**
* Set the default delimiter for repeat parameters. (default: `'/'`)
*/
delimiter?: string;
}
export interface TokensToFunctionOptions {
/**
* When `true` the regexp will be case sensitive. (default: `false`)
*/
sensitive?: boolean;
}
/**
* Parse an Express-style path into an array of tokens.
*/
export function parse (path: string, options?: ParseOptions): Token[];
/**
* Transforming an Express-style path into a valid path.
*/
export function compile (path: string, options?: ParseOptions & TokensToFunctionOptions): PathFunction;
/**
* Transform an array of tokens into a path generator function.
*/
export function tokensToFunction (tokens: Token[], options?: TokensToFunctionOptions): PathFunction;
/**
* Transform an array of tokens into a matching regular expression.
*/
export function tokensToRegExp (tokens: Token[], options?: RegExpOptions): PathRegExp;
export function tokensToRegExp (tokens: Token[], keys?: Key[], options?: RegExpOptions): PathRegExp;
export interface Key {
name: string | number;
prefix: string;
delimiter: string;
optional: boolean;
repeat: boolean;
pattern: string;
partial: boolean;
asterisk: boolean;
}
interface PathFunctionOptions {
pretty?: boolean;
}
export type Token = string | Key;
export type Path = string | RegExp | Array<string | RegExp>;
export type PathFunction = (data?: Object, options?: PathFunctionOptions) => string;
}
export = pathToRegexp;

426
node_modules/path-to-regexp/index.js generated vendored
View File

@@ -1,426 +0,0 @@
var isarray = require('isarray')
/**
* Expose `pathToRegexp`.
*/
module.exports = pathToRegexp
module.exports.parse = parse
module.exports.compile = compile
module.exports.tokensToFunction = tokensToFunction
module.exports.tokensToRegExp = tokensToRegExp
/**
* The main path matching regexp utility.
*
* @type {RegExp}
*/
var PATH_REGEXP = new RegExp([
// Match escaped characters that would otherwise appear in future matches.
// This allows the user to escape special characters that won't transform.
'(\\\\.)',
// Match Express-style parameters and un-named parameters with a prefix
// and optional suffixes. Matches appear as:
//
// "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]
// "/route(\\d+)" => [undefined, undefined, undefined, "\d+", undefined, undefined]
// "/*" => ["/", undefined, undefined, undefined, undefined, "*"]
'([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))'
].join('|'), 'g')
/**
* Parse a string for the raw tokens.
*
* @param {string} str
* @param {Object=} options
* @return {!Array}
*/
function parse (str, options) {
var tokens = []
var key = 0
var index = 0
var path = ''
var defaultDelimiter = options && options.delimiter || '/'
var res
while ((res = PATH_REGEXP.exec(str)) != null) {
var m = res[0]
var escaped = res[1]
var offset = res.index
path += str.slice(index, offset)
index = offset + m.length
// Ignore already escaped sequences.
if (escaped) {
path += escaped[1]
continue
}
var next = str[index]
var prefix = res[2]
var name = res[3]
var capture = res[4]
var group = res[5]
var modifier = res[6]
var asterisk = res[7]
// Push the current path onto the tokens.
if (path) {
tokens.push(path)
path = ''
}
var partial = prefix != null && next != null && next !== prefix
var repeat = modifier === '+' || modifier === '*'
var optional = modifier === '?' || modifier === '*'
var delimiter = res[2] || defaultDelimiter
var pattern = capture || group
tokens.push({
name: name || key++,
prefix: prefix || '',
delimiter: delimiter,
optional: optional,
repeat: repeat,
partial: partial,
asterisk: !!asterisk,
pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')
})
}
// Match any characters still remaining.
if (index < str.length) {
path += str.substr(index)
}
// If the path exists, push it onto the end.
if (path) {
tokens.push(path)
}
return tokens
}
/**
* Compile a string to a template function for the path.
*
* @param {string} str
* @param {Object=} options
* @return {!function(Object=, Object=)}
*/
function compile (str, options) {
return tokensToFunction(parse(str, options), options)
}
/**
* Prettier encoding of URI path segments.
*
* @param {string}
* @return {string}
*/
function encodeURIComponentPretty (str) {
return encodeURI(str).replace(/[\/?#]/g, function (c) {
return '%' + c.charCodeAt(0).toString(16).toUpperCase()
})
}
/**
* Encode the asterisk parameter. Similar to `pretty`, but allows slashes.
*
* @param {string}
* @return {string}
*/
function encodeAsterisk (str) {
return encodeURI(str).replace(/[?#]/g, function (c) {
return '%' + c.charCodeAt(0).toString(16).toUpperCase()
})
}
/**
* Expose a method for transforming tokens into the path function.
*/
function tokensToFunction (tokens, options) {
// Compile all the tokens into regexps.
var matches = new Array(tokens.length)
// Compile all the patterns before compilation.
for (var i = 0; i < tokens.length; i++) {
if (typeof tokens[i] === 'object') {
matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$', flags(options))
}
}
return function (obj, opts) {
var path = ''
var data = obj || {}
var options = opts || {}
var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent
for (var i = 0; i < tokens.length; i++) {
var token = tokens[i]
if (typeof token === 'string') {
path += token
continue
}
var value = data[token.name]
var segment
if (value == null) {
if (token.optional) {
// Prepend partial segment prefixes.
if (token.partial) {
path += token.prefix
}
continue
} else {
throw new TypeError('Expected "' + token.name + '" to be defined')
}
}
if (isarray(value)) {
if (!token.repeat) {
throw new TypeError('Expected "' + token.name + '" to not repeat, but received `' + JSON.stringify(value) + '`')
}
if (value.length === 0) {
if (token.optional) {
continue
} else {
throw new TypeError('Expected "' + token.name + '" to not be empty')
}
}
for (var j = 0; j < value.length; j++) {
segment = encode(value[j])
if (!matches[i].test(segment)) {
throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but received `' + JSON.stringify(segment) + '`')
}
path += (j === 0 ? token.prefix : token.delimiter) + segment
}
continue
}
segment = token.asterisk ? encodeAsterisk(value) : encode(value)
if (!matches[i].test(segment)) {
throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but received "' + segment + '"')
}
path += token.prefix + segment
}
return path
}
}
/**
* Escape a regular expression string.
*
* @param {string} str
* @return {string}
*/
function escapeString (str) {
return str.replace(/([.+*?=^!:${}()[\]|\/\\])/g, '\\$1')
}
/**
* Escape the capturing group by escaping special characters and meaning.
*
* @param {string} group
* @return {string}
*/
function escapeGroup (group) {
return group.replace(/([=!:$\/()])/g, '\\$1')
}
/**
* Attach the keys as a property of the regexp.
*
* @param {!RegExp} re
* @param {Array} keys
* @return {!RegExp}
*/
function attachKeys (re, keys) {
re.keys = keys
return re
}
/**
* Get the flags for a regexp from the options.
*
* @param {Object} options
* @return {string}
*/
function flags (options) {
return options && options.sensitive ? '' : 'i'
}
/**
* Pull out keys from a regexp.
*
* @param {!RegExp} path
* @param {!Array} keys
* @return {!RegExp}
*/
function regexpToRegexp (path, keys) {
// Use a negative lookahead to match only capturing groups.
var groups = path.source.match(/\((?!\?)/g)
if (groups) {
for (var i = 0; i < groups.length; i++) {
keys.push({
name: i,
prefix: null,
delimiter: null,
optional: false,
repeat: false,
partial: false,
asterisk: false,
pattern: null
})
}
}
return attachKeys(path, keys)
}
/**
* Transform an array into a regexp.
*
* @param {!Array} path
* @param {Array} keys
* @param {!Object} options
* @return {!RegExp}
*/
function arrayToRegexp (path, keys, options) {
var parts = []
for (var i = 0; i < path.length; i++) {
parts.push(pathToRegexp(path[i], keys, options).source)
}
var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options))
return attachKeys(regexp, keys)
}
/**
* Create a path regexp from string input.
*
* @param {string} path
* @param {!Array} keys
* @param {!Object} options
* @return {!RegExp}
*/
function stringToRegexp (path, keys, options) {
return tokensToRegExp(parse(path, options), keys, options)
}
/**
* Expose a function for taking tokens and returning a RegExp.
*
* @param {!Array} tokens
* @param {(Array|Object)=} keys
* @param {Object=} options
* @return {!RegExp}
*/
function tokensToRegExp (tokens, keys, options) {
if (!isarray(keys)) {
options = /** @type {!Object} */ (keys || options)
keys = []
}
options = options || {}
var strict = options.strict
var end = options.end !== false
var route = ''
// Iterate over the tokens and create our regexp string.
for (var i = 0; i < tokens.length; i++) {
var token = tokens[i]
if (typeof token === 'string') {
route += escapeString(token)
} else {
var prefix = escapeString(token.prefix)
var capture = '(?:' + token.pattern + ')'
keys.push(token)
if (token.repeat) {
capture += '(?:' + prefix + capture + ')*'
}
if (token.optional) {
if (!token.partial) {
capture = '(?:' + prefix + '(' + capture + '))?'
} else {
capture = prefix + '(' + capture + ')?'
}
} else {
capture = prefix + '(' + capture + ')'
}
route += capture
}
}
var delimiter = escapeString(options.delimiter || '/')
var endsWithDelimiter = route.slice(-delimiter.length) === delimiter
// In non-strict mode we allow a slash at the end of match. If the path to
// match already ends with a slash, we remove it for consistency. The slash
// is valid at the end of a path match, not in the middle. This is important
// in non-ending mode, where "/test/" shouldn't match "/test//route".
if (!strict) {
route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?'
}
if (end) {
route += '$'
} else {
// In non-ending mode, we need the capturing groups to match as much as
// possible by using a positive lookahead to the end or next path segment.
route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)'
}
return attachKeys(new RegExp('^' + route, flags(options)), keys)
}
/**
* Normalize the given path string, returning a regular expression.
*
* An empty array can be passed in for the keys, which will hold the
* placeholder key descriptions. For example, using `/user/:id`, `keys` will
* contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
*
* @param {(string|RegExp|Array)} path
* @param {(Array|Object)=} keys
* @param {Object=} options
* @return {!RegExp}
*/
function pathToRegexp (path, keys, options) {
if (!isarray(keys)) {
options = /** @type {!Object} */ (keys || options)
keys = []
}
options = options || {}
if (path instanceof RegExp) {
return regexpToRegexp(path, /** @type {!Array} */ (keys))
}
if (isarray(path)) {
return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)
}
return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)
}

112
node_modules/path-to-regexp/package.json generated vendored
View File

@@ -1,60 +1,81 @@
{
"_args": [
[
"path-to-regexp@1.8.0",
"path-to-regexp@6.2.0",
"J:\\Github\\CURD-TS"
]
],
"_development": true,
"_from": "path-to-regexp@1.8.0",
"_id": "path-to-regexp@1.8.0",
"_from": "path-to-regexp@6.2.0",
"_id": "path-to-regexp@6.2.0",
"_inBundle": false,
"_integrity": "sha1-iHs7qdhDk+h6CgufTLdWGYtTVIo=",
"_integrity": "sha1-97OAMzYQTDRoia3s5hRmkjBkXzg=",
"_location": "/path-to-regexp",
"_phantomChildren": {},
"_requested": {
"type": "version",
"registry": true,
"raw": "path-to-regexp@1.8.0",
"raw": "path-to-regexp@6.2.0",
"name": "path-to-regexp",
"escapedName": "path-to-regexp",
"rawSpec": "1.8.0",
"rawSpec": "6.2.0",
"saveSpec": null,
"fetchSpec": "1.8.0"
"fetchSpec": "6.2.0"
},
"_requiredBy": [
"/path-match"
"/"
],
"_resolved": "http://192.168.250.101:4873/path-to-regexp/-/path-to-regexp-1.8.0.tgz",
"_spec": "1.8.0",
"_resolved": "http://192.168.250.101:4873/path-to-regexp/-/path-to-regexp-6.2.0.tgz",
"_spec": "6.2.0",
"_where": "J:\\Github\\CURD-TS",
"bugs": {
"url": "https://github.com/pillarjs/path-to-regexp/issues"
},
"component": {
"scripts": {
"path-to-regexp": "index.js"
}
},
"dependencies": {
"isarray": "0.0.1"
},
"description": "Express style path to RegExp utility",
"devDependencies": {
"chai": "^2.3.0",
"istanbul": "~0.3.0",
"mocha": "~2.2.4",
"standard": "~3.7.3",
"ts-node": "^0.5.5",
"typescript": "^1.8.7",
"typings": "^1.0.4"
"@size-limit/preset-small-lib": "^4.5.6",
"@types/jest": "^26.0.9",
"@types/node": "^14.0.27",
"@types/semver": "^7.3.1",
"husky": "^4.2.5",
"jest": "^26.2.2",
"lint-staged": "^10.2.11",
"prettier": "^2.0.5",
"rimraf": "^3.0.0",
"semver": "^7.3.2",
"size-limit": "^4.5.6",
"ts-jest": "^26.1.4",
"tslint": "^6.1.3",
"tslint-config-prettier": "^1.18.0",
"tslint-config-standard": "^9.0.0",
"typescript": "^4.0.3"
},
"files": [
"index.js",
"index.d.ts",
"LICENSE"
"dist/",
"dist.es2015/"
],
"homepage": "https://github.com/pillarjs/path-to-regexp#readme",
"husky": {
"hooks": {
"pre-commit": "lint-staged"
}
},
"jest": {
"roots": [
"<rootDir>/src/"
],
"transform": {
"\\.tsx?$": "ts-jest"
},
"testRegex": "(/__tests__/.*|\\.(test|spec))\\.(tsx?|jsx?)$",
"moduleFileExtensions": [
"ts",
"tsx",
"js",
"jsx",
"json",
"node"
]
},
"keywords": [
"express",
"regexp",
@@ -62,19 +83,36 @@
"routing"
],
"license": "MIT",
"main": "index.js",
"lint-staged": {
"*.{js,jsx,ts,tsx,json,md,yml,yaml}": "npm run prettier"
},
"main": "dist/index.js",
"module": "dist.es2015/index.js",
"name": "path-to-regexp",
"publishConfig": {
"access": "public"
},
"repository": {
"type": "git",
"url": "git+https://github.com/pillarjs/path-to-regexp.git"
},
"scripts": {
"lint": "standard",
"prepublish": "typings install",
"test": "npm run lint && npm run test-cov",
"test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --require ts-node/register -R spec test.ts",
"test-spec": "mocha --require ts-node/register -R spec --bail test.ts"
"build": "rimraf dist/ dist.es2015/ && tsc && tsc -P tsconfig.es2015.json",
"format": "npm run prettier -- \"{.,src/**}/*.{js,jsx,ts,tsx,json,md,yml,yaml}\"",
"lint": "tslint \"src/**/*\" --project tsconfig.json",
"prepare": "npm run build",
"prettier": "prettier --write",
"size": "size-limit",
"specs": "jest --coverage",
"test": "npm run build && npm run lint && npm run specs && npm run size"
},
"typings": "index.d.ts",
"version": "1.8.0"
"sideEffects": false,
"size-limit": [
{
"path": "dist/index.js",
"limit": "2 kB"
}
],
"typings": "dist/index.d.ts",
"version": "6.2.0"
}