@midwayjs/core 3.3.6 → 3.4.0-beta.11

package/dist/{common/webRouterCollector.js → service/webRouterService.js}

@@ -1,39 +1,41 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebRouterCollector = void 0;
+exports.MidwayWebRouterService = void 0;
 const decorator_1 = require("@midwayjs/decorator");
 const util_1 = require("../util");
-const container_1 = require("../context/container");
-const fileDetector_1 = require("./fileDetector");
-const util = require("util");
 const error_1 = require("../error");
+const util = require("util");
+const pathToRegexp_1 = require("../util/pathToRegexp");
 const debug = util.debuglog('midway:debug');
-class WebRouterCollector {
-    constructor(baseDir = '', options = {}) {
+let MidwayWebRouterService = class MidwayWebRouterService {
+    constructor(options = {}) {
+        this.options = options;
         this.isReady = false;
         this.routes = new Map();
         this.routesPriority = [];
-        this.baseDir = baseDir;
-        this.options = options;
+        this.includeCompileUrlPattern = false;
     }
     async analyze() {
-        if (this.baseDir) {
-            const container = new container_1.MidwayContainer();
-            container.setFileDetector(new fileDetector_1.DirectoryFileDetector({
-                loadDir: this.baseDir,
-            }));
-            await container.ready();
-        }
+        this.analyzeController();
+        this.sortPrefixAndRouter();
+    }
+    analyzeController() {
         const controllerModules = (0, decorator_1.listModule)(decorator_1.CONTROLLER_KEY);
         for (const module of controllerModules) {
-            this.collectRoute(module);
-        }
-        if (this.options.includeFunctionRouter) {
-            const fnModules = (0, decorator_1.listModule)(decorator_1.FUNC_KEY);
-            for (const module of fnModules) {
-                this.collectFunctionRoute(module);
-            }
+            const controllerOption = (0, decorator_1.getClassMetadata)(decorator_1.CONTROLLER_KEY, module);
+            this.addController(module, controllerOption, this.options.includeFunctionRouter);
         }
+    }
+    sortPrefixAndRouter() {
         // filter empty prefix
         this.routesPriority = this.routesPriority.filter(item => {
             const prefixList = this.routes.get(item.prefix);
@@ -55,12 +57,17 @@ class WebRouterCollector {
             return routeB.prefix.length - routeA.prefix.length;
         });
     }
-    collectRoute(module, functionMeta = false) {
+    /**
+     * dynamically add a controller
+     * @param controllerClz
+     * @param controllerOption
+     * @param functionMeta
+     */
+    addController(controllerClz, controllerOption, functionMeta = false) {
         var _a;
-        const controllerId = (0, decorator_1.getProviderName)(module);
+        const controllerId = (0, decorator_1.getProviderName)(controllerClz);
         debug(`[core]: Found Controller ${controllerId}.`);
-        const id = (0, decorator_1.getProviderUUId)(module);
-        const controllerOption = (0, decorator_1.getClassMetadata)(decorator_1.CONTROLLER_KEY, module);
+        const id = (0, decorator_1.getProviderUUId)(controllerClz);
         let priority;
         // implement middleware in controller
         const middleware = controllerOption.routerOptions.middleware;
@@ -83,9 +90,18 @@ class WebRouterCollector {
                 middleware,
                 routerOptions: controllerOption.routerOptions,
                 controllerId,
-                routerModule: module,
+                routerModule: controllerClz,
             });
         }
+        else {
+            // 不同的 controller，可能会有相同的 prefix，一旦 options 不同，就要报错
+            if (middleware) {
+                const originRoute = this.routesPriority.filter(el => {
+                    return el.prefix === prefix;
+                })[0];
+                throw new error_1.MidwayDuplicateControllerOptionsError(prefix, controllerId, originRoute.controllerId);
+            }
+        }
         // set ignorePrefix
         if (!this.routes.has(ignorePrefix)) {
             this.routes.set(ignorePrefix, []);
@@ -95,14 +111,14 @@ class WebRouterCollector {
                 middleware,
                 routerOptions: controllerOption.routerOptions,
                 controllerId,
-                routerModule: module,
+                routerModule: controllerClz,
             });
         }
-        const webRouterInfo = (0, decorator_1.getClassMetadata)(decorator_1.WEB_ROUTER_KEY, module);
+        const webRouterInfo = (0, decorator_1.getClassMetadata)(decorator_1.WEB_ROUTER_KEY, controllerClz);
         if (webRouterInfo && typeof webRouterInfo[Symbol.iterator] === 'function') {
             for (const webRouter of webRouterInfo) {
-                const routeArgsInfo = (0, decorator_1.getPropertyDataFromClass)(decorator_1.WEB_ROUTER_PARAM_KEY, module, webRouter.method) || [];
-                const routerResponseData = (0, decorator_1.getPropertyMetadata)(decorator_1.WEB_RESPONSE_KEY, module, webRouter.method) || [];
+                const routeArgsInfo = (0, decorator_1.getPropertyDataFromClass)(decorator_1.WEB_ROUTER_PARAM_KEY, controllerClz, webRouter.method) || [];
+                const routerResponseData = (0, decorator_1.getPropertyMetadata)(decorator_1.WEB_RESPONSE_KEY, controllerClz, webRouter.method) || [];
                 const data = {
                     id,
                     prefix: webRouter.ignoreGlobalPrefix ? ignorePrefix : prefix,
@@ -136,92 +152,29 @@ class WebRouterCollector {
             }
         }
     }
-    collectFunctionRoute(module, functionMeta = false) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        // serverlessTrigger metadata
-        const webRouterInfo = (0, decorator_1.getClassMetadata)(decorator_1.FUNC_KEY, module);
-        const controllerId = (0, decorator_1.getProviderName)(module);
-        const id = (0, decorator_1.getProviderUUId)(module);
-        const prefix = '/';
+    /**
+     * dynamically add a route to root prefix
+     * @param routerPath
+     * @param routerFunction
+     * @param routerInfoOption
+     */
+    addRouter(routerFunction, routerInfoOption) {
+        const prefix = routerInfoOption.prefix || '';
+        routerInfoOption.requestMethod = (routerInfoOption.requestMethod || 'GET').toUpperCase();
         if (!this.routes.has(prefix)) {
             this.routes.set(prefix, []);
             this.routesPriority.push({
                 prefix,
-                priority: -999,
+                priority: 0,
                 middleware: [],
                 routerOptions: {},
-                controllerId,
-                routerModule: module,
+                controllerId: undefined,
+                routerModule: undefined,
             });
         }
-        for (const webRouter of webRouterInfo) {
-            // 新的 @ServerlessTrigger 写法
-            if ((_a = webRouter['metadata']) === null || _a === void 0 ? void 0 : _a['path']) {
-                const routeArgsInfo = (0, decorator_1.getPropertyDataFromClass)(decorator_1.WEB_ROUTER_PARAM_KEY, module, webRouter['methodName']) || [];
-                const routerResponseData = (0, decorator_1.getPropertyMetadata)(decorator_1.WEB_RESPONSE_KEY, module, webRouter['methodName']) || [];
-                // 新 http/api gateway 函数
-                const data = {
-                    id,
-                    prefix,
-                    routerName: '',
-                    url: webRouter['metadata']['path'],
-                    requestMethod: (_c = (_b = webRouter['metadata']) === null || _b === void 0 ? void 0 : _b['method']) !== null && _c !== void 0 ? _c : 'get',
-                    method: webRouter['methodName'],
-                    description: '',
-                    summary: '',
-                    handlerName: `${controllerId}.${webRouter['methodName']}`,
-                    funcHandlerName: `${controllerId}.${webRouter['methodName']}`,
-                    controllerId,
-                    middleware: ((_d = webRouter['metadata']) === null || _d === void 0 ? void 0 : _d['middleware']) || [],
-                    controllerMiddleware: [],
-                    requestMetadata: routeArgsInfo,
-                    responseMetadata: routerResponseData,
-                };
-                if (functionMeta) {
-                    const functionMeta = (0, decorator_1.getPropertyMetadata)(decorator_1.SERVERLESS_FUNC_KEY, module, webRouter['methodName']) || {};
-                    const functionName = (_f = (_e = functionMeta['functionName']) !== null && _e !== void 0 ? _e : webRouter['functionName']) !== null && _f !== void 0 ? _f : createFunctionName(module, webRouter['methodName']);
-                    data.functionName = functionName;
-                    data.functionTriggerName = webRouter['type'];
-                    data.functionTriggerMetadata = webRouter['metadata'];
-                    data.functionMetadata = {
-                        functionName,
-                        ...functionMeta,
-                    };
-                }
-                this.checkDuplicateAndPush(prefix, data);
-            }
-            else {
-                if (functionMeta) {
-                    const functionMeta = (0, decorator_1.getPropertyMetadata)(decorator_1.SERVERLESS_FUNC_KEY, module, webRouter['methodName']) || {};
-                    const functionName = (_h = (_g = functionMeta['functionName']) !== null && _g !== void 0 ? _g : webRouter['functionName']) !== null && _h !== void 0 ? _h : createFunctionName(module, webRouter['methodName']);
-                    // 其他类型的函数
-                    this.checkDuplicateAndPush(prefix, {
-                        id,
-                        prefix,
-                        routerName: '',
-                        url: '',
-                        requestMethod: '',
-                        method: webRouter['methodName'],
-                        description: '',
-                        summary: '',
-                        handlerName: `${controllerId}.${webRouter['methodName']}`,
-                        funcHandlerName: `${controllerId}.${webRouter['methodName']}`,
-                        controllerId,
-                        middleware: ((_j = webRouter['metadata']) === null || _j === void 0 ? void 0 : _j['middleware']) || [],
-                        controllerMiddleware: [],
-                        requestMetadata: [],
-                        responseMetadata: [],
-                        functionName,
-                        functionTriggerName: webRouter['type'],
-                        functionTriggerMetadata: webRouter['metadata'],
-                        functionMetadata: {
-                            functionName,
-                            ...functionMeta,
-                        },
-                    });
-                }
-            }
-        }
+        this.checkDuplicateAndPush(prefix, Object.assign(routerInfoOption, {
+            method: routerFunction,
+        }));
     }
     sortRouter(urlMatchList) {
         // 1. 绝对路径规则优先级最高如 /ab/cb/e
@@ -299,7 +252,19 @@ class WebRouterCollector {
         }
         return this.routes;
     }
-    async getFlattenRouterTable() {
+    async getFlattenRouterTable(options = {}) {
+        if (this.cachedFlattenRouteList && !options.noCache) {
+            if (options.compileUrlPattern && !this.includeCompileUrlPattern) {
+                this.includeCompileUrlPattern = true;
+                // attach match pattern function
+                for (const item of this.cachedFlattenRouteList) {
+                    if (item.fullUrlFlattenString) {
+                        item.fullUrlCompiledRegexp = pathToRegexp_1.PathToRegexpUtil.toRegexp(item.fullUrlFlattenString);
+                    }
+                }
+            }
+            return this.cachedFlattenRouteList;
+        }
         if (!this.isReady) {
             await this.analyze();
             this.isReady = true;
@@ -308,8 +273,34 @@ class WebRouterCollector {
         for (const routerPriority of this.routesPriority) {
             routeArr = routeArr.concat(this.routes.get(routerPriority.prefix));
         }
+        if (options.compileUrlPattern) {
+            this.includeCompileUrlPattern = true;
+            // attach match pattern function
+            for (const item of routeArr) {
+                if (item.fullUrlFlattenString) {
+                    item.fullUrlCompiledRegexp = pathToRegexp_1.PathToRegexpUtil.toRegexp(item.fullUrlFlattenString);
+                }
+            }
+        }
+        this.cachedFlattenRouteList = routeArr;
         return routeArr;
     }
+    async getMatchedRouterInfo(routerUrl, method) {
+        const routes = await this.getFlattenRouterTable({
+            compileUrlPattern: true,
+        });
+        let matchedRouterInfo;
+        for (const item of routes) {
+            if (item.fullUrlCompiledRegexp) {
+                if (method.toUpperCase() === item['requestMethod'].toUpperCase() &&
+                    item.fullUrlCompiledRegexp.test(routerUrl)) {
+                    matchedRouterInfo = item;
+                    break;
+                }
+            }
+        }
+        return matchedRouterInfo;
+    }
     checkDuplicateAndPush(prefix, routerInfo) {
         const prefixList = this.routes.get(prefix);
         const matched = prefixList.filter(item => {
@@ -321,11 +312,25 @@ class WebRouterCollector {
         if (matched && matched.length) {
             throw new error_1.MidwayDuplicateRouteError(`${routerInfo.requestMethod} ${routerInfo.url}`, `${matched[0].handlerName}`, `${routerInfo.handlerName}`);
         }
+        // format url
+        if (!routerInfo.fullUrlFlattenString &&
+            routerInfo.url &&
+            typeof routerInfo.url === 'string') {
+            routerInfo.fullUrl = (0, util_1.joinURLPath)(prefix, routerInfo.url);
+            if (/\*$/.test(routerInfo.fullUrl)) {
+                routerInfo.fullUrlFlattenString = routerInfo.fullUrl.replace('*', '(.*)');
+            }
+            else {
+                routerInfo.fullUrlFlattenString = routerInfo.fullUrl;
+            }
+        }
         prefixList.push(routerInfo);
     }
-}
-exports.WebRouterCollector = WebRouterCollector;
-function createFunctionName(target, functionName) {
-    return (0, decorator_1.getProviderName)(target).replace(/[:#]/g, '-') + '-' + functionName;
-}
-//# sourceMappingURL=webRouterCollector.js.map
+};
+MidwayWebRouterService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object])
+], MidwayWebRouterService);
+exports.MidwayWebRouterService = MidwayWebRouterService;
+//# sourceMappingURL=webRouterService.js.map

package/dist/setup.js

@@ -7,6 +7,7 @@ const decorator_1 = require("@midwayjs/decorator");
 const util = require("util");
 const path_1 = require("path");
 const logger_1 = require("@midwayjs/logger");
+const slsFunctionService_1 = require("./service/slsFunctionService");
 const debug = util.debuglog('midway:debug');
 /**
  * midway framework main entry, this method bootstrap all service and framework.
@@ -95,6 +96,8 @@ function prepareGlobalApplicationContext(globalOptions) {
     applicationContext.bindClass(_1.MidwayMiddlewareService);
     applicationContext.bindClass(_1.MidwayLifeCycleService);
     applicationContext.bindClass(_1.MidwayMockService);
+    applicationContext.bindClass(_1.MidwayWebRouterService);
+    applicationContext.bindClass(slsFunctionService_1.MidwayServerlessFunctionService);
     // bind preload module
     if (globalOptions.preloadModules && globalOptions.preloadModules.length) {
         for (const preloadModule of globalOptions.preloadModules) {

package/dist/util/contextUtil.d.ts

@@ -1,5 +1,7 @@
 import { IConfigurationOptions, IMidwayContainer, IMidwayFramework } from '../interface';
+import { AsyncContextManager } from '../common/asyncContextManager';
 export declare const getCurrentApplicationContext: () => IMidwayContainer;
 export declare const getCurrentMainFramework: <APP extends import("../interface").IMidwayBaseApplication<CTX>, CTX extends import("../interface").Context, CONFIG extends IConfigurationOptions>() => IMidwayFramework<APP, CTX, CONFIG, unknown, unknown>;
 export declare const getCurrentMainApp: <APP extends import("../interface").IMidwayBaseApplication<import("../interface").Context>>() => APP;
+export declare const getCurrentAsyncContextManager: () => AsyncContextManager;
 //# sourceMappingURL=contextUtil.d.ts.map

package/dist/util/contextUtil.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCurrentMainApp = exports.getCurrentMainFramework = exports.getCurrentApplicationContext = void 0;
+exports.getCurrentAsyncContextManager = exports.getCurrentMainApp = exports.getCurrentMainFramework = exports.getCurrentApplicationContext = void 0;
+const interface_1 = require("../interface");
 const getCurrentApplicationContext = () => {
     return global['MIDWAY_APPLICATION_CONTEXT'];
 };
@@ -17,4 +18,8 @@ const getCurrentMainApp = () => {
     return undefined;
 };
 exports.getCurrentMainApp = getCurrentMainApp;
+const getCurrentAsyncContextManager = () => {
+    return (0, exports.getCurrentApplicationContext)().get(interface_1.ASYNC_CONTEXT_MANAGER_KEY);
+};
+exports.getCurrentAsyncContextManager = getCurrentAsyncContextManager;
 //# sourceMappingURL=contextUtil.js.map

package/dist/util/index.d.ts

@@ -90,4 +90,5 @@ export declare function pathMatching(options: any): (ctx?: any) => any;
  */
 export declare function wrapMiddleware(mw: FunctionMiddleware<any, any>, options: any): (context: any, next: any, options?: any) => any;
 export declare function isIncludeProperty(obj: any, prop: string): boolean;
+export declare function wrapAsync(handler: any): (...args: any[]) => any;
 //# sourceMappingURL=index.d.ts.map

package/dist/util/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIncludeProperty = exports.wrapMiddleware = exports.pathMatching = exports.toPathMatch = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.getCurrentDateString = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetPrototypeMethod = exports.joinURLPath = exports.getUserHome = exports.parsePrefix = exports.safelyGet = exports.safeRequire = exports.getCurrentEnvironment = exports.isDevelopmentEnvironment = void 0;
+exports.wrapAsync = exports.isIncludeProperty = exports.wrapMiddleware = exports.pathMatching = exports.toPathMatch = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.getCurrentDateString = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetPrototypeMethod = exports.joinURLPath = exports.getUserHome = exports.parsePrefix = exports.safelyGet = exports.safeRequire = exports.getCurrentEnvironment = exports.isDevelopmentEnvironment = void 0;
 const path_1 = require("path");
 const fs_1 = require("fs");
 const util_1 = require("util");
@@ -238,7 +238,7 @@ function toPathMatch(pattern) {
         return ctx => pattern;
     }
     if (typeof pattern === 'string') {
-        const reg = (0, pathToRegexp_1.pathToRegexp)(pattern, [], { end: false });
+        const reg = pathToRegexp_1.PathToRegexpUtil.toRegexp(pattern.replace('*', '(.*)'));
         if (reg.global)
             reg.lastIndex = 0;
         return ctx => reg.test(ctx.path);
@@ -313,4 +313,25 @@ function isIncludeProperty(obj, prop) {
     return false;
 }
 exports.isIncludeProperty = isIncludeProperty;
+function wrapAsync(handler) {
+    return (...args) => {
+        if (typeof args[args.length - 1] === 'function') {
+            const callback = args.pop();
+            if (handler.constructor.name !== 'AsyncFunction') {
+                const err = new TypeError('Must be an AsyncFunction');
+                return callback(err);
+            }
+            // 其他事件场景
+            return handler.apply(handler, args).then(result => {
+                callback(null, result);
+            }, err => {
+                callback(err);
+            });
+        }
+        else {
+            return handler.apply(handler, args);
+        }
+    };
+}
+exports.wrapAsync = wrapAsync;
 //# sourceMappingURL=index.js.map

package/dist/util/pathToRegexp.d.ts

@@ -1,17 +1,123 @@
+interface ParseOptions {
+    /**
+     * Set the default delimiter for repeat parameters. (default: `'/'`)
+     */
+    delimiter?: string;
+    /**
+     * List of characters to automatically consider prefixes when parsing.
+     */
+    prefixes?: string;
+}
 /**
- * this file fork from path-to-regexp package v1.8.0
+ * Parse a string for the raw tokens.
  */
+declare function parse(str: string, options?: ParseOptions): Token[];
+interface TokensToFunctionOptions {
+    /**
+     * When `true` the regexp will be case sensitive. (default: `false`)
+     */
+    sensitive?: boolean;
+    /**
+     * Function for encoding input strings for output.
+     */
+    encode?: (value: string, token: Key) => string;
+    /**
+     * When `false` the function can produce an invalid (unmatched) path. (default: `true`)
+     */
+    validate?: boolean;
+}
+/**
+ * Compile a string to a template function for the path.
+ */
+declare function compile<P extends object = object>(str: string, options?: ParseOptions & TokensToFunctionOptions): PathFunction<P>;
+declare type PathFunction<P extends object = object> = (data?: P) => string;
+interface RegexpToFunctionOptions {
+    /**
+     * Function for decoding strings for params.
+     */
+    decode?: (value: string, token: Key) => string;
+}
+/**
+ * A match result contains data about the path match.
+ */
+interface MatchResult<P extends object = object> {
+    path: string;
+    index: number;
+    params: P;
+}
+/**
+ * A match is either `false` (no match) or a match result.
+ */
+declare type Match<P extends object = object> = false | MatchResult<P>;
+/**
+ * The match function takes a string and returns whether it matched the path.
+ */
+declare type MatchFunction<P extends object = object> = (path: string) => Match<P>;
+/**
+ * Create path match function from `path-to-regexp` spec.
+ */
+declare function match<P extends object = object>(str: Path, options?: ParseOptions & TokensToRegexpOptions & RegexpToFunctionOptions): MatchFunction<P>;
+/**
+ * Metadata about a key.
+ */
+interface Key {
+    name: string | number;
+    prefix: string;
+    suffix: string;
+    pattern: string;
+    modifier: string;
+}
+/**
+ * A token is a string (nothing special) or key metadata (capture group).
+ */
+declare type Token = string | Key;
+interface TokensToRegexpOptions {
+    /**
+     * When `true` the regexp will be case sensitive. (default: `false`)
+     */
+    sensitive?: boolean;
+    /**
+     * When `true` the regexp won't allow an optional trailing delimiter to match. (default: `false`)
+     */
+    strict?: boolean;
+    /**
+     * When `true` the regexp will match to the end of the string. (default: `true`)
+     */
+    end?: boolean;
+    /**
+     * When `true` the regexp will match from the beginning of the string. (default: `true`)
+     */
+    start?: boolean;
+    /**
+     * Sets the final character for non-ending optimistic matches. (default: `/`)
+     */
+    delimiter?: string;
+    /**
+     * List of characters that can also be "end" characters.
+     */
+    endsWith?: string;
+    /**
+     * Encode path tokens for use in the `RegExp`.
+     */
+    encode?: (value: string) => string;
+}
+/**
+ * Supported `path-to-regexp` input types.
+ */
+declare type Path = string | RegExp | Array<string | RegExp>;
 /**
  * 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}
  */
-export declare function pathToRegexp(path: any, keys: any, options: any): any;
+declare function toRegexp(path: Path, keys?: Key[], options?: TokensToRegexpOptions & ParseOptions): RegExp;
+export declare const PathToRegexpUtil: {
+    toRegexp: typeof toRegexp;
+    compile: typeof compile;
+    parse: typeof parse;
+    match: typeof match;
+};
+export {};
 //# sourceMappingURL=pathToRegexp.d.ts.map