https://pcgonline.org/wp-content/plugins/the-events-calendar/commo…/js/utils/query-string.js?ver=4.14.6

1(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Qs = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
2'use strict';
3
4var replace = String.prototype.replace;
5var percentTwenties = /%20/g;
6
7module.exports = {
8    'default': 'RFC3986',
9    formatters: {
10        RFC1738: function (value) {
11            return replace.call(value, percentTwenties, '+');
12        },
13        RFC3986: function (value) {
14            return value;
15        }
16    },
17    RFC1738: 'RFC1738',
18    RFC3986: 'RFC3986'

19};
20
21},{}],2:[function(require,module,exports){
22'use strict';
23
24var stringify = require('./stringify');
25var parse = require('./parse');
26var formats = require('./formats');
27
28module.exports = {
29    formats: formats,
30    parse: parse,
31    stringify: stringify
32};
33
34},{"./formats":1,"./parse":3,"./stringify":4}],3:[function(require,module,exports){
35'use strict';
36
37var utils = require('./utils');
38
39var has = Object.prototype.hasOwnProperty;
40
41var defaults = {
42    allowDots: false,
43    allowPrototypes: false,
44    arrayLimit: 20,
45    charset: 'utf-8',
46    charsetSentinel: false,
47    decoder: utils.decode,
48    delimiter: '&',
49    depth: 5,
50    ignoreQueryPrefix: false,
51    interpretNumericEntities: false,
52    parameterLimit: 1000,
53    parseArrays: true,
54    plainObjects: false,
55    strictNullHandling: false
56};
57
58var interpretNumericEntities = function (str) {
59    return str.replace(/&#(\d+);/g, function ($0, numberStr) {
60        return String.fromCharCode(parseInt(numberStr, 10));
61    });
62};
63
64// This is what browsers will submit when the ✓ character occurs in an
65// application/x-www-form-urlencoded body and the encoding of the page containing
66// the form is iso-8859-1, or when the submitted form has an accept-charset
67// attribute of iso-8859-1. Presumably also with other charsets that do not contain
68// the ✓ character, such as us-ascii.
69var isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('✓')
70
71// These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.
72var charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓')
73
74var parseValues = function parseQueryStringValues(str, options) {
75    var obj = {};
76    var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, '') : str;
77    var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;
78    var parts = cleanStr.split(options.delimiter, limit);
79    var skipIndex = -1; // Keep track of where the utf8 sentinel was found
80    var i;
81
82    var charset = options.charset;
83    if (options.charsetSentinel) {
84        for (i = 0; i < parts.length; ++i) {
85            if (parts[i].indexOf('utf8=') === 0) {
86                if (parts[i] === charsetSentinel) {
87                    charset = 'utf-8';
88                } else if (parts[i] === isoSentinel) {
89                    charset = 'iso-8859-1';
90                }
91                skipIndex = i;
92                i = parts.length; // The eslint settings do not allow break;
93            }
94        }
95    }
96
97    for (i = 0; i < parts.length; ++i) {
98        if (i === skipIndex) {
99            continue;
100        }
101        var part = parts[i];
102
103        var bracketEqualsPos = part.indexOf(']=');
104        var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;
105
106        var key, val;
107        if (pos === -1) {
108            key = options.decoder(part, defaults.decoder, charset);
109            val = options.strictNullHandling ? null : '';
110        } else {
111            key = options.decoder(part.slice(0, pos), defaults.decoder, charset);
112            val = options.decoder(part.slice(pos + 1), defaults.decoder, charset);
113        }
114
115        if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
116            val = interpretNumericEntities(val);
117        }
118        if (has.call(obj, key)) {
119            obj[key] = utils.combine(obj[key], val);
120        } else {
121            obj[key] = val;
122        }
123    }
124
125    return obj;
126};
127
128var parseObject = function (chain, val, options) {
129    var leaf = val;
130
131    for (var i = chain.length - 1; i >= 0; --i) {
132        var obj;
133        var root = chain[i];
134
135        if (root === '[]' && options.parseArrays) {
136            obj = [].concat(leaf);
137        } else {
138            obj = options.plainObjects ? Object.create(null) : {};
139            var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
140            var index = parseInt(cleanRoot, 10);
141            if (!options.parseArrays && cleanRoot === '') {
142                obj = { 0: leaf };
143            } else if (
144                !isNaN(index)
145                && root !== cleanRoot
146                && String(index) === cleanRoot
147                && index >= 0
148                && (options.parseArrays && index <= options.arrayLimit)
149            ) {
150                obj = [];
151                obj[index] = leaf;
152            } else {
153                obj[cleanRoot] = leaf;
154            }
155        }
156
157        leaf = obj;
158    }
159
160    return leaf;
161};
162
163var parseKeys = function parseQueryStringKeys(givenKey, val, options) {
164    if (!givenKey) {
165        return;
166    }
167
168    // Transform dot notation to bracket notation
169    var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;
170
171    // The regex chunks
172
173    var brackets = /(\[[^[\]]*])/;
174    var child = /(\[[^[\]]*])/g;
175
176    // Get the parent
177
178    var segment = brackets.exec(key);
179    var parent = segment ? key.slice(0, segment.index) : key;
180
181    // Stash the parent if it exists
182
183    var keys = [];
184    if (parent) {
185        // If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties
186        if (!options.plainObjects && has.call(Object.prototype, parent)) {
187            if (!options.allowPrototypes) {
188                return;
189            }
190        }
191
192        keys.push(parent);
193    }
194
195    // Loop through children appending to the array until we hit depth
196
197    var i = 0;
198    while ((segment = child.exec(key)) !== null && i < options.depth) {
199        i += 1;
200        if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
201            if (!options.allowPrototypes) {
202                return;
203            }
204        }
205        keys.push(segment[1]);
206    }
207
208    // If there's a remainder, just add whatever is left
209
210    if (segment) {
211        keys.push('[' + key.slice(segment.index) + ']');
212    }
213
214    return parseObject(keys, val, options);
215};
216
217module.exports = function (str, opts) {
218    var options = opts ? utils.assign({}, opts) : {};
219
220    if (options.decoder !== null && options.decoder !== undefined && typeof options.decoder !== 'function') {
221        throw new TypeError('Decoder has to be a function.');
222    }
223
224    options.ignoreQueryPrefix = options.ignoreQueryPrefix === true;
225    options.delimiter = typeof options.delimiter === 'string' || utils.isRegExp(options.delimiter) ? options.delimiter : defaults.delimiter;
226    options.depth = typeof options.depth === 'number' ? options.depth : defaults.depth;
227    options.arrayLimit = typeof options.arrayLimit === 'number' ? options.arrayLimit : defaults.arrayLimit;
228    options.parseArrays = options.parseArrays !== false;
229    options.decoder = typeof options.decoder === 'function' ? options.decoder : defaults.decoder;
230    options.allowDots = typeof options.allowDots === 'undefined' ? defaults.allowDots : !!options.allowDots;
231    options.plainObjects = typeof options.plainObjects === 'boolean' ? options.plainObjects : defaults.plainObjects;
232    options.allowPrototypes = typeof options.allowPrototypes === 'boolean' ? options.allowPrototypes : defaults.allowPrototypes;
233    options.parameterLimit = typeof options.parameterLimit === 'number' ? options.parameterLimit : defaults.parameterLimit;
234    options.strictNullHandling = typeof options.strictNullHandling === 'boolean' ? options.strictNullHandling : defaults.strictNullHandling;
235
236    if (typeof options.charset !== 'undefined' && options.charset !== 'utf-8' && options.charset !== 'iso-8859-1') {
237        throw new Error('The charset option must be either utf-8, iso-8859-1, or undefined');
238    }
239    if (typeof options.charset === 'undefined') {
240        options.charset = defaults.charset;
241    }
242
243    if (str === '' || str === null || typeof str === 'undefined') {
244        return options.plainObjects ? Object.create(null) : {};
245    }
246
247    var tempObj = typeof str === 'string' ? parseValues(str, options) : str;
248    var obj = options.plainObjects ? Object.create(null) : {};
249
250    // Iterate over the keys and setup the new object
251
252    var keys = Object.keys(tempObj);
253    for (var i = 0; i < keys.length; ++i) {
254        var key = keys[i];
255        var newObj = parseKeys(key, tempObj[key], options);
256        obj = utils.merge(obj, newObj, options);
257    }
258
259    return utils.compact(obj);
260};
261
262},{"./utils":5}],4:[function(require,module,exports){
263'use strict';
264
265var utils = require('./utils');
266var formats = require('./formats');
267
268var arrayPrefixGenerators = {
269    brackets: function brackets(prefix) { // eslint-disable-line func-name-matching
270        return prefix + '[]';
271    },
272    indices: function indices(prefix, key) { // eslint-disable-line func-name-matching
273        return prefix + '[' + key + ']';
274    },
275    repeat: function repeat(prefix) { // eslint-disable-line func-name-matching
276        return prefix;
277    }
278};
279
280var isArray = Array.isArray;
281var push = Array.prototype.push;
282var pushToArray = function (arr, valueOrArray) {
283    push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
284};
285
286var toISO = Date.prototype.toISOString;
287
288var defaults = {
289    addQueryPrefix: false,
290    allowDots: false,
291    charset: 'utf-8',
292    charsetSentinel: false,
293    delimiter: '&',
294    encode: true,
295    encoder: utils.encode,
296    encodeValuesOnly: false,
297    // deprecated
298    indices: false,
299    serializeDate: function serializeDate(date) { // eslint-disable-line func-name-matching
300        return toISO.call(date);
301    },
302    skipNulls: false,
303    strictNullHandling: false
304};
305
306var stringify = function stringify( // eslint-disable-line func-name-matching
307    object,
308    prefix,
309    generateArrayPrefix,
310    strictNullHandling,
311    skipNulls,
312    encoder,
313    filter,
314    sort,
315    allowDots,
316    serializeDate,
317    formatter,
318    encodeValuesOnly,
319    charset
320) {
321    var obj = object;
322    if (typeof filter === 'function') {
323        obj = filter(prefix, obj);
324    } else if (obj instanceof Date) {
325        obj = serializeDate(obj);
326    }
327
328    if (obj === null) {
329        if (strictNullHandling) {
330            return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset) : prefix;
331        }
332
333        obj = '';
334    }
335
336    if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean' || utils.isBuffer(obj)) {
337        if (encoder) {
338            var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset);
339            return [formatter(keyValue) + '=' + formatter(encoder(obj, defaults.encoder, charset))];
340        }
341        return [formatter(prefix) + '=' + formatter(String(obj))];
342    }
343
344    var values = [];
345
346    if (typeof obj === 'undefined') {
347        return values;
348    }
349
350    var objKeys;
351    if (Array.isArray(filter)) {
352        objKeys = filter;
353    } else {
354        var keys = Object.keys(obj);
355        objKeys = sort ? keys.sort(sort) : keys;
356    }
357
358    for (var i = 0; i < objKeys.length; ++i) {
359        var key = objKeys[i];
360
361        if (skipNulls && obj[key] === null) {
362            continue;
363        }
364
365        if (Array.isArray(obj)) {
366            pushToArray(values, stringify(
367                obj[key],
368                generateArrayPrefix(prefix, key),
369                generateArrayPrefix,