{"version":3,"sources":["webpack:///./node_modules/serialize-query-params/esm/withDefault.js","webpack:///./node_modules/serialize-query-params/esm/serialize.js","webpack:///./node_modules/serialize-query-params/esm/params.js","webpack:///./node_modules/serialize-query-params/esm/updateLocation.js","webpack:///./node_modules/serialize-query-params/esm/encodeQueryParams.js","webpack:///./node_modules/use-query-params/esm/shallowEqual.js","webpack:///./node_modules/use-query-params/esm/helpers.js","webpack:///./node_modules/use-query-params/esm/updateUrlQuery.js","webpack:///./node_modules/use-query-params/esm/LocationProvider.js","webpack:///./node_modules/use-query-params/esm/memoizedQueryParser.js","webpack:///./node_modules/use-query-params/esm/useQueryParams.js","webpack:///./node_modules/use-query-params/esm/QueryParams.js","webpack:///./node_modules/use-query-params/esm/QueryParamProvider.js","webpack:///./node_modules/query-string/index.js","webpack:///./node_modules/strict-uri-encode/index.js","webpack:///./node_modules/decode-uri-component/index.js","webpack:///./node_modules/split-on-first/index.js","webpack:///./node_modules/filter-obj/index.js"],"names":["__assign","Object","assign","t","s","i","n","arguments","length","p","prototype","hasOwnProperty","call","apply","this","withDefault","param","defaultValue","includeNull","decode","args","_i","decodedValue","undefined","__spreadArray","to","from","il","j","getEncodedValue","input","allowEmptyString","str","Array","decodeNumber","numStr","encodeString","String","decodeString","StringParam","encode","NumberParam","num","JsonParam","any","JSON","stringify","jsonStr","result","parse","e","DateParam","date","year","getFullYear","month","getMonth","day","getDate","dateString","parts","split","decoded","Date","bind","isNaN","getTime","equals","valueA","valueB","BooleanParam","bool","boolStr","map","d","encodeURIComponent","updateLocation","encodedQuery","location","stringifyOptions","encodedSearchString","transformSearchString","search","href","url","key","now","query","encodeQueryParams","paramConfigMap","paramNames_1","keys","paramName","is","x","y","shallowEqual","objA","objB","equalMap","_a","_b","keysA","keysB","isEqual","useUpdateRefIfShallowNew","ref","newValue","hasNew","current","getSSRSafeSearchString","window","pathname","createLocationWithChanges","queryReplacements","updateType","encodedQueryReplacements","currQuery","parseNumbers","updateInLocation","LocationContext","getLocation","setLocation","useLocationContext","LocationProvider","history","children","locationRef","push","replace","updateUrlQuery","Provider","value","initialSearchString","cachedSearchString","cachedParsedQuery","sharedMemoizedQueryParser","newSearchString","getLatestDecodedValues","paramConfigMapRef","parsedQueryRef","encodedValuesCacheRef","decodedValuesCacheRef","hasNewParamConfigMap","parsedQuery","encodedValues","decodedValues","encodedValuesCache","decodedValuesCache","paramConfig","encodedValue","useQueryParams","a","b","setQueryDeps","setQueryDepsRef","changes","encodedChanges","deps","latestValues","cachedWindowHistory","cachedAdaptedWindowHistory","cachedReachHistory","cachedAdaptedReachHistory","adaptReachHistory","adaptedReachHistory","navigate","protocol","host","getLocationProps","adaptedWindowHistory","replaceState","state","pushState","adaptWindowHistory","Error","QueryParamProvider","ReactRouterRoute","reachHistory","stringifyOptionsRef","stringifyOptionsCached","routeProps","strictUriEncode","decodeComponent","splitOnFirst","filterObject","encodeFragmentIdentifier","Symbol","validateArrayFormatSeparator","TypeError","options","strict","removeHash","hashStart","indexOf","slice","extract","queryStart","parseValue","Number","trim","parseBooleans","toLowerCase","sort","arrayFormat","arrayFormatSeparator","formatter","accumulator","exec","concat","isArray","includes","isEncodedArray","item","test","arrayValue","parserForArrayFormat","ret","create","k","reduce","Boolean","keysSorter","exports","object","shouldFilter","skipNull","skipEmptyString","index","join","keyValueSep","encoderForArrayFormat","objectCopy","filter","parseUrl","url_","hash","parseFragmentIdentifier","fragmentIdentifier","stringifyUrl","queryFromUrl","parsedQueryFromUrl","queryString","getHash","pick","exclude","exclusionFilter","module","charCodeAt","toString","toUpperCase","singleMatcher","RegExp","multiMatcher","decodeComponents","components","decodeURIComponent","err","left","right","tokens","match","encodedURI","replaceMap","entries","customDecodeURIComponent","string","separator","separatorIndex","obj","predicate","isArr","val"],"mappings":"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","file":"defaultVendors~AdviceLineListing~AplHomepageHero~AplLandscaperListing~AplSearchBanner~CourseListing~~f95978b9-fd0116b604ebdf7db528.js","sourcesContent":["var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nexport function withDefault(param, defaultValue, includeNull) {\n    if (includeNull === void 0) { includeNull = true; }\n    var decodeWithDefault = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var decodedValue = param.decode.apply(param, args);\n        if (decodedValue === undefined) {\n            return defaultValue;\n        }\n        if (includeNull) {\n            if (decodedValue === null) {\n                return defaultValue;\n            }\n            else {\n                return decodedValue;\n            }\n        }\n        return decodedValue;\n    };\n    return __assign(__assign({}, param), { decode: decodeWithDefault });\n}\nexport default withDefault;\n","var __spreadArray = (this && this.__spreadArray) || function (to, from) {\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\n        to[j] = from[i];\n    return to;\n};\n/**\n * Interprets an encoded string and returns either the string or null/undefined if not available.\n * Ignores array inputs (takes just first element in array)\n * @param input encoded string\n */\nfunction getEncodedValue(input, allowEmptyString) {\n    if (input == null) {\n        return input;\n    }\n    // '' or []\n    if (input.length === 0 &&\n        (!allowEmptyString || (allowEmptyString && input !== ''))) {\n        return null;\n    }\n    var str = input instanceof Array ? input[0] : input;\n    if (str == null) {\n        return str;\n    }\n    if (!allowEmptyString && str === '') {\n        return null;\n    }\n    return str;\n}\n/**\n * Interprets an encoded string and return null/undefined or an array with\n * the encoded string contents\n * @param input encoded string\n */\nfunction getEncodedValueArray(input) {\n    if (input == null) {\n        return input;\n    }\n    return input instanceof Array ? input : input === '' ? [] : [input];\n}\n/**\n * Encodes a date as a string in YYYY-MM-DD format.\n *\n * @param {Date} date\n * @return {String} the encoded date\n */\nexport function encodeDate(date) {\n    if (date == null) {\n        return date;\n    }\n    var year = date.getFullYear();\n    var month = date.getMonth() + 1;\n    var day = date.getDate();\n    return year + \"-\" + (month < 10 ? \"0\" + month : month) + \"-\" + (day < 10 ? \"0\" + day : day);\n}\n/**\n * Converts a date in the format 'YYYY-mm-dd...' into a proper date, because\n * new Date() does not do that correctly. The date can be as complete or incomplete\n * as necessary (aka, '2015', '2015-10', '2015-10-01').\n * It will not work for dates that have times included in them.\n *\n * If an array is provided, only the first entry is used.\n *\n * @param  {String} input String date form like '2015-10-01'\n * @return {Date} parsed date\n */\nexport function decodeDate(input) {\n    var dateString = getEncodedValue(input);\n    if (dateString == null)\n        return dateString;\n    var parts = dateString.split('-');\n    // may only be a year so won't even have a month\n    if (parts[1] != null) {\n        parts[1] -= 1; // Note: months are 0-based\n    }\n    else {\n        // just a year, set the month and day to the first\n        parts[1] = 0;\n        parts[2] = 1;\n    }\n    var decoded = new (Date.bind.apply(Date, __spreadArray([void 0], parts)))();\n    if (isNaN(decoded.getTime())) {\n        return null;\n    }\n    return decoded;\n}\n/**\n * Encodes a date as a string in ISO 8601 (\"2019-05-28T10:58:40Z\") format.\n *\n * @param {Date} date\n * @return {String} the encoded date\n */\nexport function encodeDateTime(date) {\n    if (date == null) {\n        return date;\n    }\n    return date.toISOString();\n}\n/**\n * Converts a date in the https://en.wikipedia.org/wiki/ISO_8601 format.\n * For allowed inputs see specs:\n *  - https://tools.ietf.org/html/rfc2822#page-14\n *  - http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15\n *\n * If an array is provided, only the first entry is used.\n *\n * @param  {String} input String date form like '1995-12-17T03:24:00'\n * @return {Date} parsed date\n */\nexport function decodeDateTime(input) {\n    var dateString = getEncodedValue(input);\n    if (dateString == null)\n        return dateString;\n    var decoded = new Date(dateString);\n    if (isNaN(decoded.getTime())) {\n        return null;\n    }\n    return decoded;\n}\n/**\n * Encodes a boolean as a string. true -> \"1\", false -> \"0\".\n *\n * @param {Boolean} bool\n * @return {String} the encoded boolean\n */\nexport function encodeBoolean(bool) {\n    if (bool == null) {\n        return bool;\n    }\n    return bool ? '1' : '0';\n}\n/**\n * Decodes a boolean from a string. \"1\" -> true, \"0\" -> false.\n * Everything else maps to undefined.\n *\n * If an array is provided, only the first entry is used.\n *\n * @param {String} input the encoded boolean string\n * @return {Boolean} the boolean value\n */\nexport function decodeBoolean(input) {\n    var boolStr = getEncodedValue(input);\n    if (boolStr == null)\n        return boolStr;\n    if (boolStr === '1') {\n        return true;\n    }\n    else if (boolStr === '0') {\n        return false;\n    }\n    return null;\n}\n/**\n * Encodes a number as a string.\n *\n * @param {Number} num\n * @return {String} the encoded number\n */\nexport function encodeNumber(num) {\n    if (num == null) {\n        return num;\n    }\n    return String(num);\n}\n/**\n * Decodes a number from a string. If the number is invalid,\n * it returns undefined.\n *\n * If an array is provided, only the first entry is used.\n *\n * @param {String} input the encoded number string\n * @return {Number} the number value\n */\nexport function decodeNumber(input) {\n    var numStr = getEncodedValue(input);\n    if (numStr == null)\n        return numStr;\n    if (numStr === '')\n        return null;\n    var result = +numStr;\n    return result;\n}\n/**\n * Encodes a string while safely handling null and undefined values.\n *\n * @param {String} str a string to encode\n * @return {String} the encoded string\n */\nexport function encodeString(str) {\n    if (str == null) {\n        return str;\n    }\n    return String(str);\n}\n/**\n * Decodes a string while safely handling null and undefined values.\n *\n * If an array is provided, only the first entry is used.\n *\n * @param {String} input the encoded string\n * @return {String} the string value\n */\nexport function decodeString(input) {\n    var str = getEncodedValue(input, true);\n    if (str == null)\n        return str;\n    return String(str);\n}\n/**\n * Decodes an enum value while safely handling null and undefined values.\n *\n * If an array is provided, only the first entry is used.\n *\n * @param {String} input the encoded string\n * @param {String[]} enumValues allowed enum values\n * @return {String} the string value from enumValues\n */\nexport function decodeEnum(input, enumValues) {\n    var str = decodeString(input);\n    if (str == null)\n        return str;\n    return enumValues.includes(str) ? str : undefined;\n}\n/**\n * Encodes anything as a JSON string.\n *\n * @param {Any} any The thing to be encoded\n * @return {String} The JSON string representation of any\n */\nexport function encodeJson(any) {\n    if (any == null) {\n        return any;\n    }\n    return JSON.stringify(any);\n}\n/**\n * Decodes a JSON string into javascript\n *\n * If an array is provided, only the first entry is used.\n *\n * @param {String} input The JSON string representation\n * @return {Any} The javascript representation\n */\nexport function decodeJson(input) {\n    var jsonStr = getEncodedValue(input);\n    if (jsonStr == null)\n        return jsonStr;\n    var result = null;\n    try {\n        result = JSON.parse(jsonStr);\n    }\n    catch (e) {\n        /* ignore errors, returning undefined */\n    }\n    return result;\n}\n/**\n * Encodes an array as a JSON string.\n *\n * @param {Array} array The array to be encoded\n * @return {String[]} The array of strings to be put in the URL\n * as repeated query parameters\n */\nexport function encodeArray(array) {\n    if (array == null) {\n        return array;\n    }\n    return array;\n}\n/**\n * Decodes an array or singular value and returns it as an array\n * or undefined if falsy. Filters out undefined values.\n *\n * @param {String | Array} input The input value\n * @return {Array} The javascript representation\n */\nexport function decodeArray(input) {\n    var arr = getEncodedValueArray(input);\n    if (arr == null)\n        return arr;\n    return arr;\n}\n/**\n * Encodes a numeric array as a JSON string.\n *\n * @param {Array} array The array to be encoded\n * @return {String[]} The array of strings to be put in the URL\n * as repeated query parameters\n */\nexport function encodeNumericArray(array) {\n    if (array == null) {\n        return array;\n    }\n    return array.map(String);\n}\n/**\n * Decodes an array or singular value and returns it as an array\n * or undefined if falsy. Filters out undefined and NaN values.\n *\n * @param {String | Array} input The input value\n * @return {Array} The javascript representation\n */\nexport function decodeNumericArray(input) {\n    var arr = decodeArray(input);\n    if (arr == null)\n        return arr;\n    return arr.map(function (d) { return (d === '' || d == null ? null : +d); });\n}\n/**\n * Encodes an array as a delimited string. For example,\n * ['a', 'b'] -> 'a_b' with entrySeparator='_'\n *\n * @param array The array to be encoded\n * @param entrySeparator The string used to delimit entries\n * @return The array as a string with elements joined by the\n * entry separator\n */\nexport function encodeDelimitedArray(array, entrySeparator) {\n    if (entrySeparator === void 0) { entrySeparator = '_'; }\n    if (array == null) {\n        return array;\n    }\n    return array.join(entrySeparator);\n}\n/**\n * Decodes a delimited string into javascript array. For example,\n * 'a_b' -> ['a', 'b'] with entrySeparator='_'\n *\n * If an array is provided as input, only the first entry is used.\n *\n * @param {String} input The JSON string representation\n * @param entrySeparator The array as a string with elements joined by the\n * entry separator\n * @return {Array} The javascript representation\n */\nexport function decodeDelimitedArray(input, entrySeparator) {\n    if (entrySeparator === void 0) { entrySeparator = '_'; }\n    var arrayStr = getEncodedValue(input, true);\n    if (arrayStr == null)\n        return arrayStr;\n    if (arrayStr === '')\n        return [];\n    return arrayStr.split(entrySeparator);\n}\n/**\n * Encodes a numeric array as a delimited string. (alias of encodeDelimitedArray)\n * For example, [1, 2] -> '1_2' with entrySeparator='_'\n *\n * @param {Array} array The array to be encoded\n * @return {String} The JSON string representation of array\n */\nexport var encodeDelimitedNumericArray = encodeDelimitedArray;\n/**\n * Decodes a delimited string into javascript array where all entries are numbers\n * For example, '1_2' -> [1, 2] with entrySeparator='_'\n *\n * If an array is provided as input, only the first entry is used.\n *\n * @param {String} jsonStr The JSON string representation\n * @return {Array} The javascript representation\n */\nexport function decodeDelimitedNumericArray(arrayStr, entrySeparator) {\n    if (entrySeparator === void 0) { entrySeparator = '_'; }\n    var decoded = decodeDelimitedArray(arrayStr, entrySeparator);\n    if (decoded == null)\n        return decoded;\n    return decoded.map(function (d) { return (d === '' || d == null ? null : +d); });\n}\n/**\n * Encode simple objects as readable strings. Works only for simple,\n * flat objects where values are numbers, strings.\n *\n * For example { foo: bar, boo: baz } -> \"foo-bar_boo-baz\"\n *\n * @param {Object} object The object to encode\n * @param {String} keyValSeparator=\"-\" The separator between keys and values\n * @param {String} entrySeparator=\"_\" The separator between entries\n * @return {String} The encoded object\n */\nexport function encodeObject(obj, keyValSeparator, entrySeparator) {\n    if (keyValSeparator === void 0) { keyValSeparator = '-'; }\n    if (entrySeparator === void 0) { entrySeparator = '_'; }\n    if (obj == null)\n        return obj; // null or undefined\n    if (!Object.keys(obj).length)\n        return ''; // {} case\n    return Object.keys(obj)\n        .map(function (key) { return \"\" + key + keyValSeparator + obj[key]; })\n        .join(entrySeparator);\n}\n/**\n * Decodes a simple object to javascript. Currently works only for simple,\n * flat objects where values are strings.\n *\n * For example \"foo-bar_boo-baz\" -> { foo: bar, boo: baz }\n *\n * If an array is provided as input, only the first entry is used.\n *\n * @param {String} input The object string to decode\n * @param {String} keyValSeparator=\"-\" The separator between keys and values\n * @param {String} entrySeparator=\"_\" The separator between entries\n * @return {Object} The javascript object\n */\nexport function decodeObject(input, keyValSeparator, entrySeparator) {\n    if (keyValSeparator === void 0) { keyValSeparator = '-'; }\n    if (entrySeparator === void 0) { entrySeparator = '_'; }\n    var objStr = getEncodedValue(input, true);\n    if (objStr == null)\n        return objStr;\n    if (objStr === '')\n        return {};\n    var obj = {};\n    var keyValSeparatorRegExp = new RegExp(keyValSeparator + \"(.*)\");\n    objStr.split(entrySeparator).forEach(function (entryStr) {\n        var _a = entryStr.split(keyValSeparatorRegExp), key = _a[0], value = _a[1];\n        obj[key] = value;\n    });\n    return obj;\n}\n/**\n * Encode simple objects as readable strings. Alias of encodeObject.\n *\n * For example { foo: 123, boo: 521 } -> \"foo-123_boo-521\"\n *\n * @param {Object} object The object to encode\n * @param {String} keyValSeparator=\"-\" The separator between keys and values\n * @param {String} entrySeparator=\"_\" The separator between entries\n * @return {String} The encoded object\n */\nexport var encodeNumericObject = encodeObject;\n/**\n * Decodes a simple object to javascript where all values are numbers.\n * Currently works only for simple, flat objects.\n *\n * For example \"foo-123_boo-521\" -> { foo: 123, boo: 521 }\n *\n * If an array is provided as input, only the first entry is used.\n *\n * @param {String} input The object string to decode\n * @param {String} keyValSeparator=\"-\" The separator between keys and values\n * @param {String} entrySeparator=\"_\" The separator between entries\n * @return {Object} The javascript object\n */\nexport function decodeNumericObject(input, keyValSeparator, entrySeparator) {\n    if (keyValSeparator === void 0) { keyValSeparator = '-'; }\n    if (entrySeparator === void 0) { entrySeparator = '_'; }\n    var decoded = decodeObject(input, keyValSeparator, entrySeparator);\n    if (decoded == null)\n        return decoded;\n    // convert to numbers\n    var decodedNumberObj = {};\n    for (var _i = 0, _a = Object.keys(decoded); _i < _a.length; _i++) {\n        var key = _a[_i];\n        decodedNumberObj[key] = decodeNumber(decoded[key]);\n    }\n    return decodedNumberObj;\n}\n","import * as Serialize from './serialize';\n/**\n * String values\n */\nexport var StringParam = {\n    encode: Serialize.encodeString,\n    decode: Serialize.decodeString,\n};\n/**\n * String enum\n */\nexport var createEnumParam = function (enumValues) { return ({\n    encode: Serialize.encodeString,\n    decode: function (input) { return Serialize.decodeEnum(input, enumValues); },\n}); };\n/**\n * Numbers (integers or floats)\n */\nexport var NumberParam = {\n    encode: Serialize.encodeNumber,\n    decode: Serialize.decodeNumber,\n};\n/**\n * For flat objects where values are strings\n */\nexport var ObjectParam = {\n    encode: Serialize.encodeObject,\n    decode: Serialize.decodeObject,\n};\n/**\n * For flat arrays of strings, filters out undefined values during decode\n */\nexport var ArrayParam = {\n    encode: Serialize.encodeArray,\n    decode: Serialize.decodeArray,\n};\n/**\n * For flat arrays of strings, filters out undefined values during decode\n */\nexport var NumericArrayParam = {\n    encode: Serialize.encodeNumericArray,\n    decode: Serialize.decodeNumericArray,\n};\n/**\n * For any type of data, encoded via JSON.stringify\n */\nexport var JsonParam = {\n    encode: Serialize.encodeJson,\n    decode: Serialize.decodeJson,\n};\n/**\n * For simple dates (YYYY-MM-DD)\n */\nexport var DateParam = {\n    encode: Serialize.encodeDate,\n    decode: Serialize.decodeDate,\n    equals: function (valueA, valueB) {\n        if (valueA === valueB)\n            return true;\n        if (valueA == null || valueB == null)\n            return valueA === valueB;\n        // ignore time of day\n        return (valueA.getFullYear() === valueB.getFullYear() &&\n            valueA.getMonth() === valueB.getMonth() &&\n            valueA.getDate() === valueB.getDate());\n    },\n};\n/**\n * For dates in simplified extended ISO format (YYYY-MM-DDTHH:mm:ss.sssZ or ±YYYYYY-MM-DDTHH:mm:ss.sssZ)\n */\nexport var DateTimeParam = {\n    encode: Serialize.encodeDateTime,\n    decode: Serialize.decodeDateTime,\n    equals: function (valueA, valueB) {\n        if (valueA === valueB)\n            return true;\n        if (valueA == null || valueB == null)\n            return valueA === valueB;\n        return valueA.valueOf() === valueB.valueOf();\n    },\n};\n/**\n * For boolean values: 1 = true, 0 = false\n */\nexport var BooleanParam = {\n    encode: Serialize.encodeBoolean,\n    decode: Serialize.decodeBoolean,\n};\n/**\n * For flat objects where the values are numbers\n */\nexport var NumericObjectParam = {\n    encode: Serialize.encodeNumericObject,\n    decode: Serialize.decodeNumericObject,\n};\n/**\n * For flat arrays of strings, filters out undefined values during decode\n */\nexport var DelimitedArrayParam = {\n    encode: Serialize.encodeDelimitedArray,\n    decode: Serialize.decodeDelimitedArray,\n};\n/**\n * For flat arrays where the values are numbers, filters out undefined values during decode\n */\nexport var DelimitedNumericArrayParam = {\n    encode: Serialize.encodeDelimitedNumericArray,\n    decode: Serialize.decodeDelimitedNumericArray,\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { stringify, parse as parseQueryString, parseUrl, } from 'query-string';\n/**\n * An example of a transformSearchString function that undoes encoding of\n * common JSON characters that are technically allowed in URLs.\n */\nvar JSON_SAFE_CHARS = \"{}[],\\\":\"\n    .split('')\n    .map(function (d) { return [d, encodeURIComponent(d)]; });\nexport function transformSearchStringJsonSafe(searchString) {\n    var str = searchString;\n    for (var _i = 0, JSON_SAFE_CHARS_1 = JSON_SAFE_CHARS; _i < JSON_SAFE_CHARS_1.length; _i++) {\n        var _a = JSON_SAFE_CHARS_1[_i], char = _a[0], code = _a[1];\n        str = str.replace(new RegExp('\\\\' + code, 'g'), char);\n    }\n    return str;\n}\n/**\n * Update a location, wiping out parameters not included in encodedQuery\n * If a param is set to undefined it will be removed from the URL.\n */\nexport function updateLocation(encodedQuery, location, stringifyOptions) {\n    var encodedSearchString = stringify(encodedQuery, stringifyOptions);\n    if (stringifyOptions && stringifyOptions.transformSearchString) {\n        encodedSearchString = stringifyOptions.transformSearchString(encodedSearchString);\n    }\n    var search = encodedSearchString.length ? \"?\" + encodedSearchString : '';\n    var href = parseUrl(location.href || '').url + search;\n    var newLocation = __assign(__assign({}, location), { key: \"\" + Date.now(), // needed for some routers (e.g. react-router)\n        href: href,\n        search: search, query: encodedQuery });\n    return newLocation;\n}\n/**\n * Update a location while retaining existing parameters.\n * If a param is set to undefined it will be removed from the URL.\n */\nexport function updateInLocation(encodedQueryReplacements, location, stringifyOptions) {\n    // explicitly avoid parsing numbers to ensure the\n    // return type has the same shape as EncodeQuery\n    var currQuery = parseQueryString(location.search, { parseNumbers: false });\n    var newQuery = __assign(__assign({}, currQuery), encodedQueryReplacements);\n    return updateLocation(newQuery, location, stringifyOptions);\n}\n","/**\n * Convert the values in query to strings via the encode functions configured\n * in paramConfigMap\n *\n * @param paramConfigMap Map from query name to { encode, decode } config\n * @param query Query updates mapping param name to decoded value\n */\nexport function encodeQueryParams(paramConfigMap, query) {\n    var encodedQuery = {};\n    var paramNames = Object.keys(query);\n    for (var _i = 0, paramNames_1 = paramNames; _i < paramNames_1.length; _i++) {\n        var paramName = paramNames_1[_i];\n        var decodedValue = query[paramName];\n        if (!paramConfigMap[paramName]) {\n            if (process.env.NODE_ENV === 'development') {\n                console.warn(\"Encoding parameter \" + paramName + \" as string since it was not configured.\");\n            }\n            // NOTE: we could just not encode it, but it is probably convenient to have\n            // it be included by default as a string type.\n            encodedQuery[paramName] =\n                decodedValue == null ? decodedValue : String(decodedValue);\n        }\n        else {\n            encodedQuery[paramName] = paramConfigMap[paramName].encode(query[paramName]);\n        }\n    }\n    return encodedQuery;\n}\nexport default encodeQueryParams;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license at\n * https://github.com/facebook/fbjs/blob/master/LICENSE\n */\n/*eslint-disable no-self-compare */\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n/**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\nfunction is(x, y) {\n    // SameValue algorithm\n    if (x === y) {\n        // Steps 1-5, 7-10\n        // Steps 6.b-6.e: +0 != -0\n        // Added the nonzero y check to make Flow happy, but it is redundant\n        return x !== 0 || y !== 0 || 1 / x === 1 / y;\n    }\n    else {\n        // Step 6.a: NaN == NaN\n        return x !== x && y !== y;\n    }\n}\n/**\n * Performs equality by iterating through keys on an object and returning false\n * when any key has values which are not strictly equal between the arguments.\n * Returns true when the values of all keys are strictly equal.\n\n * @pbeshai modification of shallowEqual to take into consideration a map providing\n * equals functions\n */\nexport default function shallowEqual(objA, objB, equalMap) {\n    var _a, _b;\n    if (is(objA, objB)) {\n        return true;\n    }\n    if (typeof objA !== 'object' ||\n        objA === null ||\n        typeof objB !== 'object' ||\n        objB === null) {\n        return false;\n    }\n    var keysA = Object.keys(objA);\n    var keysB = Object.keys(objB);\n    if (keysA.length !== keysB.length) {\n        return false;\n    }\n    // Test for A's keys different from B.\n    for (var i = 0; i < keysA.length; i++) {\n        var isEqual = (_b = (_a = equalMap === null || equalMap === void 0 ? void 0 : equalMap[keysA[i]]) === null || _a === void 0 ? void 0 : _a.equals) !== null && _b !== void 0 ? _b : is;\n        if (!hasOwnProperty.call(objB, keysA[i]) ||\n            !isEqual(objA[keysA[i]], objB[keysA[i]])) {\n            return false;\n        }\n    }\n    return true;\n}\n","import * as React from 'react';\nimport { extract } from 'query-string';\nimport shallowEqual from './shallowEqual';\nexport function useUpdateRefIfShallowNew(ref, newValue, isEqual) {\n    if (isEqual === void 0) { isEqual = shallowEqual; }\n    var hasNew = ((ref.current == null || newValue == null) && ref.current === newValue) ||\n        !isEqual(ref.current, newValue);\n    React.useEffect(function () {\n        if (hasNew) {\n            ref.current = newValue;\n        }\n    }, [ref, newValue, hasNew]);\n}\nexport function getSSRSafeSearchString(location) {\n    // handle checking SSR (#13)\n    if (typeof location === 'object') {\n        // in browser\n        if (typeof window !== 'undefined') {\n            return location.search;\n        }\n        else {\n            return extract(\"\" + location.pathname + (location.search ? location.search : ''));\n        }\n    }\n    return '';\n}\n","import { updateLocation, updateInLocation, } from 'serialize-query-params';\n/**\n * Creates a new location object containing the specified query changes.\n * If replaceIn or pushIn are used as the updateType, then parameters\n * not specified in queryReplacements are retained. If replace or push\n * are used, only the values in queryReplacements will be available.\n * The default is pushIn.\n */\nexport function createLocationWithChanges(queryReplacements, location, updateType, stringifyOptions) {\n    if (updateType === void 0) { updateType = 'pushIn'; }\n    switch (updateType) {\n        case 'replace':\n        case 'push':\n            return updateLocation(queryReplacements, location, stringifyOptions);\n        case 'replaceIn':\n        case 'pushIn':\n        default:\n            return updateInLocation(queryReplacements, location, stringifyOptions);\n    }\n}\n/**\n * Updates the URL to the new location.\n */\nexport function updateUrlQuery(history, location, updateType) {\n    if (updateType === void 0) { updateType = 'pushIn'; }\n    switch (updateType) {\n        case 'pushIn':\n        case 'push':\n            history.push(location);\n            break;\n        case 'replaceIn':\n        case 'replace':\n        default:\n            history.replace(location);\n            break;\n    }\n}\n","import * as React from 'react';\nimport { updateUrlQuery, createLocationWithChanges } from './updateUrlQuery';\nvar providerlessContextValue = {\n    location: {},\n    getLocation: function () { return ({}); },\n    setLocation: function () { },\n};\nexport var LocationContext = React.createContext(providerlessContextValue);\nexport function useLocationContext() {\n    var context = React.useContext(LocationContext);\n    if (process.env.NODE_ENV !== 'production' &&\n        (context === undefined || context === providerlessContextValue)) {\n        throw new Error('useQueryParams must be used within a QueryParamProvider');\n    }\n    return context;\n}\n/**\n * An internal-only context provider which provides down the most\n * recent location object and a callback to update the history.\n */\nexport function LocationProvider(_a) {\n    var history = _a.history, location = _a.location, children = _a.children, stringifyOptions = _a.stringifyOptions;\n    var locationRef = React.useRef(location);\n    React.useEffect(function () {\n        locationRef.current = location;\n    }, [location]);\n    // TODO: we can probably simplify this now that we are reading location from history\n    var getLocation = React.useCallback(function () { return locationRef.current; }, [\n        locationRef,\n    ]);\n    var setLocation = React.useCallback(function (queryReplacements, updateType) {\n        // A ref is needed here to stop setLocation updating constantly (see #46)\n        locationRef.current = createLocationWithChanges(queryReplacements, history == null || history.location == null\n            ? locationRef.current\n            : history.location, updateType, stringifyOptions);\n        if (history) {\n            updateUrlQuery(history, locationRef.current, updateType);\n        }\n    }, [history, stringifyOptions]);\n    return (React.createElement(LocationContext.Provider, { value: { location: location, getLocation: getLocation, setLocation: setLocation } }, children));\n}\n","import { parse as parseQueryString } from 'query-string';\nexport var makeMemoizedQueryParser = function (initialSearchString) {\n    var cachedSearchString = initialSearchString;\n    var cachedParsedQuery = parseQueryString(cachedSearchString || '');\n    return function (newSearchString) {\n        if (cachedSearchString !== newSearchString) {\n            cachedSearchString = newSearchString;\n            cachedParsedQuery = parseQueryString(cachedSearchString);\n        }\n        return cachedParsedQuery;\n    };\n};\nexport var sharedMemoizedQueryParser = makeMemoizedQueryParser();\n","import * as React from 'react';\nimport { encodeQueryParams, } from 'serialize-query-params';\nimport { getSSRSafeSearchString, useUpdateRefIfShallowNew } from './helpers';\nimport { useLocationContext } from './LocationProvider';\nimport { sharedMemoizedQueryParser } from './memoizedQueryParser';\nimport shallowEqual from './shallowEqual';\n/**\n * Helper to get the latest decoded values with smart caching.\n * Abstracted into its own function to allow re-use in a functional setter (#26)\n */\nfunction getLatestDecodedValues(location, paramConfigMap, paramConfigMapRef, parsedQueryRef, encodedValuesCacheRef, decodedValuesCacheRef) {\n    // check if we have a new param config\n    var hasNewParamConfigMap = !shallowEqual(paramConfigMapRef.current, paramConfigMap);\n    // read in the parsed query\n    var parsedQuery = sharedMemoizedQueryParser(getSSRSafeSearchString(location) // get the latest location object\n    );\n    // check if new encoded values are around (new parsed query).\n    // can use triple equals since we already cache this value\n    var hasNewParsedQuery = parsedQueryRef.current !== parsedQuery;\n    // if nothing has changed, use existing.. so long as we have existing.\n    if (!hasNewParsedQuery &&\n        !hasNewParamConfigMap &&\n        encodedValuesCacheRef.current !== undefined) {\n        return {\n            encodedValues: encodedValuesCacheRef.current,\n            decodedValues: decodedValuesCacheRef.current,\n        };\n    }\n    var encodedValuesCache = encodedValuesCacheRef.current || {};\n    var decodedValuesCache = decodedValuesCacheRef.current || {};\n    var encodedValues = {};\n    // we have new encoded values, so let's get new decoded values.\n    // recompute new values but only for those that changed\n    var paramNames = Object.keys(paramConfigMap);\n    var decodedValues = {};\n    for (var _i = 0, paramNames_1 = paramNames; _i < paramNames_1.length; _i++) {\n        var paramName = paramNames_1[_i];\n        // do we have a new encoded value?\n        var paramConfig = paramConfigMap[paramName];\n        var hasNewEncodedValue = !shallowEqual(encodedValuesCache[paramName], parsedQuery[paramName]);\n        // if we have a new encoded value, re-decode. otherwise reuse cache\n        var encodedValue = void 0;\n        var decodedValue = void 0;\n        if (hasNewEncodedValue ||\n            (encodedValuesCache[paramName] === undefined &&\n                decodedValuesCache[paramName] === undefined)) {\n            encodedValue = parsedQuery[paramName];\n            decodedValue = paramConfig.decode(encodedValue);\n        }\n        else {\n            encodedValue = encodedValuesCache[paramName];\n            decodedValue = decodedValuesCache[paramName];\n        }\n        encodedValues[paramName] = encodedValue;\n        decodedValues[paramName] = decodedValue;\n    }\n    // keep referential equality for decoded valus if we didn't actually change anything\n    var hasNewDecodedValues = !shallowEqual(decodedValuesCacheRef.current, decodedValues, paramConfigMap);\n    return {\n        encodedValues: encodedValues,\n        decodedValues: hasNewDecodedValues\n            ? decodedValues\n            : decodedValuesCacheRef.current,\n    };\n}\n/**\n * Given a query parameter configuration (mapping query param name to { encode, decode }),\n * return an object with the decoded values and a setter for updating them.\n */\nexport var useQueryParams = function (paramConfigMap) {\n    var _a = useLocationContext(), location = _a.location, getLocation = _a.getLocation, setLocation = _a.setLocation;\n    // read in the raw query\n    var parsedQuery = sharedMemoizedQueryParser(getSSRSafeSearchString(location));\n    // make caches\n    var paramConfigMapRef = React.useRef(paramConfigMap);\n    var parsedQueryRef = React.useRef(parsedQuery);\n    var encodedValuesCacheRef = React.useRef(undefined); // undefined for initial check\n    var decodedValuesCacheRef = React.useRef({});\n    // memoize paramConfigMap to make the API nicer for consumers.\n    // otherwise we'd have to useQueryParams(useMemo(() => { foo: NumberParam }, []))\n    paramConfigMap = shallowEqual(paramConfigMap, paramConfigMapRef.current)\n        ? paramConfigMapRef.current\n        : paramConfigMap;\n    // decode all the values if we have changes\n    var _b = getLatestDecodedValues(location, paramConfigMap, paramConfigMapRef, parsedQueryRef, encodedValuesCacheRef, decodedValuesCacheRef), encodedValues = _b.encodedValues, decodedValues = _b.decodedValues;\n    // update cached values in useEffects\n    useUpdateRefIfShallowNew(parsedQueryRef, parsedQuery);\n    useUpdateRefIfShallowNew(paramConfigMapRef, paramConfigMap);\n    useUpdateRefIfShallowNew(encodedValuesCacheRef, encodedValues);\n    useUpdateRefIfShallowNew(decodedValuesCacheRef, decodedValues, function (a, b) {\n        return shallowEqual(a, b, paramConfigMap);\n    });\n    // create a setter for updating multiple query params at once\n    var setQueryDeps = {\n        paramConfigMap: paramConfigMap,\n        setLocation: setLocation,\n        getLocation: getLocation,\n    };\n    var setQueryDepsRef = React.useRef(setQueryDeps);\n    setQueryDepsRef.current = setQueryDeps;\n    var setQuery = React.useCallback(function (changes, updateType) {\n        var deps = setQueryDepsRef.current;\n        var encodedChanges;\n        if (typeof changes === 'function') {\n            // get latest decoded value to pass as a fresh arg to the setter fn\n            var latestValues = getLatestDecodedValues(deps.getLocation(), deps.paramConfigMap, paramConfigMapRef, parsedQueryRef, encodedValuesCacheRef, decodedValuesCacheRef).decodedValues;\n            decodedValuesCacheRef.current = latestValues; // keep cache in sync\n            encodedChanges = encodeQueryParams(deps.paramConfigMap, changes(latestValues));\n        }\n        else {\n            // encode as strings for the URL\n            encodedChanges = encodeQueryParams(deps.paramConfigMap, changes);\n        }\n        // update the URL\n        deps.setLocation(encodedChanges, updateType);\n    }, []);\n    // no longer Partial\n    return [decodedValues, setQuery];\n};\nexport default useQueryParams;\n","import useQueryParams from './useQueryParams';\nexport var QueryParams = function (_a) {\n    var config = _a.config, children = _a.children;\n    var _b = useQueryParams(config), query = _b[0], setQuery = _b[1];\n    return children({ query: query, setQuery: setQuery });\n};\nexport default QueryParams;\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport * as React from 'react';\nimport { LocationProvider } from './LocationProvider';\nimport shallowEqual from './shallowEqual';\n// we use a lazy caching solution to prevent #46 from happening\nvar cachedWindowHistory;\nvar cachedAdaptedWindowHistory;\n/**\n * Adapts standard DOM window history to work with our\n * { replace, push } interface.\n *\n * @param history Standard history provided by DOM\n */\nfunction adaptWindowHistory(history) {\n    if (history === cachedWindowHistory && cachedAdaptedWindowHistory != null) {\n        return cachedAdaptedWindowHistory;\n    }\n    var adaptedWindowHistory = {\n        replace: function (location) {\n            history.replaceState(location.state, '', location.protocol + \"//\" + location.host + location.pathname + location.search);\n        },\n        push: function (location) {\n            history.pushState(location.state, '', location.protocol + \"//\" + location.host + location.pathname + location.search);\n        },\n        get location() {\n            return window.location;\n        },\n    };\n    cachedWindowHistory = history;\n    cachedAdaptedWindowHistory = adaptedWindowHistory;\n    return adaptedWindowHistory;\n}\n// we use a lazy caching solution to prevent #46 from happening\nvar cachedReachHistory;\nvar cachedAdaptedReachHistory;\n/**\n * Adapts @reach/router history to work with our\n * { replace, push } interface.\n *\n * @param history globalHistory from @reach/router\n */\nfunction adaptReachHistory(history) {\n    if (history === cachedReachHistory && cachedAdaptedReachHistory != null) {\n        return cachedAdaptedReachHistory;\n    }\n    var adaptedReachHistory = {\n        replace: function (location) {\n            history.navigate(location.protocol + \"//\" + location.host + location.pathname + location.search, { replace: true });\n        },\n        push: function (location) {\n            history.navigate(location.protocol + \"//\" + location.host + location.pathname + location.search, { replace: false });\n        },\n        get location() {\n            return history.location;\n        },\n    };\n    cachedReachHistory = history;\n    cachedAdaptedReachHistory = adaptedReachHistory;\n    return adaptedReachHistory;\n}\n/**\n * Helper to produce the context value falling back to\n * window history and location if not provided.\n */\nexport function getLocationProps(_a) {\n    var _b = _a === void 0 ? {} : _a, history = _b.history, location = _b.location;\n    var hasWindow = typeof window !== 'undefined';\n    if (hasWindow) {\n        if (!history) {\n            history = adaptWindowHistory(window.history);\n        }\n        if (!location) {\n            location = window.location;\n        }\n    }\n    if (!location) {\n        throw new Error(\"\\n        Could not read the location. Is the router wired up correctly?\\n      \");\n    }\n    return { history: history, location: location };\n}\n/**\n * Context provider for query params to have access to the\n * active routing system, enabling updates to the URL.\n */\nexport function QueryParamProvider(_a) {\n    var children = _a.children, ReactRouterRoute = _a.ReactRouterRoute, reachHistory = _a.reachHistory, history = _a.history, location = _a.location, stringifyOptions = _a.stringifyOptions;\n    // cache the stringify options object so we users can just do\n    // <QueryParamProvider stringifyOptions={{ encode: false }} />\n    var stringifyOptionsRef = React.useRef(stringifyOptions);\n    var hasNewStringifyOptions = !shallowEqual(stringifyOptionsRef.current, stringifyOptions);\n    var stringifyOptionsCached = hasNewStringifyOptions\n        ? stringifyOptions\n        : stringifyOptionsRef.current;\n    React.useEffect(function () {\n        stringifyOptionsRef.current = stringifyOptionsCached;\n    }, [stringifyOptionsCached]);\n    // if we have React Router, use it to get the context value\n    if (ReactRouterRoute) {\n        return (React.createElement(ReactRouterRoute, null, function (routeProps) {\n            return (React.createElement(LocationProvider, __assign({ stringifyOptions: stringifyOptionsCached }, getLocationProps(routeProps)), children));\n        }));\n    }\n    // if we are using reach router, use its history\n    if (reachHistory) {\n        return (React.createElement(LocationProvider, __assign({ stringifyOptions: stringifyOptionsCached }, getLocationProps({\n            history: adaptReachHistory(reachHistory),\n            location: location,\n        })), children));\n    }\n    // neither reach nor react-router, so allow manual overrides\n    return (React.createElement(LocationProvider, __assign({ stringifyOptions: stringifyOptionsCached }, getLocationProps({ history: history, location: location })), children));\n}\nexport default QueryParamProvider;\n","'use strict';\nconst strictUriEncode = require('strict-uri-encode');\nconst decodeComponent = require('decode-uri-component');\nconst splitOnFirst = require('split-on-first');\nconst filterObject = require('filter-obj');\n\nconst isNullOrUndefined = value => value === null || value === undefined;\n\nconst encodeFragmentIdentifier = Symbol('encodeFragmentIdentifier');\n\nfunction encoderForArrayFormat(options) {\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tconst index = result.length;\n\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[', index, ']'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [\n\t\t\t\t\t...result,\n\t\t\t\t\t[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')\n\t\t\t\t];\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[]'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '[]=', encode(value, options)].join('')];\n\t\t\t};\n\n\t\tcase 'comma':\n\t\tcase 'separator':\n\t\tcase 'bracket-separator': {\n\t\t\tconst keyValueSep = options.arrayFormat === 'bracket-separator' ?\n\t\t\t\t'[]=' :\n\t\t\t\t'=';\n\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\t// Translate null to an empty string so that it doesn't serialize as 'null'\n\t\t\t\tvalue = value === null ? '' : value;\n\n\t\t\t\tif (result.length === 0) {\n\t\t\t\t\treturn [[encode(key, options), keyValueSep, encode(value, options)].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [[result, encode(value, options)].join(options.arrayFormatSeparator)];\n\t\t\t};\n\t\t}\n\n\t\tdefault:\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, encode(key, options)];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '=', encode(value, options)].join('')];\n\t\t\t};\n\t}\n}\n\nfunction parserForArrayFormat(options) {\n\tlet result;\n\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /\\[(\\d*)\\]$/.exec(key);\n\n\t\t\t\tkey = key.replace(/\\[\\d*\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = {};\n\t\t\t\t}\n\n\t\t\t\taccumulator[key][result[1]] = value;\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /(\\[\\])$/.exec(key);\n\t\t\t\tkey = key.replace(/\\[\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = [value];\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\n\t\tcase 'comma':\n\t\tcase 'separator':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tconst isArray = typeof value === 'string' && value.includes(options.arrayFormatSeparator);\n\t\t\t\tconst isEncodedArray = (typeof value === 'string' && !isArray && decode(value, options).includes(options.arrayFormatSeparator));\n\t\t\t\tvalue = isEncodedArray ? decode(value, options) : value;\n\t\t\t\tconst newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map(item => decode(item, options)) : value === null ? value : decode(value, options);\n\t\t\t\taccumulator[key] = newValue;\n\t\t\t};\n\n\t\tcase 'bracket-separator':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tconst isArray = /(\\[\\])$/.test(key);\n\t\t\t\tkey = key.replace(/\\[\\]$/, '');\n\n\t\t\t\tif (!isArray) {\n\t\t\t\t\taccumulator[key] = value ? decode(value, options) : value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tconst arrayValue = value === null ?\n\t\t\t\t\t[] :\n\t\t\t\t\tvalue.split(options.arrayFormatSeparator).map(item => decode(item, options));\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = arrayValue;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], arrayValue);\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\t}\n}\n\nfunction validateArrayFormatSeparator(value) {\n\tif (typeof value !== 'string' || value.length !== 1) {\n\t\tthrow new TypeError('arrayFormatSeparator must be single character string');\n\t}\n}\n\nfunction encode(value, options) {\n\tif (options.encode) {\n\t\treturn options.strict ? strictUriEncode(value) : encodeURIComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction decode(value, options) {\n\tif (options.decode) {\n\t\treturn decodeComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction keysSorter(input) {\n\tif (Array.isArray(input)) {\n\t\treturn input.sort();\n\t}\n\n\tif (typeof input === 'object') {\n\t\treturn keysSorter(Object.keys(input))\n\t\t\t.sort((a, b) => Number(a) - Number(b))\n\t\t\t.map(key => input[key]);\n\t}\n\n\treturn input;\n}\n\nfunction removeHash(input) {\n\tconst hashStart = input.indexOf('#');\n\tif (hashStart !== -1) {\n\t\tinput = input.slice(0, hashStart);\n\t}\n\n\treturn input;\n}\n\nfunction getHash(url) {\n\tlet hash = '';\n\tconst hashStart = url.indexOf('#');\n\tif (hashStart !== -1) {\n\t\thash = url.slice(hashStart);\n\t}\n\n\treturn hash;\n}\n\nfunction extract(input) {\n\tinput = removeHash(input);\n\tconst queryStart = input.indexOf('?');\n\tif (queryStart === -1) {\n\t\treturn '';\n\t}\n\n\treturn input.slice(queryStart + 1);\n}\n\nfunction parseValue(value, options) {\n\tif (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {\n\t\tvalue = Number(value);\n\t} else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {\n\t\tvalue = value.toLowerCase() === 'true';\n\t}\n\n\treturn value;\n}\n\nfunction parse(query, options) {\n\toptions = Object.assign({\n\t\tdecode: true,\n\t\tsort: true,\n\t\tarrayFormat: 'none',\n\t\tarrayFormatSeparator: ',',\n\t\tparseNumbers: false,\n\t\tparseBooleans: false\n\t}, options);\n\n\tvalidateArrayFormatSeparator(options.arrayFormatSeparator);\n\n\tconst formatter = parserForArrayFormat(options);\n\n\t// Create an object with no prototype\n\tconst ret = Object.create(null);\n\n\tif (typeof query !== 'string') {\n\t\treturn ret;\n\t}\n\n\tquery = query.trim().replace(/^[?#&]/, '');\n\n\tif (!query) {\n\t\treturn ret;\n\t}\n\n\tfor (const param of query.split('&')) {\n\t\tif (param === '') {\n\t\t\tcontinue;\n\t\t}\n\n\t\tlet [key, value] = splitOnFirst(options.decode ? param.replace(/\\+/g, ' ') : param, '=');\n\n\t\t// Missing `=` should be `null`:\n\t\t// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters\n\t\tvalue = value === undefined ? null : ['comma', 'separator', 'bracket-separator'].includes(options.arrayFormat) ? value : decode(value, options);\n\t\tformatter(decode(key, options), value, ret);\n\t}\n\n\tfor (const key of Object.keys(ret)) {\n\t\tconst value = ret[key];\n\t\tif (typeof value === 'object' && value !== null) {\n\t\t\tfor (const k of Object.keys(value)) {\n\t\t\t\tvalue[k] = parseValue(value[k], options);\n\t\t\t}\n\t\t} else {\n\t\t\tret[key] = parseValue(value, options);\n\t\t}\n\t}\n\n\tif (options.sort === false) {\n\t\treturn ret;\n\t}\n\n\treturn (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {\n\t\tconst value = ret[key];\n\t\tif (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {\n\t\t\t// Sort object keys, not values\n\t\t\tresult[key] = keysSorter(value);\n\t\t} else {\n\t\t\tresult[key] = value;\n\t\t}\n\n\t\treturn result;\n\t}, Object.create(null));\n}\n\nexports.extract = extract;\nexports.parse = parse;\n\nexports.stringify = (object, options) => {\n\tif (!object) {\n\t\treturn '';\n\t}\n\n\toptions = Object.assign({\n\t\tencode: true,\n\t\tstrict: true,\n\t\tarrayFormat: 'none',\n\t\tarrayFormatSeparator: ','\n\t}, options);\n\n\tvalidateArrayFormatSeparator(options.arrayFormatSeparator);\n\n\tconst shouldFilter = key => (\n\t\t(options.skipNull && isNullOrUndefined(object[key])) ||\n\t\t(options.skipEmptyString && object[key] === '')\n\t);\n\n\tconst formatter = encoderForArrayFormat(options);\n\n\tconst objectCopy = {};\n\n\tfor (const key of Object.keys(object)) {\n\t\tif (!shouldFilter(key)) {\n\t\t\tobjectCopy[key] = object[key];\n\t\t}\n\t}\n\n\tconst keys = Object.keys(objectCopy);\n\n\tif (options.sort !== false) {\n\t\tkeys.sort(options.sort);\n\t}\n\n\treturn keys.map(key => {\n\t\tconst value = object[key];\n\n\t\tif (value === undefined) {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn encode(key, options);\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\tif (value.length === 0 && options.arrayFormat === 'bracket-separator') {\n\t\t\t\treturn encode(key, options) + '[]';\n\t\t\t}\n\n\t\t\treturn value\n\t\t\t\t.reduce(formatter(key), [])\n\t\t\t\t.join('&');\n\t\t}\n\n\t\treturn encode(key, options) + '=' + encode(value, options);\n\t}).filter(x => x.length > 0).join('&');\n};\n\nexports.parseUrl = (url, options) => {\n\toptions = Object.assign({\n\t\tdecode: true\n\t}, options);\n\n\tconst [url_, hash] = splitOnFirst(url, '#');\n\n\treturn Object.assign(\n\t\t{\n\t\t\turl: url_.split('?')[0] || '',\n\t\t\tquery: parse(extract(url), options)\n\t\t},\n\t\toptions && options.parseFragmentIdentifier && hash ? {fragmentIdentifier: decode(hash, options)} : {}\n\t);\n};\n\nexports.stringifyUrl = (object, options) => {\n\toptions = Object.assign({\n\t\tencode: true,\n\t\tstrict: true,\n\t\t[encodeFragmentIdentifier]: true\n\t}, options);\n\n\tconst url = removeHash(object.url).split('?')[0] || '';\n\tconst queryFromUrl = exports.extract(object.url);\n\tconst parsedQueryFromUrl = exports.parse(queryFromUrl, {sort: false});\n\n\tconst query = Object.assign(parsedQueryFromUrl, object.query);\n\tlet queryString = exports.stringify(query, options);\n\tif (queryString) {\n\t\tqueryString = `?${queryString}`;\n\t}\n\n\tlet hash = getHash(object.url);\n\tif (object.fragmentIdentifier) {\n\t\thash = `#${options[encodeFragmentIdentifier] ? encode(object.fragmentIdentifier, options) : object.fragmentIdentifier}`;\n\t}\n\n\treturn `${url}${queryString}${hash}`;\n};\n\nexports.pick = (input, filter, options) => {\n\toptions = Object.assign({\n\t\tparseFragmentIdentifier: true,\n\t\t[encodeFragmentIdentifier]: false\n\t}, options);\n\n\tconst {url, query, fragmentIdentifier} = exports.parseUrl(input, options);\n\treturn exports.stringifyUrl({\n\t\turl,\n\t\tquery: filterObject(query, filter),\n\t\tfragmentIdentifier\n\t}, options);\n};\n\nexports.exclude = (input, filter, options) => {\n\tconst exclusionFilter = Array.isArray(filter) ? key => !filter.includes(key) : (key, value) => !filter(key, value);\n\n\treturn exports.pick(input, exclusionFilter, options);\n};\n","'use strict';\nmodule.exports = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);\n","'use strict';\nvar token = '%[a-f0-9]{2}';\nvar singleMatcher = new RegExp(token, 'gi');\nvar multiMatcher = new RegExp('(' + token + ')+', 'gi');\n\nfunction decodeComponents(components, split) {\n\ttry {\n\t\t// Try to decode the entire string first\n\t\treturn decodeURIComponent(components.join(''));\n\t} catch (err) {\n\t\t// Do nothing\n\t}\n\n\tif (components.length === 1) {\n\t\treturn components;\n\t}\n\n\tsplit = split || 1;\n\n\t// Split the array in 2 parts\n\tvar left = components.slice(0, split);\n\tvar right = components.slice(split);\n\n\treturn Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));\n}\n\nfunction decode(input) {\n\ttry {\n\t\treturn decodeURIComponent(input);\n\t} catch (err) {\n\t\tvar tokens = input.match(singleMatcher);\n\n\t\tfor (var i = 1; i < tokens.length; i++) {\n\t\t\tinput = decodeComponents(tokens, i).join('');\n\n\t\t\ttokens = input.match(singleMatcher);\n\t\t}\n\n\t\treturn input;\n\t}\n}\n\nfunction customDecodeURIComponent(input) {\n\t// Keep track of all the replacements and prefill the map with the `BOM`\n\tvar replaceMap = {\n\t\t'%FE%FF': '\\uFFFD\\uFFFD',\n\t\t'%FF%FE': '\\uFFFD\\uFFFD'\n\t};\n\n\tvar match = multiMatcher.exec(input);\n\twhile (match) {\n\t\ttry {\n\t\t\t// Decode as big chunks as possible\n\t\t\treplaceMap[match[0]] = decodeURIComponent(match[0]);\n\t\t} catch (err) {\n\t\t\tvar result = decode(match[0]);\n\n\t\t\tif (result !== match[0]) {\n\t\t\t\treplaceMap[match[0]] = result;\n\t\t\t}\n\t\t}\n\n\t\tmatch = multiMatcher.exec(input);\n\t}\n\n\t// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else\n\treplaceMap['%C2'] = '\\uFFFD';\n\n\tvar entries = Object.keys(replaceMap);\n\n\tfor (var i = 0; i < entries.length; i++) {\n\t\t// Replace all decoded components\n\t\tvar key = entries[i];\n\t\tinput = input.replace(new RegExp(key, 'g'), replaceMap[key]);\n\t}\n\n\treturn input;\n}\n\nmodule.exports = function (encodedURI) {\n\tif (typeof encodedURI !== 'string') {\n\t\tthrow new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');\n\t}\n\n\ttry {\n\t\tencodedURI = encodedURI.replace(/\\+/g, ' ');\n\n\t\t// Try the built in decoder first\n\t\treturn decodeURIComponent(encodedURI);\n\t} catch (err) {\n\t\t// Fallback to a more advanced decoder\n\t\treturn customDecodeURIComponent(encodedURI);\n\t}\n};\n","'use strict';\n\nmodule.exports = (string, separator) => {\n\tif (!(typeof string === 'string' && typeof separator === 'string')) {\n\t\tthrow new TypeError('Expected the arguments to be of type `string`');\n\t}\n\n\tif (separator === '') {\n\t\treturn [string];\n\t}\n\n\tconst separatorIndex = string.indexOf(separator);\n\n\tif (separatorIndex === -1) {\n\t\treturn [string];\n\t}\n\n\treturn [\n\t\tstring.slice(0, separatorIndex),\n\t\tstring.slice(separatorIndex + separator.length)\n\t];\n};\n","'use strict';\nmodule.exports = function (obj, predicate) {\n\tvar ret = {};\n\tvar keys = Object.keys(obj);\n\tvar isArr = Array.isArray(predicate);\n\n\tfor (var i = 0; i < keys.length; i++) {\n\t\tvar key = keys[i];\n\t\tvar val = obj[key];\n\n\t\tif (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {\n\t\t\tret[key] = val;\n\t\t}\n\t}\n\n\treturn ret;\n};\n"],"sourceRoot":""}