{"version":3,"file":"index-BWIXCLy3.js","sources":["../../../node_modules/path-to-regexp/dist.es2015/index.js","../../../node_modules/url-routes-generator/lib/helpers/isAbsoluteURL.js","../../../node_modules/url-routes-generator/lib/helpers/combineURLs.js","../../../node_modules/url-routes-generator/lib/core/buildFullPath.js","../../../node_modules/url-routes-generator/lib/helpers/serializeObjectToQueryString.js","../../../node_modules/url-routes-generator/lib/core/exceptions.js","../../../node_modules/url-routes-generator/lib/core/buildURL.js","../../../node_modules/url-routes-generator/lib/generator.js","../../../node_modules/url-routes-generator/index.js"],"sourcesContent":["/**\n * Tokenize input string.\n */\nfunction lexer(str) {\n    var tokens = [];\n    var i = 0;\n    while (i < str.length) {\n        var char = str[i];\n        if (char === \"*\" || char === \"+\" || char === \"?\") {\n            tokens.push({ type: \"MODIFIER\", index: i, value: str[i++] });\n            continue;\n        }\n        if (char === \"\\\\\") {\n            tokens.push({ type: \"ESCAPED_CHAR\", index: i++, value: str[i++] });\n            continue;\n        }\n        if (char === \"{\") {\n            tokens.push({ type: \"OPEN\", index: i, value: str[i++] });\n            continue;\n        }\n        if (char === \"}\") {\n            tokens.push({ type: \"CLOSE\", index: i, value: str[i++] });\n            continue;\n        }\n        if (char === \":\") {\n            var name = \"\";\n            var j = i + 1;\n            while (j < str.length) {\n                var code = str.charCodeAt(j);\n                if (\n                // `0-9`\n                (code >= 48 && code <= 57) ||\n                    // `A-Z`\n                    (code >= 65 && code <= 90) ||\n                    // `a-z`\n                    (code >= 97 && code <= 122) ||\n                    // `_`\n                    code === 95) {\n                    name += str[j++];\n                    continue;\n                }\n                break;\n            }\n            if (!name)\n                throw new TypeError(\"Missing parameter name at \" + i);\n            tokens.push({ type: \"NAME\", index: i, value: name });\n            i = j;\n            continue;\n        }\n        if (char === \"(\") {\n            var count = 1;\n            var pattern = \"\";\n            var j = i + 1;\n            if (str[j] === \"?\") {\n                throw new TypeError(\"Pattern cannot start with \\\"?\\\" at \" + j);\n            }\n            while (j < str.length) {\n                if (str[j] === \"\\\\\") {\n                    pattern += str[j++] + str[j++];\n                    continue;\n                }\n                if (str[j] === \")\") {\n                    count--;\n                    if (count === 0) {\n                        j++;\n                        break;\n                    }\n                }\n                else if (str[j] === \"(\") {\n                    count++;\n                    if (str[j + 1] !== \"?\") {\n                        throw new TypeError(\"Capturing groups are not allowed at \" + j);\n                    }\n                }\n                pattern += str[j++];\n            }\n            if (count)\n                throw new TypeError(\"Unbalanced pattern at \" + i);\n            if (!pattern)\n                throw new TypeError(\"Missing pattern at \" + i);\n            tokens.push({ type: \"PATTERN\", index: i, value: pattern });\n            i = j;\n            continue;\n        }\n        tokens.push({ type: \"CHAR\", index: i, value: str[i++] });\n    }\n    tokens.push({ type: \"END\", index: i, value: \"\" });\n    return tokens;\n}\n/**\n * Parse a string for the raw tokens.\n */\nexport function parse(str, options) {\n    if (options === void 0) { options = {}; }\n    var tokens = lexer(str);\n    var _a = options.prefixes, prefixes = _a === void 0 ? \"./\" : _a;\n    var defaultPattern = \"[^\" + escapeString(options.delimiter || \"/#?\") + \"]+?\";\n    var result = [];\n    var key = 0;\n    var i = 0;\n    var path = \"\";\n    var tryConsume = function (type) {\n        if (i < tokens.length && tokens[i].type === type)\n            return tokens[i++].value;\n    };\n    var mustConsume = function (type) {\n        var value = tryConsume(type);\n        if (value !== undefined)\n            return value;\n        var _a = tokens[i], nextType = _a.type, index = _a.index;\n        throw new TypeError(\"Unexpected \" + nextType + \" at \" + index + \", expected \" + type);\n    };\n    var consumeText = function () {\n        var result = \"\";\n        var value;\n        // tslint:disable-next-line\n        while ((value = tryConsume(\"CHAR\") || tryConsume(\"ESCAPED_CHAR\"))) {\n            result += value;\n        }\n        return result;\n    };\n    while (i < tokens.length) {\n        var char = tryConsume(\"CHAR\");\n        var name = tryConsume(\"NAME\");\n        var pattern = tryConsume(\"PATTERN\");\n        if (name || pattern) {\n            var prefix = char || \"\";\n            if (prefixes.indexOf(prefix) === -1) {\n                path += prefix;\n                prefix = \"\";\n            }\n            if (path) {\n                result.push(path);\n                path = \"\";\n            }\n            result.push({\n                name: name || key++,\n                prefix: prefix,\n                suffix: \"\",\n                pattern: pattern || defaultPattern,\n                modifier: tryConsume(\"MODIFIER\") || \"\"\n            });\n            continue;\n        }\n        var value = char || tryConsume(\"ESCAPED_CHAR\");\n        if (value) {\n            path += value;\n            continue;\n        }\n        if (path) {\n            result.push(path);\n            path = \"\";\n        }\n        var open = tryConsume(\"OPEN\");\n        if (open) {\n            var prefix = consumeText();\n            var name_1 = tryConsume(\"NAME\") || \"\";\n            var pattern_1 = tryConsume(\"PATTERN\") || \"\";\n            var suffix = consumeText();\n            mustConsume(\"CLOSE\");\n            result.push({\n                name: name_1 || (pattern_1 ? key++ : \"\"),\n                pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,\n                prefix: prefix,\n                suffix: suffix,\n                modifier: tryConsume(\"MODIFIER\") || \"\"\n            });\n            continue;\n        }\n        mustConsume(\"END\");\n    }\n    return result;\n}\n/**\n * Compile a string to a template function for the path.\n */\nexport function compile(str, options) {\n    return tokensToFunction(parse(str, options), options);\n}\n/**\n * Expose a method for transforming tokens into the path function.\n */\nexport function tokensToFunction(tokens, options) {\n    if (options === void 0) { options = {}; }\n    var reFlags = flags(options);\n    var _a = options.encode, encode = _a === void 0 ? function (x) { return x; } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;\n    // Compile all the tokens into regexps.\n    var matches = tokens.map(function (token) {\n        if (typeof token === \"object\") {\n            return new RegExp(\"^(?:\" + token.pattern + \")$\", reFlags);\n        }\n    });\n    return function (data) {\n        var path = \"\";\n        for (var i = 0; i < tokens.length; i++) {\n            var token = tokens[i];\n            if (typeof token === \"string\") {\n                path += token;\n                continue;\n            }\n            var value = data ? data[token.name] : undefined;\n            var optional = token.modifier === \"?\" || token.modifier === \"*\";\n            var repeat = token.modifier === \"*\" || token.modifier === \"+\";\n            if (Array.isArray(value)) {\n                if (!repeat) {\n                    throw new TypeError(\"Expected \\\"\" + token.name + \"\\\" to not repeat, but got an array\");\n                }\n                if (value.length === 0) {\n                    if (optional)\n                        continue;\n                    throw new TypeError(\"Expected \\\"\" + token.name + \"\\\" to not be empty\");\n                }\n                for (var j = 0; j < value.length; j++) {\n                    var segment = encode(value[j], token);\n                    if (validate && !matches[i].test(segment)) {\n                        throw new TypeError(\"Expected all \\\"\" + token.name + \"\\\" to match \\\"\" + token.pattern + \"\\\", but got \\\"\" + segment + \"\\\"\");\n                    }\n                    path += token.prefix + segment + token.suffix;\n                }\n                continue;\n            }\n            if (typeof value === \"string\" || typeof value === \"number\") {\n                var segment = encode(String(value), token);\n                if (validate && !matches[i].test(segment)) {\n                    throw new TypeError(\"Expected \\\"\" + token.name + \"\\\" to match \\\"\" + token.pattern + \"\\\", but got \\\"\" + segment + \"\\\"\");\n                }\n                path += token.prefix + segment + token.suffix;\n                continue;\n            }\n            if (optional)\n                continue;\n            var typeOfMessage = repeat ? \"an array\" : \"a string\";\n            throw new TypeError(\"Expected \\\"\" + token.name + \"\\\" to be \" + typeOfMessage);\n        }\n        return path;\n    };\n}\n/**\n * Create path match function from `path-to-regexp` spec.\n */\nexport function match(str, options) {\n    var keys = [];\n    var re = pathToRegexp(str, keys, options);\n    return regexpToFunction(re, keys, options);\n}\n/**\n * Create a path match function from `path-to-regexp` output.\n */\nexport function regexpToFunction(re, keys, options) {\n    if (options === void 0) { options = {}; }\n    var _a = options.decode, decode = _a === void 0 ? function (x) { return x; } : _a;\n    return function (pathname) {\n        var m = re.exec(pathname);\n        if (!m)\n            return false;\n        var path = m[0], index = m.index;\n        var params = Object.create(null);\n        var _loop_1 = function (i) {\n            // tslint:disable-next-line\n            if (m[i] === undefined)\n                return \"continue\";\n            var key = keys[i - 1];\n            if (key.modifier === \"*\" || key.modifier === \"+\") {\n                params[key.name] = m[i].split(key.prefix + key.suffix).map(function (value) {\n                    return decode(value, key);\n                });\n            }\n            else {\n                params[key.name] = decode(m[i], key);\n            }\n        };\n        for (var i = 1; i < m.length; i++) {\n            _loop_1(i);\n        }\n        return { path: path, index: index, params: params };\n    };\n}\n/**\n * Escape a regular expression string.\n */\nfunction escapeString(str) {\n    return str.replace(/([.+*?=^!:${}()[\\]|/\\\\])/g, \"\\\\$1\");\n}\n/**\n * Get the flags for a regexp from the options.\n */\nfunction flags(options) {\n    return options && options.sensitive ? \"\" : \"i\";\n}\n/**\n * Pull out keys from a regexp.\n */\nfunction regexpToRegexp(path, keys) {\n    if (!keys)\n        return path;\n    // Use a negative lookahead to match only capturing groups.\n    var groups = path.source.match(/\\((?!\\?)/g);\n    if (groups) {\n        for (var i = 0; i < groups.length; i++) {\n            keys.push({\n                name: i,\n                prefix: \"\",\n                suffix: \"\",\n                modifier: \"\",\n                pattern: \"\"\n            });\n        }\n    }\n    return path;\n}\n/**\n * Transform an array into a regexp.\n */\nfunction arrayToRegexp(paths, keys, options) {\n    var parts = paths.map(function (path) { return pathToRegexp(path, keys, options).source; });\n    return new RegExp(\"(?:\" + parts.join(\"|\") + \")\", flags(options));\n}\n/**\n * Create a path regexp from string input.\n */\nfunction stringToRegexp(path, keys, options) {\n    return tokensToRegexp(parse(path, options), keys, options);\n}\n/**\n * Expose a function for taking tokens and returning a RegExp.\n */\nexport function tokensToRegexp(tokens, keys, options) {\n    if (options === void 0) { options = {}; }\n    var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function (x) { return x; } : _d;\n    var endsWith = \"[\" + escapeString(options.endsWith || \"\") + \"]|$\";\n    var delimiter = \"[\" + escapeString(options.delimiter || \"/#?\") + \"]\";\n    var route = start ? \"^\" : \"\";\n    // Iterate over the tokens and create our regexp string.\n    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {\n        var token = tokens_1[_i];\n        if (typeof token === \"string\") {\n            route += escapeString(encode(token));\n        }\n        else {\n            var prefix = escapeString(encode(token.prefix));\n            var suffix = escapeString(encode(token.suffix));\n            if (token.pattern) {\n                if (keys)\n                    keys.push(token);\n                if (prefix || suffix) {\n                    if (token.modifier === \"+\" || token.modifier === \"*\") {\n                        var mod = token.modifier === \"*\" ? \"?\" : \"\";\n                        route += \"(?:\" + prefix + \"((?:\" + token.pattern + \")(?:\" + suffix + prefix + \"(?:\" + token.pattern + \"))*)\" + suffix + \")\" + mod;\n                    }\n                    else {\n                        route += \"(?:\" + prefix + \"(\" + token.pattern + \")\" + suffix + \")\" + token.modifier;\n                    }\n                }\n                else {\n                    route += \"(\" + token.pattern + \")\" + token.modifier;\n                }\n            }\n            else {\n                route += \"(?:\" + prefix + suffix + \")\" + token.modifier;\n            }\n        }\n    }\n    if (end) {\n        if (!strict)\n            route += delimiter + \"?\";\n        route += !options.endsWith ? \"$\" : \"(?=\" + endsWith + \")\";\n    }\n    else {\n        var endToken = tokens[tokens.length - 1];\n        var isEndDelimited = typeof endToken === \"string\"\n            ? delimiter.indexOf(endToken[endToken.length - 1]) > -1\n            : // tslint:disable-next-line\n                endToken === undefined;\n        if (!strict) {\n            route += \"(?:\" + delimiter + \"(?=\" + endsWith + \"))?\";\n        }\n        if (!isEndDelimited) {\n            route += \"(?=\" + delimiter + \"|\" + endsWith + \")\";\n        }\n    }\n    return new RegExp(route, flags(options));\n}\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n */\nexport function pathToRegexp(path, keys, options) {\n    if (path instanceof RegExp)\n        return regexpToRegexp(path, keys);\n    if (Array.isArray(path))\n        return arrayToRegexp(path, keys, options);\n    return stringToRegexp(path, keys, options);\n}\n//# sourceMappingURL=index.js.map","\"use strict\";\n\nmodule.exports = function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n","\"use strict\";\n\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n  return relativeURL\n    ? baseURL.replace(/\\/+$/, \"\") + \"/\" + relativeURL.replace(/^\\/+/, \"\")\n    : baseURL;\n};\n","\"use strict\";\n\nconst isAbsoluteURL = require(\"../helpers/isAbsoluteURL\");\nconst combineURLs = require(\"../helpers/combineURLs\");\n\nmodule.exports = function buildFullPath (baseURL, requestedPath) {\n  if (baseURL && !isAbsoluteURL(requestedPath)) {\n    return combineURLs(baseURL, requestedPath);\n  }\n  return requestedPath;\n};\n","\"use strict\";\n\nmodule.exports = function serializeObjectToQueryString(obj = {}) {\n  let str = [];\n  for (const p in obj)\n    if (obj.hasOwnProperty(p)) {\n      str.push(encodeURIComponent(p) + \"=\" + encodeURIComponent(obj[p]));\n    }\n  return str.join(\"&\");\n};\n","\"use strict\";\n\nclass RouteException {\n  constructor(message) {\n    this.name = \"Route exception.\";\n    this.message = message;\n  }\n}\n\nmodule.exports = {\n  RouteException,\n};\n","\"use strict\";\n\nconst serializeObjectToQueryString = require(\"../helpers/serializeObjectToQueryString\");\nconst RouteException = require(\"./exceptions\").RouteException;\n\nmodule.exports = function  buildURL (uri, params = {}) {\n  if (typeof params !== \"object\")\n    throw new RouteException(\n      `Error on route ${uri}. Optional route params should be an object, ${typeof params} given.`\n    );\n\n  if (!params || Object.keys(params).length <= 0) {\n    return uri;\n  }\n\n  return uri + \"?\" + serializeObjectToQueryString(params);\n};\n","\"use strict\";\n\nconst pathToRegexp = require(\"path-to-regexp\");\nconst buildFullPath = require(\"./core/buildFullPath\");\nconst buildURL = require(\"./core/buildURL\");\nconst RouteException = require(\"./core/exceptions\").RouteException;\n\nclass Generator {\n  constructor( config = {}) {\n    this.defaults = config;\n\n    this.build = this.build.bind(this);\n  }\n\n  build( route, params = {}) {\n    let path;\n\n    if (typeof params !== \"object\") {\n      throw new RouteException(\n        `Error on route ${route}. Route params should be an object, ${typeof params} given.`\n      );\n    }\n\n    if (Object.keys(params).length === 0 || Object.values(params).every(o => o === undefined)) {\n      path = route;\n    } else\n      try {\n        path = pathToRegexp.compile(route)(params);\n      } catch (e) {\n        throw new RouteException(`Error on route ${route}. ${e.message}`);\n      }\n\n    const compiledUrl = buildFullPath(this.defaults.baseURL, path);\n    return optionalParams => buildURL(compiledUrl, optionalParams);\n  };\n}\n\nconst generator = new Generator();\n\n// Factory for new instances\ngenerator.create = function create(config = {}) {\n  return new Generator(Object.assign({}, generator.defaults, config));\n}\n\n// Expose class\ngenerator.Generator = Generator;\n\n// Backwards compatibility with 1.x\ngenerator.uri = generator.build;\n\nmodule.exports = generator;\nmodule.exports.default = generator;\n","module.exports = require(\"./lib/generator\");\n"],"names":["lexer","str","tokens","i","char","name","j","code","count","pattern","parse","options","_a","prefixes","defaultPattern","escapeString","result","key","path","tryConsume","type","mustConsume","value","nextType","index","consumeText","prefix","open","name_1","pattern_1","suffix","compile","tokensToFunction","reFlags","flags","encode","x","_b","validate","matches","token","data","optional","repeat","segment","typeOfMessage","match","keys","re","pathToRegexp","regexpToFunction","decode","pathname","m","params","_loop_1","regexpToRegexp","groups","arrayToRegexp","paths","parts","stringToRegexp","tokensToRegexp","strict","start","_c","end","_d","endsWith","delimiter","route","_i","tokens_1","mod","endToken","isEndDelimited","isAbsoluteURL","url","combineURLs","baseURL","relativeURL","require$$0","require$$1","buildFullPath","requestedPath","serializeObjectToQueryString","obj","p","RouteException$2","message","exceptions","RouteException","buildURL","uri","require$$2","require$$3","Generator","config","o","e","compiledUrl","optionalParams","generator","generatorModule","urlRoutesGenerator"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8]}